Software in 2025: The start of the Logic Era

Software started out as hardware’s little sibling. Hardware came first. And in those early days, software was almost insignificant. Not because it lacked potential, but because the machines were the size of buildings, cost millions, and could barely do more than automate bookkeeping. Like writing, which began as a tool for tracking grain and debts, early software existed mainly to keep a record of the flow of money.

That changed when computing hardware began its exponential climb. Computers became faster, cheaper, smaller, everywhere. As hardware accelerated, demands on software rose just as quickly, and this pressure exploded with the arrival of the internet. Today, software is everywhere.

It’s no surprise that by 2025, software has become extremely complex. Yet beneath the layers, every piece of software, from a computer virus to an AI model to a banking backend, is, at its core, a piece of business or domain logic wrapped in a technical shell that allows it to run on hardware.

That shell is rarely simple. It includes SDKs, frameworks, plugins, runtimes, orchestrators, containers, images, infrastructure, and often multiple layers on top of layers. No matter how virtualized or abstracted the hardware becomes, today’s software remains deeply aware of its older sibling. This is why modern applications still deal with databases, message queues, cloud services, endpoints, protocols, and every other technical surface of a computer.

And dealing with those surfaces consumes nearly all developer time. Developers claim to spend 85% of their time on technicalities. I suspect the real number is even higher if you count architecture design, wiring tests, debugging frameworks, and all the accidental complexity needed just to get the “real” logic into a running state.

But the ideal form of software, the one we keep promising ourselves, is a pure expression of business logic and intent. A form where logic stands on its own, completely detached from the machinery that executes it. A form where developers spend their time on the parts that are actually unique and valuable instead of on plumbing. A form that cannot be minimized or abstracted any further, because you would be removing actual functionality.

If we take that ideal seriously, we must confront a simple realization:

The logic of an application and the runtime that executes it should be separate things.

Not metaphorically separate. Literally separate. Logic in software should be as free from technical concerns as a mathematical function. And it should be expressed in a language that captures intent cleanly and directly.

To support this, a new kind of runtime must appear, a logic runtime, one that takes care of every technical concern in a consistent, invisible way. It should give the logic everything it needs, and never get in the way. In other words a world where developers no longer think about infrastructure. Infrastructure thinks about developers’ logic.

If this is the direction software should go, then the first step is to define how we want to express business intent. Only then should we concern ourselves with how to execute it.

Next steps

In the next posts, I’ll explore what this actually looks like in code. Not as abstract ideas, but through real examples of business intent expressed cleanly and directly without the usual technical noise. I’ll show how any domain, from finance to logistics to home automation, can be reduced to logic that reads almost like prose.

Once we have a feel for the shape of this logic-only code, we’ll turn to the other half of the story: the logic runtime. This is the engine that makes the separation possible. I’ll walk through what such a runtime must provide: the functional guarantees, the non-functional properties, and the practical realities like reliability, fault-tolerance, and observability.

And then we’ll look at the numbers. Performance, scalability, latency, throughput, resilience, and security, not as theoretical claims, but as concrete evidence that this new approach isn’t just elegant, but genuinely more powerful.

My hope is that these posts open up a new way of thinking about software: one where developers can focus entirely on logic and intent, while the runtime shoulders everything else. It’s an exciting shift, and I’m looking forward to sharing it with you.