20:35  * Xor_Boole hides
20:35 < Paprikachu> i don't like java, sorry
20:35 < Paprikachu> anyways
20:36 < Xor_Boole> > I don't like java
20:36 < Paprikachu> we don't have to agree on that
20:36 < Xor_Boole> > in a channel full of java devs
20:36 < Grum> too regular? too verbose? too many libraries available? Actual buildsystems that are not so archaic you want to claw your eyes out?
20:36 < Wuppie> i don't like java neither <3
20:36 < Grum> don't get me wrong, there is a lot wrong with java
20:36 < Wuppie> Paprikachu ++ :D
20:36 < Xor_Boole> Grum yes, which is why scala and kotlin are better
20:36  * Xor_Boole runs
20:36 < Grum> there is probably more wrong with c++ :)
20:36 < Paprikachu> GC is a huge issue
20:36 < Paprikachu> the lack of power too
20:36 < Bibl> java build systems make me cry omg
20:36 < Paprikachu> generics are a joke
20:37 < Xor_Boole> ^ I can get behind generics hate
20:37 < Paprikachu> no operator overloading
20:37 < Paprikachu> etc
20:37 < Paprikachu> overuse of exceptions
20:37 < Xor_Boole> no typedef is annoying
20:37 < Paprikachu> ^ that too
20:37 < Xor_Boole> (scala has typedef !!)
20:37 < Bibl> exceptions?
20:37 < Bibl> they r gr8
20:37 < Xor_Boole> exceptions are good. except they'r expensive as fuck because you have to walk the stack
20:37 < Paprikachu> not if you have to litter your code with try-catch
20:37 < Xor_Boole> well the stack frame stack
20:37 < Grum> Paprikachu: so now you are saying that c# is awesome :)
20:37 < Paprikachu> and no, in c++ exceptions are for free on x64
20:37 < Grum> exceptions are fuckign evil
20:37 < Xor_Boole> c# can burn in hell
20:38 < Wuppie> C# <3
20:38 < Grum> hahah exceptions in c++ are the worst kind of hell
20:38 < Paprikachu> and yes exceptions are evil
20:38 < Wuppie> i love c# allot
20:38 < Bibl> c isnt very sharp
20:38 < Xor_Boole> throw new RuntimeException(Grum);
20:38 < Grum> try doing your memory management when an exception and totally fuck up the flow of the code execution
20:38 < Fenhl> throw Xor_Boole;
20:38 < Bibl> mfw not camel case
20:38 < Xor_Boole> throw null;
20:38 < Paprikachu> Grum: that is simply not true
20:38 < Grum> it is?
20:38 < Paprikachu> no, not in modern c++ :)
20:38 < Xor_Boole> Bibl ssssnaaaaakeeee case!
20:38 < Bibl> exception handlers are gay in bytecode tho
20:38 < Xor_Boole> ^
20:38 < Grum> oh and c++ suck so badly that there is barely support to compile the 'latest released version' to production code
20:39 < Bibl> i dont know how else you would do it though
20:39 < Wuppie> Grum C# IS awesome.
20:39 < Paprikachu> Grum: what?
20:39 < Xor_Boole> shut up microsoft pleb
20:39 < Bibl> maybe a new opcode
20:39 < Bibl> and a check
20:39 < Xor_Boole> C# sucks
20:39 < Bibl> and then a goto
20:39 < Grum> Paprikachu: just some shitty reference implementation until the 'real compilers' catch up some months later
20:39 < Bibl> https://github.com/TheBiblMan/CFIDE/blob/master/src/main/org/topdank/cfide/engine/decompiler/asm/MethodNodeDecompilationUnit.java
20:39 < Grum> its hilarious to hear coworkers complain about it
20:39 < Xor_Boole> Grum as in the MCPC/Scrolls people?
20:40 < Paprikachu> Grum: you dont need all of the features, c++11 is pretty good already and supported in all major implementations.
20:40 < Bibl> so much garbage in class files uggghhh
20:40 < Xor_Boole> actually, what's Scrolls written in? native or java?
20:40 < Grum> haha
20:40 < Grum> we're at c++15?
20:40 < Bibl> oh yeah
20:40 < Bibl> im 16 tomorrow
20:40 < Bibl> c++16
20:40 < Xor_Boole> Bibl want garbage in class files? try scala
20:40 < Paprikachu> c++14 is the latest standard, which became an official standard just this month.
20:40 < Bibl> do you need a scala vm to run scala compiled stuff?
20:41 < Paprikachu> before that it was c++11.
20:41 < Bibl> the tables and instructions should be the same in a scala class
20:41 < Xor_Boole> Foo$$anonfun$$1$$doSomething$$anon$$1$$anonfun$$3$$apply.class
20:41 < Bibl> send me a jar that has scala compiled stuff and ill check it with my hacker ide
20:41 < Bibl> o
20:41 < Xor_Boole> legit scala class ^
20:41 < Xor_Boole> scala runs on the jvm
20:41 < Xor_Boole> Bibl just grab the java standard library
20:41 < Xor_Boole> s/java/scala
20:41 < Paprikachu> Grum: i agree that c++'s lack of modules and build systems does indeed suck, but other than that i don't have any major complaints.
20:42 < Bibl> yeah didnt know how you could have more garbage in a class with scala
20:42 < Grum> Paprikachu: header files? :D
20:42 < Bibl> eww
20:42 < Paprikachu> Grum: already said "lack of modules".
20:42 < Grum> hahah
20:42 <+Amaranth> I think they're still calling it C++14 although I believe the final spec didn't make it out until right after 2015 started
20:42 < Grum> seems like such a 'basic' feature not? ;D
20:42 < Xor_Boole> C++ lambda syntax is a joke
20:42 < Bibl> lambdas gay
20:42 < Paprikachu> Grum: it's not that much of an issue really.
20:42 < Bibl> i like verbose
20:42 < Grum> Paprikachu: except for maintainable software
20:42 < Xor_Boole> Bibl http://central.maven.org/maven2/org/scala-lang/scala-library/2.11.1/scala-library-2.11.1.jar
20:42 < Bibl> always
20:43 < Xor_Boole> > lambdas gay
20:43 <+Amaranth> C++ lambda syntax is how you do lambdas in a language with explicit control over memory allocation
20:43 < Xor_Boole> die, you OO pig
20:43 < Paprikachu> Amaranth: it was finalized in august 2014, but it became an official iso standard in january 2015.
20:43 < Grum> anyhow, last word i said on that subject, i give no fuck. Java solves the problems for now without being a bigger problem than the ones existing
20:43 < Bibl> i make objects for the fun of it somsetimes
20:43 < Bibl> sometimes*
20:43 < Xor_Boole> real neckbeards are functional
20:43 <+Amaranth> Concepts should land in C++17, dunno about modules
20:43 <+Amaranth> There is work happening on modules
20:43 < Bibl> i just put in a good for(int i=0; i < Integer.MAX_VALUE; i++)
20:43 < Bibl> new Object(){};
20:44 < Paprikachu> Grum: modules are not needed for maintainable software, but as i said, i will agree that we need them.
20:44 <+Amaranth> iirc GCC has the in progress work on concepts and clang has the in progress work on modules
20:44 < Paprikachu> Amaranth: correct
20:44 < Xor_Boole> Bibl in scala, anon classes have their own types.
20:44 < Bibl> so?
20:44 < Xor_Boole> val anon = new Foo { def bar = 1 }
20:44 < Xor_Boole> the type is Foo { def bar: Int }
20:44 < Xor_Boole> I'm waiting for you to be horrified
20:45 < Bibl> why do you even need that
20:45 < Xor_Boole> Bibl to keep the compiler sane
20:45 < Xor_Boole> not much else
20:45 < Bibl> do you eat cancer for breakfast
20:45 < Paprikachu> Grum: i suggest looking into modern c++, there are some great talks about it. that should at least show you that memory management is a totally solved issue in c++.
20:45 < Xor_Boole> read the spec, and if you come back sane then come ask me
20:45 < Xor_Boole> Bibl no, I had a nice calzone
20:45 < Bibl> whats that?
20:45 < Bibl> it sounds dangerous
20:45 < Xor_Boole> like pizza but not
20:46 < Xor_Boole> Paprikachu > totally solved issue
20:46 < Bibl> thats probably the description ive ever heard
20:46 < Xor_Boole> tell that to rust
20:46 < Paprikachu> Xor_Boole: has nothing to do with memory management.
20:46 < Paprikachu> well, little
20:46 < Xor_Boole> > memory management is a totally solved issue
20:46 < Xor_Boole> > rust is proven memory safe
20:46 < Xor_Boole> > wat
20:47 < Fenhl> > wat
20:47 < Fenhl> this
20:47 < Bibl> cfide took about 5 second to decompile the scala lib thing you send Xor_Boole
20:47 < Xor_Boole> Bibl just five? impressive
20:47 < Xor_Boole> fernflower took forever
20:47 < Bibl> if you want syntax worse than scala i got something for you
20:48 < Bibl> sec
20:48 < Wuppie> brainfuck
20:48 < Wuppie> :D
20:48 < Xor_Boole> jd-gui crashed and procyon just noped
20:48 < Paprikachu> Xor_Boole: i dont really know how to reply to that. the main reason people like GC is because they don't like manual memory management, which we don't even use in c++. everything is automatic as well.
20:48 < Xor_Boole> Wuppie brainfuck is fun
20:48 < Xor_Boole> Paprikachu what are you talking about
20:48 < Bibl> http://hastebin.com/kucutunuca.axapta
20:48 < Paprikachu> Xor_Boole: memory management in c++?
20:49 < Bibl> lmao the sig for setCanBuildFrom is
20:49 < Bibl> <A:Ljava/lang/Object;>()Ljava/lang/Object;
20:49 < Wuppie> welcome back Gurun
20:49 < Paprikachu> many people share the same view of Grum, because they learned c++ a long time ago and didn't look into modern c++.
20:50 < Paprikachu> c++ has changed radically
20:50 < Grum> modern c++ is barely supported and it is still archaic with the problems i described and you agreed to
20:50 < gurun> Java and intellij in combination
20:50 < Grum> it's time for a new language
20:50 < Grum> and not rust.
20:50 < Paprikachu> it's not barely supported.
20:50 < Paprikachu> it's very widely supported.
20:50 < gurun> C# by far the superior language on its own (but with bad editors)
20:50 < Paprikachu> http://www.g-truc.net/doc/C++%20Compiler%20Status%202015-01.pdf
20:50 < Wuppie> gurun ++ :D
20:50 < Paprikachu> here you go
20:50 < gurun> IRC votes C++ with EMACS
20:50 < Grum> C# is getting an intellij-like editor
20:50 < Fenhl> Bibl: wtf is .axapta
20:51 < Paprikachu> check the c++11 table.
20:51 < Bibl> Xor_Boole lmao look at the class explorer: http://i.imgur.com/mbboq5m.png
20:51 < Bibl> dunno
20:51 < Bibl> hastebin auto decides
20:51 < Bibl> but its CFIDEs internal lang
20:51 < gurun> C# has an intellij like editor, it's called Resharper. Without it, i couldn't code C#.
20:51 < Fenhl> Grum: wait. Why not Rust?
20:51 < Grum> Because rust looks like that on the screen
20:51 < Grum> also not data oriented
20:52 < Fenhl> like what?
20:52 < Paprikachu> > uses java
20:52 < Paprikachu> > complains about no data orientation
20:52 < Bibl> omg scala is cancer
20:52 < Bibl> http://hastebin.com/ufapogavos.m
20:52 < Bibl> the method sig
20:52 < gurun> for effecient protoco-hacking, C (with heavy pointer use) win every time
20:52 < Grum> if you make a new language you might as well make it with a proper purpose
20:52 < Bibl> ()Lscala/Function1<TT1;Lscala/Function1<TT2;Lscala/Function1<TT3;Lscala/Function1<TT4;Lscala/Function1<TT5;Lscala/Function1<TT6;Lscala/Function1<TT7;Lscala/Function1<TT8;Lscala/Function1<TT9;Lscala/Function1<TT10;Lscala/Function1<TT11;Lscala/Function1<TT12;Lscala/Function1<TT13;Lscala/Function1<TT14;Lscala/Function1<TT15;Lscala/Function1<TT16;Lscala/Function1<TT17;Lscala/Function1<TT18;TR;>;>;>;>;>;>;>;>;>;>;>;>;>;>;>;>;>;>;
20:52 < gurun> LUA by far the simliest for any already good coder to learn from scratch
20:52 < Bibl> oops
20:52 < Grum> Bibl: who cares what the signature is?
20:53 < Grum> LUA sucks
20:53 < Paprikachu> Grum: and how is rust not data oriented? it lets you write data oriented code.
20:53 < Xor_Boole> Bibl having fun yet?
20:53 < Xor_Boole> where's your god now?
20:53 < Grum> far too many tricks and horrible thing syou can do with it
20:53 < Bibl> i have scissors 2 feet away from me im so tempted
20:53 < Grum> Paprikachu: it's not made to do the things you need to do most efficiently
20:53 < Paprikachu> Grum: so you're in the boat of "powerful tools are bad because someone might misues them"?
20:53 < gurun> ML (SML/UML) win everytime in universty when they want to put all "demi-god coders" that being, on the same level as any newbi
20:54 < gurun> Pascal win on style, for being the forefather of C#
20:54 < Paprikachu> Grum: maybe, but at least you have the option to, same as in c++. in java you just don't.
20:54 < Xor_Boole> also what method is that? is that the currying method for Function18?
20:54 < Grum> Paprikachu: no? I'm just reflecting that i heard a nice talk from someone who knew what he was talking about that no language right now is proper to make games with because it simply doesn't do what is needed
20:54 < Paprikachu> Grum: you mean jonathan blow?
20:54 < Grum> here -- such rant; https://www.youtube.com/watch?v=TH9VCN6UkyQ
20:54 < Grum> yes
20:54 < gurun> Module wins for copying the best from Pascal and C++ and making it into the universities
20:54 < Paprikachu> i've watched some of his videos
20:55 < Grum> he's right
20:55 < gurun> s/Module/Modula/
20:55 < Grum> what we have now just sucks
20:55 < Paprikachu> some of his points are right, some others are based on bad c++ knowledge
20:55 < Xor_Boole> > universities
20:55 < Xor_Boole> we use python here
20:55 < Grum> doesn't matter, the general principle holds, sure you can do some stuff
20:55 < Xor_Boole> fucking casuals
20:55 < Paprikachu> "c++ does X wrong blabla" when in fact he's misinformed
20:55 < Xor_Boole> Fenhl got any popcorn left?
20:55 < Paprikachu> Grum: i don't disagree that a new language is in order
20:55 < gurun> phyton rates just below perl for being the most worthless language you ever learn
20:55 < Paprikachu> but c++ gets the job done at least
20:55 < Grum> but the whole point is that we need to get rid of all the bullshit boilerplate and useless crap and just make something that 'works for the problem we have'
20:56 < Fenhl> Xor_Boole: I have an item dupe, of course I have popcorn left
20:56 <+SpaceManiac> it's amazing how good Lua is on the C side but as a language it's quite odd
20:56 < Paprikachu> i hate lua for the simple fact that it uses 'begin' .. 'end'
20:56 < gurun> I hope everybody that vote for C++ actually undersatnd that you wouldn't be able to use it without M4. M4 IS C++
20:56 < Paprikachu> that's just tedious
20:56 < Grum> Paprikachu: who cares, that is what you have an ide for
20:56 < Paprikachu> it's also ugly imo :D
20:57 < gurun> so M4 is probably the most significant language anyone every inveted
20:57 < Paprikachu> what the hell is m4
20:57 < gurun> Paprikachu, you didn't really believe that #ifdef was part of C/C++ did you :-)
20:57 < Paprikachu> what?
20:58 < gurun> it is what runs all the macros and templates and shit that makes C++ usable
20:58 < Paprikachu> never heard of it, so probably not
20:58 < gurun> guess that is the beuty of it all then. No one every heard of it.
20:59 < gurun> Guess it is a bit like T4 then. It is what drives everything around .NET, but few heard about it or know what it actually does.
20:59 < yawkat> calling M4 the most significant language in the world is a bit of a stretch.
20:59 < Xor_Boole> yawkat correct, that would be scala
21:00 < yawkat> lol
21:00  * Xor_Boole takes yawkat's ball of yarn
21:00  * yawkat runs after Xor_Boole
21:00 < gurun> yawkat, yeah,i know it might not feel like a language. But that is just how "finnish" sounds to the rest of the world, isn't it.
21:00  * Xor_Boole throws the ball of yarn out the window
21:00 < yawkat> im not talking about it being a language, im talking about its significance.
21:00 < Bibl> Xor_Boole send me a birthday present
21:00 < Xor_Boole> Bibl no, fuck off
21:00 < yawkat> its certainly important but not the most important language in the world.
21:01 < Bibl> xor pls.
21:01 < Xor_Boole> you should be giving me offerings for showing you the greatest language ever written
21:01 < gurun> STL?!
21:01 < Bibl> cmon im not asking for much
21:01 < gurun> the template stuff you have
21:01 < Xor_Boole> also I have no money
21:01 < Bibl> send me some love
21:01 < Bibl> in an envelope
21:01 < gurun> but my personal favourite, and the first i ever learned. BASIC.
21:01 < Xor_Boole> Bibl https://gist.github.com/drXor/6867fd9a7d861be54657
21:01 < Xor_Boole> there's your present
21:02 < gurun> 10 NOT VB
21:02 < gurun> 20 REAL BASIC
21:02 < Xor_Boole> the biggest number of consequtive keywords in scala
21:02 < gurun> 30 POKE MY EYE
21:02 < Xor_Boole> 40 GOTO 10
21:02 < gurun> 40 PEEK THE SHOWER
21:02 < Bibl> that kinda hurts
21:02 < Paprikachu> can i submit c++ code for this competition
21:02 < Bibl> very hurtful bestie ;(
21:02  * Wuppie pokes gurun in the eye
21:02 < Xor_Boole> Paprikachu the competition was months ago
21:02 < Xor_Boole> but sure
21:02 < Paprikachu> aw
21:02 < Bibl> tomorrow is a great day
21:02 < gurun> Did anyone mention PHP? Probably not ...
21:03 < Bibl> school has entrance exams so we have the day off
21:03 < Wuppie> i like php gurun
21:03 < Xor_Boole> well, I posted scala and java and no one else gave a shit
21:03 <+Amaranth> Grum: My impression was that blow mostly liked Rust but was against it because it was a "big idea" language and he wasn't sure the idea was right
21:03 <+Amaranth> The big idea being compiler enforced memory safety
21:03 <+Amaranth> iirc his own language even borrows some ideas from it
21:03 < gurun> Lets not forget Ruby, for if it did not exist, we would have all the fantastic tools around refactoring we have today.
21:03 < gurun> (and not to mention that agile would exist)
21:03 <+Amaranth> Although except for the borrow checker most Rust features are borrowed from something else so it's hard to say that was actually his inspiration
21:04 < gurun> So Ruby wins the "most politically influential language award"
21:04 < gurun> Damn, i've heard Rust mention so many times in this channel the last couple of days, i fell forced to try it out :-(
21:04 < Xor_Boole> fuck ruby, it's ugly
21:05 < Xor_Boole> gurun ikr
21:05 < Xor_Boole> I think there's an intellij plugin
21:05 < Xor_Boole> this is fucking annoying
21:05 <+Amaranth> Any language that lets you control memory allocation and layer is a good fit for data oriented design
21:05 < gurun> anything in intellij would be a good language. The best editor ever inveted since vi(m) came out with syntax highlightning.
21:05 < Xor_Boole> Grum tell someone to add a this.setLocationRelativeTo(null) somewhere in the launcher after the bootstrap bit ends, it's off center when it finishes and that bothers me
21:05 <+Amaranth> And Rust leans heavily on composition with its trait system, it doesn't even have inheritance right now
21:07 < gurun> you know, a language that actually needs to tell the parser that "HEY I AM A fn'ction" has some serious problems with ambigutittty (damn word)
21:07 <+SpaceManiac> more like it's explicitly trying to avoid ambiguity
21:08 < gurun> hehe
21:08 < Xor_Boole> gurun def is better
21:08 < Xor_Boole> 'fun' and 'fn' are stupid
21:08  * Xor_Boole glares at Thinkofdeath and kotlin
21:08 < Fenhl> Rust's many sources of inspiration also make it easier to learn imo
21:08 <+Amaranth> Rust is real big on no ambiguous syntax so it can be parsed easily
21:08 < gurun> or all the languages that missinterpreted C function pointers to be "Hey anything i do can be an object"
21:08 < Thinkofdeath> My eyes have a hard time parsing rust
21:09 < Fenhl> like how leaning an indo-european language is fairly easy for most Europeans
21:09 < Xor_Boole> gurun what's wrong with OO?
21:09 < Thinkofdeath> rust seems like a easy to type, hard to read language
21:09 < Xor_Boole> I mean it's an inferior paradigm to functional but it's still pretty good
21:09 <+Amaranth> iirc the only place Rust fails this goal is literal syntax
21:09 < gurun> the guy invented rust must have done C# and fallen in love with lambda .. and decided to use all his skills of javascript to create a lambda language
21:09 < Xor_Boole> I should just go read the rust spec
21:10 <+Amaranth> The whole let foo = ''' It's amazing, you don't have to escape things in here! '''; thing
21:10 <+Amaranth> There isn't a spec
21:10 < Xor_Boole> gurun why does everyone hate lambdas?!
21:10 < Fenhl> Xor_Boole: closest thing to a spec is http://doc.rust-lang.org/reference.html
21:10 < Xor_Boole> List(1, 2, 3, 4).map(_ + 2)
21:10 <+Amaranth> Actually the original Rust was mostly OCaml with Algol/C/C++ syntax
21:10 < gurun> Xor_Boole, i just said he LOVED it :-)
21:10 < Xor_Boole> what's so bad about it =<
21:10 < Fenhl> but if you want to start out http://doc.rust-lang.org/book/ would be better imo
21:11 < Xor_Boole> gurun everyone in this chan seems to hate 'em
21:11 <+Amaranth> The compiler was even written in OCaml back then
21:12 <+Amaranth> I'm sure grayson was aware of C# but I don't think it was an influence
21:12 < Thinkofdeath> Fenhl: tried that a few days ago, still got lost
21:12 < Thinkofdeath> :P
21:12 < gurun> which language was it that had a compiler written in the language it compiled, before the language actually existed?
21:12 <+Amaranth> Most of the fancy C# features are borrowed from functional languages anyway, just like every other language :P
21:12 < Fenhl> Thinkofdeath: yeah if you want to start learning Rust someday I'd suggest waiting until 1.0 releases
21:13 <+Amaranth> gurun: That'd have to be one of the really old ones where it was normal to write machine code or assembler by hand
21:13 < Fenhl> hopefully the guides will be a lot better by then
21:13 <+Amaranth> So they'd have written the compiler then "compiled" it by hand
21:13 < Thinkofdeath> hopefully yeah, it has some pretty big gaps currently :)
21:13 < gurun> Haha, RUST: efficient C bindings
21:13 < Fenhl> sounds like Lisp
21:13 <+Amaranth> gurun: Calling a C function has the exact same overhead as calling that function from C
21:14 < gurun> Amaranth, isn't that like peek and poke stuff in a modern variant then?
21:15 <+Amaranth> Eh?
21:16 <+Amaranth> No it just can speak the C ABI
21:16 < Grum> fn args<'a, 'b, T:ToCStr>(&'a mut self, args: &'b [T]) -> &'a mut Command <-- MY EYES
21:16 < gurun> "threads without data races" doesn't sound like it matches well with "blazingly fast"
21:16 <+Amaranth> gurun: Zero runtime overhead to get that
21:17 <+Amaranth> It's all about the borrow checker
21:17 < gurun> Amaranth, yeah sounds like it has direct memory access and understand how to use it.
21:17 < Paprikachu> Grum: rust is probably not for you then :)
21:17 <+Amaranth> The thing that makes Grum's example look so ugly is the lifetime notation which is required for more complicated borrows
21:18 <+Amaranth> Things the compiler can't automatically reason about
21:18 < Paprikachu> ^
21:18 < Grum> no-one can
21:18 < Grum> that to me is worse than perl
21:18 <+Amaranth> Technically you can get data races or other non-safe things if you do the lifetimes wrong
21:19 < gurun> rust must with the "excellence in hello world speed of development award"
21:19 < dx> uh https://github.com/Aatch/rust-rfcs/blob/master/text/0141-lifetime-elision.md
21:19 <+Amaranth> But most of the time the compiler is able to determine the lifetimes automatically so you don't have to specify them
21:19 < Grum> seems trivial to do wrong if you need that sort of eye-bleech to use it
21:19 <+Amaranth> What dx linked
21:19 < Grum> wtf is 'X ?
21:19 < Grum> what is the quote?
21:19 <+Amaranth> The ' means lifetime and the X is an arbitrary identifier
21:20 < dx> my "uh" expanded: the piece of code grum pasted is in that rfc, exactly the same thing, in one of the expanded examples
21:20 < Grum> lifetime? O.o
21:21 <+Amaranth> Yeah, I see that now
21:21 <+Amaranth> fn args<T:ToCStr>(&mut self, args: &[T]) -> &mut Command is what you can put now
21:21 < Paprikachu> Grum: think of a generic parameter
21:21 < Paprikachu> except it's "kind" is not a type, but a lifetime
21:21 < Grum> a lifetime?
21:21 <+Amaranth> Grum: When the compiler is not able to reason about how long an allocation will live you use lifetimes to give it hints
21:21 < Xor_Boole> something something kotlin is better something something
21:21 < Paprikachu> a scope
21:21 < gurun> SO, this "fn get_mut(&mut self) -> &mut T;" is a simplified version of "fn get_mut<'a>(&'a mut self) -> &'a mut T;"
21:21 < gurun> makes sense
21:21 < Paprikachu> the scope of an object
21:22 < Grum> it cannot detect scopes? wtf
21:22 <+Amaranth> It can, most of the time
21:22 < Grum> where on earth cant it? O.o
21:22 < Paprikachu> it's a generic scope parameter
21:22 < Grum> i guess 'when you know better than you indicate in the code' ?
21:22 <+Amaranth> fn frob(s: &str, t: &str) -> &str;
21:22 < Grum> and let something escape a scope
21:22 < Grum> and then promise to clean it up ?
21:22 <+Amaranth> Right, although you don't actually have to clean it up yourself
21:23 <+SpaceManiac> Grum: if you plan to store a reference to something, you need to know that the reference won't become invalid
21:23 < Paprikachu> it has nothing to do with the compiler not being able to detect anything
21:23 < Paprikachu> it has to do with the code being written in a generic way to work with different kinds of scopes
21:23 < gurun> i feel compelled at writing a serializtion with it..
21:23 <+Amaranth> Paprikachu: Sure it does, the compiler is unable to solve the halting problem so it can't completely reason about your program
21:23 < Paprikachu> now that is even less related
21:24 < Grum> I think i am just happy that I have no idea what sort of horrible code you need to write that has those sort of issues
21:24 < Grum> then again, gc handles all that in java
21:24 < gurun> hihi
21:24 <+Amaranth> It's rare to actually need lifetime declarations
21:24 < Grum> so i guess i'd have to use it everywhere
21:24 < Paprikachu> ownership is not actually that hard.
21:24 < Paprikachu> most code is ownership agnostic
21:24 <+Amaranth> That RFC removed like 85% of them in the compiler
21:24 < dx> Grum: well the idea is to not need to do that in the runtime, and guarantee it in compile time
21:25 < Grum> also ... really ... fn
21:25 < Grum> was function THAT long too type?
21:25 < dx> and like Amaranth said, it can't solve the halting problem, so there's a limit to those guarantees
21:25 < Paprikachu> i like fn
21:25 <+SpaceManiac> be glad it's not ML where 'fn' and 'fun' are different things
21:25 <+Amaranth> iirc that RFC combined with the original elision rules removed more than 90% of them in the compiler
21:25 < gurun> SpaceManiac, and none of them actually mean "FUN!"
21:26 < Grum> i dislike abbreviations that are just 'lazy stupid'
21:26 < Xor_Boole> I hate "fn"
21:26 < Xor_Boole> function is too verbose, 'def' is just right
21:26 < gurun> i pity the poor guy at microsoft that feels proud and important about inenting and maintaining F#
21:26 < Paprikachu> i love stuff that saves me typing
21:26 < Grum> YOUR IDE
21:27 < Xor_Boole> gurun tell taht to Searge =p
21:27 < Paprikachu> fn is shorter than space + enter
21:27 < Fenhl> there's an RFC thread that was opened last week where people are arguing about abbreviation
21:27 < Paprikachu> and fun
21:27 < Grum> space+enter?
21:27 < Grum> lol
21:27 < Paprikachu> or whatever youtype
21:27 < Grum> get a good ide
21:27 < Grum> haahaha eclipse user
21:27 < Paprikachu> whatever it is
21:27 < Grum> a proper ide doesnt require any keypress O.o
21:27 < Xor_Boole> Paprikachu good point. we all know all shorter source files == faster runtime anyways. /s
21:27 < Paprikachu> Grum: so how does it complete
21:27 < Xor_Boole> Grum look at me I'm typing with my mouse!
21:27 < Grum> Paprikachu: by just always suggesting something?
21:27 < Fenhl> I dislike IDEs that complete stuff without being told to
21:27 < gurun> ctor, propg .. can it be written any better?
21:28 < Paprikachu> Grum: what if i dont like that
21:28 < gurun> ok, you need a <tab> too
21:28 < dx> a proper ide uses eye tracking as input
21:28 < Fenhl> way too many false positives
21:28 < Xor_Boole> dx ++
21:28 < Fenhl> :D
21:28 < Paprikachu> i dont use automatic auto completion
21:28 < Grum> Paprikachu: you have never used a proper ide then
21:28 < Paprikachu> i find that the auto completion window hides my code below and that's annoying
21:28 < Grum> Paprikachu: so you code tripple as slow as that you could :)
21:28 < gurun> i find that the only keys you need to understand in intellij is alt+enter
21:28 < Paprikachu> Grum: actually, i code pretty fast
21:29 < Paprikachu> and most time is spent thinking anyways.
21:29 < Fenhl> I don't think any good IDEs exist for OS X
21:29 < Grum> yeah you never used a proper ide and you use eclipse
21:29 < Xor_Boole> now, now, ladies, no need to fight over IDEs. unless you use eclipse in which case you deserve to die
21:29 < Grum> Fenhl: intellij is portable obviously
21:29 < Paprikachu> Grum: can you be less condescending
21:29 < Grum> Paprikachu: no
21:29 < gurun> Wuppie, what was the name of the edtior you had on your mac?
21:29 < Xor_Boole> sigh, where's md_5 when you need a netbeans shill?
21:29 < Grum> not about eclipse
21:29 < Wuppie> gurun: Xamarin Studio
21:29 < Grum> netbeans is crap too
21:29 < Grum> far better than eclipse obviously
21:29 < gurun> yeah, that was _mean_
21:29 < Fenhl> Grum: PyCharm is from the intellij family, right?
21:30 < Xor_Boole> Fenhl yes
21:30 < Xor_Boole> I tried it
21:30 < Grum> yes
21:30 < Xor_Boole> it sucks
21:30 < Grum> python sucks
21:30 < Xor_Boole> mostly because python sucks
21:30 < Grum> yes
21:30 < yawkat> you dont really need an ide for python.
21:30 < Fenhl> no that's not it
21:30 < Grum> non-static languages suck ass
21:30 < Xor_Boole> more than Bibl's mom, actually
21:30 < Xor_Boole> Grum ++
21:30 < gurun> PhpStorm makes PHP actually .. readible.
21:30 <+Amaranth> Python is my go to scripting language
21:30 < yawkat> Grum: any better alternative for scripting?
21:30 <+Amaranth> Although I mostly just use the REPL
21:30 < Xor_Boole> except Mathematica. Mathematica is awesome
21:30 < Grum> i still use perl :D
21:30 < Fenhl> PyCharm is seriously unintuitive
21:30 < Xor_Boole> > perl
21:30 < Fenhl> I don't know what the devs were thinking
21:30 < yawkat> because perl is so much better than python.
21:30 < Xor_Boole> >>>>>>>>>>> perl
21:30 < gurun> it can even tell you what type your variables are (since the PHP guys wouldn't have a clue themselves)
21:30 < Grum> nah
21:31 < Xor_Boole> >>>>>>>>>>>>>>>>>> perl
21:31 < Xor_Boole> wat
21:31 < Grum> perl just get the job done for me
21:31 < Xor_Boole> I can't stand perl
21:31 < yawkat> so does python.
21:31 < Fenhl> you can't just write a program in java and call it portable
21:31 < Xor_Boole> they only time I touch it is to write macros for irssi
21:31 < Grum> Fenhl: you kinda can for most things you do
21:31 < gurun> perl is one of these amazing languages that won't allow you to write bugs.
21:31 < gurun> it is simply impossible to allow bugs in perl.
21:31 < Fenhl> Grum: yeah but then it does weird things I as an OS X user am not expecting
21:31 <+Amaranth> gurun: Because it's impossible to write anything? :)
21:31 < Xor_Boole> fuck perl
21:31 < Xor_Boole> Amaranth ++++
21:31 < dx> i learned perl after having learned python. it wasn't too terrible
21:31 < gurun> Amaranth, no, because it is impossible to come back and fix them.
21:31 < Fenhl> Grum: see also the F11 bug in Minecraft
21:32 < Wuppie> Fenhl finally another OS X user
21:32 < Xor_Boole> I use OS X!
21:32 <+Amaranth> Also I find it amusing that Grum calls Rust a write only language then uses Perl :D
21:32 < Wuppie> Xor_Boole :-)
21:32 < gurun> haha, rust is a winner then :-)
21:32 < Xor_Boole> Amaranth what's wrong with write-only languages? you don't need to ever worry about what you wrote!
21:32  * Xor_Boole hides
21:32 < Fenhl> :D
21:32 < gurun> even php and phyton feels "structured" in comparison to rust
21:32 < yawkat> yea, bugs dont exist in rust anyway!
21:33 < Xor_Boole> php doesn't deserve to be mentioned
21:33 < gurun> On all pages of rust, i think the only truth is this: In theory. Rust is a work-in-progress and may do anything it likes up to and including eating your laundry.
21:34 < Wuppie> yes
21:34 < Wuppie> thats why im scared of rust, it will eat my laundry
21:34 < Fenhl> to be fair, Rust has never eaten my laundry
21:34 < Fenhl> as far as I know
21:34 < dx> i've lost a sock last week
21:34 < dx> it might have been rust
21:34 < gurun> hmm, maybe you should ask your mother, she might now?
21:34 < Xor_Boole> dx no it was Thinkofdeath 
21:34 < Xor_Boole> he likes socks
21:35 < gurun> i lost my pride last friday, and it wasn't the laundrary or rust stealing it.
21:35 < Xor_Boole> gurun did you check the dumpsters out back?
21:35 < Xor_Boole> pride and dignity tend to get lost there in my dorm
21:36 < Grum> Amaranth: i hate perl
21:36 < Grum> I just know it very well and it meshes nice with what i want from it
21:37 < Fenhl> I only know Perl as the language with 9001 operators
21:37 < gurun> Xor_Boole, i think it was my wife that took it :-(
21:37 < gurun> 9001?
21:37 < Fenhl> maybe I should take an actual look at it sometime
21:38 < Xor_Boole> Fenhl scala has more
21:38 < Fenhl> gurun: figuratively. As in, over 9000
21:38 < gurun> :-)
21:39 < Fenhl> hm. Is there no periodic table of Scala operators? :(
21:39 < Xor_Boole> Fenhl no point
21:40 < Xor_Boole> def %%%=> : Foo = ...
21:40 < Xor_Boole> there, another operator
21:40 < Fenhl> stdlib operators then
21:40 < Xor_Boole> not that many then
21:40 < Xor_Boole> pretty much just java ops
21:40 < Xor_Boole> pls :: and /: (cons and fold)
21:41 < Fenhl> I like this one for Perl http://glyphic.s3.amazonaws.com/ozone/mark/periodic/Periodic%20Table%20of%20the%20Operators%20A4%20300dpi.jpg
21:41 < Xor_Boole> also =>, <-, and # (keywords), and <:< and =:= (type operators)
21:43 < dx> it doesn't call <=> "spaceship operator", terrible list
21:44 < Xor_Boole> and I thought the lisp people were insane
21:51 < Grum> yay, build process now snowmanifies! =D
21:52 < Xor_Boole> Grum I'm a proguard noob, exactly what is being snowmanified?
21:52 < Xor_Boole> identifiers or something else altogether?
21:53 < Grum> jikes, that didn't work ;(
21:53 < Grum> wtb errors! fuckers :P
21:53  * Xor_Boole walks away slowly
22:00 < Wuppie> *snowmanifies*
22:00 < Wuppie> lol
22:01 < Grum> ah! i failed myself :)
22:01 < dx> does rust allow ☃ in names?
22:02 < Grum> probably not, rust sucks
22:02 < dx> or, to put it differently: is rust a decent language?
22:02 < Grum> (it better not)
22:02 < dx> :D
22:02 < Xor_Boole> wow such hate
22:03 <+SpaceManiac> it doesn't
22:03 < dx> :(
22:03 < Bibl> back
22:04 <+SpaceManiac> it requires characters to be in the Unicode categories for identifier start and continuation
22:05 < Grum> https://gist.github.com/grum/673ebecd105543d31170
22:05 < Grum> totally done =)
22:06 < dx> hahah
22:06 <+SpaceManiac> is '☃' supposed to be 'this'?
22:07 < Grum> maybe =D
22:07 < Grum> it is EVERY VARIABLE
22:07 < dx> ☃1 ☃2 ☃3 are three different local variables
22:07 < Thinkofdeath> oh wow, the decompiler listened to that
22:07 < Thinkofdeath> I though they ignored the 'this' entry
22:07 < Grum> i like this obfuscation
22:07 < Grum> Thinkofdeath: you normally do, i do not ;D
22:08 < Thinkofdeath> lol
22:08 < Grum> maybe i should .... dunno
22:08 < Grum> :D
22:08 < dx> oh there's a ☃ without number
22:08 < dx> well fuck
22:09 < dx> also the rest doesn't seem to be deobfuscated
22:09 < dx> Thinkofdeath: i want my money back
22:09 < dx> really though, what's the effect of keepattributes if it's not that?
22:10 < Thinkofdeath> innerclasses, throws (I think that was included) 
22:10 < Thinkofdeath> and things like that
22:10 < Thinkofdeath> not needed for runtime but useful when decompiling back to source
22:10 < Fenhl> ☃ without number is obviously this
22:11 < Fenhl> I like ☃ obfuscation
22:12 < MrARM> in-function variable names can be saved? I thought it can't be not stripped
22:12 < MrARM> isn't this a decompiler mod?
22:13 < Grum> yes, i am keeping the information about the type of variables/parameters in the classfil
22:14 < Grum> but i purge the name
22:14 < Xor_Boole> Grum kek
22:14 < dx> \o/
22:21 < Bibl> whats the point of that?
22:21 < Bibl> Why not just ship the jar?
22:21 < Bibl> without obfuscatio
22:21 < Bibl> n
22:22 < dx> it is a mystery, we will never know, don't ask
22:31 < Bibl> can maven submodules not interact with each other?
22:39 < Grum> Bibl: why would we do that?
22:39 < Bibl> i have my eventbus
22:39 < Bibl> and my packet library uses that eventbus
22:40 < Grum> they can, if you add the dependencies to them
22:41 < Bibl> ok
22:54 < Grum> md_5: https://gist.github.com/grum/673ebecd105543d31170
22:55 <+md_5> was just talking about that some place else
22:55 < Xor_Boole> someone's proud of their snowmen
22:58 < Aaron1011> :)
22:58 < Aaron1011> I didn't know Java supported unicode variable names
23:00 < Grum> md_5: can you let me know if you can do without 'this' and 'super' named?
23:01 <+md_5> uh
23:01 < Grum> in theory i could skip renaming those, not sure how hard it is to reconstruct 
23:01 <+md_5> this doesnt affect me at all
23:01 < Grum> kk
23:01 <+md_5> we dont use the LVT
23:01 < Grum> you should now, you have the full typing too
23:01 < Bibl> Grum what do you mean this and super?
23:01 < Grum> exceptions, innerclasses, generics
23:01 <+md_5> not really
23:01 <+md_5> we have no need
23:01 <+md_5> the decompiler can infer types
23:01 < Grum> not generics
23:02 <+md_5> yes but thats not part of the lvt
23:02 < Grum> it is
23:02 <+md_5> thats the class file attributes
23:02 < Bibl> well you can make it analyse generics
23:02 < Grum> no its both
23:02 < Grum> LVTypeT and LVT need to match
23:02 <+md_5> all it cares about is the Signature attribute
23:02 < Grum> that is just for parameters/classes/fields
23:02 < Grum> not locals
23:03 <+md_5> Im sure the decompiler can figure that out too
23:03 < Grum> nope it cant
23:03 <+md_5> point being the naming doesnt worry me
23:03 < Grum> kk
23:03 <+md_5> we have our own naming scheme
23:03 < Grum> good
23:03 < Grum> this will make it into the next release by the looks of it
23:03 < Grum> so nn =D
23:03 < Bibl> md5 do you know how mcp works?
23:07 < Bibl> md_5
23:07 < dx> asking a vague question to a random person
23:07 < dx> bad Bibl, bad
23:08 < Bibl> i saw his name somewhere in a jar shipped with mcp
23:08 < Bibl> its not vagu
23:08 < Bibl> e
23:08 < Bibl> its yes or no
23:09 <+md_5> "yes"
23:09 <+md_5> now what
23:09 < dx> s/vague/terrible/ :D
23:10 < Bibl> what structure/techniques does it use to identify stuff?
23:11 <+md_5> can you be more specific about what you are truing to do
23:12 < Bibl> well i have always had my analysis for binary data as static, so it finds patterns
23:12 < Bibl> eg. for minecraft it would find either strings or patterns of opcodes
23:12 < Bibl> but big updates like 1.8 made it shit itself
23:15 < dx> doesn't mcp just... decompile and remap names?
23:16 <+md_5> Bibl wanna know the secret? The MCP guy works for Mojang and literally has a text file with all the official mappings.
23:16 < dx> lol
23:16 < dx> "secret"
23:16 < Bibl> then why does it take 4 months for an update
23:16 < Bibl> what does that kid do for all that time
23:16 <+md_5> "kid"
23:16 <+md_5> but yeah, no one fully understands why updates take more than 2 days
23:16 < Bibl> he didnt work there before
23:17 <+md_5> he had the mappings before he worked there
23:17 < Bibl> lol wat
23:17 < Bibl> i thought they had some sort of cross binary analysis
23:18 < Bibl> http://hastebin.com/fohurewoyi.avrasm i had this before
23:19 < dx> want some *? here's a few: *******
23:20 < Bibl> same thing happened with my mc bot
23:20 < Bibl> http://hastebin.com/karorusono.avrasm
23:20 < Bibl> thing is, i have eclipse set to auto import when i save the file
23:20 < Bibl> and auto format it
23:20 < Bibl> so it just unpacks .*
23:20 < dx> haha
23:20 < dx> isn't that configurable?
23:20 < Bibl> probably lol
23:21 < Bibl> makes me feel like ive done a lot of work when i see an extra 200 lines in a class
--- Day changed mer. janv. 21 2015
00:53 < Wuppie> Bibl i know the feeling
00:53 < Wuppie> :P
02:07 < Fenhl> Paprikachu: (/¯◡ ‿ ◡)/¯ ~ http://wiki.vg/index.php?title=Protocol&diff=6389&oldid=6385
02:08 < Fenhl> hm… actually that should be worded differently since entities don't *need* to have an EID, right?
02:08 < Wuppie> hello
02:08 < Wuppie> i have a quick question
02:08 < Wuppie> im sending chunk data
02:09 < Wuppie> but the blocks i sent are not the correct ones in the client
02:09 < Wuppie> for example
02:09 < Wuppie> i send block id 7 to the client
02:09 < Wuppie> but the client thinks it is nether brick
02:17 < jython234> Wuppie: you sure you are encoding it correctly?
02:17 < jython234> Wuppie: each block id is two bytes i think
02:17 < Wuppie> Block types, two bytes per block (LE, type = x >> 4, meta = x & 15)
02:17 < Wuppie> so, 1 byte = block id?
02:17 < Wuppie> 1 byte = meta?
02:17 < jython234> yea
02:17 < Wuppie> thats what i do
02:18 < jython234> code snippit?
02:18 < Wuppie> are the network id's different or somethin?
02:19 < jython234> Wuppie: lemme check
02:19 < Wuppie> ok ;)
02:19 < jython234> interesting
02:19 < jython234> your using 1.8 right?
02:19 < Wuppie> yea
02:20 < jython234> Wuppie: can you give me a section of your code?
02:20 < Wuppie> the part where i add the block id to byte] ?
02:20 < Wuppie> byte array*
02:21 < Wuppie> http://hastebin.com/akezovediq.avrasm
02:21 < Wuppie> is where i add the block id to byte[]
02:21 < Wuppie> (currently only adding 1 layer, bedrock only)
02:22 < Wuppie> jython234 there u go
02:22 < Wuppie> oops
02:22 < Wuppie> dont mind the .toarray
02:22 < Wuppie> xd
02:22 < jython234> Wuppie: here i am
02:22 < jython234> looks right
02:22 < jython234> how are you sending it?
02:24 < Wuppie> jython234 http://hastebin.com/ucewexarum.avrasm
02:24 < Wuppie> basically
02:24 < Wuppie> and light and stuff works
02:24 < Wuppie> only problem is that it is not the correct block
02:24 < jython234> Wuppie: wow
02:24 < Wuppie> ?
02:25 < jython234> Wuppie: i have been trying to send chunks for a while now xD Never succeeded
02:25 < Wuppie> haha xD
02:25 < jython234> Wuppie: better with PE protocol
02:25 < jython234> but i can still help
02:25 < Wuppie> this is actually based of PE 
02:25 < Wuppie> :P
02:25 < jython234> nice
02:25 < Wuppie> gurun/niclas helped me
02:26 < jython234> Wuppie: ahh gurun
02:26 < jython234> Wuppie: that code is C# correct?
02:26 < Wuppie> yeah
02:26 < jython234> Wuppie: what I thought
02:26 < jython234> Wuppie: the style of capitalized method names
02:26 < Wuppie> Gurun is a nice guy btw :D
02:26 < jython234> Wuppie: i never said anything about him :)
02:26 < Wuppie> haha i know
02:27 < jython234> Wuppie: well, if you could post a zip on dropbox or something so i could test it out, that would help
02:27 < Wuppie> let me push my updates to github
02:27 < Wuppie> :P
02:27 < Wuppie> or don't you have a .net compiler?
02:28 < Wuppie> jython234
02:28 < jython234> Wuppie: ...
02:28 < jython234> Wuppie: i have visual studio express xD
02:28 < Wuppie> ok xD
02:28 < Wuppie> good enough
02:28 < jython234> Wuppie: might take me a while how to figure out how to compile lol
02:29 < jython234> Wuppie: .NEt a little rusty
02:29 < jython234> mostly work with python and java
02:29 < jython234> hence my name
02:30 < Wuppie> https://github.com/kennyvv/SharpMC-Rewrite
02:30 < Wuppie> don't mind the sloppy code
02:30 < Wuppie> and unorganized project
02:30 < Wuppie> :P
02:31 < jython234> lol
02:31 < Wuppie> xD
02:32 < jython234> May take a while for me to compile
02:32 < Wuppie> jython234 i got time :D
02:33 < Wuppie> jython234 it is only 02:31 AM
02:33 < Wuppie> xD
02:34 < jython234> Wuppie: lol
02:35 < Wuppie> jython234: isn't my code beatifull, ugly and messy? :D
02:35 < jython234> this is not going too well
02:35 < jython234> i cant find my visual studio shortcut xD
02:35 < Wuppie> wait
02:35 < jython234> found it
02:35 < Wuppie> i believe there is a compiled exe in there
02:35 < Wuppie> :)
02:35 < jython234> lol its opening
02:36 < Wuppie> SharpMC-Rewrite/bin/Debug
02:36 < Wuppie> it is compiled already
02:36 < Wuppie> xd
02:37 < jython234> its running
02:37 < jython234> lemme test it
02:37 < Wuppie> please note that most off the stuff is not implemented yet
02:37 < jython234> (while working on a PE client) xD
02:37 < jython234> nah its fine
02:37 < jython234> in fact i like your project
02:38 < jython234> I may want to help :)
02:38 < Wuppie> :)
02:38 < Wuppie> that would be nice :D
02:38 < Wuppie> Help is always welcome haha
02:38 < jython234> Wuppie: no problem xd
02:38 < jython234> Wuppie: 7:37 pm here Xd
02:38 < Wuppie> haha
02:40 < jython234> Wuppie: hm
02:40 < jython234> Wuppie: many unknown packets recevied :)
02:40 < Wuppie> yeah hahah
02:40 < Wuppie> xd
02:40 < jython234> Wuppie: as for the world
02:41 < jython234> Wuppie: i only see about a chunk of nether brick
02:41 < Wuppie> yeah
02:41 < jython234> Wuppie: don't you need to send like 49 chunks?
02:41 < Wuppie> while im sending 7
02:41 < Wuppie> (bedrock)
02:41 < Wuppie> yeah i do jython
02:41 < jython234> all bedrock?
02:41 < Wuppie> the chunk you are seeing
02:41 < Wuppie> SHOULD all be bedrock
02:42 < jython234> thats strange
02:42 < Wuppie> indeed it is
02:43 < jython234> what file has your chunk sending code? the one with the array
02:43 < Wuppie> worlds/flatlandgen.cs
02:43 < Fenhl> the duration of an entity effect is in seconds, right?
02:44 < Fenhl> packet 0x1D
02:45 < jython234> Wuppie: hold on
02:45 < Wuppie> jython234: Sure
02:45 < jython234> Fenh1: maybe ticks, idk
02:46 < Fenhl> jython234: that's not how my nick is spelled
02:46 < Fenhl> (L not one)
02:46 < Fenhl> but yeah, that's why I'm asking
02:46 < jython234> Fenhl: sorry, my font is different
02:46 < jython234> Wuppie: well it just got weirder
02:46 < jython234> Wuppie: apparently changing it to 1 is now coal blocks xD
02:46 < Wuppie> jython234: got skype?
02:47 < Fenhl> jython234: you can usually tab complete to check if you spelled it correctly ^^
02:47 < jython234> Wuppie: nope
02:47 < Wuppie> jython234, ok :P
02:47 < jython234> Fenhl, cool it works!
02:48 < Wuppie> jython234,  isn't it weird?
02:49 < jython234> Wuppie: well
02:52 < jython234> Wuppie: well i found one problem
02:52 < Wuppie> ?
02:54 < jython234> Wuppie: your not sending Map Chunk Bulk in sections
02:54 < Wuppie> im not sending Map Chunk Bulks
02:54 < Wuppie> at all
02:54 < Wuppie> xd
02:54 < jython234> ?
02:54 < jython234> your supposed to
02:54 < Wuppie> i know
02:54 < jython234> it said on the wiki
02:54 < Wuppie> i know
02:54 < jython234> thats strange
02:54 < Wuppie> i just send 1 chunk data packet
02:54 < Wuppie> :P
02:54 < jython234> it said you couldnt spawn without sending map chunk bulks
02:55 < Wuppie> you can spawn without sending any chunks
02:55 < Wuppie> ;)
02:55 < Wuppie> as long as you send the player location
02:55 < Wuppie> and rotation
02:55 < Wuppie> shit
02:55 < jython234> Wuppie: what
02:55 < jython234> Wuppie: didn't send that?
02:56 < Wuppie> didn't send what?
02:57 < jython234> Wuppie: nvm
02:58 < jython234> Wuppie: you should try sending Map Chunk Bulks
02:58 < jython234> send one chunk column
02:58 < Wuppie> i guess i could
02:58 < jython234> i would do that here, but i can't understand your code
02:58 < Wuppie> haha xD
02:58 < Wuppie> told you it was messy
02:58 < jython234> it would take me a while to figure out which file does what xD
02:58 < Wuppie> haha yeah
02:59 < Wuppie> it is a just for fun project anyways
02:59 < Wuppie> xd
02:59 < Wuppie> friend asked me to make it open source
02:59 < Wuppie> so i was like: yeah sure
03:01 < jython234> Wuppie: good
03:01 < jython234> Wuppie: gtg memo me any more questions if you have any
04:26 < Fenhl> http://wiki.vg/Talk:Protocol#Rename_category_to_state discuss
04:27 < dx> sure why not
04:45 < Fenhl> rip irccloud
04:45 < dx> ripcloud
04:46 < dx> 00:26 < dx> sure why not
04:46 < Fenhl> yay big edits :D
11:27 < Paprikachu_> Grum: http://codepad.org/eXLUu0lL
11:27 < Paprikachu_> x)
11:31 < SinZ> I dont see Mojang doing any of that
11:31 < barneygale> Why was grum changing the obfuscation to use a snowman?
11:34 <+md_5> barneygale mainly just to keep the lvt in tact, although the usefulness of that is arguably non in my opinion. As a nice side effect throws clauses will be kept in too which is good
11:35 <+md_5> Paprikachu the only one I agree with is #1, and on that respect I just think the joingame packet should be replaced by the respawn packet and allow the id to be reset on world change
11:35 <+md_5> my only use for that is it eliminates massive packet rewriting hacks
11:36 < barneygale> meh
11:36 < Paprikachu_> md_5: so you agree with #2 as well
11:36 < barneygale> I don't see the point in obfuscation when people deobfuscate everything anyway
11:36 <+md_5> not really
11:36 < Paprikachu_> #2 is about splitting join game
11:36 <+md_5> packet 1 or whatever the login packet is these days should be deleted
11:36 <+md_5> it simply shouldnt exist
11:36 < Paprikachu_> so.. what's the alternative
11:37 <+md_5> http://wiki.vg/Protocol#Join_Game
11:37 <+md_5> http://wiki.vg/Protocol#Respawn
11:37 <+md_5> notice how theyre basically duplicates
11:37 <+md_5> they should just be merged
11:37 < Paprikachu_> no, they shouldnt
11:37 < Paprikachu_> they should be clearly seperated
11:37 < Paprikachu_> because the data has different scopes
11:38 < Paprikachu_> server wide data has nothing to do with world local data
11:38 < Paprikachu_> mixing it is a bad idea
11:38 <+md_5> compre the fields in both of them
11:38 <+md_5> *compare
11:38 < SinZ> JoinGame is just the respawn packet with some padding
11:38 <+md_5> specifically respawn is a subset of join game
11:38 < Paprikachu_> yes, which is why i proposed in #2 that respawn be used in the place of join game and the rest of join game is put into login
11:39 < Paprikachu_> it allows to seperate the process of connecting from the process of entering a world
11:39 < gurun> Paprikachu_, performance of the server. What is your expectations?
11:40 <+md_5> aside from those two items the rest of your suggestions dont really make sense from a mojang perspective
11:40 < Paprikachu_> gurun: for vanilla? pretty low. for my own? 1k should be doable, but i'm aiming for 10k.
11:40 < Paprikachu_> gotta aim high.
11:40 < Paprikachu_> md_5: correct, but they benefit people like me
11:40 < Paprikachu_> :))
11:40 <+md_5> 0 - no one cares about $thirdparty. If you weren't already aware its a closed source proprietry game with only one supported implementation
11:40 < gurun> so, what would you expect from the hardware and wire if running 10k?
11:41 < Paprikachu_> md_5: maybe, not yet.
11:41 <+md_5> 3) breaking change for no reason, "devs might get it confused" is a silly justification
11:41 < SinZ> Paprikachu_: you aren't the first to ask for this stuff, and you probably wont be the last
11:41 <+md_5> 4) None of your arguments really  make sense, especially a)
11:42 < SinZ> Mojangs stance is, if it doesn't help vanilla, why bother
11:42 <+md_5> 5) just... no the whole engine is centered around 20tps
11:42 < Paprikachu_> md_5: of course it makes sense, i've implemented packet handling by hand and went for option 3.
11:42 <+md_5> 4 is the same thing as 3 as well, breaks everything for no reason
11:42 < gurun> Paprikachu_, i mean - i'm running 160 users on PE (don't expect PC to be much different). Only 160 users and hey are filling up the wire with 200mbit/s.
11:42 <+md_5> good for you and your sample size of one
11:42 <+md_5> gurun dafaq
11:42 <+md_5> PC isnt nearly that bad
11:43 < gurun> why. it is just move packages?!
11:43 < Paprikachu_> md_5: it's a provable matter of fact that efficient packet handling must work this way.
11:43 <+md_5> not if you have any sane socket engine
11:43 < Paprikachu_> this is not about libraries vs user code.
11:43 < gurun> out of 40.000 packets sent, only 4000 is ack. And the rest is basically just moves.
11:44 < Paprikachu_> it's about what happens whereever the packet handling is done, and how it is done.
11:44 <+md_5> gurun shitty udp reliabilty layer acking each packet rather than a sequence?
11:44 < barneygale> Paprikachu_, I'd agree with the fixed-size packet header stuff if it doesn't cost too much bandwidth
11:44 < Paprikachu_> barneygale: insignificant, 12KB/s for 100 players
11:44 <+md_5> well its not getting changed now, that part of the protocol is set insane for the forseeable future
11:44 <+md_5> *instone
11:44 < barneygale> two words
11:45 <+md_5> yes I know
11:45 < gurun> md_5, you are missing the point. The sheer amount of moves sent by 160 players is already enough for the solition to crumble.
11:45 <+md_5> gurun which solution? I think were confusing two different chats
11:45 < Paprikachu_> gurun: i highly doubt 160 players need 200 mbit. that's more than 1 mbit per player.
11:46 < barneygale> Paprikachu_, to a certain extent I think mojang were wary of simply increasing the size of the packet id (etc) because eventually they might start running low on numbers again
11:46 < gurun> they send 160 updates per player to 160 other players at a rate of 20ms
11:46 < barneygale> which I assume is one of the reasons for the original change
11:46 < gurun> that is a LOT of updates.
11:46 < Paprikachu_> gurun: so 50 ticks?
11:46 < gurun> yes
11:46 < Paprikachu_> well okay
11:46 < Paprikachu_> for vanilla it's 20
11:47 <+md_5> gurun any sane person would have their server cull those updates drastically
11:47 < jast> efficient packet handling? who cares. all the bottlenecks are elsewhere.
11:47 < Paprikachu_> jst: bullshit
11:47 < Paprikachu_> *jast
11:47 <+md_5> if varints are so bad, why is google protobufs designed around them?
11:47 < Paprikachu_> cpu consumption is not the issue, memory allocations are
11:47 <+md_5> not if you have any sane socket engine
11:47 < Paprikachu_> go away with that stupid argument
11:47 < jast> so you probably haven't ever heard of static buffers
11:47 <+md_5> protip: read(&buf, 64) is not a socket engine
11:48 < Paprikachu_> jast: i use fixed size buffers and buffer caching.
11:48 < jast> and, you know, block allocators and shit
11:48 <+md_5> bitcoin is another example I can think of
11:48 <+md_5> but ProtoBug is definitely the big one
11:48 <+md_5> *uf
11:49 < Paprikachu_> varints in headers are simply inconvenient as f.
11:49 < jast> boo-hoo
11:49 < Paprikachu_> there's a reason no internet protocol uses varints
11:49 < jast> maybe because for TCP and friends it actually matters
11:49 < jast> there are plenty of application-level protocols with variable width fields
11:49 <+md_5> "no internet protocol"
11:49 <+md_5> let me name two right now
11:49 <+md_5> 1) Every protocol based on Google ProtoBufs
11:50 <+md_5> 2) Bitcoin and related blockchain like experiments (bitmessage etc)
11:50 < Paprikachu_> those are application layer protocols.
11:50 < jast> here's an example of a protocol with varints: HTTP
11:50 <+md_5> ....
11:50 <+md_5> are you saying Minecraft isnt application layer
11:50 < jast> and minecraft isn't an application layer protocol, right
11:50 < Paprikachu_> where did i say that?
11:50 <+md_5> <Paprikachu_> there's a reason no internet protocol uses varints
11:50 <+md_5> <Paprikachu_> those are application layer protocols.
11:50 < Paprikachu_> zzz
11:50 < jast> you didn't say that, but then again you destroyed your argument when you didn't
11:51 < Paprikachu_> no, i didnt.
11:51 < Paprikachu_> and http is not exactly an example of a good protocol.
11:51 < jast> "hurr hurr minecraft must have super efficient packets because so do non-application level protocols"
11:51 < jast> "hurr who cares about what other application level protocols do"
11:51 <+md_5> Im pretty sure I can decode upwards of 200k varint frames a second on my hardware anyway
11:51 < jast> HTTP is an example of a _working_ protocol
11:51 <+md_5> as is everything based on ProtoBuf
11:51 < Paprikachu_> jast: except your default standpoint is wrong.
11:51 < SinZ> and probably the most used protocol
11:52 < jast> NO U
11:52 < SinZ> atleast on application layer
11:52 < barneygale> jast, the "hurr" thing is dead patronising (though I agree with you)
11:52 < Paprikachu_> your default is varints, whereas the default is actually fixed ints.
11:52 < jast> barneygale: it was supposed to be
11:52 <+md_5> <Paprikachu_> your default is varints, whereas the default is actually fixed ints.
11:52 <+md_5> says who?
11:52 < barneygale> jast, I didn't think you did it by accident
11:52 <+md_5> The internet gods?
11:52 < jast> the default according to you
11:52 < Paprikachu_> the easier thing is the default, obviously.
11:52 <+md_5> easier == better?
11:52 <+md_5> k
11:52 < jast> I stand by the same point I made in my very first comment: if efficiency is super important, fixed with fields are kind of a good idea
11:52 < Paprikachu_> easier is generally better, yes.
11:52 < jast> in this case it's not super important
11:52  * md_5 switches back to rc4 and md5
11:53 < jast> md_5: crc32 ftw
11:53 <+md_5> check rot13 might be good
11:53 <+md_5> its pretty easy
11:53 <+md_5> s/check/heck
11:53 < Paprikachu_> now you're just making a strawman.
11:53 < barneygale> christ this channel..