DEV Community: Fatema Moharam

Git: A practical guide

Fatema Moharam — Fri, 28 Jul 2023 19:01:07 +0000

In the previous posts of this series, we covered the basics of version control systems and Git fundamentals. We introduced the advantages of using Git and provided installation guides for Linux, Windows, and macOS. Now, it's time to start using Git and create your first repository. This tutorial will guide you through the process of creating a Git repository and illustrate how to use various Git commands along the way. Whether you're a beginner or you just need a refresher, this tutorial is for you. Let's dive in!

Creating a Repository

While it's possible to create a repository at any point during the development process, it's always a good practice to create one early on. This is especially true if you're working with a team. By creating a repository early, you'll be able to keep your code organized from the beginning and avoid potential headaches down the line.

To get started, let's go ahead and create a new folder on the desktop, I'll call it git-demo.

To create a git repository, open up a terminal window (CMD or Powershell on Windows) and navigate to the directory where you'd like to create your repository. You can do that either with the cd command, which means Change Directory, like the following:

cd desktop/git-demo

or if you're on Windows, you can also right-click anywhere inside the folder and choose Git Bash Here.

Once you're there, run the following command to initialize a new Git repository:

git init

This will create a new (hidden) directory named .git in your current directory, which will serve as the backbone of your repository. You can think of this directory as a hidden database that tracks all changes made to your code.

Track Your Code: Staging

Let's write some code, shall we?

Create a new Python file called hello.py using your favourite code editor. This file will contain the shortest program in history:

print('Hello World!')

Right now, our file is not tracked by Git, meaning any changes we make to it won't be saved in Git's history. To track changes to our file, we need to stage it using the following command in the terminal:

git add hello.py

The git add command adds our file to Git's staging area, which means Git will start tracking changes to the file. The git add command can take arguments like file names, directory names, or wildcards to add multiple files at once. If we want to track all the files in our directory, we can write

git add .

Committing Changes

Once you've staged your changes, you're ready to commit them to your repository using the git commit command.

git commit -m "Initial commit"

The git commit command creates a new commit with the changes we've staged. The -m flag allows us to add a commit message describing the changes we've made. Commit messages should be clear and concise and describe the changes made in the commit.

Good Practices for Git Commits

To ensure that commits are effective and easy to manage, there are several good practices to follow:

Keep commits small and focused: A commit should contain a single logical change or feature. This makes it easier to review and understand the changes made to the codebase.
Write clear commit messages: A commit message should be descriptive and explain the changes made in the commit. This helps other developers understand what has been changed and why.
Use the present tense and imperative mood in commit messages: Commit messages should start with a verb in the present tense, such as "Add," "Fix," or "Update." This makes it clear what action was taken in the commit.
Commit frequently: Committing frequently allows for better tracking of changes and makes it easier to revert to previous versions if necessary.

The Status command

The git status command is a useful tool in Git that shows the current status of your repository. It displays the state of the working directory and the staging area. When you run this command, Git will tell you which files have been modified, which files are staged, and which files are not tracked.

The git status command allows you to keep track of your changes and see which files are ready to be committed. It will tell you if the file is modified but not yet staged, or if it has been staged and is ready to be committed.

In addition, git status also provides information about untracked files. Untracked files are files that are not yet added to the repository and are not being tracked by Git. This can help you keep track of changes to your code and ensure that everything is properly tracked. Let's run it in the terminal:

git status

Branches

Let's dive into branches and the git checkout command.

git branch

Git Branches: In Git, branches are like parallel timelines that allow you to work on different features, fixes, or experiments without affecting the main codebase. You can think of branches as separate workspaces where you can freely create, modify, and delete code.

Renaming a branch: If you want to rename an existing branch, you can use git branch -M new_name.
Creating a new branch: To create a new branch, use the git branch command followed by the branch name. For example, git branch new_feature will create a new branch called "new_feature."
Listing branches: To see a list of all branches in your repository, you can use git branch -v. It will show you all the branches along with their latest commits.
Viewing all branches: To see both local and remote branches, you can use git branch -a. This will display a list of all branches available in your local repository as well as the remote repository.
Deleting a branch: To delete a branch that you no longer need, use git branch -d branch_name. If the branch has unmerged changes, you can use git branch -D branch_name to force delete it.

git checkout

Git Checkout: The git checkout command allows you to switch between different branches in your repository. It's like teleporting between different timelines, letting you work on specific branches at different times.

