6 Myths Preventing Developers from Using Git

Posted: 23 Jul 2014 03:00 AM PDT

Nowadays, you’ll have a hard time finding a professional developer who doesn’t use a version control system (VCS) such as Git.

But, there are still a few among us who choose not to use a VCS due to preconceived notions they might have about version control.

Here are some myths and excuses that dissuade developers from integrating Git — and any version control system in general — into their workflow.

Myth 1: I don’t need Git because I back up my files

Creating regular backups of your work is definitely a good habit. Consider keeping this habit even when using Git.

But Git provides you a lot more benefits compared to just a system of backing up your files.

Without a VCS, you’ll run into a several of issues.

How do you name your backups? If you’re a very organized person, you might be able to stick to an actually comprehendible naming scheme like acme-inc-redesign_2013-11-12_v23.html. However, any deviance from the file-naming convention quickly leads to confusion and, quite possibly, issues with your code.

Let a system like Git worry about the minutia so that you can focus on what you do best: Writing code.

How much of your work are you saving? Only the changed files or the complete project? In the case of the former, it will be tough to see a full picture of a version/variant of your project at any given time. In the case of the latter, where you are backing up the entire codebase at regular intervals, you’ll have huge amounts of redundant files lying around on your hard drive, and more files mean more complications.

The most important issue that can be solved with Git is probably this one:

How do you know what’s different in these backups? Very few people actually take the time to carefully document each and every change they make. On the other hand, Git acknowledges that there is only one project. Everything else — all the past versions and variants — are neatly tucked away in the back-end of the version control system, ready for you whenever you need it. And when you do need it, you can request any version at any time and you’ll have a snapshot of the complete project right at hand.

In addition, you can determine with great precision what has changed in each file. You can tell which lines have been added, which lines have been removed, and which ones have been modified — which means that bug-tracing, emergency rollbacks to stable versions of the project and partial-version rollbacks are much easier processes.

Myth 2: Git is too complicated. It’s not worth the hassle.

People often overestimate how deeply they need to dive into Git to get its main benefits.

It’s true that you can spend a whole lot of time trying to wrap your head around all the fanciest, edge-case Git commands — Git is indeed an extremely powerful and flexible system.

But, it’s also true that you can work productively and reap Git’s major perks with just a handful of commands.

Yes, learning a new skill means more additional work — no one can spare you from that — but the benefits you’ll gain when you start using Git vastly outweighs the time and effort required to learn it.

Learning Git will improve your projects’ quality, as well as your efficiency and productivity as a developer. Also, you will be able to collaborate with other developers in a more systematic and reliable way, delivering even more development-productivity improvements to you and your team.

Myth 3: Git is only for development teams

Distributed version control systems like Git or Mercurial allow you to work completely on your local computer. Should you have projects where you don’t collaborate with anyone else, it’s perfectly valid to perform all tasks on your machine. Git provides as much benefit to the solo developer as it does to dev teams.

You don’t need a remote server or code-hosting service to use Git and to reap its usefulness.

But, it’s worth pointing out that using a remote code-hosting service like GitHub makes sense even as a solo developer, so that you can have external backups of your code in case your computer breaks down or gets lost, or to sync your projects safely across multiple computers (perhaps you have a work laptop and a personal computer at home that you use to develop code with). However, this isn’t necessarily something you need to do; it’s only an optional advantage.

The benefits that Git brings you remain the same, no matter if you’re working in a team or on your own.

Myth 4: The command-line interface is too complicated

You don’t need to be a command-line interface (CLI) expert to use Git. In fact, a handful of commands is all most developers will ever need.

You can learn Git’s important commands in less than an afternoon: We created a guide called Command Line 101 that you can read to learn about the CLI as it pertains to Git — it’s part of our free online book called Learn Version Control with Git: A step-by-step course for the complete beginner.

But let’s just say a handful of basic commands is still too much contact with the CLI for you. Or maybe you made a strange, unbreakable blood pact with a friend never to use the command-line interface ever again, or, for some reason, you simply cannot use a CLI. You can still use Git through an application that has a graphical user interface (GUI). If you’re on Windows, I recommend you take a look at Tortoise Git. On Mac OS, you should give Tower — an app that my company, fournova, has developed — a look-see.

Even for users that are comfortable with the command line, a GUI could still improve productivity by making complex Git tasks easier.

Myth 5: I’m afraid I’ll break something

It should be the other way around: You should be afraid to break things if you don’t use a version control system because it’s hard to retrace your steps and your code-base changes without one.

Version control is our safety net. When things catastrophically break down, we can easily roll back to a previous version that’s stable.

Using Git, you will be able to:

undo your local changes (partially or completely)
restore any historic version in case something goes wrong
revert the effect of any change you made in the past

And I would also like to point out what is in my opinion Git’s most important feature: branches.

Branches provide us with a secure ecosystem for trying out new features, completely separated from other parts of our development project. This encourages us to experiment with new code and to see and test the effects of any code changes while giving us the confidence that we won’t be affecting anything outside of the current branch.

Myth 6: Git is all hype. It’s just a popular trend that will later fade away.

First, Git is definitely not the one and only version control system out there. There are many other great VCS options to consider, each one with its own unique merits.

But it’s not simply by chance that major projects such as jQuery, Rails and the Linux Kernel, just to name a few, rely on Git for version control and code-collaboration.

For coding projects, Git is currently one of the best systems out there. Here are several reasons why Git is a great choice.

Feature Set

Of course, Git’s feature set and philosophy are its biggest value propositions to its users: A great branching model, offline capability, and its "staging area" concept are just some of the prime features that help with the productivity, creativity and efficiency of developers.

Popularity and Staying Power

Being popular and widely available is important for any system. Popularity means there’s a community out there ready to help you get started with the system.

And when you find yourself coding collaboratively, there’s a greater chance your teammates will already know how to use Git.

In addition, being a popular VCS also makes Git attractive for third parties to develop and provide supporting tools and services (e.g. GitHub) that could further enhance your experience with Git.

Popularity also ensures that the Git open source project won’t disappear any time soon — which is an important factor for developers thinking about committing to an open source project for the long-haul.

Official Git website home page (2014)

Availability of Quality Educational Materials

It has never been easier to start learning Git. Today, there are tons of documentation, tutorials, videos and how-tos available about the VCS.

Here are a few resources to help you get started with Git.

Try Git (github.io)
Git – The Simple Guide (rogerdudler.github.io)
Git Ready (gitready.com)
Git Cheatsheet (ndpsoftware.com)
Learn Git (git-tower.com) – a free online book my company produced
Git Magic (cs-students.stanford.edu)
Git – Getting Started (git-scm.com)

Why Aren’t You Using Git Yet?

Now over to you: What’s holding you back from using version control with Git? Let us know in the comments!

About the Author

Tobias Günther is CEO and founder of fournova. In 2010, he set out to make Git easier to use: Together with his team, he develops the Git desktop client, Tower for Mac.