This chapter is from the book

In this Introduction, I briefly introduce configuration management (CM) and some basic information on how you might approach implementing CM best practices. It is common for organizations to focus on implementing only a very narrow functional area to address a specific goal or problem. In practice, this might be a perfectly fine thing to do, but it is also important to understand how each functional area of CM impacts the other. It has been my personal experience that CM consists of six functional areas, which I will describe below and throughout this book. Implementing good CM is not easy and requires a considerable amount of hard work. This introduction will help us start our journey.

Configuration Management Consists of Six Functional Areas

The six core functional areas of CM are as follows:

Source code management

Build engineering

Environment configuration

Change control

Release engineering

Deployment

Source code management involves the control of every piece of computer code, including source, configuration files, binaries, and all compile and runtime dependencies. We usually refer to all these artifacts as configuration items (CIs).1

The main goal of source code management is to effectively safeguard all the project resources. I always called this locking down the code. Source code management also involves creating a permanent record of specific milestones in the development process. This is known as baselining your code, and it is a critical CM function. Source code management also involves creating code variants to successfully manage parallel development, bugfixes, and globally distributed development. We discuss how to assess your source code management requirements and plan interventions to improve your source code management practices. We also look at how source code management is often overengineered, resulting in unnecessary complexity and automation that does not work reliably.

Build engineering involves the selection of a specific variant in the code (e.g., baseline) to reliably compile, link, and package code components. Build engineering adds value by providing a repeatable process and the management of (often complex) compile dependencies. We discuss how to implement effective build engineering to help improve your team's development process. We also discuss the value of continuous integration (CI) versus the (usually) less-rigorous nightly build.

Environment configuration involves managing the compile and runtime dependencies that can often change as code is promoted from development to test to production. Environment configuration also involves managing the environments themselves often designated as development, test, integration and production.

There are different types of change control. The most commonly implemented change control practice is essentially a "gatekeeping" function that prevents unauthorized releases from being promoted into production (or QA for that matter). There is also a priori change control, whereby intended changes, to the code, are reviewed (before they are made) and permission granted (or denied) to make the proposed changes. We discuss when a priori change control is commonly used and when it is instead left to the project or development manager as an implicit task. We also discuss the other types of change control that are commonly seen in organizations. In all, I define seven different types of change control. I also describe how they are commonly used in practice.

Release engineering involves the packaging and identification of all the components built in the build engineering function. This is somewhat different in a corporate IT function versus a software vendor. We initially focus on corporate release management in a corporate IT environment, and then discuss how this differs slightly for a software vendor (e.g., deploying packaged releases to customers). Deployment involves the staging and promotion of packaged releases and, in an IT organization, is usually performed by the operations team. Deployment also involves the monitoring of the production (and QA) environments to confirm that there are no unauthorized changes. Deployment for a software vendor usually refers to delivering the packaged release to a customer along with the requirement to manage updates and patches as needed.

All of these functions are part of a comprehensive discipline that is known as configuration management (CM). Software configuration management is a specialization of CM. Equally important and frequently overlooked is hardware CM, which we discuss in Chapter 8, "Hardware Configuration Management."

Understanding the Linkages

The six functional areas of configuration management impact each other in many ways. Build engineering is almost impossible to do well without effective source code management practices. Release management just won't happen if your releases are not built correctly, especially in terms of identifying all configuration items, as we describe in Chapter 2, "Build Engineering." Environment configuration impacts build engineering, release management, and deployment. Of course, deployment is almost impossible if the releases are not packaged correctly. All of these functional areas are impacted by change control best practices. For example, an effective change control board (CCB) will review the CM plan and release management automation before giving permission for the release to be approved. We discuss change control best practices in Chapter 4, "Change Control," including after-action reviews to ascertain whether mistakes could be avoided by improving any of these configuration management best practices.

The Traditional View of Configuration Management

They are absolutely correct, and I am not changing the substance of configuration management, but I believe that the terminology used in traditional CM is less than clear and, in this book, I seek to make the terminology that describes configuration management compelling. Generally, I jab back by challenging them to give me a clear and sensible definition for status accounting. In my opinion, the terms configuration identification and configuration audits are not much more intuitive. On the other hand, most developers have a basic idea of what's involved with source code management, build engineering, and release management. Let's bridge the gap with the traditional terminology and then dive deeper into CM.

Configuration identification refers to providing a specific and unique identity to each artifact for the purposes of tracking configuration items (e.g., source code, binaries, documents, config files). I have an entire chapter on change control, which I define as being composed of seven functions. Status accounting (my least favorite term) refers to tracking the status of a configuration item throughout its lifecycle. Configuration audits refer to being able to inspect and identify the exact version of any configuration item. In my opinion, CM experts need to make this terminology easier to understand and use on a day-to-day basis.

For example, configuration identification is actually accomplished by naming the components, streams, and subdirectories (folders) in your source code management tool in a logical and intuitive way. Build engineering best practices enable you to embed version IDs in binary configuration items (it also facilitates configuration audits), and many build tools, such as Maven, help you to organize your code in a logical and sensible way. Release management also involves configuration identification in that you must name your release packages in a clear and consistent way.

Status accounting involves tracking the status of a configuration item throughout its lifecycle. In practice, many source code management solutions are integrated with requirements and defect tracking systems (if not already built in) so that you can easily trace the evolution of a component from its requirement (or perhaps defect record) all the way through to its deployment. Configuration audit mean that you know exactly which version of the code is running in production (or QA). Unfortunately, many technology professionals cannot identify the exact version of a binary configuration item after the code leaves the source code management tool. In my world, you need to be able to tell me the exact version of the code that is running in production (or QA) and be able to retrieve the exact version of the source code used to build it so that you can also create a sandbox (in a source code management tool) and make a small change to the code—without any chance of the code regressing due to the wrong version of a header file or other dependency. If you can't do that today, you have come to the right place!

The first six chapters of the book make up Part I, "The Core CM Best Practices Framework," which describes the core functions in configuration management. I describe how the six core functions relate to the traditional view of CM. I also cover a number of other essential topics in Chapters 7 through 14, which are presented in Parts II through IV. Here is a description of these sections.

The second part of the book, Part II, "Architecture and Hardware CM," deals with understanding the impact of architecture on CM best practices and the impact of CM on architecture itself. In Chapter 8, we discuss hardware CM, which should really be a book on its own.

Part III, "The People Side of CM," covers the essential "people" issues that you need to understand to be effective in implementing CM best practices. Many process improvement efforts fail because these issues are often overlooked. The chapters in this section are as follows:

Chapter 9, "Rightsizing Your Processes"

Chapter 10, "Overcoming Resistance to Change"

Chapter 11, "Personality and CM: A Psychologist Looks at the Workplace"

Chapter 12, "Learning From Mistakes That I Have Made"

Part IV, "Compliance, Standards, and Frameworks," is the last section of this book and covers establishing IT controls and issues related to compliance, with Chapter 14 explaining the standards and frameworks that are essential for you to know to establish CM best practices: