Customer Reviews

Software Configuration Management Patterns: Effective Teamwork, Practical Integration

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

 

 

I knew this book would be different from the use of "Teamwork" in its subtitle. Many of the configuration managers with whom I've worked through the years demonstrated an attitude that was about anything but teamwork. They viewed their job as protecting the source code (and other assets) of a project to the point of getting in the way of the developers. So based on its subtitle, I had very high hopes for this book. I was not let down. This book is excellent.

The book starts with a couple of introductory chapters and then devotes a chapter to each of 16 patterns. I really like that the book devotes a full chapter to each pattern (and therefore covers substantial patterns) rather than covering each in two pages as is often the case in patterns books.

As a coach and trainer of agile software development teams, I am often asked by these teams how they handle the software configuration management with such fast-moving processes. These excellent and highly readable book has collected a wonderful set of practices and will become a part of the standard canon I recommend to clients.

Following the extremely clear patterns-based view of SCM presented in this book is allowing my organization to greatly improve our SCM processes. The patterns approach has quickly improved the communication of our process- making SCM easily understood by CM people, developers, and managers. This book and the Bays book (Software Release Methodlogy) can be combined to develop a effective, repeatable, improving SCM and release process.
To support other readers' comments (and update my review): Using a pattern language to describe SCM process has been helping people on my teams to take a more proactive role in SCM activities- identifying well thought-out branching scenarios, and how to manage their work areas (and work) to complete parallel development tasks. Impressive how describing parts of the process using several simple behavior patterns simplifies things...

This exceptionally clear and extremely concise handbook is a must read for all SCM practitioners. The book is filled with practical advice to solve classic configuration management problems that arise on software projects.

The book begins with an overview of SCM concepts and a discussion of the role of SCM in agile software development. This discussion dispels the myth that software configuration management must be process heavy to be effective.

Much of the book consists of a description of patterns (i.e., problems that occur over and over again) related to software configuration management. Each pattern is described in a brief chapter that begins with a question about a common SCM problem. For example, the chapter on the task level commit pattern begins with the question, "How much work should you do between submissions to the version control system?"

Each chapter that presents an SCM pattern describes the circumstances in which the pattern is relevant. The authors explain the pattern with the help of easy-to-understand diagrams and brief narratives of situations from real software projects in which the pattern is relevant. Most chapters also include relevant references to books and papers that elaborate on material covered in the chapter.

Perhaps the most valuable aspect of this book is that an SCM engineer can reference it when speaking to project management and members of the development team about common SCM pitfalls and practical techniques that can be used to correct or avoid these pitfalls.

This book could have also been called "Best CM and software development practices".
I've read many CM books over the years and this is one of those rare books that focuses on the "rubber meets the road" aspect of good CM and software development practices.
Many CM books out there are so theoretical that they are barely useful. This book answers many software development practice questions that I've had to address in my years of doing software process improvement and proprietary CM tool, ClearCase, Version Manager, Config Builder, Tracker, ClearQuest, and now PVCS Dimensions administration. Anyone who does CM for a living gets asked the "how do I do this" question where the question that first needs an answer is "what are you trying to do with the tool?".
This book addresses those questions in a 100% practical and easy to understand way. I recommend this book to anyone who is serious about process improvement and CM and knows that it's usually not what CM tools you have but what you do with them is what helps software development get done in a sane fashion.

Software Configuration Management (CM) is often needlessly painful. Processes don't scale, practices get reinvented after dragging everyone through long debates, shiny ... new tools get brought in as silver bullets then seem to fail. The CM failings I've seen stem in part from failure to match tools and practices to context. What works for a team of 3-5 doesn't scale once the team grows to 10 and beyond. What works when people are all within the sound of one another's voices doesn't scale when the team is split between buildings (or states).

By approaching CM from a Patterns perspective--presenting CM approaches that balance competing forces within a context--this book lays out a coherent big picture against which specific tactical decisions can be made (e.g., do we develop on a main line, do we freeze, or do we branch? when do we merge?) and then made again when the situation changes.

