Coder to Developer: Tools and Strategies for Delivering Your Software (Paperback)

by Mike Gunderloy (Author), Sybex (Author) "So there you are with your shiny new IDE and your coding skills and a vague idea of what it is that you want to..." (more)
Key Phrases: source code control database, beta testing approach, download engine, Download Tracker, Visual Studio, Windows Installer (more...)

Editorial Reviews

Product Description
Are you ready to take the leap from programmer to proficient developer? Based on the assumption that programmers need to grasp a broad set of core skills in order to develop high-quality software, "From Coder to Developer" teaches you these critical ground rules. Topics covered include project planning, source code control, error handling strategies, working with and managing teams, documenting the application, developing a build process, and delivering the product. All of the techniques taught in this unique book are language and platform neutral, and were selected to help you effectively design and develop complex applications.

From the Back Cover
No one can disparage the ability to write good code. At its highest levels, it is an art.

But no one can confuse writing good code with developing good software. The difference—in terms of challenges, skills, and compensation—is immense.

Coder to Developer helps you excel at the many non-coding tasks entailed, from start to finish, in just about any successful development project. What's more, it equips you with the mindset and self-assurance required to pull it all together, so that you see every piece of your work as part of a coherent process. Inside, you'll find plenty of technical guidance on such topics as:

Choosing and using a source code control system; Code generation tools—when and why; Preventing bugs with unit testing; Tracking, fixing, and learning from bugs; Application activity logging; Streamlining and systematizing the build process; Traditional installations and alternative approaches;

To pull all of this together, the author has provided the source code for Download Tracker, a tool for organizing your collection of downloaded code, that's used for examples throughout this book. The code is provided in various states of completion, reflecting every stage of development, so that you can dig deep into the actual process of building software. But you’ll also develop "softer" skills, in areas such as team management, open source collaboration, user and developer documentation, and intellectual property protection. If you want to become someone who can deliver not just good code but also a good product, this book is the place to start. If you must build successful software projects, it’s essential reading.

See all Editorial Reviews

Product Details

• Paperback: 352 pages
• Publisher: Sybex; 1 edition (April 9, 2004)
• Language: English
• ISBN-10: 078214327X
• ISBN-13: 978-0782143270
• Product Dimensions: 8.8 x 7.5 x 0.8 inches
• Shipping Weight: 1.2 pounds (View shipping rates and policies)
• Average Customer Review: 3.9 out of 5 stars See all reviews (23 customer reviews)
• Amazon.com Sales Rank: #532,306 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

70 of 70 people found the following review helpful:

3.0 out of 5 stars Good foundations, too technology-specific for me, June 14, 2004

By	Sean Harding (Seattle, WA USA) - See all my reviews (REAL NAME)

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.

22 of 23 people found the following review helpful:

5.0 out of 5 stars Great source of ideas, techniques and technologies, April 23, 2004

By	Jack D. Herrington "engineer and author" (Silicon Valley, CA) - See all my reviews (TOP 500 REVIEWER)    (REAL NAME)

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.

19 of 20 people found the following review helpful:

5.0 out of 5 stars Required reading for software developers, May 4, 2004

By	Wm Eric Brunsen (Colorado Springs, CO United States) - See all my reviews (REAL NAME)

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