Creating and switching to a new branch: To create and switch to a new branch at the same time, use git checkout -b new_branch_name. For example, git checkout -b feature_branch will create a new branch called "feature_branch" and switch to it.
Switching to an existing branch: If you want to move to an existing branch, use git checkout existing_branch_name. For example, git checkout main will switch you to the "main" branch.

git merge

Git Merge: Branches are often used to work on separate features, and once those features are ready, you can merge them back into the main codebase using the git merge command. It brings changes from one branch into another, creating a cohesive and up-to-date project.

Let's walk through some examples of using the git merge command.

Fast-forward merge

Let's say we have two branches: "main" and "feature_branch." The "feature_branch" has completed its development, and now we want to bring those changes into the "main" branch.

First, switch to the "main" branch:

git checkout main

Then, merge the changes from "feature_branch" into "main":

git merge feature_branch

In this scenario, if there are no conflicting changes between the two branches, Git performs a fast-forward merge. It moves the "main" branch pointer forward to the latest commit of "feature_branch," incorporating all the changes smoothly.

Merge with conflicts

Let's consider a situation where both the "main" and "bug_fix" branches have made changes to the same file, resulting in a conflict.

First, switch to the "main" branch:

git checkout main

Now, merge the changes from "bug_fix" into "main":

git merge bug_fix

If Git detects conflicts between the changes, it will pause the merge process and prompt you to resolve the conflicts manually. You'll need to open the conflicting file, identify and choose which changes to keep, save the file, and then commit the resolution.

Merge with a commit message

You can provide a custom commit message while merging to provide more context about the changes being merged.

First, switch to the branch you want to merge into, for example, "main":

git checkout main

Merge the changes from the other branch, say "feature_branch," with a custom commit message:

git merge feature_branch -m "Merge feature_branch into main: Add new feature XYZ"

This way, you can add a descriptive commit message that helps others understand the reason for the merge and what changes were introduced.

Try it out

Rename a branch

It's common practice to have your default branch called "main", so let's rename the current branch to "main". In your terminal, write:

git branch -M main

Add a new feature

Now, let's create a new branch to implement the feature "greeting".

git branch greeting-feature

then switch to the newly created branch:

git checkout greeting-feature

Or we can combine both of the previous commands in one command

git checkout -b greeting-feature

Then we'll make some changes in the hello.py file:

print('Hello World!')

name = input('Enter your name: ')
print(f'Hello, {name}! Nice to meet you.')

We can now add and commit the changes

git commit -am "add greeting by name"

git commit -am <message> is a shortcut to stage and commit changes to tracked files in one step. The -a flag automatically stages modified or deleted files. The -m <message> flag lets you add a commit message directly in the command. Note that it doesn't stage new or untracked files.

Merge changes

We can now merge the new feature into the main branch.

git checkout main
git merge greeting-feature

We see the following output, informing us that a fast-forward merge was performed.

Fast-forward
 hello.py | 3 +++
 1 file changed, 3 insertions(+)

We can now safely delete the greeting-feature branch:

git branch -d greeting-feature

Recap

In this tutorial, we've covered the essential local commands of Git, giving you a solid foundation to start using version control in your development workflow. We learned how to create a repository, track changes using staging, commit changes with informative messages, and manage branches using git branch and git checkout.

We also explored the powerful git merge command, which allows you to bring changes from different branches into the main codebase, and we saw how to handle both fast-forward merges and merges with conflicts.

By now, you should feel more confident in managing your code with Git and using branches to work on separate features. Congratulations on mastering the basics!

I hope you found this tutorial helpful, and I apologize for its length. I understand that it might have been quite detailed, but I believe that the in-depth explanations will benefit your understanding of Git. Your time and attention are greatly appreciated.

In the next tutorial, we'll take it a step further and explore the world of remote repositories. We'll show you how to collaborate with others, share your code on platforms like GitHub, and use Git's remote commands to work with repositories hosted on remote servers. Stay tuned for an exciting journey into the world of remote Git!

Feel free to leave your feedback or any questions in the comments below. Happy coding!

Git: The Basics

Fatema Moharam — Fri, 28 Jul 2023 18:51:38 +0000

In the world of software development, version control systems are an indispensable tool for managing code changes, collaborating with others, and keeping track of project history. In the previous post of this series, we discussed the importance of version control systems, and their types, and introduced some essential terminologies. In this post, we will focus on one of the most popular version control systems, Git, and its basics. Understanding the fundamentals of Git can help you streamline your workflow, avoid common pitfalls, and collaborate more efficiently with your team. So, let's dive in!

About Git

