Experiment No 2

Title: Understanding Version Control System (VCS) / Source Code Management (SCM)
Version Control System (VCS) and Source Code Management (SCM) are crucial tools and practices in software
development. They help teams track changes to the source code over time, collaborate efficiently, and ensure that
code is consistent, accessible, and recoverable.
1. What is a Version Control System (VCS)?
A Version Control System (VCS) is a tool that helps software developers manage changes to their source code. It
tracks the history of code, allowing teams to view, modify, and share code while keeping track of every modification
made by different contributors. VCS enables developers to easily collaborate, roll back to earlier versions of code,
and prevent conflicts between multiple developers working on the same codebase.
There are two main types of version control systems:
 Centralized Version Control System (CVCS): In a CVCS, there is a central repository that stores the code.
Developers check out the code, make changes locally, and commit their changes back to the central
repository.
 Distributed Version Control System (DVCS): In DVCS, every developer has a complete copy of the
repository on their local machine. Changes are committed locally, and later pushed to a remote repository
(e.g., GitHub, GitLab, Bitbucket). Git is the most popular example of a DVCS.
2. Key Concepts in Version Control:
 Commit: A commit is a snapshot of changes made to the source code. It includes information about what
was changed, who changed it, and when. Each commit has a unique identifier (hash).
 Branch: A branch is a parallel version of the code. It allows developers to work on new features or bug fixes
without affecting the main codebase. Once the work is complete, the branch can be merged back into the
main code (often referred to as the main or master branch).
 Merge: Merging is the process of combining changes from different branches. It resolves any conflicts that
arise when changes in different branches affect the same part of the code.
 Repository: A repository (repo) is where all the files and the version history are stored. In a DVCS, it exists
both locally on a developer’s machine and on a remote server.
 Clone: Cloning is the process of creating a local copy of a remote repository, which allows a developer to
work offline and later sync their changes.
 Fork: Forking is creating a personal copy of someone else's project. It is common in open-source software
development, allowing contributors to propose changes without affecting the original code.
3. Why Version Control is Important:
 Track Changes: VCS records every modification made to the codebase. This allows developers to see what
changed, when it changed, and who made the change.
 Collaboration: Multiple developers can work on the same project simultaneously without overwriting each
other's work. VCS helps to avoid conflicts by allowing different branches for feature development and bug
fixes.
  History and Rollback: VCS allows you to roll back to previous versions of the code, whether to undo a
problematic change or reference earlier versions for comparison. This helps maintain stability in
development.
 Backup: The source code is stored in a repository (locally or remotely). Even if a developer's computer
crashes, the code can be recovered from the repository.
 Version Tracking: VCS helps track different versions/releases of a project, making it easier to release,
maintain, and revert to older versions if necessary.
4. Popular Version Control Systems:
 Git: A distributed version control system, Git is the most widely used VCS in modern software development.
It enables developers to manage code locally and push changes to a remote repository.
o GitHub, GitLab, and Bitbucket are popular platforms that host Git repositories and provide
additional tools for collaboration, issue tracking, and CI/CD pipelines.
 Subversion (SVN): An older centralized version control system, SVN allows multiple users to collaborate
and manage changes to the source code. It is less flexible than Git and doesn’t support distributed
workflows.
 Mercurial: A distributed version control system, similar to Git, that allows for local repositories and
distributed collaboration. It's not as popular as Git but still used in some projects.
5. Source Code Management (SCM):
Source Code Management (SCM) refers to the process and practices used to track and manage changes to a
codebase. SCM incorporates the use of version control systems, but it’s a broader concept that includes managing
the entire lifecycle of source code — from development and testing to deployment and maintenance. SCM tools and
systems allow developers to maintain high-quality code, manage multiple versions, and coordinate efforts across
teams.
6. Key SCM Concepts:
 Code Collaboration: SCM enables multiple developers to collaborate on a project by using version control.
This minimizes conflicts and ensures that all changes are tracked and manageable.
 Release Management: SCM practices help ensure that the correct versions of code are released at the
appropriate time. Developers can manage the release cycle, from development to testing and production
deployment.
 Code Review and Quality: SCM systems integrate with code review tools, allowing developers to review
each other's changes before they are merged into the main codebase. This improves code quality.
 Automated Deployment: SCM integrates with continuous integration/continuous deployment (CI/CD)
tools to automate the deployment process, making it easy to release software updates efficiently.
7. Best Practices for Using Version Control / SCM:
 Commit Often, but with Meaning: Make frequent, small commits with clear, concise messages. This makes
it easier to understand the history and revert changes if necessary.
 Branch for Features or Bugs: Use branching to isolate work on specific features or bug fixes. Once
completed, merge it back into the main branch.
 Keep Your Branches Up-to-Date: Regularly pull updates from the main branch to avoid conflicts when
merging.
  Tag Releases: Use tags to mark specific points in history, such as a release or milestone.
 Collaborate via Pull Requests (PRs): Use pull requests to propose changes, which allows team members
to review and discuss code before it gets merged into the main branch.
Conclusion:
Version Control Systems (VCS) and Source Code Management (SCM) are essential components of modern software
development. VCS allows teams to collaborate effectively, track code changes, and ensure code integrity. Tools like
Git, GitHub, and GitLab help manage source code efficiently, automate workflows, and promote best practices like
continuous integration and testing. Understanding and implementing VCS/SCM is crucial for any development team
to maintain code quality, collaborate efficiently, and streamline the development process.

Questions:
1. What is the primary function of a Version Control System (VCS)?
2. Explain the difference between centralized version control and distributed version control. Provide
examples of each.
3. What is Source Code Management (SCM), and how does it differ from version control?
4. Why is it important for development teams to use SCM tools to manage source code across different
environments (development, staging, production)?