After reading Glyn Normington’s Top ten technical books I started thinking about what books have had the greatest impact on my thinking. While it is hard to separate personal and professional aspects of oneself, this list focuses on the technical books.
Without further ado, these are the books that made me the programmer I am today1, in order of reading (as far as I can remember).
Key insight for me was that code is not only written once, it can and needs to be continuously changed. Today, I “could not live without” many foundational refactorings like extract and inline variable/function. (Thankfully they are automated nowadays.) Some refactorings also changed how I think about design, like Move Method and Extract Parameter Object.
Mostly known for cataloging object-oriented design patterns. (Possibly did a too good job since over-application of these patterns has become a problem of its own.) Helped me understand how to look for and extract symmetries. Also explained the value of having a shared vocabulary, and gave me a better understanding of many common patterns like Composite, and Command.
Apart from introducing the idea of test-driven development, it embeds a lot of design knowledge “in disguise”. It made me better at designing the interface before implementation, and to focus on current problem rather than future ones. As an anecdote, I clearly remember that after a year or so of TDD, writing code without tests started to feel dirty and unprofessional.
Great book which covers pretty much everything from variable names and comments to systems thinking and developing personal character. Very thorough and often refers to scientific studies to back the ideas. Some of the concepts that stuck were defensive programming, cyclomatic complexity, and “enough design up front”.
Gave fuel to my thoughts about the craftmanship aspect of programming. Like Code Complete, it covers lots of stuff ranging from philosophical to practical. Some of my favorites include “Don’t live with broken windows”, “Find bugs once”, and “Abstractions live longer than details”.
Taught me the importance of working close to the problem domain. Introduced a way to model domains based on entities, values, services, and aggregates. Made me see the value of having a ubiquitous language and work with bounded contexts. Also loved the idea of anti-corruption layers.
A great book on how to tackle complexity in software design. Introduced the notion that “modules should be deep” (narrow interfaces but deep implementation), argues that good abstractions hide as much information as possible, and explains the distinction between tactical and strategic coding.
While it was only a few days since I put it down (and it is thus perhaps a bit early for a list like this), I found it insightful. Takeaways were a better understanding of coupling and cohesion, the realization that options are worth more in uncertain times, and that the cost of software is dominated by the amount of coupling.
