Chapter 32 of 32

Software Configuration Management

Imagine the night before your final-year project demo. Three teammates have been editing the same code, someone emails project_final_v3_REAL.zip, the demo machine has a different library version, and a bug fixed last week is mysteriously back. Every one of these problems is a configuration management failure.

In Software Maintenance & Reengineering we saw that software changes constantly throughout its life. Software Configuration Management (SCM) is the discipline that keeps that change under control: it tells you exactly what makes up each version, who changed what and why, and how to rebuild any release. This chapter covers configuration items, baselines, the classic SCM activities, the change control process, version control with Git (with real commands and output), branching strategies, semantic versioning and configuration audits.

Software Configuration Management is the set of activities that identify the items making up a software system, control changes to them, record and report their status, and verify that the system is complete and consistent, throughout the software life cycle.

Note that SCM is an umbrella activity: it runs from the first requirements document until the product is retired, not only during coding.


Why SCM Is Needed

Without SCM, teams hit the same problems again and again:

ProblemWhat it looks likeHow SCM prevents it
Lost changes (simultaneous update)Two people edit the same file; the second save overwrites the firstVersion control with merging
Regressed fixesA fixed bug reappears because an old copy of a file was usedSingle source of truth, baselines
"Works on my machine"Different library or tool versions on each machineConfiguration items include dependencies, build scripts and environments
Unknown release contentsCustomer reports a bug in "the March version", nobody knows exactly what that wasTagged releases, status accounting
Uncontrolled changesA developer adds a feature nobody approved; scope creepsChange control process

Software Configuration Items (SCIs)

A software configuration item (SCI) is any work product that is placed under configuration management and treated as a single unit for identification, change and versioning.

SCIs are not just source code. Typical SCIs:

  • SRS, design documents, UML models (see Software Requirements Specification (SRS) and UML Diagrams)

  • Source code, database schemas and migration scripts

  • Test plans, test cases, test data and test scripts

  • Build scripts, CI pipeline files, Dockerfiles, infrastructure-as-code files

  • Third-party libraries and their exact versions (lock files such as package-lock.json or requirements.txt with pinned versions)

  • User manuals and release notes

  • Sometimes even the tools themselves: compiler version, IDE settings

Each SCI gets a unique identifier, a version and a record of its relationships to other SCIs (for example, "design module D4 implements requirements R7–R9 and is tested by TC40–TC52"). These relationships make impact analysis possible when something changes.


Baselines

A baseline is a formally reviewed and agreed version of one or more SCIs that serves as the basis for further development, and that can be changed only through formal change control.

Before an item is baselined, its author can change it freely. After it is baselined, changes must go through the change control process. A baseline is like a "save point" the whole team agrees on.

  Requirements ──► Design ──► Code ──► Testing ──► Release
       │             │          │          │           │
       ▼             ▼          ▼          ▼           ▼
  [Requirements] [Design]  [Code      [Test-    [Product /
   baseline]     baseline]  baseline]  ready     release
   (approved     (approved  (reviewed  baseline]  baseline]
    SRS)          design)    code)

  Before a baseline: informal change (author decides)
  After a baseline:  formal change (change request → approval)

Some standards use the names functional baseline (approved requirements), allocated baseline (requirements allocated to components) and product baseline (the approved, built product).


Versions, Revisions, Variants and Releases

TermMeaningExample
VersionAn instance of an SCI that differs in some way from other instancesfees.py at commit 1c5bbd3
RevisionA new version intended to replace the old one (sequential)1.0 → 1.1 after a bug fix
VariantA version meant to exist alongside others (parallel), e.g. for different platforms or customersAndroid and iOS builds; Hindi and English editions
ReleaseA version distributed to customers or usersv1.1.0 deployed to the college on 1 July

Version control systems do not need to store every version as a full copy. Older systems such as RCS stored the latest version in full plus deltas (differences) to reconstruct earlier ones. Git stores each version as a snapshot of content-addressed objects and compresses similar objects into delta-encoded pack files, so storage stays small either way.


The SCM Activities

