- Paperback: 233 pages
- Publisher: Wrox; 1 edition (May 5, 2008)
- Language: English
- ISBN-10: 0470259248
- ISBN-13: 978-0470259245
- Product Dimensions: 7.4 x 0.6 x 9.3 inches
- Shipping Weight: 14.4 ounces
- Average Customer Review: 3.9 out of 5 stars See all reviews (6 customer reviews)
- Amazon Best Sellers Rank: #2,680,883 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Code Leader: Using People, Tools, and Processes to Build Successful Software 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
From the Back Cover
Code Leader: Using People, Tools, and Processes to Build Successful Software
"Patrick is a pragmatist with a purist's knowledge. He has a deep understanding of what 'smells' right, and he knows when and how to find the right balance to get the job done. This philosophy of balanced 'pure pragmatism' pervades this book and makes it useful."
—from the foreword by Scott Hanselman, Author of ComputerZen Blog, www.computerzen.com; Senior Program Manager, Developer Division, Microsoft Corporation
Writing code is rewarding, but writing high-quality code, on time and at the lowest possible cost, is what makes a software project successful. As the role of a professional developer has evolved and taken on additional responsibilities, it is now necessary to work in concert with a team in order to improve both the process and final results of a software project. This unique book introduces a set of concrete best practices and construction techniques that can be applied to the development process and to actual code construction, so that you can confidently solve business problems rather than deal solely with pure coding tasks.
Patrick Cauldwell understands that it is no longer sufficient to just write software that solves a problem; it must also be fast, scalable, reliable, and easy to use. In this reference, he explains how to build software that is of high quality at a lower cost and shares with you the practical steps you must take in order to transition from software engineer to technical lead.
What you will learn from this book
Practical steps you can take to combine different developmental philosophies, processes, and construction techniques into a unified approach to software
Methods for deciding which parts of a project you need to write yourself versus what you can buy or reuse
Tools and processes you can employ to improve source code quality and maintainability
How to create, run, organize, and measure tests, and then make them more useful to developers and testers
Ways that programming by contract can make your code easier for developers to understand and use
Recommended techniques for handling errors in your code that will make your application easier to debug and support
Who this book is for
This book is for experienced software developers who are looking to improve their development skill set and bring a higher level of discipline to a project.
Wrox guides are crafted to make learning programming languages and technologies easier than you think. Written by programmers for programmers, they provide a structured, tutorial format that will guide you through all the techniques involved.
About the Author
Patrick Cauldwell somehow found his way to a career in software despite earning a bachelor’s degree in East Asian Studies. From a work-study job in the student computer lab at college through early jobs in quality assurance and localization, and finally into full-time software engineering, Patrick has always been interested in what makes computers tick. He’s worked in a wide range of software operations, from very large projects at Intel to a very small start-up to a consulting job in the midst of the .COM boom.
If you are a seller for this product, would you like to suggest updates through seller support?
Top customer reviews
Enough said, this book is simply about practical (very practical!) Agile ALM for .NET/ASP.NET projects in C#. And don't get me wrong, that's a VERY good book on the subject! It helped me complete my checklist for the day-by-day software development activities with some new tools and practices.
And unlike so many other authors who wrote about building software, but they rather build experimental software and write books, you feel the author here is a guy who constantly gets his hands dirty with plenty of enterprise projects, for real clients. And I loved this.
As you read it, you'll find that much of it sounds like common sense, like some long-forgotten tidbit that you didn't realize you already knew. That's the strength of the book - bringing those things to light and showing you the benefits. The best example of this is the "Done is Done" chapter, bringing up the idea that sometimes when a developer says that a task is "done," there really are things left to do... and ideas on how to solve that so when someone says something is "done," all of the i's are dotted and t's are crossed.
At the end, the book brings all of the lessons together in a case study showing a developer performing a task from beginning to end and using the tenets described in the book. It's a good way to put everything into perspective and solidifies the concepts.
If you already practice things like test-driven devleopment and continuous integration; if you already know about the benefits of the MVP/MVC patterns (and use them); if you already know what dependency injection is and how it affects your testability; if you've got some nicely structured source control policies and do branch/merge per task (and know why that's good)... you may not get as much out of this book. You're probably already doing most of the stuff discussed and don't need to be sold a car you've already bought (so to speak).
Only two technical downsides to this book:
First, while the content could apply to any software development project in any technology, most of the tools mentioned and code samples are specifically .NET-oriented. That may be a little off-putting to non-.NET developers, but if you can get past that, you'll be rewarded.
Second, the text is abnormally small. I compared it to some of the other Wrox books I've got and there's got to be a two-or-three point size difference here, which makes the book lightweight but might give you a little eyestrain.
If you're looking for complementary books to this one, check out Coder to Developer: Tools and Strategies for Delivering Your Software by Mike Gunderloy. The two offer similar types of advice - ways to go beyond "just coding" and take your projects to the next level. While there are some overlapping topics, the two really are more complementary, each offering great guidance to help you sharpen your saw.
This book does discuss code, but isn't full of code samples because it isn't meant to be a development book; rather, it looks at the practicalities at a higher level to discuss the rational for using or not using a technology or technique. Overall, the book is a quick read, covering several topics and delving into some specifics, but only discussing a few topics in different arenas. For instance, the MVP design pattern is discussed, but this design pattern is the only pattern discussed in detail in the book.
I did find the section on creating unit/integration tests especially useful because the boundaries in my unit tests were a little gray, some being complete unit tests, while some falling under the integration test scenario, and the detailed explanation about this approach. No good application goes without source control, analysis tools (on some occasions), and tracing capabilities, and Patrick discusses each of these with good details about how a project can make the most of these points. He gets pretty detailed about the options that an application can make use of with source control, and brings light to statistical analysis capabilities in the tools on the market.
I would have like to see this book go further with what the book covered. It's a quick read (232 pages) and is generally easy to read, but there are a lot of other important topics that come with software design I wish were included.