Git is really useful.
Today a lot of development departments use it, and it’s an extremely effective way of handling any programming code. Compared to years before (SVN, CVS or even enterprise tools such as Team Foundation Server), it’s a huge upgrade in performance.
Git has a lot of features built in, and is extremely powerful and worth pursuing. As this article is made for non-techies, I also want to focus a bit on the amazing features of Git.
Let us start out with the content in this post:
- Git vs. Github/Bitbucket – what is the difference?
- Features of Git
- How to use Git for people without deep technical skills
- Other applications of Git
Git vs. Github/Bitbucket – what is the difference?
Let’s get this out of the way first: Git is not the same as Github, despite the names sometimes confusing people.
Git is an underlying system. It’s a protocol. Git is simply a system of how to handle files and commits. Git has a lot of features built in, and is the underlying system.
Github.com, Bitbucket.com and many similar websites, are websites that provide a user-friendly interface to Git. A rough explanation could be to compare Google and the Internet. Google is a user-friendly website on the Internet, which is based upon protocols such as HTTP and SMTP.
Github is a wonderful website, where code can be hosted. Here you can search solutions, see pending code, see different versions, see read mes and release notes. It’s a great system, and this is why Github is a premium product for many corporates are willing to pay.
Git, on the other hand, is an open-source protocol websites such as Github and Bitbucket use.
Features of Git
Git is very advanced and has a lot of features. Being a “startup-guy” myself (with experiences from the corporate world), I don’t even know all the features (and nor do I care).
If you’re looking for an in-depth overview of features in Git, I strongly suggest you find an additional article to become better-informed.
However, to keep it simple, I want to sum up some of the most important features of Git and why they’re great. After, I want to discuss the important features of Github. I have to split them up into two features, simply because some of them are built into Git, while other neat features come from the usability and logic of Github.
Features of Git:
- Branches, including advanced flows such as Git Flow. Developer can work on unique branches, where their code doesn’t touch other people’s code. Now, the importance here is the concept of different types of branches: develop, master, feature branches, release branches and hotfix branches.
- Develop is often used for unstable versions, where developers are merging in code from features, and making it stable.
- Master is often used for representing production. Whatever code is on master, should be able to be released to production. In some companies a continuous integration software is used, for automatically deploying code to production on commit.
- Feature branches is used for unique features, which is an isolated environment where developers can work without interrupting other people’s work.
- Release branches is often used for making a release ready. When code on development is close to being ready, a release branch can be made. Then this branch can be tested on a test environment, and the final changes can be made. When it is ready, the branch can be merged into master and be released to production.
- Hotfix branches is often used to make a quick fix to both master and develop at the same time. The idea is that something urgent can happen in production, and it’s important to be able to move small fixes into production without interrupting the workflow of development.
- Visual example of branches:
- History. Every single change that was ever made to the code, is stored in Git. That means you can go back to any point in time, at any place in the code (any feature or area), and see what happened. You can do this down to even the exact line that is relevant, leaving an extremely powerful history of what happened.
- History and dates. While the history is extremely powerful, the history combined with dates is even more powerful. You can see exactly what dates a file was changed. That means if a feature has been down for 14 days, and you can see a file was changed 14 days ago – you can better understand what happened
- Blame. Who did something that broke the system? Now, of course the most important thing is always that the system just works, but it’s nice to know if the same person keeps breaking the system. In Github, you can point at a given line in the source code, and then see who made that line of code.
- Version numbers. When a release has been made, it’s often tagged with a release number. By doing that, it is possible to always go back into a specific release. In addition you can do two very interesting things:
- If your ticket system (ie. Jira) supports versions, you can move tickets into a given release, so you always know what tickets were included in which release.
- If you are not lazy like me ( 😉 ), you can write release notes for each release:
How to use Git for people without deep technical skills
XKCD had this drawing in a recent update:
It’s pretty much true.
Most developers operate and use Git using their terminal consoles. Not only is this horrible for user-friendliness, it’s also difficult to learn.
As we want to use Git as non-programmers and non-techies, the usual way is not very good.
The big problem is we cannot either use the normal Git program. There are plenty Github programs, including the official one from Github. The only challenge is they are very simple, and don’t support most features. In many organizations these simple programs are simply not allowed and blocked from usage. Ouch.
That leaves us with a few choices. Myself, I am a huge fan of Sourcetree. Sourcetree is a client for using Git. It has most of the features and functionalities, but is still also quite user friendly.
Now, be aware: Git is not a system that is going to be very friendly towards you. Even when you use a program such as Sourcetree, you will meet a lot of very annoying errors. Luckily you are not the only one, and if you keep these two things in mind, you will be able to solve most problems:
- Read the error message. There will always be an error message, and if you relax and actually read it (in detail), you can, most of the time, solve the problem.
- Search Google for the error. Try to put ” Sourcetree” in your query, and you will be able to find a good solution.
There are many videos and helpful tutorials. I made some videos myself, and you can consider the following (there are better videos now; when I made them two years ago there weren’t a lot):
Other applications of Git
Git is mostly used for programming. It’s created to solve that need, and works really well for it.
However, the concept of Git can be used for many things – which is really interesting.
Lets say you are working with documents. Here you could easily use the same functionality as with code:
- Version control, so you can see exactly what changes has been made when and where in the document
- Features, where you work on a new version of the document
- Hotfixes – quick fixes to the document
If you think about the Git system, it can actually be used for quite a lot of things if you are a bit creative.