Rating: 
Summary: Good .NET practices......for a starter....
Review: Seriously people, this should be named as "From .NET coder to .NET developer". It cannot be denied anywhere in the book about the base fact that the author is trying hard to get the "developer" mindset into the traditional programmer....but he concentrates soo much on .NET that by the end of the 300 pages you realized that you can do so well in a .NET environment.
Of course, this is one of the books where you have the feeling of "being elightened" as you read every page (almost every page)...and new tools to use. The author provides a not soo complete comparsion of the features of the tools he describes...but he makes it specific of the tools he uses and how they helped him...which is good.
The bad part of the book is about the sample application....the download tracker. I read the entire book...cover to cover....and still am lost as to what he did eventually with the application. Yes...he starts off good on gathering requirements....bla bla bla...but after the intial start-up...he kind-off pushes it to the back..and makes it dissappear....which was bad. The only consolation is that he provides a website with the code for the sample application.
As for the million dollar question...."Would I buy this book?"......Yes
This book is recommended for a real "programmer/coder".....to get into the shoes of a "developer".
Rating: 
Summary: Absolutely required reading!
Review: 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.
Rating:
Summary: Great source of ideas, techniques and technologies
Review: 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.
Rating:
Summary: Quality read
Review: I am surprised at the number of people that complained about the .Net specific material. I have read many books using JAVA and other languages that translated well to my current development efforts. It's how the tools are used not what the tools are.
This book is a great introductory text into general programming techniques: take advantage of your IDE, use tools that complement your IDE, use test driven development, map out a project, team development, track your time, etc.
Almost all the subjects deal with programmer professionalism. Subjects that we take for granted that no one really writes about and most programming texts do not delve into: leverage your tools, look for resources beyond the accepted tool set. Will this make you a top notch programmer? No, but it's like having a break room conversation with a programmer ace and realizing that what you do could be a lot easier.
Rating: 
Summary: Should have been titled ".NET Coder to Developer"
Review: 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.
Rating:
Summary: Great addition to the library of any .NET developer
Review: 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.
Rating: 
Summary: Best for .NET-using novices
Review: 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.
Rating:
Summary: Excellent book -- buy it now.
Review: I really enjoyed this book. Specially the chapters on Unit Testing, build process, and code generation. Mike has tremendous industry experience and it clearly shows in the book. I was wondering what he thought about code generation software and Mike addressed it very well. Good job Mike and keep it up.
Rating:
Summary: Great addition to the library of any .NET developer
Review: 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.
Rating:
Summary: Best practices and tools for Microsoft .NET development.
Review: 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.
| 
