Home > Articles > Programming

  • Print
  • + Share This
This chapter is from the book

1.3 Storage

The purpose of storage is to ensure that a configuration item will not disappear or be damaged, that it can be found at any time and delivered in the condition in which you expect to find it, and that a record is kept to indicate who has been given the item or a copy of it.

Storage is something physical. Items that are stored are physically present at a specific place. In the following discussion, we shall call this place a library, but physically, it may be a directory structure on a workstation, a looseleaf binder, a shelf, or something else. Figure 1–7 shows how storage influences and is influenced by its surroundings.

Figure 1-7 Figure 1–7 Storage in Context


Storage takes place in libraries. Traditionally, three types of libraries are mentioned in connection with software development: controlled, dynamic, and static libraries.

The Controlled Library

The controlled or configuration management library is where configuration items are stored. It may be divided into a number of physical libraries, especially where the configuration items are of different types: documents, source code, hardware, and so on. Naturally, hardware cannot be placed in a database on a computer but on a shelf or directly on the site of application.

The Dynamic Library

The dynamic or development library is where items are kept while they are being produced. Typically, this will be in the producer's own area. Therefore, in reality, this library will consist of a considerable number of independent libraries. In this library, it's possible to work with an item without bringing it into contact with other items or exposing it to the influence of other items.

This library is not part of the configuration management system! It's under the responsibility of the development manager, even though many modern configuration management tools also encompass the dynamic library. In some cases the dynamic library and configuration management library may overlap. This should be carefully considered and preferably avoided, unless a deployed tool manages both libraries and the distinction between them is clear.

As an example, many companies use the same tool (such as Visual SourceSafe) during production as well as for configuration management of source code, and practically in the same way. This means that the same library is used as both dynamic and configuration management libraries. During production, a file is often checked in and out several times before it's actually finished. The configuration management library is hence also used as a backup medium for the producers' own intermediate results.

These intermediate results are neither approved nor under change control and consequently not under configuration management, but it may be difficult to distinguish them from versions of the same source code item under configuration management. This is especially true if you're not careful with status codes or if you can't extract configuration items on the basis of different status codes.

Consequently, if libraries are mixed, procedures and conventions should be em-ployed to

  • Make clear when the changed version of the source code is approved and actually placed under configuration management and in the configuration management library (by the use of status codes)

  • Ensure that if you want to extract an item, you don't just pick up the last version of the item (the one the producer is working with) but a version that has actually been approved and is under configuration management

Another consideration when mixing libraries is space. Space considerations often cause tools to save only the difference between two versions—so-called delta storage. But if the library is used for intermediate results that are later removed, it's not possible for all tools to keep only the differences between configuration-managed versions. The whole new version will have to be kept each time.

The Static Library

The static or user library is where items are used. Usage is all imaginable applications of configuration items, not just by final users. It may be a review, if a document is placed under configuration management in the form of a draft and subsequently has to be reviewed. It may be testing parts of the system, integrating a subcomponent into a larger component, or proper operation or sale of a finished system.

While being used in the static library, items must under no circumstances be changed. The static library may consist of many different physical repositories or storage media—it need not be a library in the classic sense.

When usage involves source code to be included in a module test of another item, the static library may be identical to the dynamic library of the developer. This means that the source code to be used is copied from the controlled library to a read-only copy in the developer's own environment. When usage is review of a document, the static library may be the reviewer's physical workspace, where a copy of the document is placed. When usage is the running in production of a system, the static library may be situated on a production machine or the user's workstation.

This library is not part of the configuration management system! The responsibility for this library may lie in different places, depending on the context of the use—e.g. with the developer, test manager, or customer.

Main Processes

Storage involves three main processes:

  • Placement in storage from production

  • Release from storage for usage

  • Release from storage for production

Placement in Storage from Production

The event initiating placement in storage is that the item reaches a state where it's ready to be placed under configuration management—when it's approved according to its type. It is up to each company to determine when an item can be approved. Approval criteria should be described in a quality assurance plan or the like. A source code item might be considered ready when it compiles, or perhaps when it has passed a module test with certain coverage or with less than a certain number of failures of a given type, such as a given severity. Placing an item in storage should be accompanied by item approval, so it can be documented that the criteria for finishing the item have been fulfilled.

