Customer Reviews

Coder to Developer: Tools and Strategies for Delivering Your Software

5 star:		(7)
4 star:		(9)
3 star:		(5)
2 star:		(4)
1 star:		(0)

 

 

When I picked up this book, I was expecting something along the lines of _The Pragmatic Programmer_ -- basic, broadly-applicable advice on designing and building better software. This book does have some of that. The advice is sound, and I picked up a couple of tips as I read. But I didn't realize that this is really a Windows .NET book, not a general software development book. The title didn't tip me off, and neither did the description on the back cover.

As someone who doesn't develop .NET software (nor even Windows software at the moment), I found myself skimming or completely skipping large portions of the book that described .NET- and Windows-specific tools. The further I got along in the book, the more I found myself reading only the general overview sections to get an idea of what Mr. Gunderloy was trying to say, and then skipping the specifics. A lot of the ideas and advice in this book are basic, so they may appeal more to beginning programmers than to experienced developers. However, the information is good, and it provides a helpful foundation for good development habits.

If you're a beginning .NET programmer, I think this would be a great book to read. If you're a beginning Mac, Unix or other non-Windows/.NET programmer, you'll probably pick up some good tips, but there are likely better books out there for you. If you're an experienced .NET programmer, you'll probably have a good background in most of the material, but the overviews of available tools might be helpful. If you're an experienced non-Windows/.NET programmer, I would not recommend this book -- the general ideas are fairly basic, and the specific advice will probably not be terribly applicable to your work.

Coder to Developer is one of the best technical books I have read in years. Like The Pragmatic Programmer and Software Craftsmanship before it, this book teaches how to be better engineer in the areas outside of strict coding. Yes it teaches a little about specific coding practices, but the intent of the book is to cover the breadth of skills required of a true developer. Skills like project management, architecture, engineering process, source code control, and relating to the customer. These are the types of career skills than will move you from a coder cog to an invaluable developer.

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.

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

I purchased this book thinking it would focus on the more esoteric principles and guiding forces that separate experienced developers from code slingers, without regard to any specific implementation, or at least consider multiple implementations and technologies. I couldn't have been more mistaken.

From the second chapter on, this book makes it clear that it was written by a .NET developer, for other .NET developers, and could care less about anything that isn't .NET or Microsoft. Worse, the "pearls of wisdom" that I was hoping to find in this book are so few and far between that even .NET developers will find themselves struggling to justify the price they paid for this book.

I absolutely do not recommend this book to non-NET developers and I am even hesitatant about recommending it to .NET programmers. There really isn't anything in here that will offer you any real insight into how to make that transition "from coder to developer", unless you're so hopelessly lost that you actually need someone to tell you that you need a source control system, and should test everything you write.

I really didn't get much out of the book. The .NET-specific content, of which there is plenty, wasn't useful or interesting for me, because I work on Java and Macintosh software.

If you're not a novice programmer, I'd strongly suggest looking over the text before purchasing.

It would, I think, be useful for a novice programmer, or someone fresh out of school who's been working on class assignments, rather than real-world projects.

The author is focused on individual or small-team development, but I would have liked to have seen quite a bit more on design and development processes.

I read this book from cover to cover, just to be fair. While I did find a few worthwhile tidbits, I would not recommend it to a professional working programmer.

The book is geared towards novices. It provides a lot of introduction and explanation of the reason to use a particular well-worn development practice, such as a daily build, and follows with a survey of the various ways to implement that practice. Often, the survey consists of listing five or so pieces of software to implement, followed by a three- or four-paragraph description of each one.

For the professional, all the major points are obvious and the implementation sections are too superficial to be educational. At best, this book might serve as a reminder of good development practices.

For the novice, I don't recommend it, either. As others have said, it focuses on .NET and novices should be learning general, widely used, transferable skills, not .NET specific skills.

That's really the problem. The book is too simple for experienced programmers and too narrowly focused for novices. It presumes that you are sophisticated enough to want to undertake an entire, professional development effort yourself (even including discussions on contracts and licensing) but also presumes that you need detailed introduction and explanation about why daily builds are a good idea. But, really, if you are taking on responsibility for an entire project, you should already know the basics. And, if you don't know the basics, you should concentrate on becoming an expert coder, not worry about broadening your knowledge to include contracts and licensing.

Maybe, just maybe, if you are a dedicated .NET programmer and you didn't come to it through Visual C++ (since any Visual C++ capable programmer always knows all this stuff), this book will be the right thing for you.

This is the most concise and comprehensive books on software development that I have ever read. It is loaded with good advice and examples. In addition, the author provides ample links and resources for more in-depth information. I recommend this for every developer out there.

While the first two-thirds of this book are excellent, it starts to go downhill towards the end. Except for the chapter on builds, everything after chapter 10 could have been omitted. This is not because the topics are irrelevant, but the material becomes much fluffier and includes less resource information than the rest of the book.

Overall a great book, but I only give it four stars. Reworking the last few chapters to match the quality of the earlier ones would push it over the top.

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.

The most important thing to know up front is that this book is very specific to doing development with Microsoft .NET technologies. It is not applicable to Java or any other development technology. This book is not about how to write code (although the author does develop an application as an example of good coding practices) but rather covers a set of "best practices" and tools for developing software better. This book does not go into much detail on each topic but rather just introduces concepts and tools and then gives references to places to find more information. This book is going to be most useful for those that are new to Microsoft .NET development or those have been doing it for a while but need to learn how to do it better. If you are a professional .NET developer who keeps up with software development best practices then you probably know most of what is in this book although you might find some of the author's links to different software tools useful. I think the book is very reasonably prices at $30 and when discounted becomes a bargain. In summary, rookies would greatly benefit from reading this book cover to cover while professionals might find the information on different software tools useful.

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.