5 ms·
Introduction to Compilers and Language Design (2021)
- madrajib 4mo agoLove such topics and articles in midst of AI topics/noise.
- giancarlostoro 4mo agoThe best part of the blind AI hatred is you can call literally anything AI slop without presenting evidence and the anti-slop loyalists will hate it without any evidence. 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.
- solumunus 4mo agoI guarantee half the folk commenting “ai slop” on people’s projects are folk who never read people’s code even before AI. Now they get to dismiss it without providing any specifics and feel superior.
- deleted 4mo ago[deleted]
- hansmayer 4mo ago> I guarantee How do you guarantee it, exactly? AI told you in an authoritative tone?
- devin 4mo ago50% of folks seems a pretty strong signal, though. No? 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.
- madrajib 4mo agoWho said I hated AI ? I just hate the noise. Have you delegated the self-thinking process to agents as well ?
- jdw64 4mo agoSometimes I see people who design languages and build compilers, and I find them truly amazing. I once tried making a language myself because I was curious, but it was so difficult that I just settled for a simple C backend. The people contributing to LLVM probably know everything down to assembly generation. they're truly incredible.
- t-3 4mo agoAssembly generation is actually pretty simple, it's optimizing everything that's difficult. Writing an assembler is a great way to get acquainted with compiler construction, because you don't need to think about optimization and types and the other features that make high level languages complicated aren't needed.
- jdw64 4mo agoI keep saying 'someday...' and never actually doing it because of making a living, but this time I think I should try a few small examples
- dixtel 4mo agoI fell you, My dream is to build my own compiler for WASM to use it later for my own pet projects. But after 9-5 job I'm exhusted and only able to work for max 1 hour. 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. :)
- vidarh 4mo agoI actually started my first compiler my allowing (only) inline assembler first, and then starting to wrap higher level constructs around it. 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.) [1] https://en.wikipedia.org/wiki/High_Level_Assembly https://en.wikipedia.org/wiki/High_Level_Assembly
- swordlucky666 4mo ago[flagged]
- klez 4mo agoHence why it's an "introduction" :)
- Jtsummers 4mo agohttps://news.ycombinator.com/threads?id=swordlucky666 https://news.ycombinator.com/threads?id=swordlucky666 - Sort of embarrassing that anyone vouched for this comment. Reading their history, they copy/paste the same comment or use an autogenerator (probably not an LLM, that'd produce better results) to generate comments like this one. Here's a comical one: https://news.ycombinator.com/item?id=48445529 https://news.ycombinator.com/item?id=48445529 > The discussion on Spanish traders set the standa raises interesting points. In practical applications, the key challenge is balancing performance with maintainability. Would be valuable to see more concrete examples of trade-offs. [emphasis added] They glob out part of the submission title (and took too much and cut off in the middle of a word) generating a delightful nonsense descriptor (the italicized bit). The title being: > Spanish traders set the standard for GnuCash database design
- klez 4mo ago> Sort of embarrassing that anyone vouched for this comment I'm the one who vouched it. I don't check commenters' history before doing it. Maybe I should. My LLM-detector is apparently broken (especially on short posts). At face value I saw nothing wrong with it, so I vouched it.
- Jtsummers 4mo agoI often check the history for comments that start off [dead] because I like to see if: 1. There's a problem with the account (and then inform them and maybe notify the mods myself). Sometimes people get shadowbanned without good reason (usually the result of automoderation, not an explicit human moderator action) or for something that happened years ago, but their history is pretty clean since. 2. To see if the person is just a spammer (as is the case here). Though I only do this if the comment seems like something that oughtn't be dead (as this one does on a first glance). The comment is shallow, but not necessarily wrong or bad. It just adds little to the discussion since it boils down to "The book is an introductory text." which we also get from reading the submission title.
- shuyang 4mo agoTook Dr. Thain's compilers class in college! It was the best. He's an excellent instructor, and the course project made me build a working C-style compiler step by step. I think the sample project here is pretty much the project we did; highly recommend following through the entire thing!
- coreyp_1 4mo agoDr. Thain is great!
- attila-lendvai 4mo agoit wanders within a tight circle around C and its idiosyncrasies.
- mike_hock 4mo agoProbably by design. > This book offers a one semester introduction [...] enabling the reader to build a simple compiler that accepts a *C-like language*
- trenchgun 4mo agoThen it is really not about language design... I would rather recommend https://www.plai.org/ https://www.plai.org/
- xqb64 4mo agoWhy that book specifically?
- vkazanov 4mo agoAs a lisper, i like PLAI and all the other books from the same school: Lisp in small pieces and many others. But they also felt kind of detached from realities of industrial languages and compilers. These days Crafting Interpreters is probably the best suggestion.
- whateverboat 4mo agoAlso Practical Foundations for Programming Languages by Harper.
- allankoech 4mo agoGood read. Impressive how ot sharpens past knowledge with great examples.
- conartist6 4mo agoJust scannning the table of contents and I don't see any of the major topics of language design. It seems to be more like just "intro to compilers"
- vkazanov 4mo agoThis looks like an undergrad-level walkthrough through key topics of how a language works. Say, python or ruby, or simpler pascal compilers. 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.
- whilenot-dev 4mo agoWhat books would you recommend for programming language design? What are the missing topics?
- kccqzy 4mo agoTypes and Programming Languages (TAPL) by Benjamin C. Pierce. Basically IMO the main differentiator between languages is their type system. It’s basically table stakes now for programming languages to provide generics so users can write their own type-safe containers, and one simply cannot implement this without some theoretical background like TAPL. 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.
- conartist6 4mo agoProgramming language design is way weirder than any textbook would make you think. For example, the first rule of language design is: "Sandwich Helix." https://xkcd.com/3003/ 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/ 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!
- richard_chase 4mo agoAccording to the introduction, the dragon book is at an advanced graduate level?
- vkazanov 4mo agoDragon book is a weird one. While a classic, it only decently covers basics of the theory of computation, while only doing a brief run through the rest of compilers. 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.
- adamddev1 4mo agoWhat's the "tiger book?"
- Jtsummers 4mo agohttps://www.cambridge.org/core/books/modern-compiler-implementation-in-ml/C2A59C37468AA8AAD0ADDCE080E3CB5D https://www.cambridge.org/core/books/modern-compiler-impleme... Also versions in C and Java.
- thx67 4mo agoIt really should be read in the SML/NJ as God Intended. https://www.cs.princeton.edu/~appel/modern/ml/whichver.html https://www.cs.princeton.edu/~appel/modern/ml/whichver.html https://www.smlnj.org/ https://www.smlnj.org/
- Jtsummers 4mo agoEven the preface to the 2006 edition suggest that they think of it as, largely, a graduate level text: > 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.
- deleted 4mo ago[deleted]
- dang 4mo agoRelated: Introduction to Compilers and Language Design (2021) - https://news.ycombinator.com/item?id=31388741 https://news.ycombinator.com/item?id=31388741 - May 2022 (68 comments) Introduction to Compilers and Language Design - https://news.ycombinator.com/item?id=19728749 https://news.ycombinator.com/item?id=19728749 - April 2019 (1 comment)
- userbinator 4mo agoI don't know if any courses have referenced it yet, but I think C4 (https://news.ycombinator.com/item?id=8558822 https://news.ycombinator.com/item?id=8558822) and C4x86 (https://news.ycombinator.com/item?id=8746054 https://news.ycombinator.com/item?id=8746054) would make for a great semester's worth of study; it's a tiny, self-compiling C-subset compiler that would probably make a good base for further exercises in extending it.
- Disla_chunga 4mo agoThis was a great read for me. I'm working on a DSL compiler for 3D printing (after my semester class on compilers) and it's a good reminder of how much there is to learn. It's given me great material on error handling suggestions and constant folding (although mine is not at such an advanced level). I read Chapter 12 on optimization, and it's given me a lot of good ideas in terms of tree rewriting and reducing instruction count. I implemented paging (after much research) but I still deal with crashes partly because the output is still built as a giant string in memory for smaller outputs, and partly because the paging threshold sometimes doesn't trigger early enough. Perhaps there are deeper things for me to optimize and research on. I'm keeping this read under my belt!
- nadaviv 4mo agoI really enjoyed Crafting Interpreters by Robert Nystrom and found it valuable for the development of a DSL I'm working on. From https://craftinginterpreters.com/ 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 https://craftinginterpreters.com/contents.html