DevOps Shack

DevOps Shack
5 Essential Things to Keep in Mind About Git

Introduction
Git is a distributed version control system created to help developers manage and
track changes in code collaboratively. Unlike traditional systems, Git allows for
powerful branching, seamless merging, and distributed workflows, making it
invaluable in team environments and large projects. This document covers five
core concepts to understand when using Git, with in-depth explanations, practical
examples, common issues, and best practices to avoid pitfalls.

1
DevOps Shack

1. Understanding Git Basics

Purpose of Git:
Git helps developers keep a history of all changes made to a codebase, revert to
previous versions when necessary, and work collaboratively without overwriting
each other’s work. Git records snapshots of each version of the project, allowing
teams to work on the same codebase with minimal conflicts.

This structure shows how git init creates a hidden .git folder within the project
folder. The .git folder contains all tracking and configuration data for the
repository.

Key Commands:
• Initializing a Repository:
The git init command initializes a new Git repository in your project

2
DevOps Shack

directory. This action creates a hidden .git folder containing all tracking
information.
git init
• Cloning an Existing Repository:
Cloning allows you to create a local copy of an existing repository, which
you can modify independently.
git clone <repository-url>

Common Missteps:
• Misplaced Repository: Initializing Git in the wrong directory can lead to
unintended tracking of files.
• Ignoring Important Files: Make sure to add files like .gitignore to keep
unnecessary or sensitive files (e.g., .env files with secrets) out of the
repository.
Best Practices:
• Verify Directory: Always check the current directory before initializing or
cloning.
• Secure Your Files: Use .gitignore to exclude files that should not be
committed, such as credentials or large files.

2. Making Commits Thoughtfully

Importance of Commits:
Commits in Git act as checkpoints, allowing you to track the history of changes.
They make it easy to see what was added or removed and who made changes.
Writing clear commit messages and committing frequently are crucial for a
smooth collaborative workflow.

3
DevOps Shack

This diagram illustrates the typical flow when making a commit. Changes move
from the working directory to the staging area with git add, and finally to the
commit history with git commit. Each commit creates a checkpoint in .git.

Key Commands:
• Staging Changes: Use git add to stage files, marking them as ready to
commit.
git add .
• Making a Commit: Every commit needs a descriptive message summarizing
the changes.
git commit -m "Add feature to process user data"

4
DevOps Shack

Common Challenges:
• Vague Messages: Messages like "fixed bug" make it hard to identify the
purpose of changes later.
• Oversized Commits: Including too many changes in a single commit
complicates tracking and rollbacks.
Best Practices:
• Atomic Commits: Keep commits focused on a single change or task to make
them more understandable.
• Clear Messages: Summarize changes in a message of around 50-70
characters.

3. Branching for Safer Workflows

Purpose of Branches:
Branches allow developers to work on different features or fixes independently
without affecting the main codebase. Using branches reduces the risk of conflicts
and errors by isolating new changes until they’re ready for integration.

5
DevOps Shack

Here’s a simplified view of branching. The main branch serves as the stable
version, and feature branches allow for isolated work. After finishing work, you
merge the feature branch back into the main branch. Conflicts may arise if
overlapping changes are made in both branches.

Commands to Use:
• Creating a Branch: To create a branch, use:
git branch feature-branch
• Switching to a Branch: Move to the new branch using:
git checkout feature-branch
• Merging Changes: When your feature is ready, merge the branch back into
main or master to integrate your changes.

6
DevOps Shack

git checkout main

git merge feature-branch

Common Issues:
• Merge Conflicts: Conflicts occur when two branches modify the same lines.
Use git merge and tools like git diff to resolve them.
• Untracked Branches: Avoid leaving branches unmerged for too long, as
they may diverge significantly, making merging more complex.
Best Practices:
• Descriptive Naming: Name branches based on features or issues, such as
feature-login or bugfix-issue-42.
• Frequent Merging: Regularly merge updates from main into feature
branches to minimize conflicts.

4. Mastering Git Stash

Why Use Stash?
Stash is a helpful command when you need to save changes temporarily without
committing. It’s commonly used when you want to switch branches or try out
something experimental.

7
DevOps Shack

This diagram represents how git stash temporarily saves changes, allowing you to
work on another task. You can apply stashed changes later or remove them if
they’re no longer needed.

Commands to Know:
• Saving Changes to Stash:
git stash
• Applying Stashed Changes:
git stash apply

8
DevOps Shack

Use Cases:
• Quick Branch Switches: When you’re halfway through a task and need to
work on another branch temporarily.
• Experimentation: Stash changes, test new code, and reapply if necessary.
Best Practices:
• Label Stashes: Use git stash save "message" to make it easier to remember
each stash.
• Check Stash Before Commit: To avoid accidentally leaving important
changes in the stash, use git stash list to review them.

5. Understanding Remote Repositories

Importance of Remotes:
Remote repositories allow you to store code on external servers like GitHub,
GitLab, or Bitbucket. This setup enables collaboration and backup and is essential
for working with distributed teams.

9
DevOps Shack

This layout shows the connection between the local repository and a remote
repository like GitHub. You can push changes from local to remote and pull
updates to sync with the latest version in the remote repository.

Commands:
• Adding a Remote:
git remote add origin <repository-url>
• Pushing to a Remote Repository:
git push origin main
Common Issues:

10
DevOps Shack

• Authentication Errors: These are common when incorrect credentials or

permissions are used.
• Branch Conflicts: If the remote repository has new changes, pull updates
before pushing.
Best Practices:
• Regular Pushes: Frequently push to the remote repository to keep it
synchronized.
• Pull Before Push: Before pushing, use git pull to retrieve the latest changes
from the remote branch.

Summary Checklist
1. Initialize Git: Confirm the directory and check .gitignore.
2. Commits: Make meaningful, frequent commits.
3. Branching: Use feature branches to keep the codebase clean.
4. Stash: Use stash to save changes temporarily when switching tasks.
5. Remotes: Regularly push to and pull from the remote repository.

Conclusion
Mastering Git basics is crucial for any developer or DevOps professional, as it
enables efficient, collaborative workflows for managing code. By understanding
how to initialize repositories, make clear commits, use branches, stash changes,
and work with remotes, users can keep their projects organized and minimize
conflicts.
These Git fundamentals lay the groundwork for effective version control, making
code management smoother and more productive. With practice, Git will become
an invaluable tool in your workflow. This series is just the start—stay tuned for
more as we dive into advanced Git techniques and best practices!

11