Here at Oktana, we focus on quality to ensure the applications we develop are secure, functional and scalable. However, we know that practice makes perfect and that’s why we consistently host workshops to improve our craft. Our next workshop will feature Git and best practices for navigating around it.
What is Git, you may ask? Git is an open source version control system used to manage pertinent files and company tracking history, all while coding in a secure environment.
Need further clarity? Let’s provide a little more context. In the early years of software development, engineers feared the possibility of losing their data and progress so they would record paper copies of source code throughout stages of development. Yep, that happened.
Over time, programs were eventually stored in computer hard drives, however, engineers were still cautious and thought further security measures needed to be instated. To address this issue, a lock system was created to protect data which came to be called Source Code Control System (SCCS). To put it simply, if one developer is editing a file, no other personnel can access the file.
As with anything involved with computer software, the next evolution of version control systems elevated to the cloud. There were many contenders but the most widely known was Subversion (SVN). SVN was centralized in one place and was the only source of all truth. The idea here was that if engineers still had to manage a locking file system, at least they could develop multiple versions of those files and create branches to track new versions of files without changing or rewriting the previous versions.
Everyone that had worked with SVN loves Git. It was the evolution of version control giving us the same power of the first paper copies, where you can add side notes in a file, have totally different stories, and backups but now we’re saving trees! Also, it’s in the cloud so it can be accessed from everywhere.
And thus, history was changed, or at least, a version of it.
Now that we have more of a background on Git, let’s explore the features a bit more:
1. Spread and conquer
Remember those single source of truth days? Well those are over now! Anyone who has a copy of the Git repository has access to the history log with all file versions and updates. So, if a meteorite were to crash the server, nothing would be lost because several engineers still have repositories that reflect the same information.
2. Web dependency isn’t independence
In the past, all the tracking was done in the remote repository, you needed to have an internet connection and, of course, to the repository itself. Now you can track everything locally where changes and commits are securely saved on your computer while you enjoy the hills until you return to civilization to deploy
3. Undo mistakes, look like a pro
Let’s face it, we all make mistakes. But don’t worry, in any situation, Git counts with an appropriate command. It doesn’t matter if you need to revert a commit or fix it because you forgot to add a file, you won’t need a new change in your application history.
4. Work in your own style
Git counts with a flexibility other version control systems do not possess, so, obviously, there are plenty of books that provide us with information on the right way to work with Git. However, there are as many books as teams. Every project and every developer have their own developing needs, and this is why Git is popular; it’s very flexible, adaptable, and really fosters team collaboration.