Customer Reviews

Code Leader: Using People, Tools, and Processes to Build Successful Software (Programmer to Programmer)

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

 

 

"Code Leader" is a book for developers who have been on a few projects and are ready to take that next step beyond just the "code" part of "coding." The book covers topics like when to build components vs. when to buy them, good testing practices, automating your build, and analyzing your code to learn where to improve it. Each topic is addressed at a reasonable pace, not miring you in super-low-level detail but providing enough information to get the point across.

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.

On my flight I had a chance to finish reading the book. It is a good source for ideas and concepts that any "solid" developer should employ on a daily basis. Topics such as TDD, build vs. buy, CI, choosing the right tool for the right job, contract driven development, and much more.

The book goes over subjects showing tidbits of everything, and could be probably expended and extended at least several times more. But then it would probably become "Clean Code" and "Agile Principles, Patterns, and Practices" clone, which author probably didn't want to create.

Overall, I liked the book as an introduction to so many "Alt [...]Net concepts in a single source. What I missed in this book is the human leadership in the code, the human-factor in code creation, the behavior and interaction between people that work on the same software. IMHO, code leadership is not only superiority in machine code, but also in the team environment.

This book is for experienced developers looking to take their skills to the next level. This is not a book about project management or development methodology. It's about practical techniques and practices that will help you focus on delivering software at a higher quality.

The book is divided in 3 parts. The first one, "Philosophy", describes ways of approaching problems rather than a specific solution, covering topics such as Test Driven Developement (TDD) and Continuous Integration (CI).
The second and third parts represent more concrete process and construction techniques that can improve your code and your project. They focus on the pragmatic rather than the philosophical. The topics covered in this section are: Source Control, Static Code Analysis, Dependency Injection (DI), MVP Pattern, Error Handling and Tracing.
The last chapter contains a case study using the main patterns, practices and methodologies explained in the book. I would have liked this part to be more extensive.

I think the book introduces very well the topics covered, the latest methodologies and practices in software developement, as well as some important aspects like Error Handling and Tracing. It's a good introductory book of these topics, but I would recommend you to read more in depth books of each aspect if you want to really master them.

This book does a fantastic job of presenting auxiliary processes in the software development lifecycle (processes such as unit testing, source control, continuous integration, etc.). It clearly explains the value in each process it describes, as well as various tools and options to consider. It also suggests aspects of software development itself such as the MVP (Model View Presenter) pattern, contract usage, tracing, and error handling. As with the processes, these aspects are presented clearly, objectively, and with common options and variations spelled out.

I got this book because i'm completely self-taught in programming (including mostly Wrox books) and I thought it would be useful to get more background.

I was right. I've learnt a lot about how the programming, testing, versioning process works in general, as well as some specific issues that come up with the different methods. So for me it was useful.

If you have been working with programming in a business capacity already, or are certified/graduated in IT, this probably is below your level, although it's always nice to check if there are other ways of doing thing that you may want to think about.

This book tries to get any leader of a project in any type of role up to speed on the latest technologies, concepts, or decisions that a code leader has to go through, such as build vs. buy, whether TDD practices are practical, or the value of limiting dependencies.

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.