You might be wondering what Git is, and what it’s all about?
Now I’m not going to go into detail about installing, setting up, and using git since it’s been covered quite a few times here, here, and here. Using Git and related software and tools has become a crucial tool for collaborators to work together on a project and having version control to “undo” broken or bad commits to your repo.
But that still doesn’t answer the question of “what is Git”? Well, buckle up for an adventure of how Git was started and what it has grown into today.
Git was created by Linus Torvalds in 2005 for the development of the Linux kernel, with other kernel developers contributing to its initial development. If you’re not sure what a kernel is, simply put it is the core of an operating system that’s always resident in memory and facilitates interactions between hardware and software components.
So basically what Torvald wanted to do is have some system where developers could collaborate and work together creating kernels for the Linux operating system. Back then they didn’t have free access to all the git-related tools like GitHub, GitLab, or even BitBucket as we do today.
Before Git, developers used something called BitKeeper to use as source control, but Linus wanted a distributed system that he could use like BitKeeper, but none of the available systems of the time really met his needs. Linus cited an example of a source-control management system needing 30 seconds to apply a patch and update all associated metadata, and noted that this would not scale to the needs of Linux kernel development, where synchronizing with fellow maintainers could require 250 such actions at once.
For his design criteria, he specified that patching should take no more than 3 seconds and added 3 more points:
- Take Concurrent Versions System as an example of what not to do.
- Support a distributed, BitKeeper-like workflow.
- Include very strong safeguards against corruption, either accidental or malicious.
These criteria eliminated every version-control system at the time in use, and Linus set out to write his own software.
As a Unity developer, it’s paramount that I have my projects backed up and having a version control system in place. Even the most seasoned developer might make mistakes they miss and release that without their knowledge. And having version control it’s just a few lines in Git Bash to revert a built to a previous state or a few click depending on what software you use.
Apart from version control, having those backups allow me to have a good night’s rest without having to worry about backups and hardware failure.
Before I wrap up this article I want to quickly talk about something I’ve been using for a while now and before I even learned to use command-line Git.
GitHub for Unity is a package you can install in Unity and it gives you all of the command-line features of Git and GitHub right in Unity. You can easily create, push, pull and merge branches as you would using command-line, but with a few clicks of a mouse and without leaving the editor at all.
The reason I’m sharing my experience with GitHub for Unity is that using command-line might be overwhelming or confusing with all of the commands and maybe you don’t have multiple screens and don’t want to change between windows all of the time.
I really hope you enjoyed this article on the history of Git and how it got to be. I like to share my experiences with others and I might often share tools or apps that I personally use that you might benefit from. Please note that I share these apps or tools purely out of free will and not because I’m affiliated with these products.