IT Abstraction

If you look closely at the history of technology infrastructure, you’ll notice a consistent pattern: abstraction.

Abstraction simply means hiding the complex parts to simplify the user’s experience. For example, you don’t need to know how a combustion engine works to drive to the supermarket. You just press the pedal and go. In the tech world, this trend is happening fast. If we look at the history, we can actually make some solid predictions about the future.

To understand where we are going, we have to look at how we got here.

1. Physical Servers (The Iron Age of Tech)

Computing devices based on mechanical or analog tools have been used for thousands of years, like the abacus. However, it took two World Wars and decades of research to produce the first commercial digital computer, the “Ferranti Mark 1,” in the early 1950s.

While physical servers fundamentally changed how organizations operate, they weren’t immediately adopted everywhere. Paper dominated many industries well into the early 1990s. Eventually, paper lost to digital. Institutions began relying on servers to store data, automate processes, and run critical business applications.

Following “Moore’s Law” (the observation that computing power doubles roughly every two years), computers became immensely powerful. However, they were often inefficient because they typically ran one OS for one application. This resulted in a lot of “underutilized” machines sitting around doing nothing.

2. Virtualization

Virtualization started as university research before being commercialized by companies like VMware in the early 2000s, Virtualization software is deployed on a physical server and allows us to run multiple “Virtual Machines” (VMs) on a single physical server.

This was a massive jump in efficiency and it transformed the IT industry. costs were slashed because companies didn’t need to buy as much hardware, and it made management smoother. If a server broke, you could just move the VM to another one.

But as time went on, even VMs started to feel too heavy. Every VM needed its own full operating system (Guest OS), which hogged storage and RAM. Furthermore, as applications became more complex, developers struggled with their ‘monolithic’ nature. If one part of the code needed fixing, it could break the whole app. Developers needed something more granular.

3. Containers & Microservices

Containers are like lightweight VMs that share the OS kernel. They only hold the specific part of the app they need to run.

This allowed the industry to move to “microservices.” Instead of building an app as one giant block of code (a monolith), developers began breaking apps into small, independent parts. If one part breaks, the whole app doesn’t crash. It made fixing things much easier.

4. Serverless

The trend continued. We stopped worrying about the server, then the OS, and now, with Function-as-a-Service (Serverless), we don’t even worry about the infrastructure.

With functions, you only write your specific piece of code, upload it to the cloud, define the endpoint within your application where you want the function to be called and now you’re good to go. You don’t pay for a server sitting idle at 3 AM. You only pay for the milliseconds the code is actually running. The infrastructure is basically invisible now.

The Future: Three Predictions

1. Business-as-a-Service (BaaS)

We are moving toward a future where non-technical users can spin up an entire organization as easily as we currently spin up a server. Imagine an interface where you define the purpose of your business, and the system automatically provisions the applications (CRM, Sales, ERP) and the AI agents required to run them. The “tech stack” will become a utility, as simple as electricity.

2. Natural Language is the New Compiler

As abstraction continues, “coding” as we know it will disappear for 90% of people. We moved from Machine Code → Assembly → Python. The final layer is Human Language. In the future, you won’t need to learn syntax. You will simply describe what you want in English (or your native language), and AI agents will deploy the infrastructure for you.

3. Disposable Software

Today, we build software like monuments—meant to last for years. But as creating software becomes instant and free (thanks to BaaS and AI), we will see the rise of Disposable Software. We will spin up a custom app for a specific 3-day conference or a weekend project, use it, and then discard it.

Conclusion

The trend of abstraction follows the goal of making the “how” invisible so we can focus on the “why.” We are rapidly approaching a time where the barrier to entry for building an application is zero. The technology of tomorrow will be faster, smarter, and almost invisible.