For safety-critical products and/or in very formal configuration management systems, it's sometimes considered useful to deliver the items to a person (for instance, a configuration management librarian) rather than merely enter an item into a tool. This process has a significant positive effect on the quality of the products, as it's too easy to evade quality demands when facing just a tool. However, it's both slower and more expensive to handle placement in storage manually rather than automatically, so the benefits and costs must be considered carefully.

The result of this process is that the item can be reached only through the configuration management library, and metadata for the item is properly up-to-date. Of course, it's necessary to ensure that items already in storage cannot be destroyed—for instance, by being overwritten by new configuration items. An item in version 1.3 must not overwrite version 1.2 of the item having the same name.

Release from Storage for Usage

The event initiating the release of a configuration item from storage for usage is the perception of a need for the item. Release for usage ought to be accompanied by a release request, so it can be documented that the release is permitted and has taken place. To prevent this process from becoming too costly or cumbersome, the release request could be automated, in the form of a permission scheme associated with items under configuration management and automatic control of the permission and logging. Here, too, it may be useful in some cases to have the release take place via a person (a configuration management librarian) rather than via a tool alone.

The result of this process is that the configuration item—or, for documents and software, typically a copy of the configuration item—is delivered to a static library, and an entry in the metadata registers to whom it was delivered and when.

Release from Storage for Production

The event initiating the release of a configuration item from storage for production is the need for production of a new item on the basis of one already produced. This need is typically expressed in the form of a change request. The result is that a copy of the configuration item is delivered to a dynamic library (and always a copy—never the configuration item itself if only one copy exists).

Many configuration management systems and tools can indicate that the configuration item of which they have received a copy is locked or the like. This should be unnecessary if the configuration management library is controlled so that new configuration items cannot destroy existing ones and if planning and implementation of the change request is performed correctly.

If a problem arises from two or more people working with "the same item" at the same time, it reflects a poor configuration management system—lack of control over who is permitted to work with what and lack of proper identification. If several people have to work on the same branch simultaneously, this process must be handled as parallel development.

Process Descriptions

The methods, conventions, and procedures necessary for activities in storage may be

  • Procedure(s) for placing items in storage and related updating of metadata

  • Procedure(s) for release for usage

  • Procedure(s) for release for production

  • Template(s) for item approval

  • Template(s) for release request


The librarian in charge of the configuration management library plays a decisive role in establishing and maintaining the configuration management library, so the configuration management library doesn't fall into decay. This is also true for automated configuration management systems. If others establish and maintain the configuration management library, who is responsible for what must be clearly defined.

Connection with Other Activities

Storage may overlap with identification, if, for instance, a tool adds to a counter when an item is placed in storage.


The development environment for a project, especially a large project, is much more than just a developer's directory, an editor, a compiler, and a linker. This example illustrates the controlled library and two dynamic libraries in the form of the directory structure for a project called the Meteorological Archiving and Retrieval Facility (MARF) carried out for the European Meteorological Satellite Organisation (EUMETSAT).

The directory structure, shown in Figure 1–8, includes

Figure 1-8 Figure 1–8 Example Library Structure

  • A controlled library, structured according to the architectural design, offering separate subdirectories for data, object code (compiled sources), executables, sources, test scripts, and so on

  • Dynamic libraries for all developers, reflecting the structure of the controlled library

  • Substructures for version control of sources—where "Ingestion" is one of the architectural modules and "Other-globals" indicate others

The controlled library for the MARF project is /home/MARF/marfdev. Subdirectories under the Sources directory existed according to subsystems, for example:


Each subdirectory has a repository, called AtFS (Attributed Files System), where versions of the sources are kept in a controlled manner using a simple configuration management tool. Object files are collected in object libraries, to ease linking and reduce the size of executables. There is one object library for each source subdirectory.

Each developer has a development area (dynamic library) under /home/MARF/marf/username, with a structure identical to the one just described. A link is set up from the AtFS master repository to each user area. Developers use writable copies of stored files in their own directory structure for development. Read-only copies of de-pendent files are also placed in the developer's own directory structure, to ease compilation and linking during development and test.

Files are kept in saved versions in the central AtFS areas, and read-only copies are made available there as well. This setup ensures shareability with a minimum of disturbance.

  • + Share This
  • 🔖 Save To Your Account