The strange merry-go-round of computing
Computer science is a serious, rigorous, scientific discipline that spends most of its time reinventing what it forgot it invented twenty years ago. And the worst part is that it works every time. You repackage the old thing under a new name, slap a logo on it, raise 50 million, and pat yourself on the back for the innovation. If you're not dizzy yet, you're not paying attention.
The merry-go-round
There's an unwritten law in computing that nobody teaches in class but everyone eventually discovers the hard way: everything new is old, and everything old will come back. It's a merry-go-round. A big, circular merry-go-round, with wooden horses painted different colours on each lap, but all spinning around the same axis, at the same speed, for fifty years.
The problem is that the people riding the merry-go-round can't see it spinning. They see the horse they're sitting on, they think it's marvellous, and they write a Medium article to explain that this horse is disruptive. Meanwhile, the old man on the bench across the way has been watching the same merry-go-round spin since 1975 and is wondering if anyone will ever notice. (nobody ever notices)
I teach computer science. I read code, I write code, I make people write code, and I've been watching the merry-go-round spin long enough to have started recognising the horses. This post is a non-exhaustive catalogue of the laps I've seen go by, with the benevolent weariness of a spectator who loves the show in spite of everything.
Centralised, decentralised, recentralised
I already covered this in the post about federation, but it's worth revisiting from the angle of cycles, because this one is the purest, the most beautiful, the most disheartening.
1960s–70s: the mainframe. One big central computer, dumb terminals plugged into it. All the power at the centre. All the control at the centre. If the mainframe goes down, everybody goes home. IBM reigns.
1980s–90s: the PC. We decentralise. Every person gets their own computer, their own processing power, their own files. Freedom! The individual breaks free from the mainframe! You print stuff on your dot-matrix printer and you are sovereign. It's magnificent and very noisy.
2010s–20s: the cloud. We recentralise. Your "own computer" is nothing more than a web browser plugged into the servers of three Californian companies. All the power at the centre. All the control at the centre. If AWS goes down, half of the Internet goes home. The VT100 terminal is now called a Chromebook. Time-sharing is called SaaS. The monthly bill to IBM is called "the monthly bill to Amazon". And the IT department that ran the mainframe is called "the AWS console", except it's in Seattle and you don't have the number.
We're back to the mainframe. We just renamed it. And we paid a fortune for the trip.
Monopoly, no monopoly, remonopoly
The monopoly cycle is my second favourite, because it has the regularity of a metronome. It's like a running gag in a sitcom, except the sitcom has been going for sixty years and nobody changes the channel.
IBM had the monopoly on computer hardware in the 60s–70s. So much monopoly that the US government launched an antitrust lawsuit that lasted thirteen years. Then the PC came along, IBM lost its crown, and everyone said: "See? The market self-regulates!"
Microsoft took over in the 90s. Monopoly on the operating system, monopoly on the browser, monopoly on the office suite. So much monopoly that the US government launched an antitrust lawsuit. Then the web and mobile came along, Microsoft wobbled, and everyone said: "See? The market self-regulates!"
Google took over in the 2010s. Monopoly on search, online advertising, the browser (again), the mobile operating system. So much monopoly that the US government launched an antitrust lawsuit. And here we are in 2026, waiting for what's next with a bag of popcorn.
The pattern is crystal clear. A giant settles in, crushes everything, a new technological paradigm destabilises it, another giant takes its place, crushes everything, and we start over. The monopoly never goes away. It changes its logo. And with each cycle, very serious people explain in TED talks that this time technology will democratise things, that this time the little guy will be able to compete with the big guy, that this time it's different. It's always touching. It's never true.
The old language, the new language, the old language after all
This one is the one that makes me smile most, because I live it every day.
COBOL. A language from the 60s. Verbose, rigid, boring as a tax form in triplicate. Nobody wants to learn it, everyone mocks it, students snicker when you mention it. And meanwhile, the global banking system runs on it. Insurance runs on it. Huge chunks of government administration in several countries run on it. And when there's a critical bug in a payment system, they desperately look for a 70-year-old COBOL developer to fix it, pay them a fortune per day, and nobody snickers anymore. (funny, that)
C. A language from the 70s. "Dangerous." "Low-level." "Too close to the machine." They invented C++ to improve it. Then Java to replace it. Then Go to simplify it. Then Rust to make it safe. Every decade brings a new language that's supposed to be "C, but better". And in 2026, the Linux kernel is in C, your file system is in C, your browser is partly in C, your router firmware is in C, and the satellites in orbit run on C. The language they've been burying for forty years is still the foundation of everything around you. It has outlived every single one of its designated successors. It's the computing equivalent of the cockroach: indestructible, not very pretty, and absolutely everywhere.
SQL. Also from the 70s. Relational, declarative, rigorous. And then in the 2010s, fashion decided that SQL was rigid, "not scalable", dad's thing. They invented NoSQL. MongoDB, Cassandra, CouchDB. "Relational databases are dead!" proclaimed the evangelists on their blogs hosted on relational databases. Two years later, the same evangelists were spending their nights reimplementing joins and transactions on top of their NoSQL database, because it turns out that when you have structured data, a structured database is actually pretty good. MongoDB ended up adding ACID transactions. In other words: they reinvented SQL. Worse, slower, and congratulating themselves on the innovation. (standing ovation)
JavaScript. Created in ten days in 1995 by Brendan Eich at Netscape, to add a bit of interactivity to web pages. Ten days. For a language. You can tell, and you could tell for twenty years. It was a quick-and-dirty scripting language, limited, wonky, that nobody took seriously. And then, through a series of events that no sober historian will ever be able to explain, people started writing web servers in JavaScript (Node.js), desktop applications in JavaScript (Electron), mobile applications in JavaScript (React Native), backends in JavaScript, build tools in JavaScript, and probably toasters in JavaScript. The most despised language in the industry became the most used language in the world. And now they've invented TypeScript to fix its flaws, meaning they've added a static type system on top of a language that was explicitly designed not to have one. It's like putting a tie on a cat: technically possible, aesthetically debatable, and the cat didn't ask for it.
And all this time, somewhere in a bunker, a Lisp developer is murmuring: "We had all of that in 1958." He's right. Nobody listens. The merry-go-round turns.
The architectures that keep coming back
The architecture cycle is the fastest. The merry-go-round spins so fast you can see the same ideas go by three times in a single career.
Monolith, microservices, monolith. For decades, we wrote monolithic applications. One program, one deployment, one server. It worked. It was simple. It was understandable. And then someone at Netflix said: "We should split this into microservices." And the entire world followed, because if Netflix does it, it must be good. Your expense report app with three users? Microservices. Your blog? Microservices. Your TODO list? Twelve Docker containers, an API gateway, a service mesh, a distributed tracing tool, and a full-time DevOps engineer to hold it together. For a TODO list. (Netflix has 200 million users. You have three. Including your mum.)
And then in 2023, Amazon itself published an article explaining that they had migrated one of their services from microservices to a monolith and reduced costs by 90%. Amazon. The company that sells you the infrastructure to build microservices. That bills you for every network call between your 47 micro-containers. That company said: "Actually, a monolith is better." The merry-go-round completed a full lap so fast it made everyone nauseous.
Thick client, thin client, thick client, thin client. Desktop applications were replaced by web applications. Then web applications became so complex they turned back into desktop applications disguised as browsers. Electron is literally Chrome packaged with your application. Slack weighs 300 MB. For a chat. The IRC client from 1999 did the same thing in 2 MB, but it didn't have animated GIFs, so obviously it's incomparable. (first-degree irony) Then we decided it was too heavy and invented Progressive Web Apps, which are web applications that try to look like desktop applications. Full circle. The snake eats its tail. The cat in a tie is not impressed.
REST, GraphQL, REST. REST was too simple, not flexible enough. They invented GraphQL to "solve REST's limitations". Then they discovered GraphQL had its own limitations (performance, security, complexity, caching), and "Why we moved back to REST" articles blossomed like daisies in spring. Meanwhile, a SOAP developer from the 2000s politely clears their throat to point out that strict contracts, schema validation and standardised error handling already existed. But SOAP isn't sexy, and XML is verbose, so we'd rather not talk about it. (we'd rather reinvent)
The framework of the month
We need to talk about the JavaScript ecosystem, because it's a textbook case. It's the only ecosystem in the world that reproduces the entire cycle of computing in fast-forward, like a hamster on amphetamines in a wheel spinning at the speed of light.
I have seen, with my own eyes, in less than ten years: Angular is the future. No, React is the future, Angular is has-been. No, Vue.js is the future, React is too complicated. No, Svelte is the future, Vue is just React really. No, SolidJS is the future, Svelte compiles too much. No, HTMX is the future, maybe we never needed a client-side framework. No, actually, a static site with HTML and three lines of CSS was fine all along.
We're back to square one. In ten years. With eight frameworks, fifteen build tools, three thousand blog posts, and a node_modules folder that weighs more than the Apollo programme. (I barely exaggerate)
And somewhere, a PHP developer is watching all this from a server that hasn't moved since 2009, with their crusty WordPress and their MySQL database, and they're smiling. Because their site works, their clients are happy, and nobody ever asked them to migrate to a Turborepo monorepo with streaming hydrated Server Components. They don't know what that means. Nobody really knows what that means. But it looks great on a CV.
AI, or the longest cycle of them all
I already wrote an entire post about AI, so I won't go over it all again. But you can't talk about computing cycles without mentioning the oldest, the most regular, and the most lavishly funded of them all.
1960s: AI will solve everything. Massive funding. 1970s: it doesn't work. Winter. 1980s: expert systems will solve everything. Massive funding. 1990s: that doesn't work either. Winter again. 2010s: deep learning will solve everything. Insane funding. 2020s: LLMs will solve everything. Cosmic funding.
The cycle is always the same: enthusiasm, overinvestment, absurd promises, disappointment, winter, and then we start again with a new buzzword. The only variable that changes is the amount of funding, which increases exponentially with each lap, as if money could compensate for the fact that we've been promising the same thing for sixty years.
Are LLMs useful? Yes. This post was in fact written with the help of one. Will they "solve everything"? Let me check the last sixty years of AI predictions and I'll get back to you.
Why it spins
The real question isn't "does it spin". That much is obvious. The real question is why we don't notice.
Short memory, first. The tech industry has the memory of a goldfish on caffeine. Developers change jobs every two or three years, startups are born and die in eighteen months, frameworks are obsolete before they're stable. Nobody stays in one place long enough to see the cycle complete. So we rediscover the same lessons, wrap them in fresh vocabulary ("serverless" instead of shared hosting, "container" instead of chroot, "edge computing" instead of "put a server closer to the client"), and sell them as innovations. And it works, because the buyers haven't stayed long enough to remember the previous lap either.
Money, second. Every lap of the merry-go-round is funded by people who need to sell something new. You don't raise 50 million dollars by saying "we're going to do the same thing as before, but properly". You raise them by saying "we're going to disrupt the market with a radically new approach". Even if the approach in question is a mainframe with a better logo. Venture capital doesn't fund continuity. It funds novelty. And when novelty doesn't exist, you manufacture it by rebranding the old stuff. (that's a business model in itself)
And ego, last. Every generation of developers wants to believe it's the first to solve the real problems. That the old guard didn't understand. That this time, with these tools, we'll do things properly. It's human, it's even touching, and I say this without condescension because I've been there myself. I believed, at one point, that Docker would change everything. That Node.js was the answer. That microservices were the future. And then the merry-go-round completed a lap, and I saw the same horse go by with a fresh coat of paint. It's sobering.
So what?
So nothing. The merry-go-round will keep spinning. In ten years, someone will invent a revolutionary paradigm that will, in fact, be time-sharing on a mainframe with better marketing. Functional programming languages will make their fourth comeback. A startup will raise 200 million to reinvent RSS. And some old developer somewhere will shake their head and mutter: "Told you so."
The only thing we can do is be aware of it. Know that the horse we're riding goes in circles. Enjoy the scenery as it passes, recognise the things we've already seen on the previous lap, and above all not write a blog post explaining that this lap is different.
Which is exactly what I just did, obviously.