Don't buy this book expecting specific solutions using specific tools. The major CM systems are mentioned, but without going into detail on how to use them. Buy this book to get a good map of the problem space.

Other reviews here applaud this books content. I agree completely with their positive comments, and will not repeat them. Instead, I want to point out one shortcoming.

This book could have done a better job at laying out the descriptions of each pattern. In one of the opening chapters, in a section titled "Structure of Patterns in this Book", the author lists the different parts of each pattern. Title, picture, context, problem statement, problem description, solution summary, and unresolved issues are some of the different parts of each pattern description. My complaint is that in the chapters on each pattern, only the 'unresolved description' section is actually labeled. Labeling each section (as is quite common in other pattern books) is much easier for the reader, and makes the book a useful reference.

I'm a fan of patterns because of the succinct way they convey knowledge and practices, so I rushed out to purchase this book. I was not disappointed for a number of reasons. First, it is true to the concept of patterns, and second, it is all practical with no ivory tower preaching.

The patterns given in this book comprise a complete picture of software configuration management, and will allow you to fully understand the scope and complexity of implementing, managing and continuously improving an SCM process. From the following list you'll see that these patterns are end-to-end:
- Mainline and active development line, both of which are designed to manage baselines, as well as to promote stability in the code base.
- Private Workspace, repository, private versioning, and private system build patterns are the essence of SCM as well as reflecting best practices in team-oriented integration and testing while preserving the integrity of the code base.
- Third party codeline is an interesting pattern that I've not encountered, but one that is highly useful when you are working with subcontractors, or have outsourced some development. The patterns for task level commit and task branches are also useful approaches to team-oriented development, whether internal or distributed among subcontractors.
- Codeline policy, smoke and unit test patterns govern the SCM process and prepare for the transition from development to QA. These are core patterns that are directly tied to the development process.
- Release line, release prep codeline, and regression test patterns cover the promotion to QA and release management portions of the development process.

In addition to the patterns, which are the main value of this book, the clearly articulated chapters on pattern language, SCM concepts, and other contextual information further enhance this book, and is yet another reason why anyone interested in SCM should make reading this book a priority. The supporting web site (ASIN B0000AA6G3) contains errata, a downloadable quick reference card, and sample chapters from this book. If you are still undecided visit the site and you'll find sufficient information with which to decide.

This book was the best $45 I ever spent. Took me two hours to read cover to cover; a rarity in our industry. The book first focuses on the basics of what is SCM. It then covers various recurring patterns found in configuration management such what they call the "Private Workspace" pattern (aka developer sandbox).

This book was worth every penny just for the diagram of a good way to structure third party code - something I'd been wracking by brain around with for a while.

The book is platform, programming language, and tool agnostic. It is useful if you are building the next great mod_web application in mod_perl, a or if you are shipping a "real" boxed software product in C#. You could be using CVS, Preforce, VSS, or Subversion (which wasn't stable at the time of publication and thus not mentioned anywhere in the book).

My point? Get this book.

The writing style is excellent and flows nicely, suiting a wide range of SCM folks from newbies to old hands. There's a lot of really good advice for small teams, well.

Some examples of real-world setups would be nice, as I'd assume it's hard to go from this text directly to concrete details. Additionally, some of the patterns encouraged don't scale well past teams of about 50 developers or when you're dealing with a long-term multi-version piece of software that has folks working on the version 2 but also issuing QFEs, GDRs, and SPs concurrently on the old version and trying to keep them in sync on the new version. Of course, not many folks but MSFT have to do that! Still, making sure that your SCM story will work in servicing is arguably the hardest thing after making sure that you've got something developers can understand and use on a daily basis, and it's something that can really bite you if you do it wrong.

One of the most annoying things about Software Configuration Management is the amount of different terms that exist - especially when the refer to the same things! This seminal book helps address this challenge by identifying a set of readily consumable and well defined patterns. If you don't know your code mainline from your active development line, or how developer testing, building and integration are all linked together, then you need to read this book.