Title: Software Release Methodology
Author: Michael E. Bays
Review originally posted on November 2004.
This book focuses on the release aspects of SCM (Software Configuration Management) before SCM was a well-defined concept. When originally published in 1999, there were few resources available on the subject and therefore made this book a valuable resource. The author’s writing style tends to be wordy, but the persistent reader will be rewarded by discovering some of the key insights contained within.
Recommended for those who are new to the software development release process.
Chapter 1 presents an overview of the software development process including terms, definitions, and processes commonly used. This is where the role of Software Integration and Release Methodology are introduced.
Chapter 2 is a non-technical primer on files, tools, and source code. Very introductory and can be skipped by any developer.
Chapter 3 takes a closer look at source control and various issues surrounding it. It exposes the reader to checking in/out, locks, tags, branching, and merging. Various protocols are discussed as well as branch management, merging strategies, file versioning, and tagging strategies.
Chapter 4 focuses on builds and the build process. It discusses developer environments vs. official environments, build reproducibility, build tools, product building, and the source tree. Various build strategies are explored as well as controlling the developer’s build environment. Lastly, the chapter touches on build automation.
Chapter 5 covers defect tracking and introduces the reader to the various details and processes used. This is also where release documentation and defect metrics are presented.
Chapter 6 has a larger scope and focuses on the overall system integration effort as performed by release engineering. Modularization (SDKs, classes, etc) is introduced as a concept that enables this type of activity outside of the development environment. It is in this chapter that the System Integrator role is defined and presented. An interesting insight on this process is revealed in the section on scheduled integration efforts vs. event driven integration efforts. The system integration schedule is also covered as a process mechanism. For scalability, parallelism of the process is presented along with the system integration cycle. Process aspects covered include functional verification and build qualification. Finally, large scope issues such as centralized system integration, integration protocols, and change control systems are reviewed.
Chapter 7 reviews change control processes including product functionality specifications, programming and implementation style guides, and feature design. In this chapter are also discussions of code reviews, organizational wide requirements and processes, code control, and change scheduling.
Chapter 8 discusses product release classifications and numbering. Here is where alpha, beta, and final versions are defined along with coverage of patches and emergency fixes. Rounding out the topic is release packaging, customer support for the release, and actual release classifications and numbering. This last area introduces syntax used, methodologies, iteration aspects, and presentation. Of last concern are internal vs. external numbering and just in time numbering.
Chapter 9 presents release distribution, which is simply media types, installers, mastering, and release notes.
Chapter 10 discusses release engineering service strategies. This is particularly interesting for growing organizations that need to build such a team. It reviews the nature of these service groups, flexibility vs. inflexibility trade-offs, centralization vs. decentralization, and the various resource needs such a group has over the release cycle. There is also a discussion of the impact of multiple products on such a group.
Chapter 11 covers release management and planning. Various types are identified, such as reactive/chaotic, reactive/structured, informed consultant, and dictator. The author did start out on the right path here but ultimately disappoints by his rather shallow analysis of the models. The final sections of the chapter focus on process development, deployment, determination, maintenance, evaluation, improvement, and execution.