In the beginning, there were rocks, dinosaurs, Fred Flintstone, and of course, classical CM, which was good for its time. But its time is now up. Its replacement is what I call "effective" CM. Effective CM is not your grandfather's CM. Effective CM is a non-administrivia, non-clerical, integrated, cost-effective approach to implementing CM. In summary, effective CM is

	Cost-effective project insurance, i.e., product-integrity focused.
	A manager's and developer's best friend.
	A developer's tool, i.e., developer executed.
	A systems engineering function.
	Difficult to do right.
	No cost when done right (as part of daily development activities).

Effective CM is not

	Just version management.
	Just change management.
	Just a build-and-release function.
	An administrivia function.
	A trivial task.

     The Institute of Electrical and Electronics Engineers (IEEE) definition of configuration management includes "a discipline applying technical and administrative direction and surveillance to. …" [1] The key words here are technical, administrative, and surveillance. Classical CM stresses administrative and surveillance and minimizes technical, which results in processes that developers see as obstacles to getting their job done. Effective CM stresses the technical while using tools to minimize the obstacles that can be caused by the administrative and surveillance activities. The IEEE definition further defines four functions performed by configuration management:

	Identification of configuration items.
	Change control of configuration items.
	Audit of configuration items.
	Recording and reporting of information needed to manage configuration items.

     The International Organization for Standardization defines a configuration item as "a collection of hardware, software, and/or firmware, which satisfies an end-use function and is designated for configuration management." [2] The key part here is "which satisfies an end-use function and is designated for configuration management." Classical CM has typically defined configuration items as hard-copy documents and collections of completed source code. As this article will demonstrate, effective CM treats all files produced by the development process as configuration items.¹
     Classical CM focuses on the administrative direction and surveillance aspects of CM and downplays—in some cases ignores—the technical aspects of CM. Because it is labor intensive, classical CM applies an after-the-fact, reactive, "throw it over the wall when yer done" approach to CM for a relatively small number of configuration items. To many developers, this is an obstacle to the development process that adds little value.
     Because of the lack of tools with which to manage configuration items, classical CM practitioners were and are highly detail-oriented people with a "green-eye-shades" mindset. I always envision Bob Cratchet in A Christmas Carol sitting with quill pen in hand, eyes protected by a green eye shade, slouched over Scrooge's account books, keeping detailed records of Scrooge's business transactions. Cratchet would make an excellent classical CM practitioner. Furthermore, the configuration items managed by classical CM are completed products such as documents and collections of source code with little or no support for in-process management of evolving designs and configurations or the environment used to generate them.
     Businesses pressure us to do more with less and to speed development and change cycles. Changes in tool technology and new standards that represent world-class best practices (US 12207 and ISO 12207) require and support a revised approach to CM implementation—effective CM. Effective CM

	Is a system engineering function that is a pro-active, in-yer-face discipline that stresses the technical aspects of CM.
	Satisfies the needs of management as well as developers.
	Is unobtrusive to the point of being 100 percent developer executed.
	Is integral to the software development process.
	Supports the definition and implementation of the software development environment and process.
	Manages changes to all project components as they move through their development and approval cycles.
	Focuses on the "smallest work product of significance" to the development team.
	Follows the files and work products produced by the developer's tools.

     Every file produced by the software development process can now be considered a configuration item. The number of objects managed by effective CM is orders of magnitude greater than those managed by classical CM. As a result, it carries the implicit requirement that it must be automated—automated by using CM tools that completely integrate process management (workflow), version, and change management, and that can act as the development environment and software repository.
     Effective CM incorporates a paradigm shift that extends the concepts of classical CM to in-process management of software development work products, objects, entities, and artifacts, not just product-level documentation of product-level configuration items. It manages requirement identifications, not just requirement specification documents; elements of models as opposed to documentation that contains a completed model; interface messages instead of interface documents. Production of hard-copy documentation is avoided whenever possible by using the managed work products to document the system design. The level of control applied to each managed work product is based on the maturity level of that work product. As work products mature, change authorization migrates from author to software lead engineer to subsystem or system lead to program manager to customer. The level of control is kept to the lowest level practical throughout the products' lifecycle.
    The effective CM process

	Supports and is built into the software development process.
	Is a core activity of the software development process.
	Helps manage the evolution of the software development work products.
	Focuses on management of the development process and on the work of and interactions between multiple developers.
	Applies a systems engineering view of CM to the software development process. (It is interesting to note that most industry and military standards identify CM as part of systems engineering.)
	Returns CM to its systems engineering roots and allows effective CM practitioners to act as systems engineers instead of clerks.
	Stresses the technical aspects of CM through an understanding of the development process and most important, by being part of the development process, by building CM into the development process, and by implementing tools that allow the developers to execute CM tasks with minimal intrusion into the development process.

Effective CM reinforces the belief that CM is good and that it is part of the solution, not part of the problem.
     The systems integration approach to implementing effective CM begins with the development of a "living" software development plan (SDP). Effective CM practitioners participate in the creation of the SDP and the software development process to ensure that CM is built into the development process—a significant paradigm shift from the classical CM approach. Development methods are defined and a tool suite or system/software engineering environment (S/SEE) is selected that supports the development methods. CM participants ensure that the S/SEE includes tools to implement effective CM, e.g., completely integrated process, workflow, version, and change management CM tools that will be used by the developers. For effective CM to be successful, the CM practitioner must design for success by making the "right way" an "easy way" for developers to accomplish the tasks outlined in the SDP. One must never fail to recognize human nature. Developers will always take what they perceive to be the path of least resistance. Designed correctly, that way will be the effective CM way.

Note: When this article was first written and published in 1998 Bob was an employee of Lockheed Martin Aeronautics