Customer Reviews

Software Configuration Management Patterns: Effective Teamwork, Practical Integration

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

 

 

The authors provide useful generic definitions of the critical SCM patterns. They go onto provide direct mappings between specific tool vocabulary and the patterns. This mapping has been instrumental in establishing a common SCM vocabulary in cross division projects. SCM education and planning are greatly streamlined due to this important translation. "Patterns"is an essential dictionary on all SCM adventures.

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.

Really, really good book. We were having some trouble on our project, and I needed to convince people to change over to a new way of doing things. However, I couldn't counter the age-old "but we've always done this" attitude. So, using this book, I was able to formalize my arguments, give examples of how what we were doing could get us into trouble, and also gave them a place to refer to for best practices. That certainly helped. People are slowly coming around to making the changes and there is now hope for the project!

I took off one star because there are some quirks with the writing style. For instance, the author will be talking about something that in the end turns out to be the thing /not/ to do and then launches into what to do. This can be a little disorienting. However, this doesn't happen often, and in some cases (if you have to make arguments against something) it might even be helpful.

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.

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.

An exceedingly readable book, that is not limited to practitioners of Java. Yes, yes, here and there, the text refers to java files, but it delves no further into the specifics of the language. Rather, the principles described are good, general coding practices, for teams of two or more programmers that want to maximise their efficiency. You could be a C++, C# or even a[gasp] Cobol house, and derive benefit from reading this book.

There is minimal use of jargon. The authors appear to have gone to some trouble to make their points as simply and as broadly accessible as possible. One, possibly unintended, consequence is that a tyro programmer may consider this book trivial or vacuous. No complex UML diagrams, no intricate refactoring examples,... It may well be that an experienced old hand might get more out of the book, having endured many an unwieldy or uncoordinated project.

Another significant point is that this book is accessible to nontechnical managers. Two scenarios are possible:

1. You are a manager, possibly nontechnical. You want to avoid mismanaging a team of programmers that wants to do things their way. This book might give valuable guidelines; plus you can use it to persuade the team about the logic of your decisions.

2. You are a programmer that is in a project that has had bad management decisions. This book might offer better strategies. Plus, it gives you a way to argue them persuasively to your bosses, even if they are nontechnical.

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.

I'm a senior software engineer currently working in
the UK. Some time ago days I searched the internet
to find some information about configuration management
in order to prepare an internal seminar for some
colleagues. I needed something easily explained that
could be used as a base to prepare a seminar for
beginners.
Among other documents I came across the last public draft of
this book. I've read it from cover to cover and I've
to say that is an excellent source of readily usable

information.
The patterns can be used in the same order
they are exposed to solve the most common SCM problems.
So I've used it as the main source of
information for the preparation of the seminar.
All in all is really an excellent book really useful for beginners and experts as well.
I think it will soon become a must read for every serious
software engineer.