People always ask me what I'm reading, so I figured I'd post a photo of the books that are currently on or above my desk. Some of these are older, but many of them are books I've either recently read or are currently referring to. This is a small subset of my book library. It would take more than a few blog postings to cover everything on my shelves. So, we'll start with this:
The books above the shelf are interesting, but let's focus on the titles down below...they're the ones I reach for most often. Here are my quick impressions:
The Pragmatic Programmer: An excellent book that discusses many core development practices including prototypes, domain languages, source control, debugging, exceptions, refactoring, requirements and specifications, testing, etc. Very easy to read, and one of my personal top 10.
Professional Software Development: From a favorite author, Steve McConnell, a book about professionalizing software development. I originally thought this would be a book of practices, but it is more a discussion about the need for the software industry to mature and evolve to become a more rigorous profession (similar to doctors, engineers, lawyers, etc.). I like Steve's ideas, and I think the industry will eventually need to mature along these lines, but it wasn't what I expected...my own fault.
Code Complete: Second Edition: Another McConell title that is a follow-up to his classic original. This book just showed up at my doorstep, and if it's anywhere near as good as the first edition, this will remain near the top of my must-read list for any developer. Code Complete is an excellent and detailed look at practical software construction. It even has its own site.
Extreme Programming Pocket Guide: A short, sweet, and consice guide to the core tenets of Extreme Programming. It's not detailed enough if you're new to Agile techniques, but it's a very handy reference if you are. It's by O'Reilly, so we expect nothing but the best.
Agile Software Development: Principles, Patterns, and Practices: I'm about half-way through this book, and I would highly recommend it to anyone who wants a very good introduction to Agile development practices. Robert Martin (of Object Mentor, Inc.) is an excellent writer, and the text is a very easy read. He fills the book with a number of informative, real-world scenarios and lots of code for illustration. He also covers design patterns.
Refactoring: Improving the Design of Existing Code: This classic book by Martin Fowler is the best introduction to the concept of refactoring. After the introduction, the book becomes a very useful reference that helps guide the reader through many, many useful refactorings. Definitely one to have on your own shelf.
Design Patterns: Another classic book that should be on every developer's bookshelf. Written by the “Gang of Four,” this book introduced the concept of a design pattern and contains 23 real-world, common patterns that any developer at any level can benefit from. You'll probably recognize many of them, but you'll also appreciate the thought they've been given and reach for it as a reference as you're architecting your software. Not to be confused with Dating Design Patterns.
Pattern-Oriented Software Architecture, Volume 1: A System of Patterns: Commonly referred to as POSA, this is another book of design patterns. The patterns aren't as common as those found in the Gang of Four book, but it is a great addition and handy to have on your shelf. Model-View-Controller and Blackboard are only two of the patterns that might be used more frequently.
Patterns of Enterprise Application Architecture: Another Fowler book, this is a comprehensive look at design patterns that are useful for enterprise development. If you're working in an organization that deals with specialized applications, transactions, databases, etc., and you're interested in things like queries or object-relational mapping, this book is for you. If you write shrink-wrapped commercial software, many of the concepts will still apply, but that is not the book's primary focus.
Design Patterns in C#: A recent purchase that I've only started to read. From a quick scan, it looks like a good C# version of the 23 patterns presented in the original Design Patterns by the Gang of Four. The jury is still out, but it looks promising.
.NET Framework Standard Library, Annotated Reference: Volume 1: Brad Abrams blog is a favorite of mine, and I'm always learning something new. He's mentioned this book a number of times, so I finally picked it up. I've only scanned it, but I really like the annotations that describe thoughts, facts, insight, and tips about the classes in the standard library. Not for the casual 9-to-5 developer, in my opinion.
Domain-Driven Design: Tackling Complexity in the Heart of Software: This book rocks. It jumped immediately to my top 10 list, and I expect it to remain there for awhile. Eric Evans is eminently readable and extremely practical. It is obvious that he has had many years of real, large-project experience, and the book does an excellent job describing how to design an object-oriented system by leveraging and successfully interacting with domain experts. It will probably appear mundane to an average developer, but this is a must-have resource for developers and architects who work with domain experts and want to realize their vision with an extensible and maintainable object model. Go buy it now. It also has its own site.
Object Design: Roles, Responsibilities, and Collaborations: If you've never done real object-oriented design (and there are many people who think they're doing OO, but in fact, they're just putting procedural code inside of objects), this book is a great introduction. It covers candidate selection, stereotypes, responsiblities, collaboration, and development of a flexible model. Not a “top 10” book, but a good one nonetheless.
Object Thinking: Based on its description, I was really looking forward to this book. And after reading a couple of chapters, I decided to give it a little more time. And I kept reading. And yes, there is some interesting history, and there are mildly interesting tangents into philosophy, but overall, Mr. West seems to want to listen to himself talk and drop names. He makes some good points about what it means to truly be an object in an object-oriented system, and there are kernels of good information sprikled throughout the text. But, in the end, this book wasn't written for the audience. It was written for Mr. West. Read Domain-Driven Design instead (or Object Design for that matter).
Test-Driven Development in Microsoft .NET: I haven't read this one yet, but it's coming up on my schedule (yes, I have to schedule these things). James Newkirk (of NUnit fame) is one of the authors, and I peeked at the chapter on testing with databases which looked pretty good. Otherwise, I can't say much until I've read it.
Balancing Agility and Discipline: A Guide for the Perplexed: This book discusses both Agile software development techniques and more traditional methodologies. It then talks about successfully balancing different aspects of each for different project types and sizes. If you're in an organization that is interested in Agile development, but management isn't quite yet sold on the idea, this is a good book to read. It can either be used as evidence to support your case, or it can help you blend some Agile techniques into a traditional style which might make the transition easier for those who might be uncomfortable.
Coder to Developer: Tools and Strategies for Delivering Your Software: A great book by Mike Gunderloy that I have reviewed elsewhere on my blog. It has its own site.
Writing Secure Code: Second Edition: I'm sure you've heard about the Microsoft security push, and volume 2 of Michael Howard's book contains a lot of lessons-learned from our internal experiences. Many very good techniques are discussed, including security principles, threat modeling, buffer overruns, running with least privilege, defending against bad input, reviewing code for security, and many more. If you write code and you care about security (which should be every developer), I can almost guarantee you that this book will be very insightful. Highly recommended.
I guess my “quick overviews“ weren't so quick, but hopefully they were helpful. If anyone would like more insight into any of these books, leave a comment, and I'll try to fill in some details. If enough people ask, I'll write a short book review as a posting.
We’ve struggled with database unit testing on our NxOpinion project, if only because we’re using a third-party object-relational mapping tool that doesn’t normally expose its transaction. Fortunately, we were able to make some slight code modifications to expose the transaction, and we’ve been successfully using a rollback technique to preserve the integrity of our test data. But because we don’t want to maintain a dependency on the third-party mapping tool, we’re in the process of writing our own database unit testing framework. Roy Osherove has posted a recent article titled Simplified Database Unit testing using Enterprise Services that provides an overview and some good insight into another possible solution.
Update: James Newkirk points out a series of related articles by Steve Eichert.
A new episode of The .NET Show is now available. In this episode, Sanjay Shenoy and Glenn Pittaway cover some of the core architectural concepts associated with several of the Fundamentals of Longhorn (User Experience, System Security, Application Deployment, System Manageability, as well as many other features and capabilities). Later, Jeffrey Snover and Jim Truher provide an exciting demo of "Monad" (aka. MSH), a new and highly programmable command shell that will be available in Longhorn. Check out Robert Hess’ blog for The .NET Show for additional photos and episode details.
From the capable group at Vertigo Software (the same folks who produced the venerable IBuySpy and Quake II .NET) comes FotoVision, a suite of applications that allow you to organize and manipulate digital photos and share them on a web site. A full Windows Forms desktop client is provided, along with an ASP.NET web site that exposes some Web Services, and a Pocket PC application that leverages the .NET Compact Framework. Additionally, there are a number of good white papers that explain the architecture and technology behind the solutions. And if that isn’t enough, the full source code for all three applications is provided in Visual Basic .NET (included in the installation).
These applications are well-architected and represent a lot of qualified design, and I would recommend them as great learning tools. Even if you’re not interested in the underlying technology, the applications are very easy to use and are a powerful solution for easily sharing your digital photos. Oh…did I mention that all of this is free?
Over the past week or so, I’ve had a few people ask me questions that end up relating to HTTP traffic (usually ASP.NET-related). If you’ve never actually watched the traffic between your client and the remote server, you’re missing out on a lot of great insight. Two of the questions related to ASP.NET ViewState and bandwidth usage, and the other related to Web Service requests. I used to recommend a freely available tool called ProxyTrace (which has served me well for many years), but I’ve recently come to like Fiddler, which is also free. Although you can get a lot of this information by running NetMon, these two tools are targeted to HTTP, so they’re able to parse and display the traffic in a much more readable format. If you do Web Services or are just generally curious about what ASP.NET (or any site for that matter) is sending over the transport, check out these tools.