3 ms·

is that actually easier? I know its probably way more efficient in the long run, but i really doubt you could write a bytecode compiler as easily as this was w

is that actually easier? I know its probably way more efficient in the long run, but i really doubt you could write a bytecode compiler as easily as this was written.

bad_user 16y ago
IMHO it is easier because the type system in Java has extra restrictions that the bytecode doesn't have -- for example in bytecode there is no notion of checked exceptions, and variables themselves don't have types, you only need to know the interface of the implicit parameter when calling a method, but not until the call-site. And what you gain by not learning to output bytecode, you lose by writing supporting libs. And the example in the article is too simple. Yes you can translate Scheme to Java easily, until you need to do I/O, or until you need to optimize it such that you could use it for real work. I also don't see any mention of continuations, which are surely part of the Scheme standard, or am I wrong?
sedachv 16y ago
People think real compilers are complicated, but often writing a native code compiler is simpler than writing an interpreter or translator. Abdulaziz Ghuloum has a great paper called An Incremental Approach to Compiler Construction (http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf), which shows how to build a Scheme native code x86 compiler in 10 pages. JVM bytecode isn't that far away from machine code. Another great example of how straightforward compilers can be is the Tiny C Compiler (http://bellard.org/tcc/ http://bellard.org/tcc/).
- bad_user 16y ago
  JVM bytecode isn't that far away from machine code. It is far away in the case the type system is a complete mismatch, like Haskell. Or in the case of Scheme, if you want to have continuations without a huge performance penalty, you've got to put some effort into it. For these instances I've see advices on Lambda-the-Ultimate to just go for native-code, as it is easier to experiment since you have a lot more freedom. That said, building on top of the JVM can have advantages other than being easy to write the compiler.
- spacemanaki 16y ago
  I tried to read through An Incremental Approach but found that it was really too brief. I had questions that I wanted answered but he was briskly moving on to compiling the next Scheme form. I found the first chapter of a longer version from his site, but this seems incomplete. Does anyone know what happened to that? Did it not turn into a book?

is that actually easier? I know its probably way more efficient in the long run, but i really doubt you could write a bytecode compiler as easily as this was written.

bad_user 16y ago

IMHO it is easier because the type system in Java has extra restrictions that the bytecode doesn't have -- for example in bytecode there is no notion of checked exceptions, and variables themselves don't have types, you only need to know the interface of the implicit parameter when calling a method, but not until the call-site. And what you gain by not learning to output bytecode, you lose by writing supporting libs. And the example in the article is too simple. Yes you can translate Scheme to Java easily, until you need to do I/O, or until you need to optimize it such that you could use it for real work. I also don't see any mention of continuations, which are surely part of the Scheme standard, or am I wrong?

sedachv 16y ago

People think real compilers are complicated, but often writing a native code compiler is simpler than writing an interpreter or translator. Abdulaziz Ghuloum has a great paper called An Incremental Approach to Compiler Construction (http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf), which shows how to build a Scheme native code x86 compiler in 10 pages. JVM bytecode isn't that far away from machine code. Another great example of how straightforward compilers can be is the Tiny C Compiler (http://bellard.org/tcc/ http://bellard.org/tcc/).

bad_user 16y ago
JVM bytecode isn't that far away from machine code. It is far away in the case the type system is a complete mismatch, like Haskell. Or in the case of Scheme, if you want to have continuations without a huge performance penalty, you've got to put some effort into it. For these instances I've see advices on Lambda-the-Ultimate to just go for native-code, as it is easier to experiment since you have a lot more freedom. That said, building on top of the JVM can have advantages other than being easy to write the compiler.
spacemanaki 16y ago
I tried to read through An Incremental Approach but found that it was really too brief. I had questions that I wanted answered but he was briskly moving on to compiling the next Scheme form. I found the first chapter of a longer version from his site, but this seems incomplete. Does anyone know what happened to that? Did it not turn into a book?