Recommended Books

Software Engineering

A. Highly Recommended Books
  • Code Complete: 2nd Edition (Steve McConnell)
    This book pretty much covers each aspect of writing code. It’s almost impossible to provide a short summary of what this book covers but i’ll try anyway: organizing classes, writing high-quality routines, defensive programming, properly using variables, choosing good variable names, how to properly deal with conditionals, loops, control structures, general code readability, collaborating with other developers, testing, debugging, refactoring, code-tuning strategies and techniques, writing self-documenting code, layout and style, intellectual honesty and much, much more. This book is a must-read for anyone who writes code, no matter what language or environment you work in.
  • Test-Driven Development (Kent Beck)
    Explains and demonstrates the advantages of test-driven development (TDD). After a short introduction, the book immediately starts off with 2 extensive examples of applying TDD. After that, some patterns for TDD are discussed, followed by short overview of some common refactorings and finally some tips on how to master TDD.
  • Refactoring (Martin Fowler)
    Inherently goes together with TDD... You can’t properly do TDD without refactoring and you need automated tests before you can safely refactor. The book starts off with some background on refactorying, why you should do it, and when you should do it. After that, you’ll see how to do it. A collection of code smells (= code which needs to be refactored) is listed, followed by a catalog of refactorings which get rid of the code smells. Don’t let the subtitle of the book (‘Improving the design of existing code’) fool you... it is as valuable to code that was just written as it is for code that was written months or years ago.
    • xUnit Test Patterns (Gerard Meszaros)
      Follows the same style as Refactoring, starting off with the narrative chapters followed by a list of ‘test smells’ and then the catalog of test patterns. If you’re into test driven development or are just forced to write tests at your job, you should definitely read this book. If you’re into TDD you’ll appreciate learning a lot of new ways to improve the quality of your tests. If you’re not into it but are forced to at work, you’ll appreciate the material in this book for making your job suck less.
    • Working Effectively With Legacy Code (Michael Feathers)
      The book’s main purpose is to teach you a lot of tricks on how to improve the testability of legacy code. As Feathers himself says, this book will not teach you how to go from bad legacy code to beautiful code in one go. That’s not even possible anyway, unless you start rewriting the legacy code. Instead, this book shows how you can take small incremental steps to get your code into a solid test harness which will then allow you to start refactoring to good code more safely.
      The book is divided in 3 parts. The first discusses the mechanics of making changes in code. The second part consists of very conveniently titled chapters that discuss common problems when changing legacy code. Chapters with titles like “I don’t have much time and i have to change it“, “How do I add a feature“, “I need to make a change, what methods should I test?“, “Dependencies on libraries are killing me“, etc… You can quickly look at the table of contents and find the right chapter to help you with the problem you’re facing at that time. The third part of the book contains a series of dependency breaking techniques that are referenced throughout the book.
      If you are working on a legacy code base, do yourself a favor and get this book. Put it next to your keyboard, and use it everyday. You won’t regret it.
    • The Clean Coder: A Code of Conduct For Professional Programmers (Robert C. Martin)
      It is a brilliant read. It is not the technical book one might be looking for. For a more technical approach on how to write clean code please read Clean Code (Robert C. Martin) for which I also have a review. 
      This book talks about being a professional coder. What behaviors should he follow on his everyday life as a coder on a big or a small firm. A lot of the content sounds obvious when you read it, but it's put together extremely well and will almost certainly relate to issues that you've had to deal with in your career, be it difficult colleagues or untrusting managers. It's easy to read and will probably open your eyes to becoming a more professional software developer who is better able to take responsibility for their work.

      I really wish some of the colleagues I had some time ago have read this brilliant book.

    B. Good Read
    • Clean Code (Robert C. Martin)
      Uncle Bob's first book I ever read! This book really covers a lot of ground, but in a concise way. You’ll find the typical sound advice on using good names, writing good functions, good vs bad comments, formatting, abstractions, encapsulation, robustness, integrating third-party code, testing, refactoring, class design, system design, enabling emergent design and dealing with concurrency. After all of that, there are a couple of chapters where existing code is improved step by step. To top it all off, the final chapter contains an extensive list of smells and heuristics. Some of you are probably thinking that all of this looks rather familiar, especially if you’ve read books like Code Complete, Refactoring and Implementation Patterns. And this book really doesn’t offer anything new that nobody ever wrote about before. It is however the best, and most accessible collection of good advice on good code and design that i’ve read so far.
    • Implementation Patterns (Kent Beck)
      The whole premise of this book is to help the reader understand and improve the development choices they make on a second by second basis. This is not a book about guidelines but rather explaining why a variable name is better named one way or the other. All of this is for the very valuable goal of making the code easier to read for a future maintainer.

      While the idea itself is brilliant the book itself feels very disjointed. The choices are presented entirely in text format and the density of the information is very high. This makes for a potentially very valuable reference book, but it is equally hard to read. Its not that the book is terse but rather that the level of explanation is not good enough and the sections either waffle or are so rich in things unsaid its hard to understand the reasoning.

      If you are new to programming then this book may well introduce the low level patterns a lot of the old hands are used to, all be it you'll need to read this one a few times for any of it to sink in. For the old hands it feels like an abstract view of everything you have been doing for a decade and while there may be new things in there, its going to be hard to spot them.

    Software Design / Architecture

    • Patterns Of Enterprise Application Architecture (Martin Fowler)
      A very valuable collection of patterns grouped in categories. You’ll find domain logic patterns, data source architectural patterns, object-relational behavioral patterns, object-relational structural patterns, object-relational metadata mapping patterns, web presentation patterns, distribution patterns, offline concurrency patterns, session state patterns, and some basic patterns. Very good stuff.
    • Design Patterns (Gang Of Four)
      Excellent book containing all of the classic design patterns. However, a lot of people who’ve read this book tend to over-engineer everything in their quest to use as many patterns as possible. If you’ve read the books in the Must Read section, you’ll hopefully understand that you should only use these patterns if you have a need for them. Don’t use them just for the sake of using them!
    • Release It! Design and deploy production-ready software (Michael T. Nygard)
      The subtitle of the book is: Design and deploy production-ready software. And this book really offers a lot of great advice on how to do exactly that. In the first two parts, patterns (and anti-patterns) are provided to show you how you can ensure stability and capacity in your systems. These two parts alone are already tremendously valuable, but there is a lot more goodness in this book. The book also gives excellent advice on how to configure your network of servers, security and passwords, load balancing and clustering, dealing with configuration files, making your system transparent for Operations and making your software adaptable to future changes. The author uses excellent real-word examples throughout the book to stress the importance of the advice he offers. When you skim over the table of contents before reading it, you might think not every part of this book will interest you as much as the others, but the author's writing style really does keep everything at least interesting, and in most cases, even fascinating. And often, quite funny as well.
    • Domain-Driven Design (Eric Evans)
      Very extensive book on how to work in a domain-driven way, instead of a data-driven way which is unfortunately all too common in the Microsoft world. Not everyone will enjoy this book, but there’s a lot of highly valuable material in here, even if you don’t plan on working according to the Domain-Driven Design (DDD) way.
    • REST In Practice (Jim Webber, Savas Parastatidis, Ian Robinson)
      Coming from the Microsoft world were SOAP services have for a long time been the norm in most projects, it's very interesting to see what REST is all about and how these Restful services are built. Everything is explained very clearly, and the authors continuously show both the requests and the responses that are going over the wire to illustrate what is going on at the HTTP level, which makes it even easier to understand everything that's being discussed. Read this book with an open mind, i'd bet you'll like it a lot as well.

    Programming Languages

    • The Ruby Programming Language (David Flanagan, Yukihiro Matsumoto)
      I generally approach programming language books as necessary reading (at least when you’re learning a language) but a chore at the same time. While some of the chapters in this book suffer from a lot of the same problems that you’ll find with other programming language books, it at least is less boring to read. Chapter 6 through 8 however are more than worth the cost of the book and could really change the way you think and feel about OO and if i could legally get away with it, i’d force every programmer to read those. It’s certainly not going to convince everyone, but it could open a lot of people’s eyes. This book is not only ideal to learn the Ruby language, it’ll also be an invaluable reference resource to keep on your desk as you keep taking more steps in your Ruby journey.
    • C# In Depth, 2nd Edition (Jon Skeet)
      Finally a C# book that only focuses on the language instead of focusing on both language features and .NET Framework topics. This means that the language features are covered very thoroughly, in a way you probably won't find in any other C# book. There is a lot of very complex stuff here, but Jon Skeet manages to keep it all pretty easy to understand. You don't really need this information to be a C# developer, but a lot of the content of the book will definitely improve your understanding of the language and depending on how you deal with that improved understanding, it enables you to do things in your code that you may never have thought were possible. The book basically covers all the important C# 2, C# 3 and C# 4 features, completely skipping C# 1 except for highlighting some of its shortcomings. If you want to know everything there is to know about generics, nullable types, delegates, variable capturing with anonymous methods, implementing iterators, type inference, automatic properties, simplified initialization, anonymous types, lambda expressions and expression trees, extension methods, query expressions and how LINQ really works then this is the book for you. Well, you could study the C# lanuage specification but it won't be near as clear as this book.
    • CLR via C#, 3rd Edition (Jeffrey Richter)
      Highly informative book, obviously only of use to .NET developers. Contains a lot of lower level stuff you won't find in the typical .NET books or reference materials. No matter how experienced you are with .NET, you'll probably learn some valuable things here. I didn't really like how the author stresses the importance of performance because it leads a lot of developers to write bad or unnessecary complex code, but it is nice to know that stuff when you need to make some optimizations. And not to forget that the book is probably the best resource on how threads work on .Net. Jeffrey easily could have written a separate book just with the threading stuff he throws on this book. (especially interesting are the parts that explain how the windows thread-pool is used from withing .Net TPL).

      Tools and Libraries

      • jQuery In Action (Bear Bibeault, Yehuda Katz)
        If you're new to jQuery, this book is pretty much the perfect one to pick up. It (obviously) starts with the basics, moving further continuously while hardly ever showing too much new stuff at once. You'll quickly become familiar with the basic principles that jQuery revolves around and the book then gradually builds upon that with each chapter. I can't imagine you'll have any questions left about jQuery after finishing this book. Everything is explained very clearly and thoroughly and the authors do an admirable job of avoiding boring parts.
      • NHibernate 3.0 Cookbook (Jason Dentler)
        If you are a .Net developer who writes non-trivial applications with a database backend, you probably should give NHibernate (and this book) a look. This book can serve as both an introduction to NHibernate and a reference material for a long time to come as you master the recipes over time. This book is not a classic beginner's approach but it serves great to show all the core features of NHibernate (which stay the same from version 1.2 till 3.2) and goes into further detail to some more specific 3.0 capabilities (configuration per session, context aware etc). There are some nice 3.2 features (e.g loquatious configuration) that are not included but given the fact that there are very few NHibernate specific books out there, I was totally satisfied by the material in this one.

      Software Methodologies

      • Extreme Programming Explained, Second Edition (Kent Beck)
        Very good book covering the values, principles and practices of Extreme Programming. Even though it's an easy and quick read, you will get a lot of insight and valuable information out of this book.
      • The Art Of Agile Development (James Shore & Shane Warden)
        The title says it's about agile development, but this book is very specifically about Extreme Programming, other agile methodologies aren't covered. A lot of the content of this book applies to other agile methodologies as well though. This book does an amazing job of not only showing you what agile development ideally looks like, but also gives a lot of tips and helpful information on how to get to that point. After a thorough introduction on agile development and XP, the book covers a large list of XP values, principles and practices, grouped together in different categories: Thinking, Collaborating, Releasing, Planning and Developing. Each practice is covered very thoroughly and clearly. Finally, the book closes with a few more chapters on how to master your agility as a team after you've gotten used to the values, principles and practices covered earlier. This is one of the best books on software development you'll ever read.
      • The Mythical Man-Month, 20th Anniversary Edition (Frederick P. Brooks)
        Many people consider this book a timeless classic. I don’t entirely agree with this though. It is a very good book, and a lot of the stuff in it is awfully familiar even though it’s written 30 years ago. But because it’s been written 30 years ago, there really are some parts that have become kinda dated. And I’m not even talking about the references to writing code. Those are actually interesting, from a more historical point of view. But I don’t really agree on his views on the role and power of the architect of the system. In fact, his entire Surgical Team (as he calls it) does not look appealing to me at all… it kinda conflicts with the world of agile development that we know of today. Since this is the 20th anniversary edition, the book also contains a nice chapter where he looks back on the opinions that he asserted in the original version, and corrects a few of them. That chapter was also written 10 years ago though, so I’d actually love to hear how he feels about a couple of his stated opinions these days. Don’t get the wrong idea though, i really enjoyed reading this book and most of the human and social aspects of software development that he talks about are very insightful and definitely still relevant if you’re in the business of software development, regardless of if you’re a manager or a developer or whatever