And for the curious my favourite brainfuck was code:type: and its senders. Because the first time you read (code: index type: type), you wonder * why you pass a parameter index (that overrides inst var index, but most caller invoke with index inst. var.) * with the key code: * since there is also an inst var named code that's really troubling... Also because there is a cryptic use of negated type on return And once you start analyzing senders, and inst var refs, you're puzzled... To decipher, code:type: answers an encoded bytecode, made from an index (temp index, inst var index etc..) and a type (load inst var, load temp var, etc...) thus its name code... Now, I've contemplated this code too much, and it almost sounds familiar, I can hardly remember how impenetrable it was. But make you a pleasure, put a newbie in front of it. To me, this a a very clever factorisation of bytecode encoding - much too clever - much too obfuscated - and I bet we can do much much clearer with not much more code. But I don't have to prove anything, there is Opal already... 2013/10/16 Stéphane Ducasse <stephane.ducasse@inria.fr>
Too bad :( One of the most brilliant anti-pattern onto which I burnt so many brain cells is gone, how are we going to teach good coding practices by counter examples. ;)
:) We should continue to build the new generation it is more exciting and now I can start to invest in reading the compiler code.
Stef