Archive for the ‘ITSLM’ Category

h1

In the beginning…

February 18, 2010

…was the definition.

In this article I am going to lay out my definitions for some terminology that will become increasingly important as I develop my CMS model.

The terms I will be discussing are as follows.

  • Stream
  • Branch
  • Configuration Item
  • Revision
  • Configuration
  • Component
  • Repository
  • Configuration Management Database
  • Record

At this point I caution the reader that these definitions are deliberately quite loose and informal. Each will be expanded, refined, rewritten and formalised as I work through articles in this blog. For now, my working definitions are as follows.

Project

A coordinated effort usually conducted by several individuals to deliver a Product. Project describes the totality of planning and activity requires to gather requirements and interpret these into Product.

Product

That which is to be delivered by a Project. Products include, but are not limited to:

  • Executable software
  • Documents — manuals, design documents, requirements, installation guides, administration and maintenance manuals
  • Hardware — computers, network components, any other physical components required as part of the Product
  • Training materials — exercise version of data or system components, trainer presenation, training the trainer material, sandbox systems for trainees
  • Source code — when developing for a 3rd party. Source code may also be a deliverable in interpreted languages or when delivering web content such as HTML.
  • Media — video, graphics, audio

Stream

Projects often consist of more than one piece of development. A common strategy is to manage these pieces of development as a sort of sub-project. Timescales of these Streams are overlapped to allow the project to compress its overall timescale.

Branch

An implementation technique used in development to manage simultaneous changes to common items. In software development Branches are common and used to allow two or more developers to work on the same source code simultaneously.

Configuration Item

A configuration item is an item within the configuration management system that is the focus for change management.

Revision

Each time an item is modified and submitted into version control, a new revision is created. In this way an item’s history can be traced by looking back through the sequence of revisions.

Delta

The difference between two revisions.

Configuration

A specific arrangement of item revisions.

Component

An item that is subject to version control, but is not elevated to the status of a configuration item.

Repository

A safe store for item revisions.

Configuration Management Database

A database containing information about each item revision and their relationships to one another and to records.

Record

A set of data that is subject to a process or workflow but not necessarily version control. Records normally carry information used to account for an item’s current disposition or the current state of a process or workflow.

h1

CMS Tool: High-level architecture

February 11, 2010

Continuing my musings about a universal configuration management tool I’ve drafted the basic architecture. This is summarised in the following diagram (after the break). Read the rest of this entry ?

h1

Parallel development: theory and practice

February 10, 2010

Having spent the past couple of weeks with a client working through the issues that need to be carefully considered when version controlling software, and in particular how to manage and control parallel development. I have come to three conclusions:

  1. People are often more afraid of the perceived problems than the practical realities of parallel development.
  2. People do not truly appreciate the problems and practical realities of version control and parallel development.
  3. There is a need for more theoretical work on the topic and, perhaps more significantly, a need for more formal expression of the process and problems involved.
  4. There is a quite substantial book that could be written on the subject.

Read the rest of this entry ?

h1

Who’s afraid of the big bad merge?

February 1, 2010

A common objection to using parallel development is the fear of the inevitable merging required to reintegrate the changes as the development proceeds. In this post I will take a look at some of the issues that arise from managing parallel development and, perhaps more importantly, provide some guidance on how to avoid the pitfalls of parallel development. Read the rest of this entry ?

h1

Holographic Configuration Management

January 14, 2010

The advent of the ‘cloud’ and the idea of massively distributed systems (think grid computing and SaaS) is the latest technology swing with the potential to impact configuration management practice. I say ‘potential’ because a properly designed and implemented configuration management system will be able to copy without too much difficulty. The main impact will be procedural and technical, the underlying configuration management process will remain unchanged.

A properly designed CM system will be able to handle any IT system environment. Problems only occur when you are married to the idea that centralised control of CM data and centralised change control are necessary for CM, or that a specific development process is integral to CM for it to function correctly. Read the rest of this entry ?

h1

Stubbing in build processes

January 5, 2010

When developing systems of any size the development team inevitably encounters the following problem. The developers of one sub-system need access to functionality to be provided by another, but the second sub-system is not in a position to provide the functionality and probably will not be for some time. When this happens it is common for the sub-system teams to provide stubs.

Stubs come in several flavours:

  • non-functional stubs provide no functionality, they simply provide a template interface to allow client sub-systems to compile;
  • static-function stubs allow client sub-systems to compile and also provide static responses when the interface is called;
  • dynamic stubs provide more complex responses when called. Methods used to provide these dynamic stubs vary but some common approaches are:
    • record and playback,
    • static tables,
    • randomised response, and
    • minimal function.

A stub is a proxy for the final functionality to be offered by the sub-system. As such we want the stub references in the client code to use the same calling convention as the final product. In the build process we need some means to nominate the stub or the final product into our build.

There are two principal approaches to solving this latter problem. The first relies on the build itself to select the appropriate module (stub or final). In our build script we may have, for example, a simple path modifier that builds either the stub or final code into a library which is then used by clients. The second method relies upon the source control system to deliver either the stub or final source into the source configuration, this source is then built into the target library. In this post I begin looking at some of the issues involved in both build and configuration managing stubs. Read the rest of this entry ?

h1

Stabilizing builds

January 4, 2010

One challenge facing build managers is how to control the environment in which builds are performed. How to ensure that each repeated build uses the same sources, the same libraries, the same compilers, and so on. Only by ensuring all these elements can we truly claim to be able to reproduce a build reliably and only by controlling all these elements can we be certain that derived objects built previously are compatible with incremental builds. Read the rest of this entry ?

