✒️SAP BTPFIORI / Los sistemas de control de versiones Por Jaime Gomez Arango

1 | Version Control Systems

Centralized and Distributed Version Control Systems

Version control systems are essential tools for managing changes to source code over time. There are two primary types: centralized and distributed.

• Centralized Version Control Systems (CVCS): In a centralized system, such as Subversion (SVN), all version history is stored on a central server. Developers check out files, work on them locally, and then check the files back into the central server. This setup means that to work on the code, you must be connected to the server.
• Distributed Version Control Systems (DVCS): In contrast, a DVCS like Git, Mercurial, or Bazaar allows each developer to have a full copy of the repository on their local machine. This enables them to work offline and later synchronize their changes with the central repository once they reconnect to the network.

Advantages of Distributed Version Control Systems:

• Change Tracking: Every change to the files is recorded with details such as the time, the author, and a message describing the change.
• Synchronization: Multiple developers can work on the same project simultaneously and keep their copies up-to-date with the latest changes.
• Backup and Restoration: Changes can be saved, and any file can be restored to any previous state.
• Branching and Merging: Developers can create branches to work on new features independently and merge them back into the main project when ready.

Characteristics of Git:

Git is particularly noted for its efficiency in managing branches. It allows developers to make changes in separate branches and merge them with the main project effortlessly. This makes it an invaluable tool for collaborative development.

2 | What is Git?

Git is a powerful version control system used to manage and track changes in code. It is known for its speed, simplicity, and reliability in maintaining versions of projects with numerous files. Git was designed to facilitate efficient, collaborative development by allowing developers to work on their local copies and synchronize changes with a global repository.

Benefits of Git:

• Speed and Efficiency: Git is exceptionally fast in handling branches, which makes it suitable for large projects.
• Distributed Development: Every developer has a complete copy of the repository, allowing for offline work and reducing the risk of data loss.
• Flexibility: Branching and merging are core features that support multiple lines of development.
• Open Source and Community Support: Git is free and open-source, with extensive community support and numerous resources available.

3 | Advantages of Git

Git provides several significant advantages over traditional version control systems:

• No Single Point of Failure: Being a distributed system, Git does not rely on a central server, which allows work to continue even if the server is down.
• Integration: Git integrates seamlessly with various development tools and platforms, supporting continuous integration and deployment, automated testing, and work item tracking.
• Community Support: Git's popularity ensures robust community support, abundant resources, and tools for developers.
• Team Productivity: Git enhances team productivity by enabling collaboration, policy enforcement, process automation, and improved visibility of work.
• Branch Policies and Pull Requests: Platforms like GitHub and Azure DevOps allow teams to set branch policies and conduct code reviews through pull requests, ensuring code quality and knowledge sharing.

4 | The Distributed System

The Repository

A Git repository is a collection of files and their version history, organized in a directory structure. It includes the following key areas:

• Working Directory: The workspace where developers modify files. Changes here are in the "Modified" state.
• Staging Area: Files that are staged for the next commit. These changes are in the "Prepared" state.
• Git Repository: The database where committed changes are stored permanently. Once changes are committed, they move from the "Prepared" to the "Confirmed" state.

The Three States in Git:

• Modified: Changes are made in the working directory.
• Staged: Changes are selected and staged in preparation for a commit.
• Committed: Changes are saved in the repository.

5 | The Stages of a File in Git

Workflow and Commands

• git add: Moves changes from the working directory to the staging area.
• git commit: Records the staged changes in the repository with a descriptive message.

Branching and Merging

Branches are essential for managing different lines of development. The main branch, typically called "master" or "main," contains the stable code ready for production. Other branches are created for new features or fixes and are merged back into the main branch once the work is complete.

• Creating a Branch: Use git checkout -b branch_name to create a new branch.
• Merging Branches: Use git merge branch_name to merge changes from a branch into the current branch.

Advanced Workflows

In advanced workflows, continuous integration systems automatically check for conflicts during merges. Developers are notified of conflicts, which they must resolve before the merge is completed. Once resolved, changes are merged into the "development" branch and then into "master" for production deployment.

# Basic Commands

# Initialize a new Git repository

git init

# Clone a repository into a new directory

git clone <repository_url>

# Show the working directory status

git status

# Add a file to the staging area

git add <file>

# Commit changes with a message

git commit -m "commit message"

# Show the commit history

git log

# Show changes between commits, commit and working tree, etc.

git diff

# Display help information about Git

git help

# Set the global username

git config --global user.name "Your Name"

# Set the global email address

git config --global user.email "[email protected]"

# Intermediate Commands

# List all branches

git branch

# Create a new branch

git branch <branch_name>

# Switch to a different branch

git checkout <branch_name>

# Merge a branch into the current branch

git merge <branch_name>

# List remote repositories

git remote -v

# Fetch branches and commits from the remote repository

git fetch

# Fetch and merge changes from the remote repository

git pull

# Push changes to the remote repository

git push

# Remove a file from the working directory and staging area

git rm <file>

# Stash changes in the working directory

git stash

# Apply stashed changes

git stash pop

# Create a new tag

git tag <tag_name>

# Show various types of objects (commits, tags, etc.)

git show <commit>

# Advanced Commands

# Reapply commits on top of another base tip

git rebase <branch_name>

# Apply the changes introduced by some existing commits

git cherry-pick <commit>

# Revert a previous commit

git revert <commit>

# Reset current HEAD to the specified state

git reset <commit>

# Start binary search to find the commit that introduced a bug

git bisect start

# Mark the current commit as bad

git bisect bad

# Mark the current commit as good

git bisect good

# Show the reference logs

git reflog

# Rewrite branches with a filtered history

git filter-branch --tree-filter '<command>' HEAD

# Show what revision and author last modified each line of a file

git blame <file>

# Add a new submodule to the repository

git submodule add <repository_url>

# Cleanup unnecessary files and optimize the local repository

git gc