Standards such as IEEE 828 organise SCM around a plan and four core activities. This four-part list is the classic exam answer:

ActivityQuestion it answersTypical outputs
Configuration identificationWhat are the items, and how do we name and version them?List of SCIs, naming scheme, baselines, repository structure
Configuration (change) controlHow is a change requested, evaluated, approved and implemented?Change requests, CCB decisions, change orders
Configuration status accountingWhat changed, when, by whom, and what is the state of every change?Change logs, release notes, status reports
Configuration auditDoes the product match its requirements and its documented configuration?Audit reports (functional and physical audits)

Around these sit SCM planning (a Configuration Management Plan stating policies, tools and responsibilities) and release management (building, packaging and delivering releases). Pressman lists the SCM tasks as identification, version control, change control, configuration auditing and status reporting, which covers the same ground with version control as its own item.


Change Control

Change control balances two risks: too little control lets chaos in, too much control stops useful changes. For baselined items the classic process is:

  Need for change recognised
            │
            ▼
  Change Request (CR) submitted ── e.g. "CR-17: add 25% concession for EWS"
            │
            ▼
  Change evaluated: impact analysis, effort, risk, affected SCIs
            │
            ▼
  Change Control Board (CCB) / change authority decides
     │                         │
   rejected                  approved
     │                         │
  requester informed     Engineering Change Order (ECO) issued:
                         what to change, constraints, review criteria
                                │
                                ▼
                  Check-out affected SCIs (access control)
                                │
                                ▼
                  Make change ──► review / test (incl. regression)
                                │
                                ▼
                  Check-in (synchronisation control), new baseline,
                  status accounting updated, release planned
  • The Change Control Board (CCB) may be a formal committee (customer, manager, architect, QA) in a large or safety-critical project, or simply the product owner and tech lead in a small agile team.

  • Access control decides who may check out and change an SCI; synchronisation control stops two people from overwriting each other's changes.

  • In modern teams, a pull request with required reviewers and passing CI checks is a lightweight change control step: nothing merges into the protected main branch without approval.


Version Control Systems

A version control system (VCS) is the main tool for identification, synchronisation and status accounting of code-level SCIs.

AspectCentralised (e.g. Subversion, CVS)Distributed (e.g. Git, Mercurial)
RepositoryOne central server holds the historyEvery clone has the full history
Working offlineCommits need the serverCommit, branch, diff, log all work offline
Single point of failureServer loss can lose history (without backups)Any clone can restore the repository
Branching and mergingHeavier, often avoidedCheap and routine
Fine-grained access controlEasier (per-directory permissions)Usually at repository/branch level via the hosting platform
Typical use todaySome enterprises, large binary assetsThe vast majority of new projects

Git in action: branches, a conflict and a tagged release

Let's walk through two change requests on a tiny fee module. CR-17 (EWS concession) is developed on a feature branch while CR-18 (PG fee increase) is made on main.

git init -b main fee-portal && cd fee-portal
printf 'BASE_FEE = {"UG": 45000, "PG": 60000}\n' > fees.py
git add fees.py
git commit -m "Add base fee table"
git tag -a v1.0.0 -m "Release 1.0.0"          # baseline for release 1.0.0

git switch -c feature/ews-concession           # CR-17 on its own branch
printf 'CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}\n' >> fees.py
git commit -am "Add EWS concession (CR-17)"

git switch main                                # CR-18 directly on main
sed -i 's/60000/62000/' fees.py
git commit -am "Raise PG fee to 62000 (CR-18)"

git merge feature/ews-concession -m "Merge CR-17"

Output of the merge:

Auto-merging fees.py
CONFLICT (content): Merge conflict in fees.py
Automatic merge failed; fix conflicts and then commit the result.

Both branches changed neighbouring lines of the same file, so Git cannot decide automatically. It marks the conflict inside the file:

<<<<<<< HEAD
BASE_FEE = {"UG": 45000, "PG": 62000}
=======
BASE_FEE = {"UG": 45000, "PG": 60000}
CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}
>>>>>>> feature/ews-concession

