Most people wouldn’t call version control their hobby. But in the last few years, people have also become aware of how valuable it is. Nowadays, you won’t find a top programmer, web developer, or web designer who doesn’t use version control. In part because it helps you produce better results and makes collaboration easy. But also because it can save your life when things go wrong.
When we started out creating Tower in 2010, we had a goal clearly in mind: make Git, the best version control available, easier to use. Since then we’ve made this true for over 35,000 customers in companies like Apple, Google, Amazon, and Ebay.
When we started working on version 2 of Tower, we knew this was a chance to go one step further: to make Git not only easier, but indeed easy to use.
Merge conflicts have always scared me to death. Especially since I’m a “not so technical” person. I never really understood what had happened – and, more importantly, how I could fix it.
One of my main problems with conflicts is that the situation is so abstract and hard to grasp. That’s why we introduced a visual way to solve conflicts in Tower 2.
Thereby, I can now understand the situation more easily – by clearly seeing which files clashed, how exactly they looked, who worked on them, and which commit introduced the changes. And I can then decide how the solution should look – by simply clicking the files I want in the final resolution.
I don’t like to clone a repository. Because, although it’s actually a simple process, it’s also a tedious one: first, I have to log into my service account on GitHub, Bitbucket, or Beanstalk. Troubles start right there: as if fumbling with usernames and passwords wasn’t enough, new authentication procedures now require to create passcodes on your phone, generate personal access tokens, or jump through various other hoops. After that, I have to find my repository and copy the right URL – having to choose from various options like ssh, https, or git URLs.
A new service account manager in Tower 2 lets me configure my accounts on GitHub, Bitbucket, and Beanstalk once – and then never deal with authentication and repository URLs again.
I now get a neat listing of all my repositories in these accounts. I can clone a repository to my local machine with just a single click. Or, create a new one in the account right from within Tower.
Above all: I don’t need to wrestle with usernames, passwords, tokens, or URLs anymore.
Any project evolves in little steps. If I want to keep up with the project, it’s these little steps that I need to understand. Therefore, it’s vital for me that I get all the information I need in a digestible way. In the new version of Tower, we’ve put quite some effort into all things history:
You can see the commits that you would receive when pulling from a remote – so you can clearly understand what will happen when you finally do.
You can choose between multiple different view styles – so you have the visualization that’s best for you.
You can directly access a commit’s file tree – so you can inspect all of your project’s files at any point in time.
And, finally, the search functionality now supports file paths – so you can easily see only the commits that changed a certain file.
My attitude towards mistakes has changed – although I make just as many as I used to. What has changed is that I don’t fear them as much. In the past, I was hesitant about making larger changes on a project, or trying out something new. Because I knew it was hard to recover from a mistake if one should happen.
After using Git for a while, I began to understand that I could undo everything. Git’s undo features allow you to recover from anything – but the corresponding commands are spread all over the system.
In Tower, we’ve made these things available really easily: I can fix my last commit, restore any historic version, revert a certain commit’s effects, or discard local changes in my working copy. It’s great to know that I can’t mess up.
When I began using version control with Subversion, I essentially abused it as a backup system: I crammed all my changes into a commit just to make sure they were safely stored in the repository. Accordingly, my commit messages read like this:
Fixed bug #312, implemented login feature, restructured navigation. Oh, and by the way, changed everything else, too…
When a teammate (or even myself) looked at this bloated commit, none of us knew what had actually happened.
I hadn’t understood version control back then. And to be fair, I hadn’t had the right tools at hand. Using Git, I understood that going through a project’s commit history should allow you to see how the project evolved. But this will only work under one condition: only related changes should be committed together.
For example, fixing two different bugs should produce two separate commits. Small commits make it easier for other developers to understand the changes and roll them back if something went wrong.
Git helps create such granular commits with tools like the “Staging Area”: it forces me to really craft a commit and determine which changes exactly I want to include. I can even decide on the level of a single changed line if this modification should be part of the next commit or not.
However, especially things like the latter are rather clunky to use on the command line. That’s where Tower fits in nicely, making such powerful features easily accessible with a clean interface.
Using Git can be complex. But the increase in quality, confidence, and reliability that you gain by using it is definitely worth the effort. Reducing this effort is exactly what we wanted to do with Tower 2. We want to make using Git faster and easier. Let’s take some examples of where this shows in Tower:
- You don’t have to download new changes for a project manually. Instead, Tower now automatically and regularly performs a “Fetch” operation in the background. Thereby, you instantly know if something new is available on the remote server.
- The app automatically saves your current changes to the Stash (a kind of clipboard) when you’re switching branches, pulling, or rebasing. Actions like these are best performed with a clean working copy – and Tower saves you the hassle of remembering and doing it.
- A new “Open Quickly” dialog lets you find and open any project in seconds. After typing just a few characters from the project’s name, Tower will offer you any matching repositories.
- We’ve made committing much quicker. The UI for the commit message is now neatly integrated into the main interface; amending a commit can be done by simply holding the ALT key.
- On popular demand, we’ve integrated the “git-flow” workflow into Tower. git-flow fans can now use it directly from within Tower.
- You can use drag & drop to achieve rather complex Git tasks very simply in Tower: from creating and merging branches, to cherry-picking commits or applying even parts of a Stash.
We’ve implemented quite a list of new features in Tower 2. But above all, we focused on ease-of-use: a good tool, we believe, should help you become a better professional – easily.