On Thursday, Microsoft had a bad day. Problems with its infrastructure resulted in a widespread outage of Microsoft 365 services, including Outlook, Teams and SharePoint. The disruption continued well into Friday, affecting businesses, schools, government departments and countless individuals around the world.
It wasn't a cyberattack. Apparently, changes to Microsoft's network infrastructure had caused problems which proved unexpectedly difficult to resolve.
The remarkable thing about this outage wasn't that Microsoft's systems failed. All complex systems fail occasionally. It was that so much of the world found itself inconvenienced, or worse, because something had gone wrong with the computers belonging to a single American corporation.
We've built a global network designed to connect independent computers, and then arranged things so that millions of those computers become considerably less useful when one company messes up.
There's something very odd about that.
The internet was originally conceived as a network of networks. Its great achievement was enabling independent computers, running different operating systems and belonging to different organisations, to communicate using common protocols.
No single organisation needed to control the whole thing. Anyone with the necessary equipment and knowledge could operate a server, publish information, exchange messages or develop new services.
Of course, the early internet wasn't quite the democratic paradise that some enthusiasts remember. Access was limited, technical knowledge was essential, and its development depended heavily on government, academic and corporate institutions.
Nevertheless, its architecture embodied an important principle: the network could function without everything being controlled from the centre.
Over the years, we've moved away from that principle.
Increasingly, our email, calendars, documents, photographs, conversations and even the applications we use are entrusted to a relatively small number of enormous corporations. We call it the cloud, which sounds rather ethereal, but really means somebody else's computers.
There's nothing inherently wrong with using somebody else's computers, of course. It can be enormously convenient, and often makes possible things that would otherwise be difficult or expensive.
But convenience comes at a price.
When we become dependent upon services we don't control, we also become dependent upon the decisions, competence and continued goodwill of the organisations providing them.
And sometimes their computers stop working.
I've become increasingly interested in what is sometimes called the small web: personal websites, Gopher, Gemini, and the various efforts to recover a simpler, less commercial and more decentralised internet.
Some of this undoubtedly appeals to my nostalgic tendencies. I like text-based interfaces. I enjoy the relative tranquillity of Gopher and Gemini, where the attention-seeking clutter of the modern commercial web is largely absent.
But I think there's something more substantial going on here than nostalgia.
The small web offers a different understanding of our relationship with technology.
Instead of treating us primarily as consumers of services supplied by large corporations, it encourages us to become participants in a network of independently operated systems.
You don't need a commercial publishing platform to put your thoughts online. A modest computer, a text editor and somewhere to host your files will do the job.
A document doesn't have to be stored in a proprietary format or managed by a complex application. Sometimes a plain-text file is perfectly adequate.
And information stored in simple, open formats can be transferred between computers and applications without requiring permission from whoever happens to control the software.
These things seem increasingly important to me.
For the past few months I've been developing a personal information system which I've called DeckZero.
At its heart are four ordinary text files containing my calendar, tasks, journal and working notes. Using Git and a collection of small programs and scripts, I've made these files available across several computers and devices, including a laptop, a Raspberry Pi and a remote Unix host.
I'll readily admit that I've spent considerably more time developing this system than I would have spent simply entering appointments into Google Calendar. If I had to answer to a manager, I might have some explaining to do.
But the result is something I understand, can modify and can repair. My information is stored in formats that virtually any computer can read.
If one of my computers fails, I have copies elsewhere. If the remote host is unavailable, I can carry on working locally. If synchronisation stops working, my calendar doesn't disappear.
This doesn't make DeckZero infallible. Indeed, I've occasionally created some spectacular Git tangles through my own carelessness. But when something goes wrong, I can usually understand what has happened and do something about it.
That feels very different from staring at an error message and waiting for a distant corporation to restore its services.
I don't want to suggest that the small web is necessarily more reliable than the commercial internet.
A personal website running on an elderly computer might be considerably less reliable than Microsoft's enormous data centres. Small services can disappear without warning, and their operators may lack the resources to maintain them properly.
Nor is running your own systems a guarantee of independence. We all depend upon electricity, networks, hardware manufacturers and numerous other things beyond our control.
The more useful distinction, I think, is between reliability and resilience.
Reliability is about how frequently something fails. Resilience is about what happens when it does.
A highly reliable system can nevertheless be remarkably fragile if its failure leaves you completely helpless.
A less sophisticated system may fail more frequently, but if it can continue operating in a reduced capacity, or if its components can easily be replaced, it may actually serve you better.
One of the virtues of simple systems is that they can fail gracefully.
If my synchronisation service fails, I still have my files. If my preferred text editor stops working, I can use another. If a hosting provider disappears, I can move my website elsewhere.
This isn't magic. It's largely the consequence of avoiding unnecessary dependencies.
And perhaps that's something we should take more seriously.
There's a danger, though, that enthusiasm for the small web becomes an exercise in technological elitism.
It's all very well for people like me, who enjoy tinkering with computers, to celebrate text files, command lines and self-hosted services.
Most people have neither the time nor the inclination to learn how to configure a Unix server, administer a Git repository or debug a shell script. And why should they?
One of the genuine achievements of modern commercial services is that they've made sophisticated computing accessible to people who don't want to become computer experts.
A small-web movement that expects everyone to abandon familiar applications and learn the command line isn't going to get very far.
The challenge, surely, is to preserve the advantages of simplicity, openness and independence while making them accessible to ordinary users.
There's no reason why a friendly graphical interface shouldn't sit on top of simple, portable data. Indeed, that's one of the directions I'm exploring with DeckZero.
The important thing isn't whether somebody uses a terminal or a mouse. It's whether they're able to retain meaningful control over their information and the tools they use.
Ultimately, I think this is about more than technology.
The concentration of digital services in a handful of enormous corporations represents an extraordinary concentration of power.
These companies can change their prices, alter their terms of service, discontinue products and make decisions which affect millions of people who have no meaningful influence over them.
And when something goes wrong, we're expected simply to wait. I think that's disturbing.
Not because I imagine that all large technology companies are malevolent, or that their employees are anything other than people trying to do their jobs, but because I think there's something unhealthy about allowing so much of our common life to become dependent upon organisations over which we have so little control.
It seems to me that the small web offers at least a partial response.
We can't pretend that we can do without large-scale infrastructure, nor can we simply reject everything the modern internet has made possible. But we can demonstrate that there are other ways of doing things.
Ways which give individuals and communities rather more control, and which don't require every aspect of our digital lives to be mediated by somebody else's commercial platform.
Perhaps the greatest contribution of the small web isn't the technology itself, but the alternative vision it keeps alive.
We don't have to surrender ownership of our information in exchange for convenience. We don't have to assume that bigger and more complicated always means better. And we don't have to regard technological dependence as the inevitable price of progress.
To my mind, the small web isn't really about making the internet smaller. It's about recovering some of the independence, diversity and freedom that made the internet such an exciting idea in the first place.
And every so often, when a major technology company has a bad day and the rest of us discover just how dependent we've become, that seems like an idea worth remembering.
---
richard <AT> deckzero <DOT> uk