The part between <<<<<<< HEAD and ======= is main's version; the rest is the feature branch's. A human must decide: we want both changes, the new PG fee and the concession table. This is the "synchronisation control" problem solved safely: nothing was silently overwritten.

printf 'BASE_FEE = {"UG": 45000, "PG": 62000}\nCONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}\n' > fees.py
git add fees.py
git commit -m "Merge CR-17: EWS concession"
git tag -a v1.1.0 -m "Release 1.1.0"           # new release baseline
git log --oneline --graph --decorate --all

Output:

*   98d8a3b (HEAD -> main, tag: v1.1.0) Merge CR-17: EWS concession
|\
| * 9258274 (feature/ews-concession) Add EWS concession (CR-17)
* | 1c5bbd3 Raise PG fee to 62000 (CR-18)
|/
* 62a2817 (tag: v1.0.0) Add base fee table

Now status accounting questions have exact answers. "What changed between the two releases?"

git diff v1.0.0 v1.1.0
diff --git a/fees.py b/fees.py
index f217937..11e8e5d 100644
--- a/fees.py
+++ b/fees.py
@@ -1 +1,2 @@
-BASE_FEE = {"UG": 45000, "PG": 60000}
+BASE_FEE = {"UG": 45000, "PG": 62000}
+CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}

"Which change introduced each line?"

git blame -s fees.py
1c5bbd3f 1) BASE_FEE = {"UG": 45000, "PG": 62000}
92582747 2) CONCESSION = {"SC": 0.5, "ST": 0.5, "EWS": 0.25}

Because each commit message names its change request, every line traces back to an approved CR. (Commit hashes will differ on your machine, since they depend on author, time and content.)

Mapping Git to SCM concepts

SCM conceptGit feature
Configuration identificationFiles in the repository, commit hashes, tags
Baseline / releaseAnnotated tag (v1.1.0), release branch
Change request / ECOIssue in the tracker, pull request
CCB approvalRequired reviews and branch protection rules
Synchronisation controlMerge, conflict detection
Status accountinggit log, git diff, git blame, release notes
VariantsLong-lived branches or build-time configuration flags

Branching Strategies

StrategyHow it worksSuits
Git FlowLong-lived main and develop; feature, release and hotfix branchesProducts with scheduled, versioned releases (installed software, mobile apps)
GitHub FlowOne main that is always deployable; short feature branches merged via pull requestsWeb apps deployed continuously
Trunk-based developmentEveryone integrates into trunk at least daily; very short branches or none; unfinished work hidden behind feature flagsTeams practising CI/CD at high frequency

The longer a branch lives, the harder its merge, which is why DevOps & CI/CD recommends integrating small changes often.


Semantic Versioning

Release identifiers should carry meaning. Semantic Versioning 2.0.0 (semver.org) is the most widely used scheme: MAJOR.MINOR.PATCH.

IncrementWhenExample
MAJORIncompatible (breaking) change to the public API2.4.1 → 3.0.0 (API renamed payFee to createPayment)
MINORNew functionality, backward compatible2.4.1 → 2.5.0 (EWS concession added)
PATCHBackward-compatible bug fixes2.4.1 → 2.4.2 (rounding bug fixed)
  • Incrementing MINOR resets PATCH to 0; incrementing MAJOR resets both.

  • Pre-release versions add a hyphen: 3.0.0-alpha.1, 3.0.0-rc.2. A pre-release has lower precedence than the normal version: 3.0.0-rc.2 < 3.0.0.

  • Build metadata follows a plus sign, 3.0.0+build.57, and is ignored when comparing precedence.

  • Major version 0 (0.y.z) means initial development: anything may change at any time.


Build and Release Management

A release is only reproducible if everything that went into it is controlled:

  • Automated builds from a clean checkout, never from a developer's laptop.

  • Pinned dependencies via lock files, so the same tag always pulls the same library versions.

  • Artifact repositories store the exact built binaries or container images for each release, labelled with the version and commit.

  • Configuration as code: environment settings and infrastructure definitions live in version control too (secrets excluded, kept in a secrets manager).

  • Release notes generated from the change log, listing the CRs included.


