#410 in Computers & technology books
Use arrows to jump to the previous/next product
Reddit mentions of Advanced Compiler Design and Implementation
Sentiment score: 6
Reddit mentions: 10
We found 10 Reddit mentions of Advanced Compiler Design and Implementation. Here are the top ones.
Buying options
View on Amazon.comor
- 3mm diameter, 1kg net weight, ABS Filament
- Filament Roundness: +/- 0.07mm
- Filament Diameter: +/- 0.05mm
- Recommended Print Temperature: 230 - 240°C, depending on printer model
- Compatible with RepRap, Makerbot, Afinia, Solidoodle or any standard spool based 3D printer
Features:
Specs:
Height | 9.75 Inches |
Length | 7.75 Inches |
Number of items | 1 |
Weight | 3.60014873846 Pounds |
Width | 1.75 Inches |
I started from scratch on the formal CS side, with an emphasis on program analysis, and taught myself the following starting from 2007. If you're in the United States, I recommend BookFinder to save money buying these things used.
On the CS side:
On the math side, I was advantaged in that I did my undergraduate degree in the subject. Here's what I can recommend, given five years' worth of hindsight studying program analysis:
Final bit of advice: you'll notice that I heavily stuck to textbooks and Ph.D. theses in the above list. I find that jumping straight into the research literature without a foundational grounding is perhaps the most ill-advised mistake one can make intellectually. To whatever extent that what you're interested in is systematized -- that is, covered in a textbook or thesis already, you should read it before digging into the research literature. Otherwise, you'll be the proverbial blind man with the elephant, groping around in the dark, getting bits and pieces of the picture without understanding how it all forms a cohesive whole. I made that mistake and it cost me a lot of time; don't do the same.
You missed out. Compiler design was my favorite course in college.
Anyway, if you don't mind reading textbooks and digging deep into them, you can teach yourself compilers. The seminal work is the Dragon Book. I'd highly recommend supplementing is with Appel's Modern Compiler Implementation in ML (if you're a wimp, you can get the Java or C versions, but I wouldn't recommend it). SICP can also give you some useful perspectives. If you want to go further, there's Advanced Compiler Design and Implementation by Steven Muchnik.
There are also a couple of web tutorials that give you a really quick, whirlwind overview. Graydon Hoare's One Day Compilers uses Ocaml to write a native-code compiler for a Make-like language in 40 slides. My Write yourself a scheme in 48 hours has you write a Scheme interpreter in Haskell, though it sorta assumes you're already familiar with the basics of parsing/lexing/interpreting.
For designing programming languages, my favorites are
If you only get one then go with Pierce. But If you want to get serious about semantics, then Winskel is the way to go.
On the implementation side my favorites are
Just read the table of contents of a couple of advanced compiler books:
Advanced Compiler Design and Implementation
Optimizing Compilers for Modern Architectures: A Dependence-based Approach
It is a different ball game.
Read the source code to LLVM, Ocaml, Jikes RVM and SBCL.
Read papers on CiteSeer.
Here are few more advanced books that I highly recommend after you learn the basics and want to really implement something.
​
- Modern Compiler Implementation in Java 2nd Edition
- Advanced Compiler Design and Implementation 1st Edition
​
Also here is a link to a GitHub page with tons of compiler related resources. awesome-compilers
It seems that most introductory texts focus on parsing. However, in my experience, the dragon book does a good job on introductory code generation. Appel's Tiger Book had good information as well. As a heads up, the C and Java versions of the same book are done as an afterthought, and you can tell that the code was translated after the fact. Stick with the ML version.
For optimization algorithms, I've heard good (And bad) things about Muchhnik: Advanced Compiler Design and Implementation.
However, I've had better luck just reading various papers. If there's a specific part of code generation and emission, I can point you to plenty of good papers.
Another potential replacement for dragon book: http://www.amazon.com/Advanced-Compiler-Design-Implementation-Muchnick/dp/1558603204
I've been playing around with writing a programming language and compiler in my spare time for a while now (shameless plug: http://eigenstate.org/myrddin.html; source: http://git.eigenstate.org/git/ori/mc.git). Lots of fun, and it can be as shallow or as deep as you want it to be.
Where are you with the calculator? Have you got a handle on tokenizing and parsing? Are you intending to use tools like lex and yacc, or do you want to do a recursive descent parser by hand? (Neither option is too hard; hand written is far easier to comprehend, but it doesn't give you any correctness guarantees)
The tutorials I'd suggest depend on exactly where you are and what you're trying to do. As far as books, the three that I would go with are, in order:
For basic recursive descent parsing:
For general compiler knowledge, here are the books that I'd recommend in order:
This is a great book. It's fairly modern, written reasonably well, covers most topics you'll need. Just stick to the ML version, because it's pretty clear that Appel wrote first in that language, and then did pretty poor translations to C and Java for the other books.
Another good compiler textbook. Covers language design, a large number of various programming models, and so on. Too light on optimization, IMO.
This is the classic compiler book. It's one of the oldest, and it focuses a bit heavily on parsing, but it covers a large number of topics. It's, in my opinion, dense but very well written and surprisingly easy to follow.
This book's main claim to fame is that it's a decent overview, but it's available online for free.
This is the fastest zero-to-compiler book out there, but it's ridiculously simplistic, and doesn't lead to any next steps. It just tells you how to generate terrible machine code. But it's hands on.
And for later,
More a collection of papers on optimization than a textbook, it's a good summary of relatively advanced techniques to explore once you have a compiler that works and does what you want, and generates tolerably good code.
As for how folks feel about derivative notation? Maybe a little. ;) Sure, Liebnitz had a way better notation than Newton, but folks still use Newton's notation in some small physics examples, so depending on what someone was struggling with... As for SICP, well, it depends, I'd rather someone swallowed a sugar coated pill than spit it out and never get better.
From a compiler design perspective there are really 2 very different paths you can take (they do start to converge at the end, but you still wind up with ANF vs. SSA, etc) You can explore the scheme/haskell/etc functional programming path or you can go down the Steven Muchnik Advanced Compiler Design and Implementation path., which is much more traditional in terms of the kinds of languages it seems to consider.
http://www.amazon.com/Advanced-Compiler-Design-Implementation-Muchnick/dp/1558603204
Both offer very different seeming designs. So, if lisp was a non-starter, I'd probably send them over to the Dragon book and then down towards Muchnik from there.