10 ms·
Show HN: Crafting Interpreters – A handbook for making programming languages
- trishume 10y agoA fantastic book covering similar things that you can read right now is https://pragprog.com/book/tpdsl/language-implementation-patterns https://pragprog.com/book/tpdsl/language-implementation-patt.... It's the book that got me into interpreters and compilers, I highly recommend it. It's slightly less in depth than the roadmap of "Crafting Interpreters", but again, it exists right now.
- agumonkey 10y agoHa yeah, Terence parr is a référence.
- msangi 10y agoI really enjoyed http://gameprogrammingpatterns.com/ http://gameprogrammingpatterns.com/ and I've been looking forward for this book since I saw the link on munificent's homepage
- nickpeterson 10y agoThis looks great, for some reason the idea of creating a language from scratch and then using it in some professional capacity always seemed really cool to me.
- kovrik 10y agoThank you so much for the book, please, continue! I am currently working on Scheme R5RS implementation in Java. It is a hobby project, but I'm really enjoying it. It is somewhat enlightening. Look forward to reading the Optimization chapter: I couldn't find much useful and practical info on that. I think it is quite easy to implement your interpreter, but it is really difficult (at least for me) to make it fast. Can anyone recommend any articles or books with common optimization tricks and techniques?
- agumonkey 10y agoI'm trying to bootstrap a forth and a scheme but i'm still at the thinking phase right now.
- ioddly 10y agoFor making an efficient Scheme implementation: most everything written by R. Kent Dybvig or his students. I'd start with his PHd thesis (Three Implementation Models for Scheme, specifically the stack-based part). http://www.cs.indiana.edu/~dyb/ http://www.cs.indiana.edu/~dyb/ (See also Lua's upvalues for a way to optimize closure variable access that's a bit simpler than his display closures).
- munificent 10y ago> See also Lua's upvalues for a way to optimize closure variable access Yes! In fact, that's how the C version of the interpreter in my book implements closures. It's pretty brilliant. <3 those Lua folks.
- Flow 10y agoWill you cover anything about LuaJIT's "NaN-coding"? Or perhaps do you have a link about how it works?
- munificent 10y agoYes, we'll do NaN-tagged values in the last chapter on optimization.
- munificent 10y ago> Thank you so much for the book, please, continue! I will! > Look forward to reading the Optimization chapter: I couldn't find much useful and practical info on that. There's not too much depth in that particular chapter. The whole second part is really about implementing an interpreter (fairly) efficiently in C. As you probably know, you have to think about performance at every level—your object model, bytecode format, hash table implementation, etc. If you'd like a sneak peek, the code for the entire book is actually done already (!). You can see which snippets go into each chapter cloning the repo[1] then running: make chapters make c_chapters make diffs Then take a look in build/diffs. There are a ton of optimization tricks that are specific to Scheme and Lisps and a lot of literature behind them. Macros and eval make it a lot harder. It's pretty dense, but I liked "Lisp in Small Pieces" a lot. [1]: https://github.com/munificent/craftinginterpreters https://github.com/munificent/craftinginterpreters
- jnbiche 10y agoAnother great-looking book on making dynamic languages. There's been some good ones recently, and this one looks like another good one covering how to make a basic, interpreted language. Some of us have written 1 or 2 dynamic, interpreted languages, feel pretty comfortable with those concepts, and are interested in transiting to more advanced, static type systems and writing a good type checker. Anyone up for writing such a high-quality book as this one on statically-typed languages, ideally functional languages? The only decent books I've found on the subject are 20-30 year-old textbooks. I'm watching "Write You a Haskell" with interest (and have partially read it), even though I'm more into ML and Scala than Haskell, but it's still pretty unfinished. There's also the plzoo, which is a great resource but not a book. Oh, and I definitely need to read Pierce's Types and Programming Languages textbook, I've ordered it and need to sit down with it. I suspect it will be very enlightening. But a more approachable book on statically-typed languages in the same genre as this one is (popular, less academic) would also be welcome.
- johnbender 10y ago> Pierce's Types and Programming Languages Pierce's book is as approachable as you're likely to see with respect to type systems. You mostly just have to dig in.
- jnbiche 10y agoYeah, I suspect you're correct at the moment. In fact, TaPL looks pretty approachable for an academic book. But it seems to be there's a place for a more popular book on type systems and making a statically-typed language, in the vein of this Crafting Interpreters book (and others like it). Perhaps I'll read TaPL, write a nice statically-typed language, and then write the book I'm looking for.
- bbcbasic 10y agoI'm reading TaPL, done 4 chapters. I think you can replace the math with intuitive diagrams and be a little less rigorous and that would be a book for the masses. TaPL requires you to learn a lot between coding sessions too which may put off more practically minded folk.
- GavinMcG 10y agoReally looking forward to this! A much less involved language-building tutorial that's available now is Beautiful Racket.[0] Racket is a Scheme, but it's also specially outfitted to be a language workbench.
- GavinMcG 10y agoAnd 16 hours later: [0] http://beautifulracket.com http://beautifulracket.com
- d0m 10y agoOne question here for the more advanced compiler writers.. How do you go about writing a "pre-lexer" for LISP like language where you want to expand sexpr? I.e. Does the lexer even see `(...), or does it get pre-extracted to (quote ..)? And if so, how does the pre-extraction work exactly? Is it built using regex..? That can be tricky.
- munificent 10y agoThose are handled by the reader. If you Google "Lisp reader" and "Lisp reader macro", you should find a bunch of info.
- kazinator 10y agoLisp dialects usually have an input mechanism called a "reader". It scans the character syntax and produces the equivalent object, combining lexical analysis and parsing. Special notations like 'x denoting the same thing (quote x) are easily handled here. When the reader sees a quote, it consumes it, calls itself recursively to scan the expression which follows to get an object O and then returns the object (quote O).
- peetle 10y ago'Git ta werk. ;)
- mwcampbell 10y agoLooking forward to the chapters about the C interpreter. Meanwhile, it looks like both interpreters are available to study now in the Git repo. [1] [1]: https://github.com/munificent/craftinginterpreters https://github.com/munificent/craftinginterpreters
- munificent 10y agoYes! The code for the whole book is done already and sliced into chapters. I had to do that first before I started putting things online. I didn't want to paint myself into a corner by having something in an earlier chapter that ended up not making sense later. So the code is all done, and now "all" that's left to do is write and edit all of the prose. Which, of course, is really the hardest part by far.
- zengid 10y agoMe too; I'm looking for a way to learn more about building data-structures in C.
- sn9 10y agoHanson's C Interfaces and Implementations [0] is one of the best books on the subject. Strongly complemented by Sedgewick's Algorithms in C. [0] https://www.amazon.com/Interfaces-Implementations-Techniques-Creating-Reusable/dp/0201498413 https://www.amazon.com/Interfaces-Implementations-Techniques...
- zengid 10y agoI added both to my wish-list; Thanks!
- throwathrowaway 10y agoNice project. What do all the //> SomeName not-yet in the code mean? Are they meant for some kind of automatic processing? Its a bit hard to read with all of them there...
- plttn 10y agoJust from reading the first few pages of the book, I'm already a fan. However my one tiny complaint is that the sign-up box is on every page, and even after I've signed up, it still has to be closed every page I go to.
- munificent 10y agoYeah, that is annoying. I think for my previous book, I used a little cookie support in JS to hide it persistently after the first time you closed it. I'll try to resurrect that for this one. https://github.com/munificent/craftinginterpreters/issues/11 https://github.com/munificent/craftinginterpreters/issues/11
- codebeaker 10y agoSeems to be a hot topic, a friend and colleague published this in December 2016 and I can thoroughly recommend it (Uses Go as an implementation language): - https://interpreterbook.com https://interpreterbook.com
- jalfresi 10y agoI bought this when it appeared on HN around xmas, can recommend, its a pretty great introduction to the subject
- bruth 10y agoI can recommend this book as well! It is easy to read and understand and the choice of Go as the host language is also great. I am in the process writing a semi-natural query language (boolean logic) targeted at domain experts (in this case biomedical researchers) that compiles to either database queries (e.g. SQL) or a function call for arbitrary logic. The goal of the compiler bit is to abstract away where the data ultimately lives (similar to GraphQL) or how it is structured.
- munificent 10y agoYeah, I've talked to Thorsten over a email a little. I'm excited about his book too, and I hope it does really well. Go is a cool choice for a language book. It's low-level enough to let you show some of the fundamental algorithms, but not as tedious to work with as C and its manual memory management.
- jonathanstrange 10y agoThis is awesome, since I'm currently working on my own (toy) language! Thanks for making this public! On a side note, to anyone interested in an overview of high-level language features and what their implementation requires, I can wholeheartedly recommend Michael Scott's Programming Language Pragmatics. It doesn't go into implementation details, but tells you a lot about the historical choices and implementation possibilities of (mostly) mainstream languages.
- munificent 10y agoYes! PL Pragmatics was the first book on languages I read and I really enjoyed it.
- Philomath 10y agoThat's so cool! Learning to make a programming language is in my life's todo list, just as doing my own (super simple) operating system. Thank's for contributing with a free book, I very much appreciate it. Does anybody know of something similar but for operating systems?
- iKlsR 10y agoNot quite but this is a good read. https://littleosbook.github.io/ https://littleosbook.github.io/
- Philomath 10y agoThis is good! It will definitely do. Thank you very much!
- chester195 10y agoI found https://www.cs.bham.ac.uk/~exr/lectures/opsys/10_11/lectures/os-dev.pdf https://www.cs.bham.ac.uk/~exr/lectures/opsys/10_11/lectures... from a UK university. I like the style of it and the emphasis on getting started coding straight away.
- szabot 10y agoI clicked the link without looking at the poster, and by the end of the "What’s the Catch?" paragraph I was thinking to myself that this really seems like something written by The Munificent Bob. Then I read the first sentence of the next paragraph :) I really like your blog, I have read all of it, some posts even 2-3 times, and not only because of the content, but your writing style. I will probably read this book too ;) Also, I think Magpie is awesome.
- munificent 10y ago\o/
- zitterbewegung 10y agoI've been reading http://beautifulracket.com/ http://beautifulracket.com/ and its a really good introduction on making interprets.
- wuschel 10y agoI agree. Scheme/lisp based languages and Haskell are a great choice for this kind of project.
- throwaway7645 10y agoInteresting! I like racket...just wish it was faster. Anybody know if there will be a successor to "Realm of Racket"? Edit: Now I remember it uses LGPL as the license. I understand the reasoning, but I've always viewed the freedoms as giving the user freedom over the implementer...kind of just trading power.
- bogomipz 10y agoThis looks great. Thanks for sharing. Looking forward to updates.
- xrayspec 10y agoRacket is also a great environment for making languages. See, e.g.: http://beautifulracket.com http://beautifulracket.com
- whistlerbrk 10y agoA little late to the party here, but I'll throw another tutorial that I absolutely loved, buildyourownlisp.com which guides you to building 'lispy' in C.
- ftomassetti 10y agoOne think I find lacking in books about building languages is a focus on tool. I am working on one (available for 0$ on leanpub: "How to create pragmatic, lightweight languages" https://leanpub.com/create_languages https://leanpub.com/create_languages ) with the intention to focus more on building editors and simulator. If you are interested in the subject you could take a look to my blog (https://tomassetti.me https://tomassetti.me) I write 1-2 posts per week on building languages. Most of the time I talk about DSL.
- dman 10y agoAny pointers to intermediate representations for compilers?