Configuration Audits

Change control ensures that changes are approved; audits check that the result is correct and complete.

AuditChecksExample question
Functional Configuration Audit (FCA)The product's actual functionality and performance meet its requirements (based on test results)Do the test reports show every requirement in the SRS was verified?
Physical Configuration Audit (PCA)The delivered product matches its documented configurationDoes release 1.1.0 contain exactly the files, versions and documents listed in its baseline?

Pressman's audit questions are a useful checklist: Was the change specified in the ECO made, with no extra modifications? Was a technical review held? Were SCM procedures (noting the change, date, author) followed? Were all related SCIs updated?


Common Mistakes

  • Treating SCM as "just Git". Version control is one tool; SCM also covers identification, change approval, status accounting and audits, across all work products.

  • Putting only source code under control. Requirements, tests, build scripts and dependency versions are SCIs too.

  • Confusing a version with a baseline. Every commit is a version; a baseline is a reviewed, agreed version that changes only through change control.

  • Confusing revisions and variants. A revision replaces its predecessor; a variant lives alongside other variants.

  • Resolving merge conflicts by blindly picking one side. That silently drops someone's approved change.

  • Committing secrets or build outputs into the repository.

  • Calling a breaking change a minor version. Under SemVer, any incompatible API change requires a MAJOR increment (after 1.0.0).


Interview and Exam Questions

Q1. What is a software configuration item? Give examples.

Any work product placed under configuration control and managed as a unit: SRS, design models, source files, test cases, build scripts, dependency lists, user manuals.

Q2. What is a baseline and why is it important?

A formally reviewed and agreed version of one or more SCIs that can be changed only through formal change control. It gives the team a stable reference point and makes it possible to know and rebuild exactly what was approved or released.

Q3. List and explain the main SCM activities.

Configuration identification (naming and versioning items, defining baselines), change control (evaluating and approving changes), status accounting (recording and reporting what changed and the state of every change) and configuration audit (verifying functional and physical correctness). Plus SCM planning and release management.

Q4. Describe the change control process.

A change request is submitted and evaluated (impact, cost, risk). The change control board approves or rejects it. If approved, an engineering change order is issued; the SCIs are checked out, changed, reviewed and tested, then checked in, a new baseline is set and status accounting is updated.

Q5. Differentiate centralised and distributed version control.

Centralised VCS keeps history on one server and needs it for commits; distributed VCS gives every clone the full history, supports offline work and cheap branching, and has no single point of failure.

Q6. A library is at 2.3.4. What is the next version for (a) a bug fix, (b) a new backward-compatible function, (c) removing a public function?

(a) 2.3.5, (b) 2.4.0, (c) 3.0.0.

Q7. What is the difference between a functional and a physical configuration audit?

FCA verifies that the product meets its functional and performance requirements; PCA verifies that the delivered product and its documentation match the recorded configuration baseline.

Q8. How does a pull-request workflow implement SCM?

The PR is a change request tied to an issue; required reviewers and CI checks act as the change control board; protected branches enforce access control; merge handles synchronisation; the commit history, tags and release notes provide status accounting.


Summary

  • SCM is an umbrella activity that controls change across the whole life cycle.

  • SCIs include every controlled work product, not just code. Baselines are reviewed, agreed versions changed only via formal change control.

  • Revisions replace earlier versions; variants exist side by side; releases go to users.

  • Core activities: identification, change control, status accounting, audit (plus planning and release management).

  • Change control: CR → evaluation → CCB → ECO → check-out → change and review → check-in → new baseline.

  • Git provides versioning, branching, conflict detection, tags as baselines and log/diff/blame for status accounting.

  • Branching strategies: Git Flow, GitHub Flow, trunk-based. SemVer: MAJOR.MINOR.PATCH.

  • FCA checks the product against requirements; PCA checks it against its documented configuration.

If you cannot say exactly what is in a release and how it got there, you do not control your software; SCM is how you get that control.