Beyond Code Control: Git for Everything!

If you’re a software developer or involved in programming in any way, you’ll be intimately familiar with git. If you’re a “normal person,” though, there’s a good chance you’ve never heard of it.

Simply, git is a version control tool. It was originally invented by Linux founder Linus Torvalds in 2005 to help manage the development of the Linux kernel.

Git solved a problem for open-source software: individuals anywhere in the world are looking at the code of a project and making changes like fixing bugs or adding features. How can anyone keep control without having changes that cancel each other out or lead to chaos?

To edit a project in git, you make your own copy of it first (a “fork”) and change it. Then you make a “pull request” where you ask to add your changes to the original project repository. Someone else then accepts the request (or rejects it). To help manage git, there are also services like GitHub.

Developers live in git because it lets them keep control of their code. Changes are tracked and linked to who made them, traceable and reversible, and there’s only one true final version of the project.

But what if git could be used for more than just software? What if there were ways of using it to do… everything?

Here are a few uses of git that take it beyond code and show how it everything can benefit from version control.

1. Manage Your Progress Lists and Work-Plans

Developers live in git. In most companies, the rest of the company lives somewhere else, like a project management tool such as Trello, Jira, Asana or Monday. Developers have to keep track of both their pull requests and their Trello or Jira tickets, making things unnecessarily confusing.

New tools, though, are removing this friction. Waffle.io looks at GitHub issues and pull requests and uses them to create project management charts. ZenHub goes a step further, building a project management tool inside Github itself that is operated by pull request, making things more consistent for developers but still accessible for everyone else.

2. Updating Your Website

Uploading websites can be annoying. You need to connect to a web-server and send the files, set up any services, and mess around with passwords and configuration options. Once it’s up, modern websites usually have a content management system (CMS) that connects to a database, instead. It’s inelegant and a slow process that often creates inefficient sites too, and if something goes wrong then the site can be ruined unless you take regular backups

That’s where git can come in. A website is a great example of something that can live in git and be auto-deployed when it changes. Once that’s true, the CMS doesn’t need to be on the live site at all; it can be just a way of changing files in a git repository that are then pushed live. Netlify offers these features for deploying and updating websites via git, and other similar services are coming too.

3. Giving Presentations

Presentations are one of those annoying facts of modern life. If you work in an office, at some point you’re going to be asked to make a slideshow.

Of course, the most well-known presentation program is so dominant that people use its name to mean any presentation: Powerpoint. But there are drawbacks: Powerpoint isn’t very portable. Often, a team has to collaborate on a presentation and Powerpoint has no good collaboration tools.

Obviously, the solution is… yup, Github-based presentations that you can write and edit via pull request. These presentations are browser-native and work almost anywhere. Team members can submit changes via pull request and it creates an audit trail. There are a few implementations of this idea available online: Reveal.js and GitPitch are two good examples.

4. Controlling your Word and Excel documents.

Now we’re getting to an area which is desperate for a good version control solution. How many times have you ended up with a filename like this?

Businessplan-v3_FINAL_withcomments_REVISED_final_USE-THIS-ONE.docx

Yes, there’s SharePoint with its check-in/check-out capability. Yes, there’s Google Docs or other collaborative solutions. But in most companies and organizations are using bare Microsoft Word or Excel to edit files, and people are emailing different copies to each other and editing them locally. It’s a mess and a very familiar mess to anyone who’s worked in almost any organization.

In many ways, document management is an ideal use-case for git-based tools and it’s surprising that more large organizations haven’t taken this route that would preserve a single source of truth for documents, cut down on accidental forking and keep a reversible audit trail.

Most of the solutions currently available are partial, at the moment, because git can’t understand Excel or word files and just treats them as black-box “binary” files. Xltrail will keep track of the cell-by-cell commit history of an Excel spreadsheet that’s stored in git, but it can’t handle merges and pull requests itself.  There are clever but hacky solutions for Word documents, which involve converting them into a text-based format that git can understand like Markdown. But it’s all a bit inelegant.

One company, Simul, has created a git-like experience via a plugin for Word docs. And using other Office suites like OpenOffice/LibreOffice, you can just save files natively as XML which lets git work its magic. But this is such a great use-case for git that it deserves more attention.

5. Ordering a Pizza

OK, at the moment I don’t think there’s a standard implementation for ordering a pizza via pull request (though you can do it from the command line). But perhaps it’s just a matter of time.

Some companies already use git to put together complicated shared food orders, even if they do print out the final product rather than having lunch auto-delivered. How difficult would it be to send the finalized order automatically to a restaurant, or have it integrate with an online ordering API?

Sometimes it can take a while before we figure out all the powerful uses of a new technology. As Clay Shirky noted, it took almost a decade of the World Wide Web before people realized that blogs were a good idea. That wasn’t a technology change; it was a paradigm shift that we could use the web for more than crappy homepages on Geocities.

A similar shift is happening now with source control like git. We can use it for code — we pretty much have to use it for code — but it can be so much more.