Jason J. Gullickson

Jason J. Gullickson

Human-Scale Software

This all started with a post I made to the fediverse:

The post was boosted a lot, and I received a number of replies of support, of encouragement and several thank-yous. One of them simply said:

This has encouraged me to spend a little more time thinking about and elaborating on the idea that writing small software is not only worthwhile, but noble and important; perhaps more important now than ever before.

Over the last decade or so there has been increasing pressure on programmers to make sure everything the write can “scale”, which typically refers to “Internet scale”; the ability to support millions of users and billions of megabytes of data. As a result many ideas for new software never get off the ground, and those who do are encumbered by requirements and dependencies which make them difficult to “try on”, or make them impossible to run outside expensive, complex systems. As a result additional layers of software have been applied on top of this (for example, “containers”) in an effort to manage all this complexity. The result is akin to an arms race between usability and scalability, where the answer to the need for simplicity is additional complexity.

Stop for a moment and think about how absurd that sounds.

What I propose is a way out of this madness by encouraging and supporting the development of human-scale software: programs that are valued even if only one person uses them.

That one person might only be the person who wrote the program in the first place, or it may be a few of that person’s friends who are happy to accept something that is rough around the edges if it meets their needs in a way specifically tailored to them.

I believe this helps erase another problem that plagues software design and that is the line between “users” and “developers”. I’m a firm believer that software should be designed to serve the people who will use it above all else, and what better way to achieve that goal than to have the software written by the person who will be using it, or for that programmer to have a personal relationship with the other people who put their code to work?

This isn’t possible with “Internet scale” systems designed for millions of “users”. Systems like this must compromise and serve at best the common denominator of all their users. Often they must compromise in ways that don’t benefit their users at all just to support the (often fictional) belief that their software is only valid if it can “scale”.

So what does this mean in a practical sense? What is the “actionable information” here?

First if you talk to someone who is writing a piece of software support them if you think it is cool. Don’t jump to judging the work based on its ability to take over the world, instead think about how you might use it and if you see yourself doing so, offer to get involved.

If you’re a programmer pursue writing software you need yourself over building something because you think someone else will buy it, and try not to worry about making it work for everyone all the time, make something good enough for yourself, share the results and if others find it interesting let them use it and get their feedback. This is much better than trying to guess what everyone else needs and wasting time building things with no real evidence that they are needed.

We need computers to do more than they do now, but we also need them to do less. So much of what’s wrong with technology comes from the idea that everything has to be everything to everyone all the time to the exclusion of everything else, and this results in boring, brittle products that are laden with compromise and systemic weaknesses. We’ve lost much of the promise of the “personal computer” by accepting this as the only legitimate way to write software and I’m here to tell you that this is a lie.

Let’s stop worrying and build some cool shit.