Git is a distributed version control system that was created by Linus Torvalds in 2005. It's incredibly popular due to its flexibility, speed, and ability to handle large codebases. With Git, developers can work on the same codebase simultaneously, and easily switch between branches to work on different features or fixes. Git also provides a wide range of tools to help with collaboration, such as merge requests and pull requests.

Snapshots, Not Differences

Git is different from other VCS because it thinks of its data like a series of snapshots of a miniature filesystem rather than a list of file-based changes. Git stores data as snapshots of the project over time.

Nearly Every Operation Is Local

In Git, nearly every operation is local because most operations only require local files and resources to operate. This means that it is very little you cannot do if you are offline.

Git has Integrity

Git has integrity because everything in Git is checksummed before it is stored and is then referred to by that checksum. Git uses SHA-1 hash to store everything in its database not by file name but by the hash value of its contents.

Git Generally Only Adds Data

When you do actions in Git, nearly all of them only add data to the Git database. It is hard to get the system to do anything that is not undoable or to make it erase data in any way. After you commit a snapshot into Git, it is very difficult to lose, especially if you regularly push your database to another repository.

The Three States

Git has three main states that your files can reside: modified, staged, and committed.

Modified means that you have changed the file but have not committed it to your database yet.
Staged means that you have marked a modified file in its current version to go into your next commit snapshot.
Committed means that the data is stored in your local database.

In simple terms, Git has three main parts: the working tree, the staging area, and the Git directory.

The working tree is the current version of the project that you are working on. It contains all the files you need to use or modify.
The staging area is a file that contains information about what changes you want to include in your next commit. You can selectively stage changes, which means you can choose which changes you want to commit and which ones you don't.
The Git directory is where Git stores all the information about your project, including the history of changes and the current state of the project. When you clone a repository from another computer, you are copying the Git directory.

The basic Git workflow involves making changes to your working tree, selectively staging the changes you want to include in your next commit, and then committing those changes to the Git directory.

Getting Started

Enough with the boring stuff! Now that we've covered the basics of Git, it's time to take the next step and start using Git.

Installing Git

Linux

The easiest way to install Git on your system is through the command line. Let's open a terminal. If you are working on Ubuntu or Debian, all you need to do is run the following command.

apt-get install git

For Ubuntu, this PPA provides the latest stable upstream Git version

add-apt-repository ppa:git-core/ppa
apt update
apt install git

If you are using a different Linux distro, you can find instructions on the Official Downloads Page.

Windows

To install git on windows, all you need to do is follow these steps.

Go to the Git website at https://git-scm.com/download/win
Click the download button for the 64-bit Git for Windows Setup
Once the download is complete, double-click on the downloaded file to start the installation process
Select the desired language for the installer and click 'OK'
Follow the on-screen instructions to complete the installation

To verify the installation, you can do any of the following:

Go to any folder or the desktop and right-click, if you see "Git Bash Here", then you successfully installed Git on your machine.
Open a Command Line or Powershell, and type:
```
git --version
```

If you see something like this: git version 2.39.1.windows.1, then you successfully installed Git on your machine.

Mac OS

There are several ways to install Git on a Mac. The easiest is probably to install the Xcode Command Line Tools. On Mavericks (10.9) or above you can do this simply by trying to run git from the Terminal the very first time.

git --version

If you don’t have it installed already, it will prompt you to install it.

Or you can follow the following steps:

Go to the Git website at https://git-scm.com/download/mac
Click the download button for the macOS installer
Once the download is complete, double-click on the downloaded file to start the installation process
Follow the on-screen instructions to complete the installation
Open the Terminal app and type git --version in the terminal window and press enter to verify that Git is installed correctly. If you see the Git version information, it means Git has been successfully installed.

That's it! You now have Git installed on your machine and you're ready to start using it.

Conclusion

In this post, We've explained what Git is, how it works, and its advantages. We've also explored the three main states your files can reside in and provided installation guides for Linux, Windows, and macOS. I hope this post has been helpful to you, and I welcome your feedback in the comments. In the next post, we will dive deeper into Git's basic commands and help you create your first repository. So, stay tuned!

References

The Pro Git Book

Can Someone Tell Me What a Repo Is?

Fatema Moharam — Fri, 17 Feb 2023 14:25:19 +0000

As a software developer, you know how frustrating it can be to manage changes to your code when working on a project with others. That's where version control comes in - it's a lifesaver! Version control is a powerful tool that tracks changes made to files over time, allowing you to easily revert to previous versions if something goes wrong. And the best part? You can work on the same project with other developers without any pesky conflicts. Version Control can help you improve your workflow and become a more efficient and effective coder.

