Software Configuration Management
Open in the Padhaiko app8.1 Software configuration management
Because software requirements, designs, code, and test suites change continuously throughout development and maintenance, teams risk overwriting each other's edits, shipping mismatched file versions, or losing the ability to reproduce an older release. Software Configuration Management (SCM) is the umbrella discipline that prevents this chaos.
Software Configuration Management (SCM)
Software Configuration Management (SCM) is a set of tracking, control, and auditing activities designed to systematically manage change throughout the software lifecycle, ensuring the integrity and traceability of all software work products.
Software Configuration Items (SCIs) and Baselines
- Software Configuration Item (SCI): Any artifact produced as part of the software process that is placed under configuration control—including source code modules, SRS documents, architectural diagrams, database schemas, build scripts, test suites, and user manuals.
- Baseline: A formally reviewed, approved, and frozen specification or set of SCIs (e.g., Design Baseline, Release v1.0 Baseline) that serves as a stable reference point for further development. Once baselined, an SCI can only be altered through a formal change control procedure.
- SCM Repository: A centralized or distributed database storing all versions of SCIs, dependency metadata, baselines, and change histories.
Four Core SCM Activities
| SCM Activity | Purpose | Key Output / Mechanism |
|---|---|---|
| 1. Configuration Identification | Name, label, and organize every SCI and its version relationships unambiguously | Unique naming scheme, dependency graph, and baselines |
| 2. Change & Version Control | Manage parallel edits, revisions, branches, and formal approval of changes | Version history, Change Control Board (CCB) decisions, merge rules |
| 3. Configuration Auditing | Verify that built software matches its functional specs and documented baselines | Functional Configuration Audit (FCA) and Physical Configuration Audit (PCA) |
| 4. Configuration Status Reporting (CSR) | Record and communicate what changed, who approved it, when it happened, and what else was affected | Release notes, audit logs, and traceability reports |
8.2 Version control and continuous integration
Version Control Systems (VCS)
A Version Control System (VCS) tracks every revision of source files and artifacts over time, recording who changed what, when, and why, and allowing teams to revert mistakes, compare diffs, and work in parallel branches.
| Aspect | Centralized VCS (CVCS) | Distributed VCS (DVCS) |
|---|---|---|
| Repository Location | Single central server stores full version history; clients hold only working copies | Every developer clones a complete local repository with full commit history |
| Offline Work | Requires network access to commit, view history, or create branches | Commits, diffs, history inspection, and branching work offline locally |
| Branching & Merging | Heavyweight server-side operations; slower branch switching | Fast, lightweight local pointers; easy frequent feature branching |
| Single Point of Failure | If the central server disk fails without backups, history is lost | Every clone acts as a full cryptographic backup of the repository |
Semantic Versioning (MAJOR.MINOR.PATCH)
Release baselines commonly follow Semantic Versioning (vX.Y.Z):
MAJOR(X): Incremented when making incompatible / breaking API changes.MINOR(Y): Incremented when adding backward-compatible functionality.PATCH(Z): Incremented when making backward-compatible bug fixes.
Continuous Integration (CI)
Continuous Integration (CI) is the practice of developers integrating code changes into a shared mainline repository frequently (at least daily), where every push automatically triggers a deterministic build and automated test suite.
[ Developer Commit ] ---> [ Push to Repo ] ---> [ CI Server Triggered ]
^ |
| v
Fix immediately <---- [ Fail / Pass Report ] <--- [ Build + Lint + Unit/Integration Tests ]- Why CI Matters with Version Control: Without CI, long-lived unmerged branches accumulate integration hell—diverging interfaces and conflicting edits discovered only weeks later. CI detects merge conflicts, build breaks, and regressions within minutes while the change is small and fresh.
8.3 Change management process
Even in agile projects, uncontrolled edits to released or baselined artifacts introduce regressions and scope creep. Change management governs how requested changes are evaluated, approved, implemented, and verified.
[1. Change Request (CR)]
|
v
[2. Technical & Impact Evaluation] (cost, schedule, affected SCIs, risks)
|
v
[3. Change Control Board (CCB)] ---> [Rejected / Deferred]
| (Approved)
v
[4. Engineering Change Order (ECO) & Branch/Check-out]
|
v
[5. Implement Change + Code Review + Regression Testing]
|
v
[6. Merge / Check-in + Configuration Audit + New Baseline & Status Report]Key Roles and Artifacts in Change Management
- Change Request (CR): Formal proposal describing the bug fix or enhancement, its business justification, and priority.
- Impact Analysis: Engineering assessment estimating effort, affected modules/SCIs, downstream test scope, and risk to schedule or budget.
- Change Control Board (CCB): Cross-functional authority (product, engineering, QA, operations) that approves, defers, or rejects CRs based on impact analysis. (In agile teams, urgent minor fixes are often delegated to a lightweight pull-request + PO approval rule.)
- Synchronization & Audit: Ensures all dependent docs, tests, and release notes update together so the new baseline remains self-consistent.
8.4 Branching strategies (Git-flow basics)
A branching strategy defines rules for creating, naming, testing, and merging parallel lines of development in a VCS like Git.
Git-Flow Basics (Vincent Driessen)
Git-flow is a structured branching model well-suited for software with scheduled, versioned releases (desktop apps, mobile APKs, enterprise software):
main : ---(v1.0)---------------------------------------(v1.0.1)---------(v1.1)--->
\ ^ ^
hotfix : \---[hotfix/login-bug]----------------------/---(merge)-----\
\ \
release : \ /--[release/1.1]-------/
\ /
develop : -----------*----*------*--------*----------*------------------------*---->
\ / \ /
feature : \-[feat/cart]-/ \-[feat/pay]-/| Branch | Lifetime | Purpose & Merge Rules |
|---|---|---|
main (or master) | Permanent | Holds strictly production-ready, tagged releases (v1.0, v1.1). Never committed to directly. |
develop | Permanent | Main integration branch holding completed features ready for the next upcoming release. |
feature/* | Temporary | Branched off develop for one new feature or story; merged back into develop once reviewed and tested. |
release/* | Temporary | Branched off develop when feature-complete for a release; allows only bug fixes, version bumps, and doc polish before merging into both main (tagged) and develop. |
hotfix/* | Temporary | Branched directly off main to patch an urgent production defect; merged back into both main (new patch tag) and develop. |
# Start a new feature from develop
git checkout develop
git checkout -b feature/invoice-pdf
git commit -m "Add PDF invoice generator and unit tests"
# Merge finished feature back into develop (--no-ff keeps feature history)
git checkout develop
git merge --no-ff feature/invoice-pdf
# Emergency production hotfix from main
git checkout main
git checkout -b hotfix/null-tax-fix
git commit -m "Guard null tax rate in invoice total"
git checkout main && git merge --no-ff hotfix/null-tax-fix && git tag v1.0.1
git checkout develop && git merge --no-ff hotfix/null-tax-fixWorked Examples
8.1
Before adopting Continuous Integration (CI) and short-lived branches, a team of developers merged long-lived feature branches only once every weeks. Over a -week quarter ( integration cycles), resolving painful merge conflicts and broken builds took an average of per merge cycle (plus total manual smoke-test failures? Specifically, integration/conflict incidents at each). After adopting daily CI with automated unit tests, major integration conflicts dropped to minor incidents across the entire quarter, averaging each to resolve.
- Compute the total integration/rework hours before and after CI, and the percentage reduction in wasted integration effort.
- Explain why integrating small commits daily prevents "integration hell."
Part 1 — Compute Integration Rework Hours: Before CI ( major merge conflicts ):
After CI ( minor incidents ):
Percentage reduction in wasted integration time:
Part 2 — Why Daily CI Prevents Integration Hell: When commits are small and integrated daily, two developers editing overlapping modules discover API or schema mismatches within hours—when each diff is tiny and fresh in mind—rather than untangling weeks of diverging assumptions at release time.
- Integration rework fell from to , an reduction.
- Frequent CI catches interface mismatches and build regressions immediately on small diffs before branches diverge.
8.2
A bank's core payment service is currently running tagged baseline v2.4.1. A Change Request (CR-104) proposes adding support for a new QR-payment provider without breaking existing REST API clients. Impact analysis estimates:
- Coding new adapter module:
- Updating SRS/API docs & config files:
- Writing & running regression/integration tests:
- Peer code review & Configuration Audit:
- Compute the base estimated effort and the contingency-adjusted effort (adding a risk buffer).
- Under Semantic Versioning (
MAJOR.MINOR.PATCH), what should the new release version tag be? - Under Git-flow, trace the exact branch sequence from creation to release tag.
Part 1 — Base and Contingency-Adjusted Effort:
Part 2 — Semantic Version Tag: Because the change adds new backward-compatible functionality (a new QR provider without breaking existing API clients), we increment MINOR and reset PATCH to 0: v2.5.0.
Part 3 — Git-Flow Branch Sequence:
- Branch
feature/qr-provideroffdevelop; implement, review, and pass CI tests. - Merge
feature/qr-providerback intodevelop. - Create
release/2.5.0offdevelop; bump version metadata, run full QA/audit, and fix any minor release bugs. - Merge
release/2.5.0intomain, tagv2.5.0, and mergerelease/2.5.0back intodevelop.
- Base effort is ( with the buffer).
- New version tag:
v2.5.0(backward-compatible feature incrementsMINOR). - Git-flow path:
developfeature/qr-providerdeveloprelease/2.5.0main(taggedv2.5.0) + back-merged todevelop.
8.3
How to Answer a Past Exam Question: "Explain the role of Baselines, the Change Control Board (CCB), and Configuration Auditing (FCA vs. PCA) in Software Configuration Management."
1. Define Baseline: Explain that a baseline is an approved, frozen snapshot of SCIs (e.g., SRS baseline, release baseline) serving as a controlled foundation; changes after baselining require formal change control.
2. Describe the CCB and Change Flow: Explain that the CCB evaluates Change Requests against impact analysis (cost, schedule, risk) and approves/rejects/defers them to prevent uncontrolled scope creep.
3. Contrast FCA and PCA:
- Functional Configuration Audit (FCA): Verifies through test results that the built SCI satisfies its specified functional/performance requirements.
- Physical Configuration Audit (PCA): Verifies that all physical deliverables (source files, build artifacts, documentation, version tags) are complete, consistent, and accurately assembled for release.
A complete answer links Baselines (frozen reference points), the CCB (formal change gatekeeper using impact analysis), and Configuration Auditing (FCA checking functional compliance vs. PCA checking completeness of release artifacts and documentation).
Exercises
Practice Exercises — Software Configuration Management
Define Software Configuration Management (SCM), Software Configuration Item (SCI), and Baseline. Briefly explain the four core SCM activities.
Definitions:
- SCM: Systematic discipline for identifying, controlling, auditing, and reporting changes to software artifacts throughout the lifecycle.
- SCI: Any controlled project artifact (code, SRS, design models, test scripts, manuals).
- Baseline: Formally reviewed and frozen version of SCIs used as a stable reference point for future work.
Four SCM Activities:
- Configuration Identification: Uniquely naming and tracking SCIs and baselines.
- Change & Version Control: Managing revisions, branching, and CCB change approvals.
- Configuration Auditing: Conducting FCA (functional compliance) and PCA (artifact completeness).
- Configuration Status Reporting: Logging what changed, why, by whom, and release notes.
SCM controls software evolution across SCIs (tracked artifacts) and Baselines (approved frozen snapshots) through four activities: Configuration Identification, Change/Version Control, Configuration Auditing, and Status Reporting.
Compare Centralized Version Control (CVCS) and Distributed Version Control (DVCS), and explain how Continuous Integration (CI) complements version control.
CVCS vs. DVCS: A CVCS (like SVN) keeps the full history on one central server, requiring network access to commit or branch and creating a single point of failure. A DVCS (like Git) gives every developer a full local repository clone, enabling fast offline commits, lightweight branching, and built-in redundancy.
Role of Continuous Integration: CI automatically builds and tests every commit pushed to the shared repository, catching integration conflicts, broken builds, and test regressions within minutes rather than letting long-lived branches drift apart.
CVCS centralizes history on one server, whereas DVCS gives every developer a complete local repository for fast offline branching and resilience. CI complements VCS by automatically building and testing every push to prevent integration conflicts.
Trace the six steps of the formal Change Management Process and explain the responsibility of the Change Control Board (CCB).
Six-Step Change Management Flow:
- Submit formal Change Request (CR).
- Conduct Technical & Impact Analysis (effort, risk, affected SCIs).
- CCB Decision (Approve, Defer, or Reject).
- Generate Engineering Change Order (ECO) and check out / branch affected SCIs.
- Implement modification, peer review, and run regression tests.
- Check in / merge, audit, update baseline, and publish status report.
Role of the CCB: The CCB balances customer urgency against engineering cost, risk, and schedule impact so unauthorized or poorly analyzed edits never destabilize a baselined system.
Change management flows through CR submission impact analysis CCB review ECO/branching implementation & regression testing audit & new baseline. The CCB governs approval decisions using cost, risk, and schedule impact.
Explain the Git-flow branching strategy by describing the roles of main, develop, feature/*, release/*, and hotfix/* branches, including how a hotfix branch is merged back.
Five Git-Flow Branches:
main: Always holds tagged, production-ready releases.develop: Integration branch for upcoming release features.feature/*: Branched from and merged back intodevelopfor new features.release/*: Branched fromdevelopfor final release stabilization/tagging, then merged tomainanddevelop.hotfix/*: Branched directly frommainto patch an urgent production bug.
Why Hotfixes Merge to Both main and develop: Merging hotfix/* into main deploys the patched production release (e.g., v1.0.1), while merging it into develop guarantees the bug fix is not accidentally lost in the next scheduled release.
Git-flow uses permanent main and develop branches plus temporary feature/*, release/*, and hotfix/* branches. A hotfix/* branch is created from main and merged back into both main and develop so production is patched immediately and future releases retain the fix.
- A software project has modules in its
v1.2.0baseline. After a breaking API redesign, backward-compatible optimizations are skipped and a new incompatible schema is shipped, followed by two backward-compatible bug-fix patches and one backward-compatible feature addition. Assuming sequential Semantic Versioning (MAJOR.MINOR.PATCH), what is the resulting version tag after those releases (1breaking +2patches +1feature, or verify step by step)? Let us trace strictly in order: start atv1.2.0, apply (a) breaking API change, (b) backward-compatible feature addition, and (c) backward-compatible bug-fix patches. State the exact version tag after each step. - An automated CI pipeline runs in per build. If a team of developers pushes commits per week, calculate the total weekly CI compute time in minutes and hours.
Part 1 — Sequential Semantic Versioning Trace from v1.2.0:
- After (a) breaking API change (
MAJORincrements,MINOR&PATCHreset to0):v2.0.0. - After (b) backward-compatible feature (
MINORincrements,PATCHresets to0):v2.1.0. - After (c) backward-compatible patches (
PATCHincrements twice):v2.1.1, thenv2.1.2.
(Total releases applied .)
Part 2 — Weekly CI Compute Time:
- The sequential version tags are
v2.0.0v2.1.0v2.1.1v2.1.2. - Weekly CI compute time is ().