- Wren (http://wren.io/): another project by Bob Nystrom, a scripting language written in C with beautifully documented code (I recommend checking it out on GitHub (https://github.com/munificent/wren))
(I didn't check if the links posted here are in the awesome-compilers repo though.)
Edit: I also want to thank OP for continuing part 2. I didn't read part 1 completely because I figured it had a chance to be an abandoned blog post series. Keep it up OP!
Nice article and a good read!
Just came in and read part 2, so please don't blame me if the following has been posted in a comment for part 1 already.
IMHO there are plenty of good books on compiler construction. One of the best ones I ever got my hands on was a book by Niklaus Wirth (a now-retired professor, among other things, he created Pascal, Oberon and other languages). He explains all the details of creating your own compiler from the ground up.
In that book, he is creating a compiler for Oberon, a language that was more or less used for didactic purposes only.
The book is also pretty dated, so there is not much to take away in terms of practically usable compiler code. But I can still recommend it to everyone, because I think it's didactically very good, and provides all the necessary details that make compiler construction so worthwhile (and annoying).
Thanks, my hope is that the Oberon language will not be forgotten.
The Oberon0 language, described in the compiler book, is just a toy to illustrate basic compiler techniques. The full Oberon language is a simple but powerful language, that inspired Go.
I think tcc is now community maintained, see "Savannah project page and git repository", and you can get there link to project git, which was last updated just few days ago. (http://repo.or.cz/w/tinycc.git) so seems to be active.
This is an important result for activities such as Diverse Double-Compiling (a response to the Trusting Trust attack), and as part of the exciting work being done towards bootstrapping a modern Linux environment from source and a hex/assembly base:
I really feel it doesn’t make much sense to generate assembly any longer. It’s much more reasonable to generate IR (for example for llvm). Then you get free optimizations and at least some portability. It’s probably easier as well to not keep track of registers.
As a learning experience I don't think it is a bad thing, though I would generally agree with what you're saying for any new compilers. Really though, writing a new compiler doesn't really make much sense anyway. Adding a frontend to LLVM or GCC would likely give much better results (Though I can't really say which one is easier - writing a dumb compiler for a simple language isn't too hard).
It's also worth noting that his compiler creates an intermediate AST (As any sane compiler should), so it's really not that hard to write multiple backends if he wanted.
but you can actually implement ! in just three lines of assembly
I was actually expecting the "classic" x86 idiom for !, which also happens to be 3 instructions, but is slightly shorter and likely faster than the sequence presented:
neg eax
sbb eax, eax
inc eax
As a bonus, it also works in 16-bit mode (using the 16-bit registers) on everything back to the 8086, since SETcc is 386+, and given that I've seen it in early DOS compiler output, this neg/sbb/inc idiom has likely been known for a very long time. Figuring out how it works is left as an exercise for the reader ;-)
24 comments
[ 3.1 ms ] story [ 72.9 ms ] threadhttps://news.ycombinator.com/item?id=15821899
MOOC/Courses:
- https://cseweb.ucsd.edu/classes/sp17/cse131-a/
- http://cs.brown.edu/courses/cs173/2016/index.html
- https://lagunita.stanford.edu/courses/Engineering/Compilers/...
- http://www.craftinginterpreters.com/
Blog posts:
- An Intro to Compilers (https://nicoleorchard.com/blog/compilers) and the accompanying Hacker news comments (https://news.ycombinator.com/item?id=15005031)
- Resources for Amateur Compiler Writers (https://c9x.me/compile/bib/)
Other resources:
- Tweet (https://twitter.com/munificentbob/status/901543375945388032) by Bob Nystrom (works on Dart VM and creator of Crafting Interpreters) -
- Wren (http://wren.io/): another project by Bob Nystrom, a scripting language written in C with beautifully documented code (I recommend checking it out on GitHub (https://github.com/munificent/wren))
- Ask HN: Resources for building a programming language? (https://news.ycombinator.com/item?id=15171238)
- Mal – Make a Lisp, in 68 languages (https://news.ycombinator.com/item?id=15226110)
Markup ate your Wren source link [1].
[1]: https://github.com/munificent/wren
Your comment made me do a quick Google for "Awesome Compilers"
Sure enough: https://github.com/aalhour/awesome-compilers
(I didn't check if the links posted here are in the awesome-compilers repo though.)
Edit: I also want to thank OP for continuing part 2. I didn't read part 1 completely because I figured it had a chance to be an abandoned blog post series. Keep it up OP!
IMHO there are plenty of good books on compiler construction. One of the best ones I ever got my hands on was a book by Niklaus Wirth (a now-retired professor, among other things, he created Pascal, Oberon and other languages). He explains all the details of creating your own compiler from the ground up.
It's available only here: https://www.inf.ethz.ch/personal/wirth/CompilerConstruction/...
In that book, he is creating a compiler for Oberon, a language that was more or less used for didactic purposes only. The book is also pretty dated, so there is not much to take away in terms of practically usable compiler code. But I can still recommend it to everyone, because I think it's didactically very good, and provides all the necessary details that make compiler construction so worthwhile (and annoying).
To showcase Wirth's approach, I wrote a self hosted Oberon compiler for the JVM: https://github.com/lboasso/oberonc
The compiler can also be used to compile and run the source code of Oberon0 provided in the book, all you need is a JVM installed.
The Oberon0 language, described in the compiler book, is just a toy to illustrate basic compiler techniques. The full Oberon language is a simple but powerful language, that inspired Go.
It has been unmaintained for a while now, but it's still good as a starting point.
Interestingly enough it's a spin-off of a code submission for winning the international obfuscated C code contest (http://www.ioccc.org/).
Original code (covering just a subset of C) can be found here: https://bellard.org/otcc/
http://lists.nongnu.org/archive/html/tinycc-devel/2017-05/ms...
This is an important result for activities such as Diverse Double-Compiling (a response to the Trusting Trust attack), and as part of the exciting work being done towards bootstrapping a modern Linux environment from source and a hex/assembly base:
http://bootstrappable.org/
It's also worth noting that his compiler creates an intermediate AST (As any sane compiler should), so it's really not that hard to write multiple backends if he wanted.
AST are better suitable for the frontend, and even then, they only became a thing after we started having tons of RAM available.
Besides, IR has always been around, it is a requirement for many optimization algorithms.
I was actually expecting the "classic" x86 idiom for !, which also happens to be 3 instructions, but is slightly shorter and likely faster than the sequence presented:
As a bonus, it also works in 16-bit mode (using the 16-bit registers) on everything back to the 8086, since SETcc is 386+, and given that I've seen it in early DOS compiler output, this neg/sbb/inc idiom has likely been known for a very long time. Figuring out how it works is left as an exercise for the reader ;-)It was a really fun project, and I learned a lot from it.