In this blog post, we'll cover everything you need to know to get started with version control. We'll cover the different types of version control, how they work, and why you should use version control.

What is Version Control?

Version control systems are software tools that help track changes made in code over time. As a developer edits code, the version control system takes a snapshot of the files. It then saves that snapshot permanently so it can be recalled later if needed.

Why Use Version Control?

As a developer, you may face many challenges that can take up a lot of your time. Some of these challenges include fixing bugs, figuring out how to use new tools, or adding new features or content to your project. As your project becomes more complex, version control helps teams focus on what matters - delivering high-quality software on time. Here are some situations where version control can save you:

Collaborating with others: Version control makes it easier to collaborate on code with other developers. You can work on the same codebase without worrying about interfering with each other's changes. With version control, you can also easily see who made what changes and when.
Easy Undo: Remember that time when you deleted a whole folder of code? Yeah, we don't want to talk about it. With version control, you can easily undo changes and go back to a previous version of your code. It's like a time machine, but for your code!
Track Changes: You're trying to figure out why your code isn't working, and you realize that it's been changed. But by whom? And when? With version control, you can track all changes made to your code, and by whom. make it easy to visualize the changes and understand the development history of your codebase. This allows you to easily track down the culprit of any issues, and roll back to a previous version if necessary.

Commit graphs are a visual representation of the history of changes made to your code, and they show the relationships between different versions of your code. They can be very useful for understanding the evolution of your codebase over time, and for troubleshooting issues that may have been introduced in a recent change. With a commit graph, you can see which versions of the code are related, who made changes to the code, and when those changes were made. This helps you quickly pinpoint when and where problems were introduced, so you can address them more efficiently. Some popular tools for viewing commit graphs in Git include GitLens and Git Cola. Here's a commit graph example from GitLens.
Experimentation: Version control makes it easy to experiment with new features and changes. You can create a branch for your experiment, make changes, and easily switch back to your main branch if things don't work out.
Backups: You're about to turn in your project, but your computer crashes. Panic sets in as you realize you forgot to save the latest version. But don't worry! With version control, you always have a backup of your code, so you can retrieve it even if your computer decides to take a nap.

Types of Version Control

Before we dive into the types of version control, let's first take a moment to explain some important terms.

Repository: A repository, or "repo" for short, is a directory or folder where your project's files and code are stored. It's a centralized location where all changes and versions of your project can be tracked, managed, and stored. You can think of it as a digital filing cabinet that holds all of your project's documents, images, and code.
Remote repository: A remote repository is a repository that is hosted on a remote server or online platform, such as GitHub, Bitbucket, or GitLab. It's a place where you can store your code in the cloud, and collaborate with other developers on the same project. This allows multiple developers to work on the same codebase and share changes with each other in real time.
Local repository: A local repository is a repository that is stored on your own computer. It's a copy of the remote repository, which you can edit and make changes to without affecting the remote version. This allows you to work on your project even if you don't have an internet connection, and make changes to your code and files at your own pace. Once you're ready to share your changes with others, you can push your changes to the remote repository.
Codebase: The term "codebase" refers to the entire collection of source code files for a particular software project. It includes all the code that is written for the project, including any libraries or third-party dependencies that the project relies on.

There are three types of version control systems: local, centralized, and distributed.

Local version control is the simplest type, where changes to files are tracked on the developer's local machine.

Centralized version control systems are designed for teams to collaborate on a shared repository. Changes are tracked and stored on a central server, allowing team members to access the most up-to-date version of the code. Examples of centralized version control systems include Apache Subversion (SVN) and Azure DevOps Server.

Distributed version control is similar to centralized version control, but each developer has a complete copy of the repository on their local machine. Changes are tracked and can be shared among team members, allowing for more flexible collaboration. Git is an example of a distributed version control system that has become extremely popular in recent years due to its speed, flexibility, and powerful branching and merging capabilities.

Conclusion

In conclusion, version control is a powerful tool that software developers can use to track changes made to code over time, collaborate with others, and easily revert to previous versions if something goes wrong. There are three types of version control: local, centralized, and distributed, with Git being a popular choice for distributed version control. By using version control, developers can focus on delivering high-quality software on time, experimenting with new features and changes, tracking changes, and allows them to have backups of their code, easily accessible at any time.

In the next post of this series, we'll dive into the most popular version control system, Git, and how it can be used to improve collaboration and productivity. Stay tuned for more!