EXPERIMENT 11

AIM: Case Study: GitHub for version control

Introduction

Version control systems (VCS) are essential tools in software development and collaborative
projects, enabling multiple users to work on a project simultaneously, track changes, and
manage different versions of files. This assignment aims to explore the concept of version
control, detail the steps involved in the version control process, provide a basic overview of
popular tools like GitHub, and present a case study highlighting the practical application of
version control in a real-world scenario.

Part 1: What is Version Control?

Version control is a system that records changes to files over time so that specific versions can
be recalled later. It allows multiple people to collaborate on a project, track modifications, and
manage different versions of files. Version control systems are crucial in software
development, documentation, and any project involving collaborative work on digital files.

Key Features of Version Control:

1. Tracking Changes: Every change made to the files is recorded, allowing users to track
who made changes and what changes were made.

2. Collaboration: Multiple people can work on the same project simultaneously without
overwriting each other's work.

3. Branching and Merging: Developers can create branches to work on different features
or fixes independently and later merge them into the main project.

4. Reversion: Easily revert to a previous version if a problem is introduced in the current

version.

Types of Version Control Systems:

1. Local Version Control Systems: Simple systems that keep all changes to files on the
same local machine. Example: RCS (Revision Control System).

2. Centralized Version Control Systems (CVCS): Uses a single server to store all versions
of files. Example: SVN (Apache Subversion).

3. Distributed Version Control Systems (DVCS): Each contributor has a complete copy of
the repository, including its full history. Examples: Git, Mercurial
Part 2: Steps in the Version Control Process

The version control process typically involves several key steps, which help in managing
changes to files systematically. The steps can vary slightly depending on whether the VCS is
centralized or distributed, but the general workflow remains consistent.

Step-by-Step Version Control Process (Using Git as an Example):

1. Initialize a Repository:

o Git: To start using Git for a project, you initialize a Git repository in the project
directory using the command git init.

2. Clone a Repository:

o If the repository already exists (e.g., on GitHub), you can clone it to your local
machine using git clone <repository_url>.

3. Make Changes:

o Edit files in your local repository as needed. These could be code changes,
document updates, etc.

4. Stage Changes:

o Before committing changes, you need to stage them. Staging allows you to
review and prepare a snapshot of changes for the next commit using git add
<file_name> or git add . to stage all changes.

5. Commit Changes:

o Once the changes are staged, commit them to the local repository with a
descriptive message using git commit -m "Description of changes".

6. Push Changes:

o To update the central repository (e.g., GitHub), you push your local commits
using git push origin <branch_name>.

7. Pull Changes:

o Fetch and merge changes from the central repository to your local machine
using git pull. This ensures your local copy is up-to-date with the central
repository.

8. Branching and Merging:

o Branch: Create a new branch for each feature or fix using git branch
<branch_name> and switch to it using git checkout <branch_name>.
 o Merge: After completing work on a branch, merge it back to the main branch
(often main or master) using git merge <branch_name>.

9. Resolve Conflicts:

o If there are conflicts between different changes, they need to be resolved

manually before the merge can be completed.

10. Revert or Reset Changes:

 If needed, you can revert to a previous commit using git revert <commit_id> or reset
your repository using git reset.

Diagram: Version Control Workflow

Part 3: Basic Description of Tools like GitHub with Respect to Version Control

GitHub Overview:

GitHub is a cloud-based platform that provides hosting for software development version
control using Git. It offers all of Git’s version control and source code management (SCM)
functionality, along with additional features like bug tracking, task management, and
collaborative tools for developers.

Key Features of GitHub:

1. Repository Hosting: GitHub hosts your Git repositories in the cloud, making it easy for
teams to collaborate on projects from anywhere.
 2. Pull Requests: A feature that allows developers to notify team members about
changes they've pushed to a GitHub repository, facilitating code review and discussion
before merging the changes.

3. Issues and Project Management: GitHub provides tools for bug tracking and project
management directly within the platform.

4. GitHub Actions: A CI/CD (Continuous Integration/Continuous Deployment) service

integrated into GitHub that allows you to automate workflows.

5. Forking and Branching: Users can fork repositories, create branches, and work
independently before contributing back to the main project.

GitHub and Version Control:

GitHub enhances the basic Git version control workflow by providing a user-friendly interface,
enhanced collaboration tools, and a robust ecosystem for open-source and private projects.
By leveraging GitHub’s capabilities, teams can improve their workflow efficiency, enhance
collaboration, and ensure better project management.

Part 4: Case Study: Version Control in Open Source Software Development

Background:

Open source software development relies heavily on version control systems, particularly
distributed systems like Git and platforms like GitHub. The Linux kernel is one of the most
significant examples of an open-source project that uses Git for version control.

The Linux Kernel Development:

1. Project Overview:

o The Linux kernel is a critical component of the Linux operating system. It has
thousands of contributors worldwide and is managed through a distributed
version control system (Git) hosted on multiple platforms, including GitHub.

2. Version Control Usage:

o Branching: Developers create branches to work on specific features or fixes.

Each branch can be worked on independently without affecting the main
project.

o Pull Requests: When a developer completes a feature or bug fix, they create a
pull request on GitHub. Other developers review the code, suggest changes,
and approve the pull request for merging.
 o Continuous Integration: Every pull request triggers automated testing using
tools like GitHub Actions to ensure that the new code does not break existing
functionality.

o Merging: After a successful review and passing all tests, the code is merged
into the main branch, making it part of the official kernel release.

3. Benefits of Version Control in Linux Kernel Development:

o Enhanced Collaboration: Thousands of developers can contribute to the

project simultaneously without conflicts.

o Code Review and Quality Assurance: Pull requests and automated tests help
maintain high code quality and prevent errors.

o Efficient Management of Changes: The Git workflow allows for efficient

tracking of changes, reversions, and branching, enabling rapid development
and deployment of new features.