Introduction to Compilers and Language Design (2021)
dthain.github.io
dthain.github.io
But I still have hope that I will make it. Maybe coding agent will help me but I dont like the idea that I need help from AI to build this. I want to create compilers through my own hands.
Anyway, I hope you will make it anyway. :)
It adds a little bit of complexity (you need to be very clear on how you handle registers) but it worked surprisingly well, and it makes it easy to built up the complexity step by step.
It also meant I could bootstrap the compiler itself with just an assembler.
Sadly I lost the source decades ago.
(Making assembler an integral construct of a higher-level language is also not a unique approach - there's Randall Hyde's High-Level Assembly[1] and others.)
Which is to say: no shame in just settling for that simple C backend!
Not really. I was webdev who then switched into compilers job with LLVM being foundation
LLVM itself is huge, it is not trivial to be familiar with every it's areas/mechanisms, but writing not-complex passes, bug fixing, regression fixing does not require some fancy knowledge
I've been searching for something challenging and found some very random post on programming forums about how compilers are hard etc and decided to give it a try.
I had kind of advantage that I accidentally had some significant amount of experience with handwritten parsers (at first job we were doing custom-markdown-like-language renderer as PoC or even when doing apprenticeship in high school I was rolling out csv parser instead of using libs, because... I'm not sure why, I probably didnt know how to use package manager or something)
I started reading about it a lot like dragon book (but it wasnt that useful tbh, too much math heavy)
or https://www.cs.cornell.edu/courses/cs6120/2020fa/self-guided...
or playlist like this: https://www.youtube.com/watch?v=wgHIkdUQbp0
And after year of jumping into it from time to time I've implemented small, custom-lang to LLVM IR to webassembly (via LLVM) compiler.
Then I had to find new job (we were very poorly paid) and I was interested in semiconductors industry because it was gaining traction (e.g chip war book) and it felt way more engineering oriented unlike web dev. Web dev tech decisions felt for me very religious, like fancy-conferences/blogposts oriented.
And since semiconductor industry often touches compilers, then that was opportunity for: better salary, interesting projects and in future transition to compilers
I've joined semico company as C# dev and then due to project cancellations/lay offs I managed to join compiler team and stress hard during first months since I had to learn new lang, new ecosystem, tools, approaches, techniques (e.g debugging) and only familiar thing was LLVM, which I was very beginner at.
but after that initial shock things were better, but I feel like I still need to improve my knowledge related to modern hardware, modern computer architecture, etc.
Debugging is very, very useful, cross-stack skill :)
Well, there are no universal rules
Sometimes it could make your life easier, sometimes it wouldnt change anything.
It's kinda luck dependent - what companies you apply for, what hiring manager needs at particular moment, etc.
But if your masters program is same length as mine (1.5 year) then if you feel like doing it, then I recommend it because 1.5 year will pass quickly and you'll have decent paper (and hopefully experience, knowledge, skills and networking) :p
From https://craftinginterpreters.com/:
> Crafting Interpreters contains everything you need to implement a full-featured, efficient scripting language. You’ll learn both high-level concepts around parsing and semantics and gritty details like bytecode representation and garbage collection. Your brain will light up with new ideas, and your hands will get dirty and calloused. It’s a blast.
The book is available for free on the website: https://craftinginterpreters.com/contents.html
Introduction to Compilers and Language Design (2021) - https://news.ycombinator.com/item?id=31388741 - May 2022 (68 comments)
Introduction to Compilers and Language Design - https://news.ycombinator.com/item?id=19728749 - April 2019 (1 comment)
> This book offers a one semester introduction [...] enabling the reader to build a simple compiler that accepts a *C-like language*
But they also felt kind of detached from realities of industrial languages and compilers.
These days Crafting Interpreters is probably the best suggestion.
None of modern grad-level compiler topics are decently covered. The dragon is also not a very practical book.
Tiger book is a much better introductory read, balancing between practical and theoretical aspects.
Most truly advanced compiler topics are not really covered by any single book.
Also versions in C and Java.
> It takes at least two quarters or even two semesters to cover all or most of the material in this book. It is common to cover the first half in an undergraduate course and the second half of the book -- stressing code optimization -- in a second course at the graduate or mezzanine level.
I do value both correct high quality AI usage and non-AI works, would be nice if we could have a bar for the AI stuff that makes sense instead of dismissing peoples work blindly.
How do you guarantee it, exactly? AI told you in an authoritative tone?
While I agree that simply calling something "AI slop" is not constructive, it is not my job to voluntarily review LLM-extruded crap. In the past I would provide constructive criticism because there was an actual conversation taking place. The producer had put at least enough thought into it such that my engagement didn't feel like replying to a chatbot, but that's what it feels like now, so unless I see some considerable effort and original thought on the author's part, I am likely to drop a "slop" comment and move on with my day.
Have you delegated the self-thinking process to agents as well ?
Both compilers and language design are as old as this industry, and have too much knowledge for a single course.
This one is ok, better than most similar courses based on, say, the dragon book.
In contrast you can easily skim Chapter 7, Semantic Analysis and realize this book gives extremely rudimentary information on type systems. Even if you were to design a dynamically typed language, this book doesn’t cover user-defined structs let alone modern essentials like user-defined sum types or closures.
For example, the first rule of language design is: "Sandwich Helix." https://xkcd.com/3003/
You'll also want to study how human language evolves, e.g. through "vernacularization," which is the laziness that drives people to create short words and phrases for ideas they need to communicate often.
You'll want to learn about the differing purposes of formal and informal constructions, and about why and how meaning itself drifts with time.
You'll want to learn why "DSL" is a nonsense word and what it means for a language to be embedded in more than one domain (e.g. English is both spoken and written).
Even a simpler discipline like API design will be incredibly enlightening. How do you get users to upgrade from an old version of your API to a new version? You need to learn how to guide people towards behaving how you want without any kind of coercion: the only power you have is the power to offer incentives. Can you figure out how to create a stable equilibrium of social behavior out of dreamed-up nonsense? If you remember nothing else remember this: every language design decision that now seems inevitable and set in stone, once seemed completely, pointlessly arbitrary. Survivorship bias is very tricky to reason about! Every attempt to create a language is "creating a 15th standard" (https://xkcd.com/927/), but you have to remember that that doesn't mean that it will fail. Every language that has ever succeeded has passed through this seemingly-impassable gate!