13:55 < pbunny> please read more carefully
13:55 < l4mRh4X0r> nope.
13:55 < Grum> not really o.O
13:55 < Grum> plants are just blocks
13:55 < l4mRh4X0r> rather, really not.
13:55 < pbunny> ok, i meant - no metaentities spawning either
13:55 < Grum> but then it is not minecraft
13:55 < l4mRh4X0r> True, true.
13:55 < pbunny> Grum: metaentity is a block that does something, in terms of my server
13:55 < Grum> i mean, i could point at any section of ram in any system and then claim: 'look minecraft'
13:55 < pbunny> Grum: by that example i tried to show that keeping chunks 'loaded' doesn't have any performance impact
13:55 < Grum> but 'grass' doesnt 'do' anything
13:55 < Grum> BUT it does spread
13:56 < pbunny> entities/metaentities processing do
13:56 < Grum> would be a silly world, without grass ;)
13:56 < ShaRose> don't forget leaves
13:56 < pbunny> Grum: spreading means doing anything.
13:56 < pbunny> well trees are definetely metaentities
13:56 < ShaRose> villages have farming areas as well
13:56 < TkTech> pbunny, Has anyone described you as bullheaded before?
13:56 < pbunny> at least their edges (from which they can grow)
13:56 < Grum> not at all :/
13:56 < Grum> trees do not grow
13:56 -!- yorick [~yorick@oftn/member/yorick] has joined #mcdevs
13:56 < l4mRh4X0r> Oh, what about other blocks?
13:56  * md_5 grabs more popcorn
13:56 < l4mRh4X0r> They do something.
13:56 < Grum> i mean if you are going this way, you might as well use 1 bit per block, saves a lot of space :p
13:57 < Grum> i mean, 'stone' doesnt 'tick' =)
13:57  * l4mRh4X0r tosses md_5 a beer
13:57 < l4mRh4X0r> ;)
13:57 < l4mRh4X0r> You're gonna need it.
13:57 < l4mRh4X0r> Or would you prefer something else?
13:57 < pbunny> Grum: i'm not doing that way..
13:57 < pbunny> it was just an example that 'keeping chunks loaded' is not a problem
13:57 < pbunny> processing stuff is
13:57 <+md_5> I'll just drink till I pass out, better for my brain cells than reading ths
13:57 < Grum> pbunny: i've always said that you'll run out of cpucycles :P
13:57 < pbunny> and if i unload chunks that doesn't require processing - i won't win anything
13:58 < pbunny> because they wasn't using CPU anyway
13:58 < Grum> weren't and yes
13:58 < pbunny> and if they need processing - they must be loaded
13:58 < pbunny> well i just thought of alternative
13:59 < pbunny> unload chunks, and when player comes nearby - load them and cycle the amount of iterations that they skipped
13:59 < pbunny> but i won't win in performance by doing that anyway
13:59 < TkTech> pbunny, What do you define as processing? Just growing or moving stuff doesn't require loading.
13:59 < l4mRh4X0r> Ah, he's even unloading chunks now!
13:59 < pbunny> TkTech: how so? you must update block data when something grows
14:00 < pbunny> ( if it grows to new block )
14:00 < l4mRh4X0r> We're getting through, somehow :P
14:00 < TkTech> pbunny, No you don't!
14:00 < TkTech> pbunny, All you need is a timestamp and a finite automata.
14:00 < TkTech> pbunny, This started growing at 102042042, and was in the 2nd state of growth.
14:00 < pbunny> TkTech: how about mobs?
14:00 < l4mRh4X0r> finite automata or a finite automaton
14:00 < l4mRh4X0r> Not a finite automata
14:00 < Grum> TkTech: this is what we eventually plan to do to get rid of 'random updates'
14:00 < pbunny> mobs ai depend on many surrounding stuff
14:00 < TkTech> pbunny, Someone walks near the chunk at 10206204, it loads, you update everything as it "should be".
14:01 < pbunny> TkTech: i got it for plants
14:01 < pbunny> what about mobs?
14:01 < TkTech> Moving entities isn't any different.
14:01 < pbunny> they are always alive
14:01 < TkTech> Their "AI" is still finite.
14:01 < zutto> pbunny: you can calculate where mob would be after X amount of time, if player gets close enough to see it
14:01 < TkTech> Same with projectiles, you can always "catch up" later.
14:01 < pbunny> TkTech: sounds like idea i just sounded
14:01 < pbunny> however, some ai may need to depend on chunks that is actually loaded and has players doing somethign on it
14:01  * TkTech kills himself
14:02 < pbunny> in that case i will have to save history of updates too
14:02 -!- exe [~exe@85.28.181.103] has joined #mcdevs
14:03 < pbunny> TkTech: imagine mobs that are gathering around player 10 chunks away from him because one of slime near him detected him
14:03 -!- exe is now known as Guest2411
14:03 < pbunny> how is it possible to use finite automata/whatever for it?
14:03 < pbunny> how is it possible on unloaded chunks?
14:03 < pbunny> i mean - when player comes nearby and chunk will be loaded - you can't just iterate mobs ai
14:03 < pbunny> because information that they would depend one is no more actual
14:03 < pbunny> on *
14:04 < pbunny> also mobs can come out from chunks that you would have unloaded
14:04 < pbunny> etc
14:04 < pbunny> they all need real-time data
14:04 < zutto> they dont need real time data
14:05 < pbunny> they do if they want to be smart
14:05 < zutto> you can dig up the data you need as the AI progresses
14:05 < pbunny> zutto: from history?
14:05 < pbunny> they i must keep history aswell
14:05 < pbunny> zutto: also, some cases won't work like that
14:05 < pbunny> zutto: i.e. mobs won't gather far away and attack player
14:05 < zutto> from database/memory/whereever you store your data
14:05 < pbunny> until he comes closer
14:06 < zutto> why are you so attached to this real-time shit
14:06 < pbunny> TkTech: have you understood my argument about mobs needing real-time data?
14:07 < pbunny> of course i can treat mobs like players, and load chunks when they come at them
14:07 < zutto> have you ever written or studied any AI pathing methods?
14:07 < l4mRh4X0r> pbunny, so when you need mobs from 10 chunks away, you load those chunks, fast-forward the mobs in them, and then use it
14:07 < zutto> ^ you have absolutely no need for real-time data
14:07 < l4mRh4X0r> I don't see the problem
14:07 < pbunny> l4mRh4X0r: what if player will stand on single chunk?
14:07 < pbunny> mobs will never attack him
14:07 < l4mRh4X0r> pbunny, that's what your AI says, right?
14:07 < pbunny> ?
14:08 < pbunny> l4mRh4X0r: if player won't load the chunk, mobs won't attack him
14:08 < l4mRh4X0r> Also, a player generally has a 9x9 chunk area around him loaded
14:08 < pbunny> right?
14:08 < pbunny> l4mRh4X0r: imagine army of mobs 15 chunks away
14:08 < zutto> pbunny: have you played any games before?
14:08 < pbunny> it won't attack him until he loads their chunks?
14:08 < zutto> games with AI i mean
14:08 < l4mRh4X0r> 15 chunks away
14:09 < l4mRh4X0r> 15 chunks is 240 blocks.
14:09 < pbunny> yes.
14:09 < l4mRh4X0r> You won't even see them from that distance
14:09 < pbunny> mobs may have a command center there
14:09 < pbunny> fortress etc
14:09 < pbunny> l4mRh4X0r: exactly
14:09 < l4mRh4X0r> So mobs won't see you either.
14:09 < pbunny> but they somehow detected you
14:09 < pbunny> i.e. by nearby mob
14:09 < zutto> whew
14:09 < pbunny> that transmitted your location to them
14:09 < pbunny> then they gather an army there
14:09 < pbunny> surround you and attack
14:09 < zutto> 15:09:25       pbunny | but they somehow detected you
14:09 < zutto> suddenly feels like we are talking to 5 year old child
14:09 < pbunny> zutto: go away
14:10 < zutto> somehow the bear started flying!
14:10 < l4mRh4X0r> pbunny, he has a point though.
14:10 < pbunny> l4mRh4X0r: so basically your idea (and TkTech's?) won't allow me to do things i need to do on my server
14:10 < l4mRh4X0r> It will
14:10 < l4mRh4X0r> You just need to think.
14:10 < pbunny> l4mRh4X0r: bs.
14:10 < zutto> pbunny: going for minimal sloc isnt always the way to go
14:10 < Flemmard> why thinking when you have a lots of ram ?
14:10 < pbunny> l4mRh4X0r: imagine a chunk with mob army that is unloaded for million ticks
14:10 < zutto> this is good example where it isnt good way to go
14:10 < pbunny> how will i iterate it when its loaded?
14:11 < pbunny> keep a history forever?
14:11 < l4mRh4X0r> I have no experience with AI
14:11 < l4mRh4X0r> But if you have a finite automaton, you can just save the state.
14:11 < pbunny> state of what?
14:11 < l4mRh4X0r> the automaton, of course.
14:11 < pbunny> l4mRh4X0r: i.e. mob army on this chunk would have attacked 900000 ticks ago if player was in chunk X
14:11 < l4mRh4X0r> automata have states.
14:12 < pbunny> how will i determine if player was in chunk X 900000 ticks ago?
14:12 < l4mRh4X0r> And each state uniquely describes a situation
14:12 < pbunny> also, even if army attacks - player isn't there anymore.
14:12 < pbunny> l4mRh4X0r: no.
14:12 < pbunny> l4mRh4X0r: the idea of mobs unable to attack until player unlocks their chunk is BULLSHIT
14:12 < l4mRh4X0r> pbunny, then you make sure the player loads the relevant chunks.
14:12 < pbunny> can we please move along
14:12 < zutto> pbunny: bullshit?
14:12 < pbunny> zutto: bullshit.
14:13 < zutto> all other rpg(and some non-rpg's) do this
14:13 < pbunny> zutto: because its easier to do.
14:13 < pbunny> and consumers are happy with it
14:13 < l4mRh4X0r> pbunny, instead of calling bullshit, can you prove it is?
14:13 < pbunny> l4mRh4X0r: i just proved like 5 times
14:13 < zutto> pbunny: ofcourse consumers are happy with it
14:13 < l4mRh4X0r> If not, I'm afraid your argument is invalid.
14:13 < pbunny> mobs must be able to act always
14:13 < pbunny> not only when their chunk is loaded
14:13 < l4mRh4X0r> well, that's not possible.
14:14 < pbunny> l4mRh4X0r: it is possible when everythign is loaded and mobs can get real-time data
14:14 < l4mRh4X0r> So unless you manage to divide by zero, your argument is invalid.
14:14 < pbunny> ....
14:14 < pbunny> ok, go away
14:14 < pbunny> next!
14:14 < l4mRh4X0r> No! :D
14:14 < l4mRh4X0r> mobs can't act when their chunk is not loaded.
14:14 < l4mRh4X0r> Simple as that.
14:14 < zutto> l4mRh4X0r: dividing by zero is possible if we can use imaginary fourth dimension
14:14 < zutto> and third infinite
14:14 < pbunny> l4mRh4X0r: yes, that's why i need to have everything loaded.
14:15 < l4mRh4X0r> No.
14:15 < l4mRh4X0r> That's why you need to have every relevant thing is loaded.
14:15 < pbunny> yeah.
14:15 < pbunny> and basically everything is relevant.
14:15 < l4mRh4X0r> s/is//
14:15 < l4mRh4X0r> pbunny, it isn't.
14:15 < pbunny> i.e. mobs can plan their attack with choosing the optimal ground structure etc
14:16 < pbunny> predicting player movements depending on surrounding building
14:16 < pbunny> caves
14:16 < pbunny> etc
14:16 < l4mRh4X0r> Oh, right
14:16 < l4mRh4X0r> Your plans were near impossible to start with
14:16 < pbunny> why?
14:16 < l4mRh4X0r> Carry on, don't mind me.
14:16 < zutto> l4mRh4X0r: impossible? BULLSHIT!
14:16 < zutto> with 1tb of ram and 512 cores, he can do it!
14:17 < pbunny> zutto: i used that word after giving my argument 5 times in 2 minutes
14:17 < pbunny> don't act childish
14:17 < zutto> yes, i was copying you
14:17 < pbunny> no.
14:17 < zutto> yes, i was
14:17 < pbunny> i haven't heard any argument except for "you don't know servers" from you
14:17 < pbunny> go away.
14:17 < l4mRh4X0r> pbunny, then read again
14:17 < l4mRh4X0r> And stop telling people to go away
14:17 < zutto> you apparently dont read what i write then
14:18 < pbunny> **:10:09        zutto | l4mRh4X0r: dividing by zero is possible if we can use imaginary fourth dimension
14:18 < pbunny> was that your argument?
14:18 < l4mRh4X0r> If they're trying to stop you from wasting years of your life.
14:18 < pbunny> months. not wasting.
14:18 < l4mRh4X0r> You'll see.
14:19 <+Amaranth> I've just been trying to catch up on scrollback and it was amusing to see the discussion end up with TkTech, Grum, and pbunny basically discussing what Grum did almost 2 years ago for block ticking in beta 1.7
14:20 <+Amaranth> Well, it did the hard half of it anyway
14:20 < pbunny> block ticking?
14:22 <+Amaranth> grass spread and such
14:22 < pbunny> Amaranth: this is not the hardest issue to do with chunk unloading.
14:22 < Flemmard> where can i buy popcorn ?:D
14:23 <+Amaranth> Oh no, I'm not getting into this conversation with you
14:23 < l4mRh4X0r> Popcorn! Popcorn! Only 50 cents for a bucket!
14:23 < pbunny> Amaranth: read the end of discussion - the hardest (impossible) part is that mobs must be able to get real-time information i.e. about player movements
14:23 <+Amaranth> I was just commenting on the discussion, I'm being meta
14:23 < l4mRh4X0r> Beer! $2 per bottle!
14:23 < zutto> 50 cents?
14:23  * l4mRh4X0r pretends to be a salesman
14:23 < zutto> holy shit thats cheap
14:23 < pbunny> that requirement alone requires everything loaded
14:24  * Amaranth struggles to not take bait/give pbunny useful ideas
14:24 < pbunny> Amaranth: you may try to give an argument against "everything always in RAM" approach then :p
14:26 < pbunny> i think the misunderstanding here lies in the fact that you think i am trying to reproduce vanilla minecraft server
14:26 < pbunny> in reality i am trying to make something different - a real-time world which is independent from players
14:26 <+Amaranth> I was more amused with you saying your chunks take almost 5x what I figured was the most inefficient storage of the data was
14:26 < pbunny> so, most of vanilla server's approaches doesn't work for me
14:26 < TkTech> Amaranth, Pfft, I had it first!
14:26 < pbunny> Amaranth: it was a typo/misremember
14:27 < pbunny> its 164Kb per chunk
14:27 < TkTech> Amaranth, Lots of us had done similar concepts for physics in classic (minus the idea of chunks) long ago.
14:27 <+Amaranth> TkTech: He did the part of making block ticking not random but still almost the same as vanilla behavior statistically
14:28 <+Amaranth> The missing part was saving the schedule/timestamp/etc to catch up the growth on the next chunk load
14:28 < Grum> that actually worked
14:28 < Grum> but it needed tweaksings :)
14:28 <+Amaranth> Oh I didn't see where that was hooked up to anything
14:28 < Grum> i still have that diff somewhere
14:29 < TkTech> Is that actually what the game does now? I haven't kept up to date in a long, long time.
14:29 <+Amaranth> I do too, it's in CraftBukkit-Bleeding
14:29 < Grum> TkTech: more change, less random
14:29 < Grum> *chance
14:29 <+Amaranth> No, this was Grum code from beta 1.7 that never got updated
14:29 <+Amaranth> Vanilla still does random ticking
14:29 < Grum> yeah but far less
14:29 < Grum> it used to be 80 times per chunk per tick
14:29 <+Amaranth> Well, it does have some optimizations
14:30 < Grum> btw jens actually agreed to do this
14:30 < Grum> so once upon a time ... :p
14:30 <+Amaranth> Yeah, for one thing 1.0 changed it to 7 chunk radius around each player and 30 blocks per chunk instead of 9 radius and 80 per chunk
14:30 < Grum> yeah
14:30 <+Amaranth> And 1.2 changed it to only attempt ticking sections that have tickable blocks as a part of the anvil change
14:31 < Grum> i missed that one
14:31 <+Amaranth> And iirc 3 blocks per section
14:31 < TkTech> Sensible optimizations
14:31 < Grum> that seems inefficient :/
14:31 < Grum> all is inefficient
14:31 <+Amaranth> 3*16 = 48
14:31 < Grum> we just had a scheduler
14:31 < Grum> so you could actually ask every block when it would get ticked
14:31 <+Amaranth> Well, only ticking sections that have something tickable is not inefficient
14:31 < Grum> and it would just need 64bits per ticking block
14:32 < Grum> remembering which sections are tickable is ;)
14:32 < pbunny> Grum: so persistent mobs will never be implemented in vanilla mc?
14:32 <+Amaranth> You keep track of if it has tickable things at the point you set block types
14:32 < pbunny> independent mobs
14:32 <+Amaranth> (and chunk load you iterate all blocks)
14:32 < Grum> pbunny: you have persistent mobs
14:32 < pbunny> Grum: No, they freeze when chunk is unloaded
14:32 < Grum> some of them stay if you give them an item ;)
14:32 < Grum> i have no idea how a mob can walk when you remove the chunk from memory :P
14:32 < pbunny> Grum: well i won't remove chunks from memory :)
14:33 < pbunny> good. so my server will be superior to vanilla
14:33 < SinZ> uhh
14:33 < pbunny> :p
14:33 < Grum> except your server will not be vanilla
14:33 <+Amaranth> So the slight overhead of managing the tickable count in the block set code is worth the savings of not trying to tick solid stone sections
14:33 < pbunny> Grum: it doesn't need to be
14:33 < SinZ> If the chunk is unloaded, chances are you don't need the mob to move anyway
14:33 < Grum> but then it cannot be superior
14:33 < TkTech> So who has the popcorn bucket now?
14:33 < pbunny> Grum: why?
14:33 <+Amaranth> Grum: They're also persistent if you name them :D
14:33 < Grum> as you are comparing apples and pears
14:33 < SinZ> TkTech: I had noodles, does that count
14:33 < pbunny> Grum: no, more like a dryed-up peach with fresh peach
14:34 <+Amaranth> l4mRh4X0r has the popcorn, jump him
14:34 < Grum> yeah yours being the dryed up one and then you claim it will get less fungus 
14:34  * l4mRh4X0r flees
14:34 < Grum> yeah ofc, it is way less ;)
14:34 < pbunny> Grum: so vanilla mc will always be boring lonely place where mobs are only a temporary illusion
14:34 < Grum> pbunny: no?
14:34 < pbunny> Grum: yes. you can logout and they disappear :)
14:34 < Grum> but why would mobs do anything if there is no-one near to do anything to? :)
14:35 < pbunny> on my server they will wait for you for some time :p
14:35 < TkTech> I want to stay, as this is entertaining, but I also want to beat the storm.
14:35 < Grum> no they do not dissapear
14:35 < pbunny> then go away killing somebody else
14:35 <+Amaranth> Grum: Still not as amusing as the servers that basically only implement walking around placing blocks bragging about how much faster than vanilla they are ;)
14:35 -!- Brandon15811_ [~Brandon15@2a01:e0b:1:156:986d:67b:1976:e18] has quit [Ping timeout: 245 seconds]
14:35 < Grum> this is about the same as the age old question: does a tree falling in forrest without anyone around make sound
14:35 < Grum> also, it does not make sound
14:35 < Grum> because for it to be sound there has to be an observer
14:36 < pbunny> Grum: because mobs can populate, mine resources, build fortresses, gain intelligence on players, ambush them, etc
14:36 < Grum> and we just said there are no observers :P
14:36 < Grum> can they?
14:36 < pbunny> and on my server there will be 2 fighting sides of the mobs - the overworld ones and the nether ones
14:36 < Grum> not in minecraft ;D
14:36 < Grum> slightly boring then
14:36 < Grum> pour lava over the portal ... win
14:36 <+Amaranth> Grum: Actually one of the big optimizations some vanilla mods make is to stop ticking entities that are loaded but a certain distance away from any player
14:36 < Grum> yeah
14:36 < Grum> because they have nothing to do with the player anyhow
14:37 <+Amaranth> Right and sometimes they are not even drawn on the player's client
14:37 < Grum> yup
14:37 <+Amaranth> But they are still running full AI code
14:37 < Grum> i'll get around to that too ... eventually
14:37 <+Amaranth> :D
14:37 < SinZ> throw it on the todo list
14:37 < pbunny> Amaranth: full ai code is terribly simple in vanilla mc
14:37 < Grum> and terribly expensive
14:38 < Grum> mostly because of pathing
14:38 < pbunny> and its impossible to make mobs smarter because they are not real-time
14:38 <+Amaranth> Selecting AI goals to run makes me cry
14:38 < Grum> Amaranth: same
14:38 < Grum> again, i will fix that ;)
14:38 < SinZ> make the client more fussy about how it receives chunks? <3
14:38 < Grum> hahahah
14:38 < Grum> that too
14:39 <+md_5> still going
14:39  * md_5 shoots self
14:39 < SinZ> not sure if it is worth getting some popcorn or not
14:39 <+Amaranth> md_5: Nah, now we're talking about more generic things and tricking Grum into saying he will fix them in vanilla
14:40 <+md_5> X-forwarded-for type paccket/plugin message please
14:40  * md_5 ducks
14:40 <+Amaranth> haha
14:40 < SinZ> launcher blog in the new launcher
14:40  * SinZ hides
14:40 < pbunny> Grum: will persistent furnaces be ever implemented in vanilla?
14:40 <+md_5> wat
14:40 < Grum> yes but through another mechanic
14:40 < pbunny> furnaces that burn even when nobody's around
14:41 < Grum> each unloaded chunk will remember what its ticktime was when it was unloaded
14:41 <+Amaranth> Furnaces are quite possibly the easiest thing to make appear to burn even when the chunk is unloaded
14:41 < Grum> and on load just fastforward
14:41 <+Amaranth> Yep
14:41 <+Amaranth> That's really simple to do
14:41 < Grum> this is also what we did in that patch of 1.7 iirc
14:41 < pbunny> Grum: what if a mob robs furnace during its operation?
14:41 < Grum> pbunny: it cannot do that?
14:41 < pbunny> how can you fastforward that
14:41 -!- Brandon15811_ [~Brandon15@2a01:e0b:1:156:cac:2537:c7ad:8447] has joined #mcdevs
14:41 < SinZ> the chunk would of been unloaded, so nothing could of altered it
14:41 < pbunny> Grum: it can on my server
14:41 < Grum> pbunny: it can't
14:42 <+Amaranth> If mobs ever gain the ability to keep chunk loaded I'm patching that shit out :D
14:42 < SinZ> Vannila != your server
14:42 < pbunny> it will be able to.
14:42 < pbunny> SinZ: exactly
14:42 < Grum> then show it now, let me login, o wait ...
14:42 < Grum> indeed
14:42 < l4mRh4X0r> SinZ, could have*
14:43 < pbunny> its funny how mojang fails to understand that all performance issues come from poor language choise alone :)
14:43 <+Amaranth> Oh god
14:43 <+Amaranth> Here we go
14:43 < l4mRh4X0r> pbunny, they don't.
14:43 <+md_5> disclaimer: pbunny doesnt even own minecraft
14:43 <+md_5> please no pbunny 
14:43 < pbunny> java isnt designed for servers
14:43 <+md_5> pbunny uuh
14:43 < l4mRh4X0r> actually, it is.
14:43 < SinZ> you arn't designed for this channel
14:43 <+Amaranth> Oh god, is he actually going there?
14:43 <+md_5> vert.x
14:43 < pbunny> java is for simple mobile apps etc
14:43 <+md_5> hornetq
14:43 < Grum> pbunny: java is designed for servers
14:43 <+Amaranth> Holy shit, he is doing it
14:43 < Grum> it just depends on how you use it
14:43 < Grum> bad code is bad code in any language
14:43 < pbunny> Grum: java uses memory irrationally
14:44 < Grum> it doesnt if you know how to use it
14:44 <+md_5> infinispam
14:44 < pbunny> and you cant optimize that
14:44 <+md_5> elasticsearch
14:44  * md_5 head desk
14:44 < Grum> you can? :/
14:44 < pbunny> no.
14:44 <+Amaranth> Lucene!
14:44 < Grum> i've done it >.>
14:44 < l4mRh4X0r> pbunny, stop talking about stuff you know shit about.
14:44 < Grum> i've actually done just that for my work O.o
14:44 < l4mRh4X0r> shit being nothing, in this case.
14:44 < SinZ> It is getting to the stage, where he needs to join SirCmpwn
14:44 <+Amaranth> Half of Google runs on Java I think
14:44 < Grum> dropping a 'c' radix-tree down from ~6gb to 2.2gb in java
14:44 <+md_5> Amaranth twitter and google, yah
14:45 < pbunny> Grum: is that why mc client uses 4Gb of RAM to display initial menu?
14:45 < Grum> the problem is never in the language, the problem is always in implementation
14:45 <+md_5> pbunny you do know the avast definition servers are java?
14:45 <+Amaranth> That's right, twitter uses scala now, right?
14:45 < Grum> pbunny: it doesn't
14:45 <+Amaranth> Well, scala and java
14:45 < Grum> it uses <120mb
14:45 <+md_5> thats 100 million clients right there
14:45 < pbunny> Grum: it does,
14:45 < Grum> pbunny: the normal client doesnt even GET 4gb of ram
14:45 < Grum> so stop being retarded
14:45 < pbunny> Grum: ok, isnt' 120mb too much for displaying a simple menu?
14:45 <+Amaranth> Grum: He uses magic launcher and gave it 4GB I bet
14:45 < l4mRh4X0r> Amaranth, didn't scala run on java? :P
14:45 <+md_5> pbunny my client uses 96mb of ram
14:45 <+md_5> literally
14:45 <+md_5> pisses me off when people say MC is a hog
14:45 < Grum> pbunny: yes, but it preloads *ALL* assets
14:45 <+md_5> mods are hogs, MC is not
14:45 <+Amaranth> l4mRh4X0r: Well, Scala runs on the JVM but it is a different language
14:45 < Grum> which a good game does
14:46 < l4mRh4X0r> Yeah, same difference :P
14:46 < l4mRh4X0r> It's what I meant anyway.
14:46 <+md_5> again, my client runs fine on 96mb
14:46 < Grum> same
14:46 < Grum> no issues at all
14:46 <+Amaranth> md_5: I used to actually reduce the client's heap
14:46 <+clonejo> Hey, don't feel the trolls, he'll learn eventually ;-)
14:46  * l4mRh4X0r feels pbunny 
14:46 < Grum> and i should add, the client right now is not at all in any way or form optimized to use 'little memory'
14:46 < l4mRh4X0r> Eww
14:46 < SinZ> clonejo: thats what we said with SirCmpwn, we were wrong
14:46 < l4mRh4X0r> All gooey.
14:46 <+md_5> eucalyptus is also Java
14:47 < Grum> java is just a language, a bloody portable on at that
14:47 < Grum> and that is the reason why minecraft should be and stay java
14:47 < pbunny> Grum: bloody unoptimized
14:47 <+md_5> so is akka: High Performance
14:47 <+md_5> 50 million msg/sec on a single machine. Small memory footprint; ~2.7 million actors per GB of heap.
14:47 < l4mRh4X0r> pbunny, heh!
14:47 < l4mRh4X0r> Hypocrite.
14:47 <+md_5> please
14:47 <+md_5> I cant take this
14:47 < Grum> pbunny: do it better
14:47  * md_5 calls suicide hotline
14:47 < Grum> (i know i can, i just do not have the time for it right now)
14:47 < Grum> also, it would murder the community to stop using java
14:48 <+ammar2> there's a certain word for people who try to provoke responses with strong words and stupidity you know :P
14:48 < SinZ> and would require too much cost for so little gain
14:48 < l4mRh4X0r> (in spanish accent) "Yes, hello? This is suicide hotline!"
14:48 < pbunny> Grum: java community isnt needed
14:48 < SinZ> pbunny: so you expect Mojang to completelly remake their game just for minor optimisations
14:48 < l4mRh4X0r> Meh, I'm outta here.
14:48 < pbunny> SinZ: not minor.
14:48 < l4mRh4X0r> Yes minor.
14:48  * md_5 head desk
14:48 <+md_5> 96mb
14:48 < SinZ> and lose cross-platform compatiblility in the process
14:48 <+md_5> what game runs on 96mb
14:48 < pbunny> java is the only reason for the need to unload chunks
14:48 <+Amaranth> *headdesk*
14:49 <+md_5> team fortress uses like 15 times that
14:49 < SinZ> and common sense...
14:49 < pbunny> its a memory hog :)
14:49 < l4mRh4X0r> pbunny, have you ever actually used the JVM like it's supposed to?
14:49 <+ammar2> pbunny: wtf are you even talking about now
14:49 < SinZ> Common sense is to unload chunks
14:49 <+md_5> team fortress uses 15x more ram than Minecraft, and its written in C++
14:49 <+md_5> what the f*** is your  point pbunny 
14:49 < pbunny> ?
14:49 < Grum> pbunny: not really, i can perfectly keep the data in memory in java without major overhead over c/c++
14:49 <+Amaranth> I tried to calculate how much overhead java adds to each chunk once
14:49 <+md_5> Grum please code next client in forth
14:49 <+Amaranth> I'm pretty sure the number was less than 100 bytes
14:49 < Grum> its less than 150bytes
14:50 <+ammar2> Amaranth: and that 100 bytes is why we need to unload chunks
14:50 < Grum> sure objects cost memory, there are no structs like in c
14:50 <+ammar2> pbunny please, just stop ;_;
14:50 < Grum> who cares?
14:50 < Grum> you can also code it without losing your mind :)
14:50 < l4mRh4X0r> And without using defines
14:50 <+Amaranth> The trick is objects full of arrays instead of arrays full of objects
14:50 < l4mRh4X0r> Oh wait, you can do that in C as well!
14:51 -!- edlothiol [~edlothiol@2a02:810b:80c0:27:f2de:f1ff:fe78:51cf] has joined #mcdevs
14:51 <+Amaranth> Beyond that limitation the only major problem with java memory use is the fact that people use memory without thinking about it
14:51 < pbunny> my second point - java is interpreted language, so it uses CPU awfully inefficiently
14:51 < Grum> also pbunny, c sucks speedwise
14:51 < edk> java does have a memory problem, it just doesn't really affect chunks
14:51 < Grum> asm is far better
14:51 < pbunny> i.e. single + operation takes about 100 CPU instructions
14:51 < pbunny> etc
14:51 < edk> pbunny: that's not true
14:51 < Grum> erm java is a compiled language
14:51 < edk> pbunny: do you understand what JIT is?
14:51 <+md_5> nope
14:51 < pbunny> Grum: but nobody compiles mc server into binary
14:51  * md_5 head desk
14:51 < Grum> its not compiled to native bytecode
14:51  * md_5 grabs shotgun
14:51 < Grum> pbunny: JIT?
14:51 < pbunny> jit?
14:51 < Grum> seriously within 10 seconds the most important parts of the code are native
14:52  * SinZ hands md_5 a shotgun pellet
14:52 < pbunny> Grum: native to what?
14:52 < pbunny> to java interpreter?
14:52 < edk> pbunny: Java is compiled to JVM bytecode, right?
14:52 <+md_5> no
14:52 <+Amaranth> SinZ: It's called a shell :P
14:52 < Grum> yeah. the piece of a jvm that translate the heavily used calls to nativebyte code from jvm :p
14:52 < SinZ> same difference!
14:52 <+md_5> TO YOUR PROCESSOR
14:52 < edk> pbunny: when the JVM runs it, it generates native code for the platform it's running on
14:52 <+md_5> TO x86 INSTRUCTIONS
14:52 < Grum> this is why java is so hard to benchmark btw
14:52 < pbunny> md_5: what about x86_64
14:52 < Grum> it does that as well
14:52 <+Amaranth> Like gcc -O2 levels of optimization to your CPU
14:52 < edk> it can do those too, obviously
14:52 <+md_5> ok
14:52 < Grum> whatever the host os is on
14:53 <+md_5> now you are just fucking trolling
14:53 < pbunny> still, it compiles it inefficiently
14:53 <+Amaranth> (he knows what gcc is, right?)
14:53 < pbunny> i.e. range checking
14:53 < pbunny> etc
14:53 < edk> not particularly inefficiently
14:53 < pbunny> no memcpy analogues
14:53 < Grum> pbunny: not really
14:53 < pbunny> because you can't operate pointers in java
14:53 < Grum> o.O
14:53 < pbunny> you are not in control of memory
14:53 < Grum> the jvm can
14:53 <+Amaranth> I can bitch about low hanging fruit in the Java optimization world all day
14:53 < pbunny> its all virtualised
14:53 < edk> pbunny: current JVMs are actually rather competitive speed wise
14:53 < Grum> pbunny: yeah it is
14:53 < pbunny> and jvm guesses about optimal memory usage
14:53 <+Amaranth> But it's still incredibly effective
14:53 < Grum> which means i can run it on any system without much troubles :P
14:54 <+md_5> jit can sometimes do better than gcc on trivial cpu bound algorithms
14:54 <+md_5> just saying
14:54 < pbunny> Grum: do you know what a pointer is?
14:54 < pbunny> =[
14:54 < Grum> pbunny: my dick
14:54 < edk> pbunny: do you?
14:54 < Grum> its pointing down because of this discussion
14:54 < pbunny> edk: yeah
14:54 < edk> go on, then: enlighten us
14:54 <+md_5> pbunny do you know what duffs device is? Just curious
14:54 < pbunny> pointers allow for direct operations with memory
14:54 < pbunny> in java you can't directly operate on memory
14:54 < Grum> you can
14:54 <+md_5> sun.misc.unsafe
14:54 < Grum> that YOU do not know how is your problem :p
14:54 < pbunny> i.e. copy 15 bytes of A to B
14:54 <+md_5> m8
14:54 <+Amaranth> Wait wait, this is reminding me of a youtube video
14:54 < pbunny> md_5: yeah, but nobody uses it
14:55 < Grum> pbunny: because it is not needed or portable
14:55 <+md_5> and your point?
14:55 < edk> pbunny: do you know what the C Abstract Machine is?
14:55 < edk> Amaranth: I bet I know what it is
14:55 < pbunny> Grum: so, everybody codes in OOP that is then mapped to memory operations by JVM which is not smart
14:55 <+Amaranth> https://www.youtube.com/watch?v=bzkRVzciAZg
14:55 < l4mRh4X0r> "You can't use pointers in java"
14:55 < pbunny> so memory is used inefficiently
14:55 <+Amaranth> edk: You do know what it is :D
14:55 < l4mRh4X0r> "So you can, but nobody uses it, so my point is still valid"
14:55 < l4mRh4X0r> That's not how life works, pbunny.
14:55 < edk> once more, with feeling
14:55 < edk> pbunny: do you know what the C Abstract Machine is?
14:56 < pbunny> yeah
14:56 <+md_5> This troll has been fed so much I'm surprised he hasnt exploded
14:56 <+Amaranth> md_5: This is helping me stay awake :D
14:56 < pbunny> md_5: im not troll. i'm a minecraft server developer
14:56 <+md_5> pbunny yeah me too, I googled it about the same time as you
14:56 < edk> pbunny: so you know you can't directly operate on memory in C
14:57 < pbunny> edk: i can tell it how to operate it accurately though
14:57 < pbunny> i.e. take something frmo here, write here
14:57 <+Amaranth> Ooh ooh can we talk about segments and FAR pointers now?
14:57 < l4mRh4X0r> Amaranth, if you want to :)
14:57 < edk> pbunny: if you're copying, your code is probably inefficient :)
14:58 < pbunny> edk: ...
14:58 < pbunny> edk: what is inefficient in memcpying the item when you drop 1 of the stack?
14:58 < pbunny> then assigning the quantity
14:59 < pbunny> ( memcpying the part without quantity )
14:59 <+md_5> Pbunny have you ever worked as a programmer?
14:59 < edk> well, for that case you should just use struct assignment
14:59 < pbunny> in java, you would probably use some Class, ClassFactory or ClassIndustrialSector
14:59 < pbunny> for that 
14:59 < Grum> Amaranth: epic
14:59 -!- Yoshi2 [~chatzilla@xdsl-78-35-205-16.netcologne.de] has joined #mcdevs
14:59 < pbunny> edk: lol.
14:59 <+Amaranth> Grum: ?
15:00 < pbunny> edk: you do understand that struct assignment assigns pointer to another pointer?
15:00 < edk> I would, if that weren't bullshit
15:00 < edk> go learn C
15:00 < pbunny> LOL.
15:00 <+md_5> Brain cells... Facing
15:00 <+md_5> Fading
15:00 < pbunny> edk: oh, you mean non-pointer struct?
15:00 < pbunny> i don't have those
15:00 < pbunny> and assigning those is still memcpy
15:00 <+Amaranth> Grum: If you mean the youtube video just remember "You may recall sequential code, that's the code you can read" and smile :)
15:00 <+md_5> Don't make as embarrass you in ##c again
15:00 < edk> md_5: he got banned from there
15:01 <+md_5> Why?
15:01 < pbunny> edk: no.
15:01 <+md_5> Lmfao
15:01 < pbunny> i just joined there
15:01 <+Amaranth> Stack allocation. Still memcpy. Is this guy real?
15:01 < Grum> Amaranth: yeah the video is epic
15:01 < edk> ok, quieted*
15:01 < pbunny> Amaranth: no, stack allocation is malloc :)
15:01 < edk> oh god
15:01 <+Amaranth> Ow.
15:01 <+Amaranth> This is physical painful.
15:01 <+md_5> Wha
15:01 <+Amaranth> My brain cannot take it anymore.
15:02 < Grum> pbunny: it really doesn't matter what you say, c is a shitty language to work with in these days
15:02 < pbunny> **:57:16 freenode  -- | ##c q *bunny*!*@* Zhivago!~lys@unaffiliated/zhivago 1366282232
15:02 <+md_5> Am I missing something or are you retarded
15:02 < pbunny> edk: no, they just don't like bunnies there
15:02 < edk> pbunny: yeah, that was for you
15:02 < pbunny> no.
15:02 < Grum> haha
15:02 < edk> I saw Zhivago do it, you evolutionary cul-de-sac
15:02 < pbunny> edk: logs please.
15:02 < edk> one sec
15:04 < edk> https://gist.github.com/edk141/1ebab643b3cb5763b533
15:04 <+md_5> You are a moron
15:04 < SinZ> You only just worked that out?
15:05 <+md_5> Do you know what clang is?
15:05 < pbunny> aah, just some morning trololo there
15:05 < pbunny> nothing serious
15:05 < edk> there was I attributing it to your lack of functioning brain cells
15:05 <+md_5> Do you know what clang is?
15:05 < SinZ> shame tk is afk
15:05 < pbunny> md_5: a sound of metallic instrument?
15:06  * md_5 cries
15:06 < pbunny> :)
15:06 < pbunny> of course i know what it is
15:06 < pbunny> gcc is superior to it
15:06 <+md_5> /
15:06  * SinZ looks for a sturdy piece of rope
15:06 <+md_5> Tk get it over and ban
15:07 < pbunny> why?
15:07 <+Amaranth> He isn't entirely wrong there at least
15:07 < pbunny> i'm just having some fun
15:07 < pbunny> fun isn't forbidden here, is it?
15:07 < SinZ> so was the person robbing a bank
15:07 <+Amaranth> So when we back him into a corner he starts saying it's all a joke
15:07 < pbunny> not all
15:08 -!- BizarreCake [~BizarreCa@46.121.251.157] has joined #mcdevs
15:08 < edk> where have I seen that before...?
15:09 < pbunny> **:57:32         Grum | pbunny: it really doesn't matter what you say, c is a shitty language to work with in these days
15:09 < pbunny> please back this statement up with something
15:09 < pbunny> most of linux userspace is in C
15:09 < pbunny> linux kernel is in C
15:09 < pbunny> would it be better if it was in java? (lol)
15:09 < Grum> yes, and how many people use linux?
15:09 < pbunny> Grum: 80% of clever people
15:09 < edk> lol
15:09 < pbunny> others use BSD
15:09 < ShaRose> pbunny a lot of programs run java
15:09 < Grum> ok wait
15:09 < edk> C is a good choice for writing kernels
15:10 < pbunny> edk: why?
15:10 < Grum> so 40% of the people uses linux?
15:10 < edk> therefore it's good for every single other purpose
15:10 < edk> amirite?
15:10 < Grum> god tell this to linus
15:10 < pbunny> Grum: not 40%
15:10 < SinZ> We really need to have more people with op in here
15:10 < pbunny> only 1% of people can be considered clever
15:10 < pbunny> so its 0.8%
15:10 <+Amaranth> C is a great choice for plumbing, whether you should use it for "apps" depends on the situation
15:10 < edk> you're not one of them
15:10 < pbunny> however, we don't need to bother about others
15:10 < pbunny> Amaranth: a server is not just "an app"
15:10 < pbunny> especially if its server not for distribution
15:10 <+Amaranth> Grum: Actually a large portion of the world does use linux
15:11 < pbunny> server's requirements are similar to kernel's
15:11 < ShaRose> servers
15:11 <+Amaranth> Android and all
15:11 < Grum> pbunny: yes 40%; 80% of smart people -> based on IQ scales; 50% of the population is below average and 50% is above; therefor you can call this 50% above 'smart' (compared to the other half) -- so 80% of the smart people means 80% of the 50% ... which is 40% of all people
15:11 < pbunny> Grum: lol, IQ means nothing
15:11 < SinZ> its what defines it
15:11 < pbunny> its just ability to solve typical riddles
15:11 < Grum> you are talking about smart, i'm just putting a metric next to it
15:11 <+md_5> Pbunny, so assembly, forth or lisp for next server?
15:11 < pbunny> i.e. you can pass the test 10 times and your IQ will be higher every time
15:11 < pbunny> does it mean you become smarter?
15:11 < Grum> but anyways, you are retarded to code in c
15:11 < Grum> you should be coding in asm
15:11 < pbunny> md_5: C
15:12 < Grum> its fucking faster
15:12 < pbunny> Grum: asm takes long time to code
15:12 < pbunny> C does not
15:12 < SinZ> So you are being less efficient
15:12 <+md_5> Uh
15:12 < pbunny> in fact, you can code in C faster than in java
15:12 < ShaRose> C takes more time than java
15:12 < Grum> nah that just means you suck at asm pbunny
15:12 < pbunny> no need for ridiculous OOP, ClassIndustrialSectors etc
15:12 <+md_5> C takes. About 4 times as long to produce quality code
15:12 < pbunny> Grum: no, i just don't have that much time
15:13 < pbunny> md_5: in java you must create a class to do a=1+1;
15:13 < pbunny> that is ridiculous
15:13 <+md_5> Maybe if you actually knew one thing about Java this discussion wouldn't be so bad
15:13 < pbunny> this is then compiled into like 1Mb binary
15:13 < pbunny> which uses 1Gb of RAM
15:13 <+md_5> .......
15:13 < ShaRose> lol wut
15:13 <+md_5> There is a java 4k competition
15:13 < Grum> pbunny: you must be the most clueless smart person on the planet
15:13 < SinZ> pbunny: are you by any chance a creationist?
15:13 <+md_5> 4kb java games
15:13 <+md_5> Some are amazing
15:14 < pbunny> SinZ: what is it?
15:14 < SinZ>  
15:14 < ShaRose> how old do you think the earth is
15:14 < Grum> pbunny: i know this is a stupid question, but how old are you?
15:14 < Grum> we need some perspective
15:14 <+md_5> 12 or surfing
15:14 <+md_5> Something
15:14 < pbunny> md_5: there was a 64Kb FPS once that had textures and other stuff packed extremely dense
15:14 < pbunny> and it was a binary
15:14 < Calinou> lol programming language talk
15:15 <+md_5> 64kb is massive
15:15 < Calinou> let's make a more interesting debate instead: 0-indexed vs 1-indexed
15:15 < Calinou> pbunny: kkrieger
15:15 < pbunny> md_5: for a FPS with quake-like graphics it is not
15:15 < pbunny> Calinou: maybe
15:15 < Calinou> not packaged, generated
15:15 < Calinou> md_5: go update zombe :3
15:15 <+Amaranth> pbunny: That is procedurally generated, not packed
15:15 < Grum> pbunny: url?
15:15 < Calinou> and it fits in 96k and not 64k
15:15 < Grum> did you ever even play quake pbunny? :D
15:15 < Grum> the oldskool 'normal' quake :)
15:15 < Calinou> Grum plays Q4, we know
15:15 <+md_5> Not old enough to have
15:16 < Calinou> lol
15:16 < pbunny> ok 96kb
15:16 < SinZ> I regret not getting popcorn
15:16 < Calinou> KB, not kb
15:16 < pbunny> Grum: sure, and i can rape your ass in it
15:16 < pbunny> :p
15:16 < ShaRose> SinZ I don't regret getting it
15:16 -!- Calinou [~Calinou@unaffiliated/calinou] has quit [Quit: Excess Flood]
15:16  * ShaRose actually DID go get popcorn
15:17 < Grum> pbunny: not when i was at my best hehe
15:17  * SinZ gets popcorn while SinZ still can
15:17 < pbunny> Grum: what happened now?
15:17 < pbunny> brain java?
15:17 < Grum> we're 20 years later? ;)
15:17 < pbunny> i'm not that young too
15:17 < pbunny> im in ut2004 now though
15:17  * ShaRose is 22, never played quake
15:17 < Grum> but i actually used to go to eu tournaments for quakeworld :P
15:17 < edk> pbunny: this is a 1MB binary, right? https://gist.github.com/edk141/5ae51b5c2d2720646db1
15:18 < pbunny> edk: i meant compiled binary.
15:18 < Grum> so long ago hehe
15:18 <+Amaranth> That is compiled :D
15:18 < ShaRose> that is a compiled binary dumbass
15:18 < Grum> someone like him a minecraft_server.exe orso >.>
15:18 < Grum> (link
15:18 < pbunny> compiled binaries aren't usually called *.class
15:18 < edk> java ones are
15:18 < pbunny> they are executables
15:18 <+Amaranth> ...
15:18 < ShaRose> yes they are
15:18 < ShaRose> lol
15:18 < Grum> pbunny: .exe right? ;)
15:18 < pbunny> you can't just execute a class.
15:18 <+md_5> .....
15:18 < ShaRose> ... yes you can
15:18 < edk> yes I can
15:18 <+md_5> Yes you can
15:18 < ShaRose> are you really that dumb hahaha
15:18 < pbunny> u sure?
15:19 < edk> yes
15:19 <+Amaranth> Especially on linux you can
15:19 <+md_5> Java that program.class
15:19 < Grum> yes; java foo
15:19 < Grum> done! :p
15:19 <+md_5> Yeah
15:19 <+md_5> Retard
15:19 < pbunny> Grum: execute with java != execute
15:19 < pbunny> ...
15:19 <+Amaranth> I'm trying to remember the feature
15:19 < ShaRose> .... EXECUTE with java
15:19 < pbunny> you can't just do ./test.class
15:19 < pbunny> without java installed
15:19 <+md_5> .....
15:19 <+md_5> Are
15:19 < Grum> you mean getting a standalone executable?
15:19 <+md_5> Yoiu
15:19 < Grum> you should be more clear with what you want ;)
15:19 < pbunny> Grum: YES.
15:19 <+Amaranth> You can, if you set it up. I mean, obviously you need java installed
15:19 < Grum> pbunny: but i can run it on any system that has java
15:20 <+Amaranth> You can't run your C app without libc installed
15:20 <+md_5> You can't do that without c stdlib either
15:20 < Grum> oh wait your shitty crapshit cant
15:20 < pbunny> Amaranth: well i meant non-java binary executable.
15:20 < pbunny> machine-code executable.
15:20 < pbunny> is it clear now?
15:20 <+md_5> You are fucked
15:20 < Grum> pbunny: java is not machinecode? O.o
15:20 <+md_5> Also suddenly gcj
15:20 < Grum> but i really do not see any issue :p
15:20 < ShaRose> pbunny is so dumb I don't even know
15:20 < pbunny> md_5: which produces 1Mb binaries.
15:20 <+Amaranth> Oh yeah, quick, run it through gcj :D
15:20 < pbunny> Grum: java is not machine code.
15:20 < pbunny> processors doesn't operate java yet.
15:20 <+Amaranth> I'm sure it'll make something horrible
15:20 < Grum> that is what i said O.o
15:20 <+md_5> TkTech: ban please
15:20 <+md_5> Pbunny yes they do
15:20 < Grum> nah dont ban
15:20 < ShaRose> no don't
15:21 < Grum> just ignore it :P
15:21 < ShaRose> he's hilarious
15:21 < pbunny> ban md_5 
15:21 <+md_5> You can get some that do
15:21 < pbunny> he's boring
15:21 <+Amaranth> Actually you don't want a processor that runs java bytecode directly
15:21 < Grum> pbunny: you've wasted so much time you should have been typing asm meanwhile, you could have had a WAY faster codebase
15:21 < ShaRose> whenever I'm down I can just stop and think "At least I'm not as deluded as pbunny is"
15:21 < edk> :D
15:21 <+Amaranth> The JIT does a _lot_ of optimization to make java bytecode run efficiently
15:21  * SinZ has popcorn now
15:21  * dx walks in
15:21 <+Amaranth> You wouldn't want all of that hard coded in a CPU or in the CPU microcode
15:22 <+md_5> http://en.m.wikipedia.org/wiki/Java_processor
15:22 < dx> oh god what the hell guys
15:22 < pbunny> Amaranth: it isn't smarter than good programmer though
15:22 < ezdiy> awww
15:22 < pbunny> it doesn't have intellect.
15:22 < ezdiy> is it java is retarded again?
15:22 < pbunny> its just an algorithm
15:22 < edk> I bet it's a lot smarter than you
15:22 < pbunny> ezdiy: it is always retarded.
15:22 < ShaRose> .m
15:22 < dx> ezdiy: yeah, seems like it
15:22 < ShaRose> >:(
15:22 < jast> fortunately most programmers are stupid, too
15:22 < ezdiy> i skipped that show lately
15:22 < ezdiy> is there something new to the plot?
15:22 < dx> i'm mostly annoyed because i see Grum and Amaranth are here, wasting their time
15:22 < Grum> btw pbunny, why don't you write your code in hardware? why not just make it silicon directly?
15:22 < jast> few programmers know the intricacies of cache lines by heart
15:22 < Grum> WAAAY faster
15:22 < ezdiy> i heard memory hog argument is irrelevant now
15:23 < Grum> dx: I'm working on minecraft meanwhile ;)
15:23 < pbunny> Grum: takes more time.
15:23 < ezdiy> since ram is cheap and abundant
15:23 < jast> not to mention for each common architecture
15:23 < Grum> pbunny: as does coding c :)
15:23 <+Amaranth> I'm watching a dota 2 stream :D
15:23 < pbunny> ezdiy: not for minecraft server.
15:23 < pbunny> java is the reason they have to unload chunks
15:23 < Grum> no
15:23 < ezdiy> pbunny: why?
15:23 < dx> man, seriously
15:23 < pbunny> which destroys the persistence of the world
15:23 < Grum> sanity is the reason we unload chunks :)
15:23 < ShaRose> no they unload chunks because it's sane
15:23 < ezdiy> pbunny: i keep all the chunks in ram :)
15:23 < dx> we don't need to have this conversation anymore
15:23 < pbunny> ezdiy: how many of them?
15:23 < jast> the reason is that it's... rather special purpose to keep everything loaded
15:23 < ezdiy> pbunny: whole map
15:23 < ShaRose> it's funny though
15:23 < SinZ> dx: we are stalling for tk to ban
15:23 < pbunny> ezdiy: how big is it?
15:23 < edk> dx: we find it fun plumbing the depths of pbunny's idiocy
15:24 < dx> heh
15:24 < Grum> I'm finally overhauling resourceloading in the client right now
15:24 < Grum> so much fun ;)
15:24 < ShaRose> earlier he said a .class wasn't compiled
15:24 <+Amaranth> TIL you do stack allocation in C with malloc
15:24 < SinZ> also, I just cooked popcorn, need to eat it with something
15:24 < Grum> i need something like this to not make my kill myself
15:24 < jast> edk: the word you're looking for is 'enlightenment'
15:24 < dx> edk: yeah actually i did that once, for some reason i'm on the other side today
15:24 < jast> ShaRose: for different values of 'compiled'
15:24 < edk> hehe
15:24 < pbunny> ShaRose: i meant a machine-code executable.
15:24 < dx> edk: mostly because i think it's sad that most of the activity of #mcdevs is this
15:24 < pbunny> not java executable.
15:24 < ezdiy> pbunny: ~40gb
15:25 < pbunny> ezdiy: how many chunks are there
15:25 < l4mRh4X0r> pbunny, hang on then
15:25 < edk> dx: sure, i'd have banned him ages ago
15:25 < ezdiy> pbunny: on disk AND in ram
15:25 < pbunny> ezdiy: on disk?
15:25 <+Amaranth> dx: Mixed in with this we had some neat design and performance discussion
15:25 < pbunny> you said you keep all chunks in RAM
15:25 < ezdiy> pbunny: you still need to save the changes
15:25 < pbunny> ezdiy: world saves?
15:25 < ezdiy> otherwise players throw autistic tantrums
15:25 < pbunny> what
15:25 < ezdiy> well
15:25 < dx> Amaranth: oh nice, thanks for telling me, it doesn't feel so bad anymore
15:25 < edk> i saw a good video about autism
15:25 < pbunny> ezdiy: why is disk needed to save changes?
15:25 < ezdiy> pbunny: electricity goes off
15:26 < pbunny> ezdiy: ah, ok.
15:26 < ezdiy> and poof, every change gone
15:26 < pbunny> ezdiy: so how many chunks are in the map currently?
15:26 < edk> https://www.youtube.com/watch?v=Yng0V0TCl9s
15:26 < ezdiy> no idea too lazy to log in the server
15:26 < pbunny> ezdiy: i just save world periodically
15:26 <+md_5> 30k^2
15:26 < ezdiy> pbunny: whole world?
15:26 <+md_5> 30k^2
15:26 < ezdiy> that oughta be slow on my server
15:26 < pbunny> ezdiy: yeah
15:26 < ezdiy> luckily, even notchian server saves only the changes
15:27 < ezdiy> and notch is exceptionally bad programmer
15:27 < ezdiy> so i guess its just common sense
15:27 <+Amaranth> :/
15:27 < ezdiy> to save things on disk
15:27 <+md_5> I think I'm just gonna leave, this is sad
15:27 < pbunny> ezdiy: i don't have anything against world save
15:27 < pbunny> but disk shouldn't be engaged in normal server operation
15:27 <+md_5> ...?
15:27 <+md_5> .....
15:27 <+md_5> .....
15:27 < pbunny> i.e. read stuff frmo it
15:27 < edk> I googled: that phenomenon when stupid people think they are clever
15:27 < ezdiy> pbunny: world save is just saving changes in bulk
15:27 < pbunny> unload chunks
15:27 < pbunny> etc
15:27 < edk> found it. first result
15:28 < pbunny> ezdiy: yes
15:28 < edk> http://en.wikipedia.org/wiki/Dunning%E2%80%93Kruger_effect
15:28 < ezdiy> pbunny: ok, again, you dont need to unload chunks :)
15:28 < pbunny> edk: are you clever?
15:28 <+Amaranth> ezdiy: Minecraft actually does a lot of things in ways that "common sense" would tell you are not the most optimal but end up actually being such
15:28 < Grum> 15:27:17 < ezdiy> and notch is exceptionally bad programmer  <-- not true
15:28 < ezdiy> Amaranth: trust me, i know
15:28 < pbunny> ezdiy: tell that to TkTech md_5 and Grum  :()
15:28 < pbunny> :)
15:28  * pbunny grabs popcorn
15:28 < Grum> notch is an exceptionally MESSY programmer
15:28 < ezdiy> pbunny: frankly, chunks are unloaded because those are cpu hog
15:28 < dx> "exceptionally bad programmer"? seriously? we have one exceptionally bad programmer here, and notch isn't as bad as him
15:29 < ezdiy> when chunk is loaded, it runs the ticker
15:29 < Grum> also, he has more $ than you have milligrams of bodyweight
15:29 < ezdiy> and there can tick only so many chunks in single thread
15:29 <+Amaranth> Grum: I was trying to segue into saying a mediocre programmer but a good designer :P Messy works too though, that is definitely true
15:29 < pbunny> ezdiy: oh, so you are one of them :(
15:29 < pbunny> you don't understand the problem of chunk unloading
15:29 < Grum> he hasnt designed a single aspect of the codebase
15:29 < Grum> but meh thats what i'm fixing now ;)
15:29 < edk> Grum: appeal to majority, not a good argument
15:29 < edk> not to say you're wrong
15:29 < edk> but arguing fallacies is what pbunny is doing :P
15:29 <+md_5> Did you know processors can run infinite threads at once
15:30 < jast> fallacies are awesome
15:30 <+md_5> That's what makes his threading model so effective
15:30 < jast> I know that because they clearly are
15:30 < edk> md_5: infinite threads = INFINITE POWER!oneoneoneoneoneoneone
15:30 < ezdiy> jast: for persistent trolls indeed
15:30 < ezdiy> :)
15:30 < dx> jast++
15:30 < pbunny> edk md_5 : please stay serious
15:30 < jast> okay, let me make a stronger argument
15:30 < edk> ++jast; // a c++ programmer told me this was more efficient
15:30 < jast> fallacies are awesome because everything else is stupid
15:30 < Grum> fallusies are better
15:30 <+Amaranth> Grum: I was talking more about high level stuff
15:31 < dx> ++(*(&jast)) /* thanks stack overflow */
15:31 < pbunny> **:25:29        +md_5 | Did you know processors can run infinite threads at once
15:31 < pbunny> LOL
15:31 < pbunny> no they can't
15:31 < pbunny> OS can.
15:31 < jast> no it can't
15:31 < pbunny> you can't just feed multiple code streams to a CPU.
15:31 <+md_5> You said that yourself..... back when we first met
15:31 <+Amaranth> Grum: Like chunks, their in memory format, and some other stuff
15:31 < pbunny> md_5: no.
15:31 <+md_5> I'm gonna use each thing in a new thread so it doesn't lag and I get good performance
15:32 < pbunny> lies.
15:32 <+Amaranth> I already know of a minecraft server that started with that idea and then tried to make a real thing out of it
15:32 < Grum> Amaranth: yeah some things are ok
15:32 < pbunny> it was something like: "i'm using a thread for every chunk now for better debugging"
15:32 < Grum> some are semi suboptimal :)
15:32 < dx> write a bytecode parsing virtual machine, make it run every single bytecode in a different thread = infinite performance!
15:32 <+Amaranth> Grum: The networking model is actually good too
15:33 < Grum> not really
15:33 <+Amaranth> The implementation is shit but the model is good
15:33 < Grum> it sucks hard :p
15:33 < Grum> meh not really
15:33 < Grum> has already been improved a ton
15:33 < Grum> (for example for xbox where traffic matters)
15:33 <+Amaranth> I meant the overall sync vs async stuff
15:33 <+Amaranth> Which will probably get me crucified in here
15:33 < dx> Grum: interesting, i'll have to look at the xbox protocol
15:33 <+Amaranth> dx: xbox cheats
15:33 < dx> Amaranth: hm?