BHARATI VIDYAPEETH’S COLLEGE

OF ENGINEERING

INTRODUCTION TO SOFTWARE
ENGINEERING

Pbl Topic:-Configuration and Version

Management in Software Projects

Submitted By:-
Tushar kumar Enroll. No-00311507622
Semester-7th Course Title – ISE
Software Configuration Management
When we develop software, the product (software) undergoes many changes in their
maintenance phase; we need to handle these changes effectively.

Several individuals (programs) work together to achieve these common goals. This
individual produces several work products (SC Items) e.g., Intermediate version of modules
or test data used during debugging, parts of the final product.

The elements that comprise all information produced as a part of the software process are
collectively called a software configuration.

As software development progresses, the number of Software Configuration elements

(SCI's) grow rapidly.

These are handled and controlled by SCM. This is where we

require software configuration management.

A configuration of the product refers not only to the product's constituent but
also to a particular version of the component.

Therefore, SCM is the discipline which

○ Identify change
○ Monitor and control change
○ Ensure the proper implementation of changes made to the item.
○ Auditing and reporting on the changes made.

Configuration Management (CM) is a technique of identifying, organizing, and

controlling modification to software being built by a programming team.

The objective is to maximize productivity by minimizing mistakes (errors).

CM is used to essential due to the inventory management, library management,

and update management of the items essential for the project.

Why do we need Configuration Management?

Multiple people are working on software which is consistently updating. It may
be a method where multiple versions, branches, authors are involved in a
software project, and the team is geographically distributed and works
concurrently. It changes in user requirements, and policy, budget, schedules
need to be accommodated.

Importance of SCM
It is practical in controlling and managing the access to various SCIs e.g., by
preventing the two members of a team from checking out the same component
for modification at the same time.

It provides the tool to ensure that changes are being properly implemented.

It has the capability of describing and storing the various constituents of

software.

SCM is used in keeping a system in a consistent state by automatically producing

a derived version upon modification of the same component.
SCM Process
It uses the tools which keep that the necessary change has been implemented
adequately to the appropriate component. The SCM process defines a number of
tasks:

○ Identification of objects in the software configuration

○ Version Control
○ Change Control
○ Configuration Audit
○ Status Reporting
Identification

Basic Object: Unit of Text created by a software engineer during analysis, design,
code, or test.

Aggregate Object: A collection of essential objects and other aggregate objects.

Design Specification is an aggregate object.

Each object has a set of distinct characteristics that identify it uniquely: a name, a
description, a list of resources, and a "realization."

The interrelationships between configuration objects can be described with a

Module Interconnection Language (MIL).

Version Control

Version Control combines procedures and tools to handle different version of

configuration objects that are generated during the software process.

Clemm defines version control in the context of SCM: Configuration

management allows a user to specify the alternative configuration of the
software system through the selection of appropriate versions. This is supported
by associating attributes with each software version, and then allowing a
configuration to be specified [and constructed] by describing the set of desired
attributes.

Change Control

James Bach describes change control in the context of SCM is: Change Control is
Vital. But the forces that make it essential also make it annoying.

We worry about change because a small confusion in the code can create a big
failure in the product. But it can also fix a significant failure or enable incredible
new capabilities.

We worry about change because a single rogue developer could sink the project,
yet brilliant ideas originate in the mind of those rogues, and

A burdensome change control process could effectively discourage them from

doing creative work.
A change request is submitted and calculated to assess technical merit; potential
side effects, the overall impact on other configuration objects and system
functions, and projected cost of the change.

The results of the evaluations are presented as a change report, which is used by
a change control authority (CCA) - a person or a group who makes a final decision
on the status and priority of the change.

The "check-in" and "check-out" process implements two necessary elements of

change control-access control and synchronization control.

Access Control governs which software engineers have the authority to access
and modify a particular configuration object.

Synchronization Control helps to ensure that parallel changes, performed by

two different people, don't overwrite one another.

Configuration Audit

SCM audits to verify that the software product satisfies the baselines
requirements and ensures that what is built and what is delivered.

SCM audits also ensure that traceability is maintained between all CIs and that all
work requests are associated with one or more CI modifications

SCM audits are the "watchdogs" that ensure that the integrity of the project's
scope is preserved.

Status Reporting

Configuration Status reporting (sometimes also called status accounting)

provides accurate status and current configuration data to developers, testers,
end users, customers and stakeholders through admin guides, user guides, FAQs,
Release Notes, Installation Guide, Configuration Guide, etc.

.
Version Management in Software Projects

Version management (also known as version control or source control) refers to

the process of managing changes to software code, configuration files, and other
resources in a software project over time. This is crucial for maintaining software
quality, collaboration, and consistency, especially in team-based development
environments. It enables teams to track changes, revert to previous versions, and
manage conflicts that arise from simultaneous edits.

Here’s an overview of key concepts and best practices for version management in
software projects:

Version Control Systems (VCS)

A Version Control System helps manage changes by tracking revisions to files. It
ensures that every change to the codebase is recorded, and historical versions of
the code can be accessed at any point. There are two main types of version
control systems:

a. Centralized Version Control (CVCS)

In a CVCS, there is a central repository that holds the complete history of the
project. Developers check out files from the central repository, make changes
locally, and then commit those changes back to the repository.

● Examples: Subversion (SVN), CVS

● Pros: Simplicity, central point of access.
● Cons: Single point of failure, poor offline capabilities.

b. Distributed Version Control (DVCS)

In a DVCS, every developer has a local copy of the entire repository, including its
history. Changes are first committed locally and later pushed to the central
repository, allowing for greater flexibility and offline work.

● Examples: Git, Mercurial, Bazaar

● Pros: Off-line capability, faster operations, branch-heavy workflows.
● Cons: More complex to manage, but tools like GitHub and GitLab abstract
complexity for users.

Key Concepts in Version Control

● Repository (Repo): A storage location for your codebase and its entire
version history.
● Commit: A snapshot of the changes made to files in the repository. Each
commit is associated with a unique ID (e.g., a hash).
● Branch: A separate line of development in the repository. Branches allow
developers to work on features independently without affecting the main
codebase (e.g., the main or master branch).
● Merge: Combining changes from different branches back into a single
branch, often with the resolution of any conflicts that arise.
● Tag: A reference to a specific commit, often used for marking important
milestones like releases (e.g., v1.0.0).
● Pull Request (PR) or Merge Request (MR): A method for submitting
changes to a repository for review and merging into the main branch.

Why Version Management is Important

● Collaboration: Developers can work on separate parts of a project

simultaneously without overwriting each other's work.
● History and Auditing: Every change is recorded with an identifier,
timestamp, and author. This makes it easy to track and understand the
evolution of the project.
● Reverting Changes: If a bug is introduced or an error is made, version
control allows you to revert to previous versions of the codebase.
● Conflict Resolution: Version control systems can highlight conflicting
changes, allowing developers to resolve issues before merging changes.
● Branching and Parallel Development: Developers can create new
branches for features, experiments, or bug fixes, allowing them to work in
parallel without interfering with the main codebase.
 ● Release Management: Tags and branches can be used to manage
releases and maintain multiple versions of a project.

Best Practices for Version Management

a. Commit Early, Commit Often

Make commits frequently with small, logical changes. This reduces the
complexity of each commit and makes it easier to understand and track
progress. Each commit should have a clear, meaningful message explaining the
purpose of the changes.

b. Use Branches for Features and Fixes

Branches are one of the key tools for working in a collaborative environment.
Create a new branch for each feature or bug fix and merge it back into the main
branch when it's complete. This helps keep the main branch stable.

c. Write Meaningful Commit Messages

A good commit message explains what changes were made and why. This is
crucial for understanding the code's history, especially when you need to
troubleshoot or review changes.

Example:

sql

Copy code

Fix bug in user authentication module

- Fixed issue where session tokens were not being properly

validated.

- Added test cases to cover new validation logic.

d. Regularly Pull Latest Changes

If you're working in a team, regularly pull changes from the main branch (or the
branch you're collaborating on) to avoid merge conflicts. This ensures that you're
working with the most up-to-date version of the code.

e. Avoid Large, Monolithic Commits

Try to avoid committing large chunks of work that make it difficult to understand
the intent or separate logical changes. Break down tasks into smaller, more
manageable commits.

f. Review Pull Requests (PRs) and Merge Requests (MRs)

When using a DVCS like Git, it's standard practice to submit pull requests for new
features or bug fixes. Team members can review code, suggest improvements,
and test changes before they are merged into the main branch.

g. Tagging Releases

Use tags to mark specific versions of the software for release (e.g., version 1.0, 1.1,
2.0). Tags are immutable and provide a reference point for future work, bug fixes,
or deployments.

Common Version Control Tools

● Git: The most popular distributed version control system, often used with
platforms like GitHub, GitLab, and Bitbucket.
● Subversion (SVN): A centralized version control system, which is less
commonly used today but still in some legacy environments.
● Mercurial: Another distributed version control system, similar to Git but
with a simpler interface.
● Perforce: A version control system popular in industries like gaming and
large-scale enterprises due to its scalability.

Version Management in the Software Development

Lifecycle
Version control integrates with the software development lifecycle (SDLC) in the
following ways:

● Continuous Integration (CI) / Continuous Deployment (CD): Version

control is central to CI/CD pipelines. Automated tools like Jenkins, CircleCI,
 or GitLab CI/CD trigger builds and deployments based on commits and
merges.
● Release Management: Tagging versions and using branches helps
manage different stages of releases (e.g., alpha, beta, stable). Version
numbers can follow Semantic Versioning (SemVer) to clearly indicate
breaking changes, new features, and bug fixes.

Semantic Versioning (SemVer)

Semantic Versioning is a versioning scheme that helps to communicate the
nature of changes in a project. A typical version follows the format
MAJOR.MINOR.PATCH:

● MAJOR version: Incremented for incompatible API changes or significant

changes that break backward compatibility.
● MINOR version: Incremented for backward-compatible new features or
improvements.
● PATCH version: Incremented for backward-compatible bug fixes or minor
improvements.

Challenges and Pitfalls

● Merge Conflicts: Merge conflicts arise when two developers modify the
same line or section of a file in different ways. It's crucial to have good
conflict resolution strategies and communicate with team members to
resolve these issues.
● Branching Strategies: Improper branching strategies can lead to a
fragmented repository with overlapping changes or difficulty in merging.
Consider using strategies like Git Flow or GitHub Flow to ensure organized
development.
● Repository Bloat: Large repositories can become unwieldy if too many
binaries or non-source files are stored. It’s recommended to store large
assets outside the version control system, in services like Amazon S3 or
cloud storage.

Popular Platforms for Version Management

● GitHub: A web-based platform that hosts Git repositories and provides
tools for collaboration, issue tracking, pull requests, and CI/CD integration.
 ● GitLab: A similar platform to GitHub, but with built-in CI/CD features and
support for self-hosting.
● Bitbucket: A Git-based version control platform, often used in conjunction
with Atlassian tools like Jira and Confluence.
● Azure DevOps: A suite of development tools, including Git repositories,
pipelines for CI/CD, and agile planning tools.

Conclusion
Version management is an essential part of modern software development. It
enables collaboration, maintains project history, and ensures that teams can
safely and efficiently develop, release, and maintain software. Whether using a
centralized or distributed version control system, following best practices and
adopting appropriate tools will improve both individual and team workflows. By
incorporating version control and proper branching strategies into the software
development process, teams can maintain better quality, scalability, and
maintainability throughout the lifecycle of their projects.