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.

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

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.

Language/Technology specific

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

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

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