Hi there! If I can take 5 minutes of your time I’ve got a short story for you on how software is made.

As you might already know, software is not built from scratch to finish in one go. All software evolves organically, one chunk of code at a time; fixing a bug here, adding a feature there, refactoring some existing code. This work goes on even long after the first release has been shipped to production.

To see how this looks like, here’s the spiky chart of all commits to the master branch of Facebook’s React repository (a very popular JavaScript library) from 2013 to the present day:

Number of commits to the master branch of Facebook React, May 26, 2013 — Feb 19, 2019

The current version of React is 16 and as you see there’s still a lot of development activity after 6 years.

Just as software, developers also don’t evolve from zero to hero overnight. Developers get their experience by making small code contributions (fixes, improvements, refactorings) to a lot of different codebases in their programming career.

Software grows patch by patch

In the early era of digital computers, programs were written on punch cards and a patch was a physical piece of tape used to fix bugs in those programs. Like the black patch in the picture below.

A computer program on a punch card that was “patched”

But as storage devices became digital (tape, disk, somewhere in the cloud) patches also became digital.

If you’re working with a modern version control system such as Git and you’re pushing code to a repository, you’re actually offering a patch to be included in the codebase. Such a way of patching is not only done to fix small bugs but also to change code to make it do something else, or something better.

A modern day patch

Take for example the patch that fixed the interoperability between two of my most favourite shell tools: sl and lolcat. In case you don’t know those programs, let me give you a short introduction.

The sl program shows a running steam locomotive on your terminal every time you mistype the ls command:

The sl(1) program

My other favourite tool, lolcat, colourizes text output in the shell (in case your code is a bit boring, like this piece of Java):

The lolcat program

But what happens when those programs are combined?

sl and lolcat working together, not exactly unicorns and rainbows

What a mess!

This is what the combination of sl and lolcat looked like for quite some time…

Until the developer Grimy on GitHub in April 2018 decided enough was enough and opened a pull request to fix the issue (and not only fix it for lolcat but also for a lot of other programs such as nethack):

After the Pull Request was merged (on April 8, 2018), both programs worked together like a charm again:

sl and lolcat == unicorns and rainbows!

And that’s an example of modern day patching!

Developers are patchers

At its core a pull request on GitHub is just a patch for an existing piece of software in order to change that piece of software. If you put .patch at the end of any pull request URL the raw patch reveals itself, showing which lines of code were added, modified and removed by the developer. See for yourself how the lolcat patch discussed above looks:

As a software developer you need to think about requirements, technologies, architecture, algorithms, and many many more things. But at some point, you open your development environment, checkout the latest version of the codebase from version control and make sure an open issue gets done. It may take you a couple of hours or a couple of days but at the end of your work the result is a single patch with added, deleted and modified code. And when that patch passes all the checks of the review process your code can be shipped 🚀 to production.

And that is how software is made.

Say hello to is a place where patches are shared. Developers keep track of the work done by other developers as they see patches coming by on their timeline. At you can follow both individual developers and repositories. showing the latest patches of the Tensorflow repository

Ever wondered what Guido van Rossum, creator of Python, is up to these days? Find out on Patching. Or when you’re curious about the latest developments in Yarn, a JavaScript dependency management tool, find out on Patching.

But Patching is not only for the highest ranked developers or most starred projects. You can also use it to keep updated on the work of your friends or colleagues. What technologies are they into these days? What projects are they contributing to?

Currently, every merged pull request on GitHub is automatically placed on the timeline of a developer or repository on Patching. See for example the lolcat patch that you can find under the Patching account of Grimy:

Every patch has a ❤️ button that lets you show your love for the work done by the developer. There’s also a 💬 button to leave your comments in the discussion section.

✨ See for yourself ✨

Go to and look around. You can search for users and repositories using the search box or select one of the trending GitHub developers/repositories (updated daily).

You can see and share your own track record of patches by surfing to<YOUR-GITHUB-USERNAME>

To start following developers and repositories you need to sign in with your GitHub account, click the login button in the menu bar.

Happy patching! has just been launched. There are many items on the roadmap (for example: search patches on technologies and topics, see what development tools have been used and a̶n̶ ̶i̶O̶S̶/̶A̶n̶d̶r̶o̶i̶d̶ ̶m̶o̶b̶i̶l̶e̶ ̶a̶p̶p̶ ( is a PWA website now, save the app on your homescreen). If there is anything you would like to see, let us know by opening an issue.