“Beautiful Code: Leading Programmers Explain How They Think” is yet-another-excellent book put out by O’Reilly Books. It contains 33 essays written by respected members of the Software Development community and each essay is a variation on the theme of how we define “Beautiful Code”. The range of topics is vast and includes subjects like “A Regular Expression Matcher”, “Distributed Programming with MapReduce”, “Python’s Dictionary Implementation”, and [one my favorites] “The Most Beautiful Code I Never Wrote”. Each of the authors does a fantastic job of being as concise as possible without sacrificing an accurate presentation and solution of the covered problem.
Although the authors certainly deserve applause, the editors Andy Oram and Greg Wilson are truly the unsung heroes in this publication. I can imagine it was a difficult task to make these separately written essays feel more like a book and less like a collection of chapters. How they accomplished this, however, may not be immediately apparent. What I found was that within each of the 33 individual essays, lies a unique engineering principle that will emerge in successful software development endeavors. Moving beyond each of those principles within each of those essays, I realized that it is only the developer who grasps these tenets who is capable of writing Beautiful Code.
Before moving on, I would like to point out that “Beautiful Code” is a book written for advanced developers. If you do not have some degree of familiarity with topics like: Finite Automata, C Programming, Concurrency Problems, Protocol Stacks, Haskell, Cryptography, Algorithm Proof Techniques, and Kernel Development, this book is probably not for you. Even if you are comfortable with these topics, be prepared to encounter a few chapters that may need to be read twice or require a bit of internet sleuthing before you grok it.
Below, I’d like to present an example of what I mean by “the essay” versus “the extracted principle”.
Chapter Three is titled “The Most Beautiful Code I Never Wrote”. It is written by Joe Bentley and it takes an unique look at the famed QuickSort algorithm. Without delving into the essay itself, Joe cleverly presents how the beauty of the famed QuickSort algorithm lies within the code that is not written at all. Two quotes I’ve highlighted from the chapter are:
“A designer knows he has achieved perfection not when there is nothing left to add, but when there is nothing left to take away” - Antoine de Saint-Exupery
“Simplicity does not precede complexity, but follows it” - Alan Perlis
I once overheard a seasoned developer say to a younger developer, “Develop a little, refactor a little. This is your mantra. Simple code simply works”. Developers who strive for simplicity, who strive to write code that not only “works” but “works well”, are developers who produce code with less bugs and require less maintenance. That is the extracted principle presented in this chapter and, ultimately, that is the difference between brute force workmanship and eloquent craftsmanship.
Within each essay is a life lesson for anyone who is a practicing technologist and I highly recommend this book to anyone who fancies themselves as such. I suspect that “Beautiful Code” would fit nicely between “The Pragmatic Programmer” and “The Practice of Programming” on any development shop’s bookshelf.