Prerequisites

Before reading this post, you should have a basic idea of:

• How programs run on a computer

• What a CPU and memory are

• Difference between machine code and high-level code

• What a compiler or interpreter does

When we try to understand computers, we often study hardware and software as separate worlds.

Hardware feels like circuits, processors, and memory chips. Software feels like code, applications, and programs.

But in reality, they are deeply connected.

An effective way to explain how a computer’s hardware and software are related is called the Virtual Machine Concept. This model was famously described by Andrew Tanenbaum in his book “Structured Computer Organization”.

Let’s break it down from the very basics.

The Most Basic Job of a Computer

At its core, a computer has one fundamental purpose i.e “Executing Programs“

Most computers can directly execute programs only if they are written in their native machine language – the language the processor understands.

This machine language consists of extremely simple instructions, each of which can be carried out by a small number of electronic circuits.

For simplicity let’s call this low level language

Language Level 0 → L0

This is the raw, native language of the hardware.

The Problem with L0

While L0 is perfect for processors, it is terrible for humans

Programs written in L0 are :

1. Enormously detailed

2. Hard to write

3. Hard to debug

4. Composed purely of numbers

No loops, no functions, no readable structure just machine instructions.

Naturally, programmers needed something better.

Enter a New Language: L1

Imagine a new language, L1, that is easier for programmers to use.

If we could somehow make the computer run programs written in L1, software development would become far more practical.

But since the hardware only understands L0, we need a way to connect the two.

There are two main approaches:

1. Interpretation

In this method:

• The L1 program starts running immediately

• Each instruction is decoded on the fly

• A program written in L0 reads and executes it step-by-step

Pros

• Immediate execution

• No need to convert the whole program beforehand

Cons

• Slower, because decoding happens at runtime

Think of Python: it is mostly interpreted.

2 . Translation

In this method:

• The entire L1 program is first converted into an L0 program

• A special translator (like a compiler) written in L0 performs this task

• The resulting L0 program runs directly on hardware

Pros

• Much faster execution

• No runtime decoding overhead

This is how C, C++, Go, Rust etc. work.

Thinking in Terms of Virtual Machines

Rather than thinking only about languages, it is easier to imagine a hypothetical computer at each level.

informally :

A Virtual Machine is a software program that emulates the functions of some other physical or virtual computer.

So we can imagine :

• VM0 - The machine that understands L0

• VM1 - The machine that understands L1

Programs are written for VM1, but executed on VM0 using interpretation or translation.

Each level hides complexity from the level above it.

The Layered Model

This Process can continue :

• If L1 is too complex build L2

• Then L3

• Until we reach a powerful programmer-friendly level

Modern computing is built exactly like this:

Application Level → Operating System Level → Hardware Level

Every layer behaves like a virtual machine for the layer above.

Real World Example : Java

The Java programming language is one of the clearest implementations of this idea.

• Java code is compiled into Java Bytecode

• Bytecode is executed by the Java Virtual Machine (JVM)

• The JVM is implemented on many platforms

This makes Java programs relatively system independent.

You write once for VM(Java) and run anywhere.

Beyond Java - Modern uses

Today we see virtual machines everywhere :

• VirtualBox / VMware – emulate entire computers

• Docker containers – emulate operating environments

• Cloud VMs – AWS EC2, Azure Virtual Machines

• Game console emulators

• Android Runtime (ART)

All of them rely on the same principle:

👉 Software pretending to be hardware so that other software can run more easily.