Introduction
One of the most popular version control systems (VCS) among software developers, IT professionals, and even people with a non-technical background nowadays is Git, but it can also be intimidating/unfriendly, especially for those who want to start learning it for the first time.
In this article, I'll talk about the following points
First, I'd like to briefly explain how developers coded before version control existed.
What is the version control system (VCS)?
What are Distributed version control systems(DVCS), And how do they work?
What Git is, and how it's used.
What makes Git unique from other similar version control?
The purpose of this article is to give you a solid understanding of Git and version control systems in general, so that you can use it more easily, dive deeper into Git features, and learn more about its capabilities.
How did Software Developers code before version control existed?
Before version control systems, software developers used a variety of methods to manage their code. Some common methods are:
Using filenames to identify different versions.
Manually copying and saving files to create backups in their computer.
(When the number of project folders and files increases from a few to hundreds or even thousands, this method becomes a nightmare).
Print a hard copy of their code as a backup.
The code was written separately by developers and sent to a central server; other developers were unaware of changes made to the code by their colleagues.
(Whenever something goes wrong with the central server, for example, data is corrupted, developers will lose their code since they don't have it locally on their computer.)
Manually merging changes made by multiple developers.
These methods were often time-consuming and error-prone. It is very difficult to track down bugs that may appear in an older version of code to fix them, especially in real life since most projects involve tens or hundreds of lines of code. this is why version control systems were developed. These systems allow developers to easily track changes to their code, revert to previous versions if necessary, and collaborate more efficiently with other developers.
What is a version control system?
A version control system (VCS)is a software tool that helps manage changes to computer files over time. These systems are used in a wide range of industries, from software development to digital media and beyond.
The basic idea behind version control is simple: whenever a change/modification is made to a file, the version control system saves a new version of the file. This allows developers to keep track of the changes that have been made to a file over time, and to easily revert to earlier versions of the file if necessary.
There are many different version control systems available, but they all have the same basic features. These include the ability to:
Files can be saved in different versions over time.
Compare different versions of a file to see what has changed.
Revert to earlier versions of a file if necessary.
Collaborate with other users on a project by sharing files and changes.
There are two types of version control systems:
Centralized version control system or (CVCS).
Distributed version control systems or (DVCS).
As I mentioned earlier, Git is the most popular version control system used by software developers. Other popular systems include:
Subversion. (CVCS).
Mercurial. (DVC).
Perforce. (CVCS).
Overall, version control systems are a very important tool for anyone who works with digital files and is especially important for teams of people who need to collaborate on a project. These systems make it easy to track changes to files over time and roll back to earlier versions if necessary.
What are Distributed version control systems and how it works?
Distributed version control systems, or DVCS, are a type of version control system that allows developers to access the full repository, including its complete history, without the need for a central server. This means that each developer who works with the codebase has a full copy of the repository on their local machine, and they can work on it independently of other developers
When a developer makes changes to the code, they can commit those changes to their local repository first. They can then push those changes to a remote repository, where they can be shared with other developers. This allows for collaboration on the codebase without the need for a central server.
One of the key benefits of using a DVCS is that it allows developers to work on the codebase even when they are offline. They can make changes to the code and commit them to their local repository, and then push those changes to the remote repository when they are back online. This can be especially useful for developers who work in remote or disconnected environments.
In summary, distributed version control systems allow for collaboration on a codebase without the need for a central server, and they give developers the ability to work on the code even when they are offline.
What is Git and how is it used?
Git is a version control system that is widely used for software development and version control. It allows developers to track changes to source code and keep a history of different versions of their code project/application.
Git is designed to be a distributed version control system, meaning that developers can work on their own copies of the code and then push their changes to a central repository, where the changes can be merged with the rest of the codebase. This allows multiple developers to work on the same codebase simultaneously and collaborate on the development of a project.
How to use Git?
Git must be installed before you can use it. If it is not installed, follow these steps, and since I am using Ubuntu, these steps will be applied to it
Open a terminal window by pressing
Ctrl + Alt + T.Update your system's package list by running the following command:
sudo apt update
- Install Git by running the following command:
sudo apt install git
- To verify that Git has been installed, run the following command:
git --version
This should output the version of Git that is installed on your system.
- Configure Git with your name and email address, which will be used to identify your commits, run the following commands, replacing "
YOUR_NAME"and "YOUR_EMAIL"with your own name and email address.
git config --global user.name "YOUR_NAME"
git config --global user.email "YOUR_EMAIL"
Although this step is optional, it is a good practice, and I will explain why below:
You should configure Git with your name and email address on Ubuntu, or any other operating system since this information identifies you as the author of commits you make.
With every commit, Git records the author's name and email address along with the commit message. It allows other developers working in the same repository to see who made the commitment and contact the author if necessary.
By configuring Git with your name and email address, you also ensure that your commits are correctly attributed to you.
When you work on multiple projects or with multiple repositories, configuring Git with your name and email address can also be useful. You will be able to keep track of your contributions across different repositories and ensure that your work is properly credited.
To use Git, a developer must
- First, initialize a Git repository in the root directory of the project using this command:
git init
This will create a new subdirectory called ".git" in your project's root directory, which will contain all of the necessary files for tracking changes to your project with Git.
To ensure that your Git is initialized correctly you can type the "ls -a" command in your terminal to list the contents of your current directory
ls -a
This will list all of the files and directories in the current directory, including hidden files and directories that start with a .. If a .git the directory is present, it will be listed in the output
- Next, you need to add the files in your project to the staging area. To do this, run the following command (make sure you are in its root directory):
git add .
In the command above, the dot means all/everything.
Congrats you just creates a hidden .git directory that stores all of the version control information for the project.
Afterward, it's a good idea to check that all your contents have been tracked and added to the stage area, you can do that by using the following command.
git status
This command will show you the current status of your Git repository, including any changes that have been made but are not yet committed. so the output should be something like this
On branch main
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: .gitignore
new file: README.md
new file: src/main.c
new file: src/utils.c
new file: src/utils.h
Then, the developer can make changes to the code and use Git commands to stage and commit those changes. These changes are then stored in the local repository and can be shared with other developers by pushing the changes to a central repository. The following steps will help clarify this point.
- Once you have added the files you want to commit to the staging area, you can commit them to your local repository by running the following command:
git commit -m "Initial commit"
Replace "Initial commit" with a message that describes the changes you are committing. This message is important because it will help you and others understand the purpose of the commit.
At this point, you have initialized a Git repository for your project and made your first commit. Your repository is now stored locally on your machine.
- To push your repository to a remote repository, such as on GitHub, you will need to create a repository on the remote service and obtain the URL for the repository
Once you have the URL for the remote repository, you can add it as a remote for your local repository by running the following command:
git remote add origin <repository-url>
Replace <repository-url> with the actual URL of the remote repository.
To push your local repository to the remote repository, run the following command:
git push origin main
This will push all of your commits to the main branch of the remote repository.
The origin remote is a convention that refers to the main remote repository for your project.
That's it! You have now initialized a Git repository for your project, made your first commit, and pushed the repository to a remote repository.
Git also includes a number of features that make it easier to collaborate with other developers, such as the ability to create branches, merge changes, and resolve conflicts. It is a powerful tool that is widely used in the software development industry and is an essential tool for any developer working individually or on a team project.
What makes Git unique from other similar version control?
There are a few key features that make Git unique from other version control systems:
Decentralization: Git is a decentralized version control system, meaning that each developer has a complete copy of the repository on their local machine. This allows for more flexibility and makes it easier for developers to work independently.
Branching and merging: Git's branching and merging capabilities are robust and efficient, making it easy for developers to work on different features or bug fixes without affecting the main codebase.
Distributed workflow: Git allows developers to collaborate on code without necessarily having to push their changes to a central repository. This allows for more flexibility in the development process.
Large community: Git has a large and active community of developers, which means there is a wealth of resources and support available for users.
Overall, Git's decentralized structure, powerful branching and merging capabilities, and large community make it a popular choice for version control in software development.