This is a list of books that i really enjoyed and would recommend to other software developers.

Writing Code / Working With Code

• 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.

• Implementation Patterns (Kent Beck)

  The goal of Implementation Patterns is helping you communicate your intentions as a developer through your code. The patterns in this book are all very short, and usually are nothing more than simple descriptions of different implementation choices that you as a developer can make. Don’t think that these patterns are similar to design patterns or anything like that… these patterns are about how and when you should create classes, how to deal with state in classes and methods, how to implement behaviour, dealing with exceptional flow and exceptions, different ways of defining and implementing methods, choosing between collection types, and there’s even a chapter that deals with some of the complications of developing frameworks and allowing the framework to evolve while minimizing or avoiding breaking code for clients of the framework. This book is just filled with a lot of great insight on how to write code that clearly expresses the intent of what it’s supposed to do. And while it is a very short book (only 130 pages), it’s one of those books that’ll teach you something new every time you read it.

• 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.

• Clean Code (Robert C. Martin)

  At around 350 pages (depending on which of the appendices you find useful), this book really covers a lot of ground, but in a concise (without being _too_ 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.

• 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.

Software architecture/design

• 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.

• Applying Domain-Driven Design and Patterns (Jimmy Nilsson)

  More on DDD. The original DDD book by Eric Evans is very high on theory, but this book is much more focused on how to apply it (duh, it says so in the title…). Again, even if you’re not into DDD this book is still very valuable as it also contains some great discussions on current popular design techniques such as Dependency Injection, Inversion of Control and Aspect Oriented Programming. Also contains a nice introduction to using NHibernate.

• 97 Things Every Software Architect Should Know (edited by Richard Monson-Haefel)

  Even though this is a book, it isn’t a ‘real’ book… it’s pretty much a collection of bits of wisdom and advice from a bunch of leading software architects. There are no chapters, there is no unifying theme, there is no structure whatsoever. There is just a lot of great content. Around 50 software architects contributed 97 pieces to the book, each one filling up about 2 (small) pages. In a way, reading these pieces feels like reading great blog posts, though without the usual blogodrama. It’s great stuff for when you want to spend an hour reading, or for when you have a couple of minutes to spare. There’s even a website which contains all of the original, unedited contributions so the cheapskates among you can read it all as well

Language/Technology specific

• NHibernate In Action (Pierre Henri Kuaté, Christian Bauer, Gavin King, and Tobin Harris)

  Everyone working with NHibernate would benefit greatly from reading this book. If you’re just getting started with NHibernate, it will indeed lower your learning curve significantly. If you already have experience with NHibernate, you will most likely learn some tricks that you didn’t know about yet. It’s a good book to read cover to cover, but at the same time it will be of great service to you as a reference book. Chapter 3 through 7 especially are chapters you’ll probably revisit frequently while you are working with NHibernate.

  There is one thing to keep in mind though… this book targets version 1.2 of NHibernate, which is a bit of an old release. This is rather unfortunate since NHibernate 2.0 and 2.1 introduced a lot of great new features. Obviously, these great new features aren’t covered here, but the most important things of working with NHibernate are all covered thoroughly so don’t let the 1.2 version number make you think that this book isn’t relevant to the current versions. This book is by far the best source of information on how to get the most out of NHibernate.

• Building Domain Specific Languages in Boo (Ayende Rahien)

  For those of you who are familiar with Ayende’s blog, you’ll be happy to know that the writing style is very similar. It’s very engaging, it keeps you interested in the topic at hand throughout the book, and he often makes you marble at his ability to come up with simple and elegant solutions to difficult problems. I used to be skeptical towards the actual value of creating your own DSL, but now i know that it is not only doable, there really are a lot of cases where it makes sense to create a DSL, more than i’d ever imagined.

  I think Ayende achieved his goal. I do think that i can now create a DSL, and i’m sure many of you would agree with me after reading this book. In most cases, it’s pretty easy with this book by your side. And for those cases where it gets hard, this book thoroughly covers all of your options. Do yourself a favor and read this book, you won’t only learn a lot about DSL’s, but also about problem solving in general.

• C# In Depth (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 and C# 3 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#, Second 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.

• Learning WCF (Michele Bustamante)

  While this book certainly won’t make you an expert on WCF, you do get a pretty good grasp on how it works, what’s possible with it, and how you use it. The book mainly covers contracts, bindings, hosting options, instancing and concurrency options, service reliability, security and dealing with exceptions/faults. If you want to ease into the WCF world, this book is perfect for you.

• Programming WCF Services (Juval Lowy)

  I had very mixed feelings about this book while i was reading it. It was just so incredibly boring and pretty much impossible to continue reading for a few hours. My biggest mistake was that i was trying to read this book like i do every other book: cover to cover. And it really isn’t suited for that, unless you’re battling a sleeping disorder. It is however very valuable as a WCF reference book and if you plan on using it as such, then it definitely is worthy of recommendation. You’ll quickly find whatever it is you need to know about specific WCF area’s, but if your goal is to learn WCF, get Bustamante’s Learning WCF instead.

• Silverlight 2 In Action (Chad Campbell & John Stockton)

  This book is a great resource for those who are new to Silverlight, as the authors gradually build up your understanding of Silverlight’s features and capabilities. While it probably doesn’t cover everything there is to know about Silverlight, it definitely covers most of the things you’ll be dealing with when developing with Silverlight. However, it doesn’t really teach you how to build real-world applications with it. There is very little focus on application architecture, so if you’re already familiar with Silverlight and want to learn how to properly build your applications with it, then this book is probably not for you. But if you are new to Silveright or have little experience with it, then i would definitely recommend it to get to know what Silverlight can do for you, and for what you can do with Silverlight.

• Programming In Objective-C (Stephen G. Kochan)

  Very thorough book on the Objective-C language. The only downside of this book is that it’s also targeted at novice programmers, so the pace of the book is sometimes frustratingly slow, especially at the beginning of the book. That said, it does cover pretty much everything you need to know to work effectively with Objective-C. Note that it doesn’t cover the Cocoa frameworks so you will need to get another book if you want to start native OS X applications.

• Cocoa Programming For Mac OS X, Second Edition (Aaron Hillegass)
  

  Excellent book for quickly learning how to develop native applications for Mac OS X using the Cocoa frameworks. Contains a lot of good examples and exercises. This book isn’t really huge (428 pages) but you’d be amazed how extensively it covers various typical development tasks in Cocoa.

Software development approaches/practices/methodologies

• 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

• 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.

• Ship It! (Jared Richardson & William Gwaltney Jr.)

  The subtitle of Ship It is “A Practical Guide To Successful Software Projects”, which it most certainly is. While it doesn’t cover nearly as much ground as The Art Of Agile Development, it does contain enough valuable information that will improve the way you attempt to deliver working software.

  That is, unless you’re already doing things like Continuous Integration, automated testing and code reviews. While these topics certainly aren’t the only practices that are discussed in the book, they are pretty much the practices ‘building blocks’ that this book depends on. If you’re already using these practices in your projects, then odds are that you won’t really learn anything new from this book. However, if you’re not doing this, or your projects are just a mess and you really have problems delivering software, then this book will definitely help you to improve your situation.

• Continuous Integration: Improving Software Quality And Reducing Risk (Paul M. Duvall, Steve Matyas, Andrew Glover)
  

  Great book that covers implementing CI, reducing the amount of repetitive tasks in your build process, several practices and guidelines for effectively using CI, reducing risks and also includes an assessment of several CI servers and tools.

Management

• Behind Closed Doors: Secrets Of Great Management (Johanna Rothman, Esther Derby)

  It consists of two parts. The first 120 pages is a bit of a story about a manager who was just hired to lead one of the departments of a software development company. In between the story (which is an easy and interesting read), you’ll find lots of great insight into what great management is all about. The last 40 pages are great descriptions of 13 management techniques.

  This book is a must-read for anyone doing any kind of management (even if it’s just project management), and i’d even recommend it to non-managers as well. It is just filled with great insight, tips and things that everyone should know about, not just managers.