Git: The tree of possibilities for the curious designer

How using a Git repo is not just about code versioning but gives modern day designers the freedom to explore the new.

I’m not especially organised. I’m not into the whole “getting things done” ethos; my brain just doesn’t work that way and even when I’ve tried to enforce some kind of rules to the way I work — be that a series of lists or a file naming convention — I usually end up back in my old ways, whatever they are.

One thing that is consistent when I make things, like so many others, is the process of iteration. Along the way to getting to a finished thing I make a lot of crap — failed experiments, tangents into the stupid and non-sensical, detours into the rediculous and chaotic. It’s an important part of making things because occasionally (and thankfully) wonderful surprises jump out at you from unexpected places.

As someone who uses code as part of their design process I would end up with a myriad of files exploring different versions of the same idea. You know the kind of thing — sphere_mesh_001, sphere_mesh_010_final, sphere_mesh_135_final_re-edit_output_not_joking. This quickly got messy and worse still was a pain, duplicating files, or whole folders, losing track of which version is which and even worse, actually screwing up the one that was half-way good, with no way to go back.

Duplicate folders for new iterations with stupidity matching filename length.

It was time for a change. I didn’t want to lose the organic (read chaotic) way I work but I did need a system that would not only help me organise things a little better but maybe a system that might actually increase my forays into the unexpected — after all, that’s where the good stuff happens.

I’d always known about versioning systems, in fact I’d used one when I wrote my book Analog In, Digital Out back in 2006. There was a thing called CVS which was quite complicated to set-up and I always felt like I had no idea what was really happening when I interacted with it. Then there was SVN and now there is Git. According to Wikipedia “Git is a distributed version control and source code management (SCM) system with an emphasis on speed.” Whatever. Actually to me it’s a system made for design exploration, for the curious and adventurous.

Branches of possibilities

At first I was using Git with all my projects for versioning files; making updates to code, committing those updates which gave me the luxury to rewind a file if anything went wrong.

This wasn’t however solving my crazy file naming system for new iterations. Then I saw this button on the Git interface I was using called Branch. Without worrying what might happen I pushed it, like pushing open a slightly ajar door to some other place. It asked me to name this new branch afterwhich I then had another version of my project to play with. I didn’t have duplicate files — the files were the same ones I had been playing with, but these were effectively on a different branch — a new path to travel down, a new place to play around in.

Lots of branches, same files.

Here lies the beauty and power of branches in Git when designing. I can explore something new, mess around, push things about and if anytime I decide things aren’t working or I want to go back to the original version I can just switch back to the original branch and my code magically changes back. No duplicate files, no duplicate folders, no having to remember which version was which. Or I can make another branch from an existing branch. Repeat, wash, spin, soak. Now I never have a fear of trying something new, or exploring what might happen if I just change one thing. I make a branch, mess about and see if it’s anything worthwhile. Sometimes it is and sometimes it isn’t. And that’s OK. What mattered was the freedom I now have to explore these new possibilities.

I think many people look at Git and think it’s just for hardcore coders or huge open source type projects working with big teams. That can be true but it’s also for the individual, for the person who wants to explore new things within their work, without all the hassle of crazy file naming conventions with all the benefits that version control brings.

Most of all for me, as someone who uses code as part of their design process, it’s a system of possibilties, of twisting paths leading to the unexpected, the new and exciting.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.