Thorough but readable reference book for developers who have a clear idea of how to code, but may not have thought about all the supporting activities and tools to help do them. Probably more appropriate for new developers just out of university, where computer science, but not necessarily software development, is taught. Written for developers in small companies, but addresses same topics that apply in large companies too.

This is a book that, while probably beneficial to all coders, seems particularly useful to junior programmers and technical managers. If you are a more experienced developer and/or don't develop using .NET, then you will find yourself skimming about a third of the book. Before you decide that a automatically disregarding a large portion of a book's contents qualifies that book as not worthwhile, I would point out that the other two-thirds of the contents make up for any "deficiencies." The important thing that this book does is provide a list of sorts of all of the areas that are important for a high-quality developer (or manager) to bear in mind.

Gunderloy walks through the development process, from planning to delivery, discussing many of the ideas and processes that one learns by working on a high-quality software development team. Many of the code snippets or details concerning tools are MS, if not .NET, specific. However, a junior programmer will likely learn a number of things by reading these sections - even if they do not develop .NET applications. More experienced programmers may even discover some useful notions as they peruse these sections. The key here is that Gunderloy is covering the span of the software development process instead of addressing a single area in depth. Thus, where the reader may have a number of areas of expertise, he or she stands a good chance of shoring up weaknesses in those regions between areas of expertise.

As this book is a relatively quick read and covers a wide area in less than 300 pages, it goes without saying that none of the areas discussed are covered in great depth. However, after reading it, one is more likely to be able to effectively investigate weak areas. Gunderloy does provide some useful starting places to begin these explorations.

Gunderloy assumes you can already program well. But he shows how making a commercial product means you need extra skills. It is the assimilation of these skills that makes you into a developer, in his eyes.

Unit testing is one of these skills. Vital in verifying that crucial routines work. While this might not be feasible for all routines, you should aspire to do so as much as possible. Plus, it would be good if the unit tests could be run in an automated fashion. So that you can easily and often test.

Another necessary trait is to use a source code control system. So that you can roll back to an earlier known good version if necessary. More importantly, it enables a team of programmers to work on the same code base.

Having a streamlined build is also good. It is convenient to be able to type 'make' [or the equivalent] and have all your code compile.

The book tries to cover the whole of the software development process from planning, team management, coding best practices and finally creating an installer and releasing the product. With such a broad range of topics each one is only treated very superfluosly and shallow. The author has a very tool centric view on things and as such many chapters are just a market overview of available software for the task at hand. I don't think this is of much use for the reader since that is exactly the kind of information you can gather in half an hour of internet research with google - and even after reading the book you'd still have to do this research anyways in order to gather current prices for the latest gadgets. All software solutions presented in the book are for windows only and Microsoft's tools seem to get extra focus and attention. The intended target audience for the book are independant developers and small software shops. As such the author assumes that you are wearing multiple hats and are filling all kinds of different roles from designer to coder to management. I very much liked this perspective on the software world because for one thing I am one such lone wolf developer and second because there are already tons of software books for the large corporate software developer. Those books typically assume loads of process and management and different departments etc which all don't apply for the single developer. Two important things missing in the book's coverage are two chapters: One for the time before concrete planning actually begins on the question of "what to develop" and determining markets. Another one for the other end of the road on how to market your software, how to price it and how to present and distribute it. If those were included I think the book would truly cover the complete process a lone developer goes through from idea to product.
All in all, the book gave me little new information but a good checklist to work through on a project.

Coder to Developer is one of those books that you don't read just one time. In fact, you'll want to keep this book handy because it's one of the better reference guides on the market. Creating great software means examining the process you use to design, develop, test, and distribute it. Mike does a great job of covering all of these bases and more.

The most important aspect of this book is that Mike doesn't tell you just one right way to get the job done. This book is all about options and alternatives. Sure, you can use a particular technique for testing your software, but what will that technique cost you? Mike gives you the answers so that you can make a resonable choice based on your specific needs, rather than what Mike thinks you might need.

I liked the fact that Mike used the DownloadTracker application throughout the book to demonstrate various techniques. It's as if Mike is developing this application as you read and wants to clue you in on the techniques he's tried to build a complete application--not just code snippets. So, in addition to providing you with great theory, you get to see that theory in action. This is a great book and you should have it on your bookshelf.