What I’m Reading: Engineering a Compiler by Cooper & Torczon

Engineering a Compiler

Engineering a Compiler is an excellent introductory text on compilers. I particularly enjoyed the textbook’s clean layout and design and cleanly written algorithms placed very close to the paragraphs where they are relevant.

Particularly after reading Muchnick, I found the amount of text explanation with a lack of concrete examples to be disturbing. Whole sections pass without any accompanying code examples. While I didn’t think that pseudocode would have particularly enriched these topics, and I could certainly look up the relevant papers provided in the bibliography, I found the lack of a concrete representation to work with left me somehow wanting more. This may trouble other readers less than it did myself.

All in all I suggest Engineering a Compiler as an excellent candidate for easy entry into a discussion on compilers, or an undergraduate text. After reading this textbook, if you’re still hungry for more on compilers, try Appel’s Compilers in ML and Muchnick’s Advanced Compiler Design and Implementation.

Why I Still Read Textbooks

“Perilous to all are the devices of an art deeper than we possess ourselves.” – Gandalf the White

I have a monthly textbook budget of $200/month. For the last year, I’ve exclusively spent that on hardcopy Computer Science and Software Engineering textbooks. Whenever anyone catches me reading these eight hundred page beasts, they always ask the same question:


I’m already employed as a Software Engineer, and I’m not reading these books to earn an additional degree, moreover, these books can’t be fun to read, so why would I spend time doing this when I could be smelling the roses or whatever normal people do with their spare time.

Normal People.

In the following thousand or so words, I’ll do my best to answer that question.

Continue reading Why I Still Read Textbooks

Screenshot from 2016-07-15 15-27-47

Neural Networks Part 5: So You’ve Made A Neural Network. What Can We Use It For?

In the last two installments of this series, I showed how we can use Haskell to define a dynamically-sized single-threaded Neural Network and explained things along the way. So yay! We’ve got a Neural Network! Great!

But now that we’ve got it, what in the heck do we do with it? Find out after the cut.

Continue reading Neural Networks Part 5: So You’ve Made A Neural Network. What Can We Use It For?

Neural Networks Part 2: What does Feed Forward even mean anyways?

When I set out to design a neural network for this project, I knew very little about neural networks, artificial intelligence, or anything along those lines, and so I can’t say that I chose as I did out of any deep knowledge — what I can say is that a coworker told me that a fully-connected feed forward neural network is easy to implement.

Software Engineering is a constant fight against added, unnecessary complexity so yeah, simplicity, let’s go with that!

So… what’s a fully-connected feed forward neural network and how do I build one?

Continue reading Neural Networks Part 2: What does Feed Forward even mean anyways?


This paragraph ends the acknowledgments section of Advanced Compiler Design and Implementation by Steven Muchnick, which I just started yesterday.


This acknowledgment time-traveled from 1998. Steven might not have been risking chemical castration or life like if he’d penned this less than a half-century prior, but the notion of same-sex partnership definitely wasn’t so accepted as it is today. It’s hard to imagine the courage, love, and possibly defiance that this paragraph represents.

LGBTQ colleagues, friends, neighbors, fellow countrymen, fellow world citizens: From the bottom of my heart, thank you for your contributions. We wouldn’t be where we are without you. Happy Pride.