DevOps Implementation - Week 2: Git Basics

DevOps Implementation - Week 2: Version Control with Git

• The topic for week 2 is Version Control using Git
• The objectives are to study Version Control Systems (VCS) and Git fundamentals.

What is Version Control?

• Version control manages multiple versions of a project.
• Every change (addition, modification, removal) to project files needs to be tracked.
• Changes can be undone and recovered.
• The tool for version control is called a Version Control System.

Different Types of Version Control Systems

• Local Version Control System: Stores the change history locally in a single database, impacting team work significantly.
• Source Code Control System (SCCS): A popular system developed by AT&T in the 1970s.
• Centralized Version Control System: Stores change history on a single server. Clients (authors) connect to access the system. Files are locked when being used, limiting concurrent work.
• Distributed Version Control System (DVCS): Similar to centralized systems, but every client has a full copy (clone) of the repository. This allows for efficient teamwork, as every collaborator can operate on and potentially update projects concurrently. Branching and merging work becomes far more efficient compared to centralized systems, as each developer has a local copy allowing for easier, smoother collaborations. This facilitates faster development cycles when compared to other systems.

Centralized VCS vs. Distributed VCS

• Centralized systems require network connection for operations.
• Distributed systems mostly do not rely on constant network access, allowing for offline work.
• Operations like adding, editing, deleting, checking in/out, branching, and merging occur differently between the two. Centralized systems have distinct checkout/checkin processes, unlike distributed systems which are more fluid in terms of operations performed on files and branches.
• Server awareness in centralized systems is direct and immediate. Distributed systems don't have immediate awareness of remote changes until they are 'pushed' into the centralized repository.

Git

• Git was created by Linus Torvalds in 2005 as a replacement for BitKeeper.
• Git is a distributed version control system.
• Git is a command-line system using checksums to guarantee data integrity.
• Git is cross-platform, open-source, and free. Downloadable from https://git-scm.com/download/

Git Popularity

• Git is very popular, accounting for a large portion of version control use.

Install & Setup Git

• Download Git from https://git-scm.com/downloads

Some Key Terms in Git

• Repository: A storage for projects and all changes made.
• For each project, you create a repository using git init or git clone.
• Working Directory: The current project's working area.
• Files exist in the working directory.
• Staging Area (Index): A temporary place where files are placed before permanent inclusion in a commit.
• Commit: A snapshot of a project's state at a specific time. Changes which are prepared (staging area) are integrated into a snapshot (commit) after which the staging area is prepared for the next round of commits.
• Stash: Temporarily stores changes to your working copy that you might want to preserve but aren't ready to commit yet.

Git's 4 Areas

• Data movement occurs between different regions; Working Directory; Staging Area; and the Repository.

A Simple Git Workflow Example

• Actions are performed to track files within a project (adding new files or modifying existing ones), stage them for commits, and commit these changes, after which the current project state is recorded in the git repository.

Check commit log

• Checking the commit log is a crucial feature of Git to see a history of all commits made in the repository.
• Commands are used to inspect commit data effectively.

View Previous Versions

• Git show is used to inspect and view specific commits. The name or the first 7 letters of the commit are used to identify.

Manage Commits -- revert

• git revert reverses specific changes from a commit.
• A new revert commit is created with inverse changes from the original commit.

Manage commits - reset

• git reset is used to revert to a previous commit, discarding all newer commits.
• Modes (soft, mixed, hard) determine how the reset works.

Git reset vs Git checkout

• git checkout switches between different branches or specific commits.
• git reset changes the commit history by discarding future commits

Stash

• Git stash is used to preserve local changes for later use.
• Commands are used to manage stash data.

.gitignore File

• The .gitignore file is used by Git to track changes and determine what files should not be tracked. This aids in keeping large, unchanging resources separate from the tracked project history.

More on .gitignore

• The .gitignore file is a critical component of Git's organization function and ensures that only the files required for work are tracked. This separation ensures that unrelated and unneeded files/folders do not accidentally become part of the project's version history.

Git Commit Best Practices

• Each commit should be atomic (single, self-contained).
• Split complex tasks into smaller, logical chunks for committing.
• Commit messages should be clear, concise, and descriptive.