GitHub, Glitch and the Future of Social Coding

Here’s the short version: We’re excited about GitHub becoming part of Microsoft, and think it’ll be good news for developers. But based on the huge adoption we’re seeing for Glitch and our own decade of experience in building version control tools, it’s clear many developers also think it’s time to explore new approaches, so we want to build on this milestone for the coding community by articulating a new vision for social coding.

GitHub + Microsoft = Good 👍

Let’s put it short and sweet: Microsoft buying GitHub is likely to be good news for developers. There’s no better evidence of how Microsoft has been revitalized under the leadership of Satya Nadella than to point to bold moves like this, which would have seemed incredible (and also not seemed credible!) in the past. Old-timers can remember when Microsoft was often described as the Evil Empire, but their moves to embrace open source and non-Windows platforms have seemed sincere and sustained, and we’re happy to see that flourish.

Similarly, GitHub has earned its place as an indispensable developer platform through breaking ground as the first large-scale social coding experience over 10 years ago. Having strong leadership from Microsoft can only be good news, especially for developers using Microsoft platforms.

But if we have a concern, it’s that there hasn’t been a huge leap forward in social coding in the last decade. We simply haven’t seen enough innovation in recent years in the way that coders collaborate, and since every developer will be thinking about these big ideas right now, we wanted to paint a picture of what social coding could look like over the next decade. A lot of people will (understandably) be thinking about backing up their GitHub projects just in case, and we think you should use that opportunity to look at Glitch and consider if it’s time to rethink traditional views on version control entirely.

(Spoilers: If you’re using Glitch, you’ve already got a preview of where we’re headed. If you’re not, here’s how to import a GitHub repo to Glitch. If you have a Node app that you’ve built or like to use, start with that!)

A Decade of Building Better Version Control ⏪

First, some background. Many developers may not know this, but at Fog Creek, we have a deep background in distributed version control systems. We launched Kiln (now available as an integrated version control system in Manuscript) almost a decade ago with a number of groundbreaking features for teams to collaborate on coding. Our path was to take great project management and add version control to it, and this approach taught us a lot about how people can do their best coding together.

We learned exactly what parts of the typical commit-pull request-merge workflow were still far too difficult and complex to understand.

Based on what we had learned, and what we heard from the developer community, we started rethinking some of the assumptions about workflow and collaboration that everyone was taking for granted in version control. Then, earlier this year, we brought Glitch out of beta with a complete re-imagining of version control, and we called it Glitch Rewind. It uses regular git under the hood, but the user experience is a huge leap forward.

Rewinding code commits in Glitch

Glitch Rewind & Reinventing Social Coding 💡

Glitch does a few things nobody’s pulled off before:

• Glitch automatically commits your changes while you work to a git repo in the background — even with multiple simultaneous people editing the same file at the same time. Imagine if the basic commit process was as easy, and as multi-player, as editing in Google Docs. Even non-devs can do it instantly.
• Glitch Rewind lets you roll back commits on a project just by moving back a slider like you’re rewinding a video. If you want to work from that older version, just hit play and keep working. You’ll get a live preview of your changes as you slide around the timeline. Anybody who can play a YouTube video can revert git commits now. Even if you do know the arcane git command line options, you’ll prefer working this way most of the time.
• Under the hood, it’s all just git. This means your tools, processes, workflows, integrations and automations can move seamlessly over to projects on Glitch.
• We’re building on Glitch’s “remix” feature that lets you clone live, running, code and will make merging changes from remixes as easy as rewinding commits is today.
• Glitch’s project pages and user profiles are an open source project maintained on Glitch itself. That means if you want the community features and social networking features on Glitch to evolve, you can make it happen yourself, and become part of a vibrant new community when you do so.
• The business tools you use to collaborate on code should be a seamlessly connected part of the larger network where everyone codes together. Glitch for Teams is bringing all the power of Glitch’s collaboration to your work, but without the complexity of having to go through an enterprise procurement process.
• Glitch is also trying to be a better, more inclusive community with everything from a friendly and approachable design, to built-in tools for managing codes of conduct and licensing, to our unique Glitch Help feature — if you get stuck coding on Glitch, you can just raise your hand to ask for help!

We’ve got more coming, but you have to see it in action to really understand the magic.

What about other tools? 🤔

The skeptics among you must be thinking, “Well, that’s all fine, but we’ve got GitLab or BitBucket as alternatives now, why not just use those?” And those are great tools! But they make the same fundamental assumptions about workflow that all the older generation of tools — including our own — had settled upon.

We now think those assumptions didn’t try hard enough. This is where we want to raise the bar:

• The basic building block of social coding should be an app, not a commit. The default state of a project should be a functional, running app or site or bot, not a pile of code that you then have to figure out how to get running. (“Start from something that works.”)
• Creativity is enabled when everyone can make changes to code and try new things out without fear, thanks to automatically being able to undo any change.
• Every member of your team should be able to commit to a project, even if they’ve never coded before, don’t know what git is, or haven’t even heard of git.
• Even experienced developers shouldn’t have to memorize obscure command line tools for common tasks like reverting a commit. Very, very few developers feel confident about their expertise in git, yet nearly all have to make use of it. This mismatch helps make coding more stressful, less inclusive, and less fun.
• The social network where we show off our code should be as delightful and creative as networks where we find great photos or videos or music.
• The community platform that coders use to share their work should be open source, so that we can all improve it together. The business model behind a coding community should be transparent and sustainable, so we can trust it. And the company behind a coding community should be credible, with a track record of being accountable.

There’s a lot more — in fact, we wrote a whole list of the principles behind Glitch if you want to check it out. But the bottom line is simple: GitHub has radically changed coding in the last 10 years, and we should all celebrate this milestone for Microsoft and for the community. It’s a validation of an important idea: We don’t code alone.

This is also the perfect time to ask ourselves as coders and as creators, how we can set our sights far higher than merely being social while we code, and truly bring community and culture into the heart of how we create together.

That’s what Glitch is all about. We can’t wait to see what you create!