h1

Differentiating Configuration Items from Components

November 17, 2009

Configuration management literature is replete with references to something called a ‘configuration item’ and most attempt to explain what a configuration item is. Despite this there remains confusion. “Should all files in my software system be a configuration item?” is a common enough question to raise concern that the concept of configuration item is not fully understood.

A configuration item is the unit of change for the configuration management system. A configuration item may consist of one or more other configuration items (sub-configuration items) and may also consist of one or more components. A component is always part of a configuration item; components cannot exist within a configuration management system independent of the configuration item hierarchy.

So, in software systems files are often only components. Configuration items within software systems tend to be larger entities such as sub-systems or libraries. The precise level at which you choose to identify a configuration item will depend upon where you want to exercise change control.

h1

The importance of release identities

October 13, 2009

Having carefully avoided ‘release numbers’ in the title of this post, I shall now proceed to describe a release numbering scheme. The specifics of release numbering schemes are endlessly discussed. Each proponent of a specific scheme believing that their scheme is the best. I shall be no different. Read the rest of this entry ?

h1

Software Configuration Management: An Investement in Product Integrity

October 1, 2009

For me, this book holds a special significance. This is the very first book I ever read that dealt exclusively with software configuration management. For me, this book started a career and lifelong passion for software product integrity and software configuration management in particular.

Title: Software Configuration Management: An Investment in Product Integrity
Authors: Bersoff, Edward A.; Henderson, Vilas D.; Siegel, Stanley G.
Publication Date: 1980
Publisher: Prentice Hall
Pages: 351 (main body only); 11 (bibliography)
ISBN: 0-13-821769-6
Availability: Out-of-print but available from specialist dealers
Amazon: UK US
Price guide: Varies widely. Reasonable condition copies can be obtained for ~£15 / ~$20

Review in a Nutshell

I maintain that this is still one of the best books written on the subject.

Review in Detail

As I said in the opening remark, this book was, for me, quite literally life changing. I read this book while working as a software engineer in the mid-80’s. Why? Partly from curiosity, but also because the team I was working on were looking to improve control on the product as we migrated from an old PDP-11 to a new MicroVAX.

That was my motivation, so should you seek out a copy and read it?

Who is it aimed at?

The book is aimed at a non-technical audience unfamiliar with software configuration management (SCM). This does not mean there is no value in reading the book if you are technically inclined or already familiar with configuration management. Far from it. I enjoyed rereading it recently and, even though it has been over twenty years since I first stumbled across this book in the underused library where I worked, I enjoyed being reminded of the fundamentals (with a twinge of nostalgia admittedly).

The book’s aim is to lay out the core principles of SCM and places them in the context of system development. This it does effectively. If you are looking for a step-by-step implementation guide then this is not the book for you.

Is it well written?

Bersoff, Henderson and Siegel write in a relaxed, semi-formal style that is easy to read. On occasion the walked through examples become a little laboured, but this may be a consequence of my familiarity with the subject. People reading the book early in their configuration management careers will find the detail helpful.

Does it cover the subject matter?

The book is divided into eight chapters:

  • Chapter 1: The Problem of Software

    Where we are introduced to the nature of software and the problem to be solved.

  • Chapter 2: Managing the System Development

    Configuration management is put into context within the system development lifecycle.

  • Chapter 3: Attaining and Maintaining Product Integrity

    Lays the foundation for implementing configuration management.

  • Chapter 4: Configuration Identification

    Explains the identification problem and lays out it solution within the SCM framework.

  • Chapter 5: Configuration Control

    Explains the problem of change control and then proceeds to explain its implementation in the context of the configuration management plan.

  • Chapter 6: Configuration Auditing

    Explains the problem that auditing addresses. Expands on the auditing principles and demonstrates them with a case study.

  • Chapter 7: Configuration Status Accounting

    Explains the problem that status accounting addresses and the principles on which it is founded.

  • Chapter 8: Epilogue

    Ties up loose ends and discusses the consequences of implementing configuration management.

These eight chapters cover all that matters in configuration management and places it into the wider system development context well.

The material discusses at length the documentation used in configuration management and some of this is a little dated. There is, for example, much emphasis on manual processing and little on automation. This is entirely forgivable given the paucity of supporting applications at the time the book was written.

The development methodology described in the book is, as one might expect of a book written some thirty years ago, based on a more traditional waterfall model. This should not, however, deter you from reading this book. The core principles remain sound and are easily adapted to any development methodology.

Despite the lack of coverage for support applications (such as change control systems or even version control systems) the principles are described well and almost all of the manual processes described are relevant to modern implementations of SCM even though we tend to rely more on databases, rather than manual paper records, to hold and process information.

What is missing?

Automation and the use of modern applications to control the SCM process are not covered for the obvious reason that they were less common in the late 70’s and early 80’s when this book was written.

This book, quite rightly in my opinion, is ‘bare metal’ SCM. There is no discussion of other lifecycle disciplines beyond that required to place SCM in the context of the system development processes.

While the book discusses some implementation issues it is not a guide to implementation. As such there is no implementation plan beyond a brief discussion of the configuration management plan.

Standards are not discussed, but any standards extant in the early 80’s would be superseded by now so this is no great loss.

Would I but it now?

So, would I buy this book now, knowing what I do?

Yes! Absolutely and without reservation. (In fact I did. The copy I recently re-read was obtained only six months ago from a second hand book seller on Amazon for the princely sum of fifteen of your English pounds sterling.)