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): nherently 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.
The Passionate Programmer (Chad Fowler): While not actually a technical book, I didn't find a better category to put this in. This book is a fantastic guide on having a succesful career as a software developer. Chad offers a truckload of solid advice on things like figuring out which technologies to focus on, expanding your skill-set to more than just coding, improving yourself continuously, being as effective as you can be, getting the word out on how good you are, and making sure you keep improving as your career progresses. It's a quick and easy read, and the cost of the book and the amount of time you put into it are only a fraction of the value you'll get out of reading this book.
Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman: I'm not a fan of the Software Craftsmanship movement. Well, I do love the goals and the principles behind it but I kinda dislike the terminology they've chosen to try to spread those goals and principles. It has this elitist connotation to it which just rubs a lot of people the wrong way. Instead of trying to pull people in to the concept of continuous improvement, this whole "I'm an apprentice! I'm a journeyman! I'm a master!" thing just makes us look kinda stupid. It's just rather off-putting to many of the people we ought to try to reach. In fact, I wouldn't be surprised if this movement would've gotten more traction and less blog-o-drama if they'd simply called themselves the Continuous Improvement movement. No silly metaphors that don't hold up in this day and age, no titles to be earned, no roles to be played. Just people continuously trying to get better and helping others to improve as well. Which sort of captures the essence of it, no? Alas, Software Craftsmanship it is.It is with that opinion in mind that I was at first hesitant to read Apprenticeship Patterns: Guidance for the Aspiring Software Craftsman. But when I glanced over the table of contents, I couldn't help but think that this is the kind of stuff I wished was available when I first started my career. So I figured I had to give it a shot. And I'm glad I did. It's a very quick read (only 168 pages) but it does have a lot of great advice for people who want to become better developers. The only downside about this book is that you have to continuously read about the whole apprentice/journeyman/master thing. If the authors had left out the craftsmanship-fantasy and background, they probably could've gotten the exact same amount of great advice in just about 100 pages.But again, despite the issues I have with the craftsmanship terminology, the actual content of this book is fantastic. I've been applying a lot of those patterns over the past couple of years and they've benefited me greatly. And there are a couple of them that I really want to incorporate in my 'routine' as well. By reading this book, you'll either learn a lot about how you can make yourself better or if you feel like you're already there, you'll at least know of a reference to pass to other people you want to assist on their journey of Continuous Improvement. I'm sorry, I meant their apprenticeship. It really is a blueprint to becoming a Jedi. I'm sorry, I meant master craftsman. Or just a very valuable and great developer.
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. It also covers a lot of ground. I grok the REST architectural style now, and definitely like it. If you read this book with an open mind, I'd bet you'll like it a lot as well.
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.
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.
Metaprogramming Ruby (Paolo Perrotta): If I had to describe this book in one word, I'd go with 'fascinating'. It's eye-opening, highly informative and fun to read. It'll inspire you to change the way you write your code and the perspective you'll gain on OO topics that you already thought you knew well is just invaluable.
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.
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.
DSLs In Action (Debasish Ghosh): All in all, there is a lot of very interesting and useful information in this book. You’ll learn a lot of the things that you’ll need to know about to make an informed decision as to which approaches you should following when implementing a DSL. You’ll also learn a lot of cool tricks to make your DSLs as expressive as they can be. I can’t think of a better book to get you started with DSL development. The only thing that prevents me from labeling this as a Highly Recommended book is that it doesn’t cover some of the topics you need to learn about to make sure your success with a DSL is sustainable in the long term. Things like testing your DSL, backwards compatibility, versioning, etc are not covered and it is somewhat missed.
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.
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.
ReWork (Jason Fried, David Heinemeier Hansson): The book consists of 10 chapters, each of which deals with a coarse-grained topic like progress, productivity, competitors, hiring, evolution, culture, etc. Each chapter consists of a set of ‘posts’ (think ‘blog posts’) about the topic at hand. Most of them are pretty short, yet they all contain a lot of wisdom. You might be very surprised by some of the advice they offer, or you might find yourself nodding in agreement from time to time. Or even often, depending from person to person obviously. They don’t have all the answers, and in some cases they will tell you to avoid certain things while not telling you how you should do it instead. But as they make clear in the beginning: it’s actually a good thing to just go with the flow, see how things play out and deal with problems as they present themselves, and not before that. Read their advice, stick to it, and you just might be able to prevent the otherwise inevitable slope to mediocrity that looms for pretty much every other company which sticks to mostly conventional ways of doing things.So, is this book useful for you? If you’re an entrepreneurial type, and you still don’t know the answer to this question, then you really shouldn’t be running your own business. I’d also recommend this book to anyone who is working as an employee for the following two reasons: it’ll either improve the way you do parts of your job depending on what your responsibilities are, or you’ll figure out whether or not your current employers are worth working for in the long term . That’s a win-win situation if you ask me. The only people who won’t really get any value out of this are people who are already ‘institutionalized’… those who have been working in big companies for a while now and wouldn’t be able to adapt to life without them.I can imagine that quite a few people who read this review will still be skeptical. That is of course your prerogative but keep in mind that these guys do have a proven track record that few can match. Read the book, and you’ll understand why. If you’re still skeptical after reading the book, go out and prove them wrong. These guys would love it if you did.