Coder to Developer: Tools and Strategies for Delivering Your Software

Mike finds the right depth in the book, not too deep into the technical details, nor so abstract as to be an architectural tome for the ages. When it comes to coding the book is primarily focused on C# on the .NET platform, but you should let that dissuade you. He covers a wide variety of techniques and technologies and the book is valuable for anyone involved in the engineering side of the software industry.

The book follows the rough timeline of application development, from nailing down the feature set in the first chapter to delivering the product in the last chapter. The book is fairly brief (roughly 300 pages). Chapter by chapter:

Chapter one covers planning out your project. It covers gathering requirements and how to decide on a development methodology for the project. It gives a decent overview of all of the popular development methodologies and pointers as to where to learn more. It also covers some software that you probably didn't know was out there but that can help you as you nailing down the feature set.

Chapter two covers architecture and gives a nice overview of both the UML and Patterns side of the business, and the more fast and loose XP development process.

Chapter three covers source code control and it's one of the best chapters in the book. When I got through chapter three I knew already that the book was worth the purchase price. This chapter covers in a very concise manner the best practices of source code control and the products that are available on the market.

Chapter four is a brief introduction to sane coding practices; using tools like assertions and exceptions, and how to comment code effectively.

Chapter five gives a high level, but insightful, summary of the unit testing, system testing, and the technique and benefits of test driven development. This is one of the best chapters.

Chapter six covers the IDE and how to make the best use of it. This is a fairly Microsoft specific chapter, but you can learn some tricks that are applicable to other development environments.

Chapter seven covers a topic which is often ignored, the skill of digging into code at the system level and finding your way around. This one is definitely .NET specific, and it was a little too low level for me. Your mileage may vary.

Chapter eight covers code generation, a topic near and dear to me. It's a very practical chapter introduction and should save .NET developers a lot of time.

Chapter nine is about bug tracking and fixing. As with the rest of the chapter this is a concise introduction to the topic that gives you a feeling for the benefits of bug tracking, which should be obvious, and advice about tools and process. Once again I have never seen a book that provides a good argument with the brevity of Mike's writing style. Code Complete, for example, covers this stuff, but it's thick and impenetrable. This book gets right to the core of the topic and presents it in a very accessible way.

Chapter ten covers logging, which can be overdone. Again pragmatic and practical advice. But this chapter is fairly .NET specific.

Chapter eleven is about the dynamics of small teams. He introduces Instant Messaging, Wikis, and group ware. A nice introduction, but a bit brief.

Chapter twelve is about both end-user and code documentation and the tools to develop it quickly.

Chapter thirteen covers the build process. The tools are fairly .NET specific (nant), but the process and the methodology are appropriate to any production software development shop. Another nice chapter with content you will be hard pressed to find in such a concise form anywhere else.

Chapter fourteen is about licensing. This is important for open source developers. It has a nice comparison of the popular open source licenses and makes sense of all of the legal gobbledygook.

Chapter fifteen is about installers and application delivery. It's primarily for .NET desktop application developers.

There is an old story about a developer that is walking out of a tech show empty-handed, he says to the security guard that he 'Stole a fortune'. The security guard, puzzled, asks, 'But you have nothing.' The developer responds that he now has new ideas! This is that kind of book. It's full of ideas for the software process, ideas about how to code, and ideas about tools you can use.

If you are an engineer who is passionate about his craft, this is an important book for you to read. But you probably know that already.


Required reading for software developers   May 4, 2004
Wm Eric Brunsen (Colorado Springs, CO United States)
19 out of 20 found this review helpful

I purchased this book prior to it being available, based on articles and newsletters that I had read by the author. I eagerly awaited its release and delivery to my doorstep. Upon receiving the book, my initial reaction was one of skepticism and worry. I have MANY other computer books that don't claim to cover nearly as much ground, and yet, are much longer. Knowing the level of Mike's work (from articles and newsletters), I kept an open mind and started reading. After 3 days of reading and digesting the information in the book, I must say that it is one of the best computer books I have ever read (and one of the very few that I have read cover-to-cover, and not only cover-to-cover, but cover-to-cover to the exclusion of all else). After reading the first couple of chapters, I decided to put aside the software application that I was working on, and read the entire book. I will now go back to the start of my application and apply the lessons from the book to the project. I don't feel that I have "lost" the time working on the software project, because I think that what I learned in the book will more than pay for itself in saved time during development.

