Scribd
Upload
6 views

OOSE_Software_Configuration_Management_Lecture

ff

Uploaded by

yasiniqbal302
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
6 views

OOSE_Software_Configuration_Management_Lecture

ff

Uploaded by

yasiniqbal302
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Software Configuration Management

(SCM)

1. Introduction to Software Configuration Management (SCM)

Software Configuration Management (SCM) is a discipline for systematically controlling


the changes that occur during software development and maintenance. As systems grow
in complexity, it becomes critical to manage the various components and configurations
in an organized manner.

SCM answers questions such as:


- What has changed?
- Who made the changes?
- Why were the changes made?
- How can the changes be tracked or reverted?

2. Importance of SCM in Software Engineering

SCM is crucial in large-scale software development projects where:


- Multiple developers are involved.
- Different components or versions are in use simultaneously.
- Long-term maintenance and updates are required.

SCM ensures:
- Traceability of changes.
- Consistency across the software lifecycle.
- Accountability of modifications.
- Easier maintenance and troubleshooting.
Example:
Imagine a software product like a word processor with multiple teams working on
features like text formatting, spellcheck, and user interface. SCM would manage different
versions of each feature and ensure consistency when integrating them.

3. Key Concepts of SCM

- Configuration Item (CI): Any artifact in the software project that needs to be managed
(source code, documents, scripts, etc.).
- Baseline: A set of CIs that are formally reviewed and agreed upon. Baselines can only
be changed through formal procedures.
- Versioning: Assigning unique identifiers to different states of CIs as they evolve over
time.
- Branching: Creating independent lines of development (e.g., working on a new feature
without disrupting the main codebase).
- Merging: Combining changes from different branches.

4. SCM Process Activities

4.1 Configuration Item Identification

This involves identifying the components that need to be managed (e.g., source code
files, libraries, documents). Every CI should have a unique identifier, such as a version
number.

Example:
A project might have the following CIs:
- `app_v1.0.py` (source code)
- `database_schema_v1.2.sql` (database schema)
- `user_guide_v1.0.docx` (documentation)

4.2 Change Control

Changes in CIs must be controlled through a formal process. A Change Request (CR) is
submitted, reviewed, and either accepted or rejected.

Steps:
1. Submit a CR.
2. Evaluate the CR (impact analysis, risk assessment).
3. Implement the change if approved.
4. Test and verify the change.
5. Update the baseline.

Example:
A developer submits a CR to fix a bug in `app_v1.0.py`. After approval, they create
`app_v1.1.py`, integrate and test it, and update the baseline.

4.3 Version Control

Version control tracks changes to files over time. Developers can check in/out files,
maintain a history of changes, and restore older versions when needed.

Two models of version control:


- Centralized Version Control Systems (CVCS): A single central repository is used (e.g.,
Subversion).
- Distributed Version Control Systems (DVCS): Every developer has a full copy of the
repository (e.g., Git).

Example:
In Git, a developer works on a bug fix in their branch (`bugfix-branch`). Once complete,
they commit their changes and merge it into the `main` branch.

4.4 Configuration Auditing

Audits ensure that all configuration items conform to their specifications and that all
changes have been properly tracked and approved. Audits are typically performed before
major releases or deployments.

Example:
Before releasing a new version of a software application, an auditor ensures that:
- All changes are documented.
- All files have version numbers.
- There are no unauthorized modifications.

5. SCM Tools and Automation

SCM Tools facilitate automation and management of SCM activities. Popular tools
include:
- Git: For version control.
- Jenkins: For continuous integration.
- Subversion (SVN): A centralized version control system.

Automation in SCM helps streamline tasks such as builds, testing, and deployments,
ensuring consistency across environments.
Example:
Using Jenkins, a developer’s commit in Git triggers an automated pipeline that builds the
software, runs tests, and deploys to a staging environment.
6. SCM in Agile Environments

In Agile, SCM becomes even more critical due to the rapid iteration and continuous
integration/deployment (CI/CD) practices. Agile teams use SCM to ensure:
- Changes are small, incremental, and reversible.
- Continuous integration allows for early detection of integration issues.

Example:
In an Agile team, developers push code daily to the repository. Each push triggers an
automated CI process that integrates and tests the changes to ensure they work alongside
the existing codebase.

7. Examples and Case Studies

Example 1: Version Control in a Collaborative Project


In a team of 5 developers working on different features, SCM ensures that each developer
works on separate branches. At the end of the sprint, they merge their branches into the
main branch after reviewing and resolving conflicts.

Example 2: Handling Change Requests in a Banking Application


A team managing a banking application receives a request to add a new feature. The
feature is developed in a separate branch, reviewed, and tested before merging into the
baseline. SCM tools track who made the changes, when they were made, and what
exactly was changed.

Conclusion
Software Configuration Management is essential in ensuring that software development remains
structured, traceable, and maintainable. It supports collaboration, prevents conflicts, and allows
teams to build robust, reliable software. From version control to automated pipelines, SCM
ensures that every component of a project is carefully managed.

You might also like