This book is not a "how-to" book, but rather a "what-to" book. That is, there are very few "step by step" examples for a given task (such as unit testing), but rather, an entire collection of tasks that any coder/developer should not only know, but practice regularly. However, the entire book itself can be viewed as a step-by-step guide to software development from start to finish.

While much of the book seems to be "common sense" as you read through it, I found at least 1 thing that I didn't know or hadn't considered in every chapter. In many respects, not only can this book be used to get a handle on what needs to be done, but it can also be used as a task list for software development projects.

This book, for me, will be used time and again as a "blueprint" for creating software. The structure and organization of the book make it an excellent "task list" for creating good software from start to finish. Using the book, a person can start in the "Planning" phase of the application and move step-by-step through to the "Delivery" phase.

Even though the focus is on the single developer or small development team, the majority of the lessons can be applied in any project, however large. For example, the majority of the book could be applied to the development of a single object in a large scale project.

I am sure there will be readers who bought this book expecting it to tell them how to do everything in a 123 manner, that they would ever need to do in order to be a successful software developer, that will give this book a bad rating. Those people, however, should seriously consider how large that book would be. For every chapter in the book there are many books that are devoted specifically to that very topic. I think that this is actually the strength of this book, it doesn't try to tell you how to do every task (such as unit testing), but rather informs you about what tasks you need to do, why you need to do them, some of the tools that can be used for the task, and where to find resources related to the task. Mike also gives a brief (but informative) review of several of the tools that pertain to a particular task.

Even if the book itself was not worth the money (which it definitely is), the list of tools and links to resources is an incredible time saver.

This book should be REQUIRED READING in every CIS/CS/IT/IS university/college program. I will be asking my manager to purchase a copy for each of the developers in our team.

I would suggest that anyone who is developing software or writing code, order this book, and then take the time to read it thoroughly as soon as you get it, and then go back to your current project. You will NOT be disappointed.

Eric


Great addition to the library of any .NET developer   June 19, 2004
7 out of 7 found this review helpful

If you're a .net developer working alone or in a small team, this book will be a great addition to your library. It's basically a summary and repository of all the good practices that they don't teach you in CS classes in college but that you learn the hard way in real life. Although it's definitely geared more towards Microsoft .NET development (Chapter 6 for example deals entirely with "pumping up" the Visual Studio IDE), it still has a lot of tips and good practices to offer to any developer regardless of their platform. The author concisely reviews many tools to support the practices he's discussing (Unit testing, source control, daily builds, etc.) Those reviews alone are worth the purchase price of the book since you might (as I have) pick up a tool or two that will save you a lot of time in your development work (for a complete list of all the tools discussed in the book, see the book's companion website at codertodeveoper.com). Another reviewer concluded that the book was too shallow for experienced programmers and too narrow for novices. I believe it's quite the opposite, it's a great summary for experienced developers and a great start for novices.


Absolutely required reading!   June 13, 2004
Bob Walsh (Sonoma, CA United States)
3 out of 4 found this review helpful

As freshly-minted computer science majors pick up their diplomas, they should buy, beg or borrow this book. Coder to Developer will take them from the mindset of interesting but academic code problems into the trenches of achieving professional success in this globalized world.

Coder to Developer pulls together all the aspects of being a successful programmer who delivers solid code on time.

Other reviewers have said this is only a .NET programmer book. Not true. While .NET programmers will benefit the most from buying Coder to Developer, Java, VB6 and even open-source diehards will find more than enough to be worth their while.


A Cut Above the Rest   April 24, 2005
John Paul Mueller (Wisconsin)
0 out of 2 found this review helpful

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.