What happens when I run a program? Where does the code actually run? What is a process? What is a thread?

I realized that I was trying to understand higher-level concepts without having a clear picture of these fundamentals.

So today, instead of memorizing more definitions, I decided to go back to the basics and understand what actually happens when a program runs.

Let's start from the simplest question:

What actually happens when a program runs?

Lets first understand a simple program

A program is essentially a set of instructions or instructions that tells computer what to do.

Lets forget computers for a moment and think about your body.

Your body can perform many activities:

• walk

• run

• lift

• eat

• speak

• hear

• breathe

• sleep

But you body does not perform these activities randomly. They are coordinated by your brain.

For example: You decide to pick a glass.

Your brain has to coordinate a series of actions:

1. Decide to pick up glass

2. Move your hand

3. Make sure the hand has reached the glass correctly

4. Close your fingers

5. Lift the glass

Now connect this to programming:

A program is like a set of instructions for a computer

Just like your body needs instructions to perform an action, a computer needs instruction to perform a tasks.

Lets take an example of simple calculator program, what will be the task that it will perform lets analyse:

• Take two numbers as input

• Take the operation to be performed

• Performs the calculation

• Store the result

• Display the result

Just like picking up a glass required multiple coordinated actions, even a simple computer requires multiple instructions.

Now lets understand how program works within a computer in detail:

Program → Program starts running → Process → Thread → Instructions are executed

Program = Instructions

Okay, but what happens when these instructions actually starts running.

This is where the concept of a Process comes in.

Process is also known as running of a program.

A process is a running instance of a program.

Think your body as a system that can perform different activities.

When you are sitting still, nothing is necessarily "running" in the programming sense we're trying to illustrate.

Now imagine you decide to go for a run. Your brain gives instructions to your muscles, your muscles start working, and your body actively performs the activity.

In a similar way, a program is a set of instructions. When we start the program, the operating system creates a running instance of that program — a process.

Okay, so we understand that a process is a running instance of a program. But who actually executes the instructions?

A process contains one or more threads, and threads provide the execution paths through which instructions are executed.

A thread is an active execution path within a process that executes instructions.

Process is just the container that hold the memory and resources of a program, the thread is the moving part that reads code line by line and get the work done.

Let's take an example from our daily life.

Think of your body as a program.

You feel hungry and decide to eat something.

Your body now needs to perform a series of actions to accomplish this task. We can think of this as a process of eating.

Within this process, different parts of your body are involved in performing different tasks.

For the purpose of this analogy, let's think of different parts of the body as workers performing different pieces of work.

For example:

• 👀 Eyes → locate the food

• ✋ Hands → reach for and pick up the food

• 👄 Mouth → eat the food

Each worker has a particular job to perform.

Similarly, in a computer program, a thread provides a path through which instructions are executed.

A process can have one thread or multiple threads.

With multiple threads, different work can potentially make progress concurrently.

Imagine a program that needs to download a file while also processing some data. With multiple threads, different threads can execute different work concurrently, depending on the program and runtime.

Lets understand the program with an example:

const http = require("http");

const server = http.createServer((req, res) => {
    if (req.url === "/login") {
        // Task 1: Check user credentials
        // Task 2: Get user data
        // Task 3: Send response

        res.end("Login successful");
    }
});

server.listen(3000);

This is a program named login-server.js

It is simply a collection of instructions:

1. Create a server

2. Listen for requests

3. When /login arrives

4. Check the request

5. Process Login

6. Send response

Now we run the program

We execute:

node login-server.js

The operating system now creates a running instance of your program.

That running instance is a:

Process

The process gets things such as:

• Memory

• Resources

• Execution context

• One or more threads

The program is the instructions.
The process is the running instance of those instructions.

Now our process needs to actually execute the instructions, that's where thread comes in.

A thread is essentially an execution path through the program.

So when the server starts:

Program → Process created → Thread executes the program → Server starts listening

Now user sends a request:

Suppose you open a browser:

http://localhost:3000/login

When a user sends a request, the process now has work to perform. We can think of this work as a task.

Task might involved:

• Read the request

• Check credentials

• Fetch user data

• Send response

So:

Task = a piece of work that needs to be performed.

How Does a Thread Execute a Task?

Okay, so now we know that a process contains one or more threads and that a thread is responsible for executing instructions.

But there is one thing I still want to understand:

How does a thread actually get the work done?

Let's go back to our simple calculator example.

Suppose our program has this code:

function add(a, b) {
    return a + b;
}

const result = add(10, 20);

console.log(result);

The task of this program is pretty simple:

Take two numbers, add them, and display the result.

But the computer cannot just look at the code and magically know that it needs to add 10 + 20.

The code has to be executed.

We can roughly visualize what happens like this:

Program
   │
   ▼
Process
   │
   ▼
Thread
   │
   ▼
Execute instructions
   │
   ├── Call add()
   ├── Pass 10 and 20
   ├── Perform the addition
   ├── Store the result
   └── Display the result

The task is:

Calculate 10 + 20

The instructions are the individual steps required to complete that task.

The thread provides the execution path through which those instructions are executed.

Let's bring the human-body example back

Imagine you decide to pick up a glass.

The task is:

Pick up the glass.

Your body has to perform several actions to accomplish it:

1. Locate the glass

2. Move your hand

3. Reach the glass

4. Close your fingers

5. Lift the glass

You don't think about every muscle movement individually. Your brain coordinates the actions, and your body carries them out.

We can use a similar idea to understand program execution.

A computer program contains instructions, and those instructions need to be executed to accomplish a task.

But who actually executes the instructions?

This is where the CPU comes into the picture.

A thread provides the execution path for the work, and the CPU executes the actual machine instructions.

A very simplified view would be:

PROCESS → THREAD → Instructions → CPU → Execution

The CPU repeatedly performs operations on instructions. At a very high level, this is often described as:

Fetch → Decode → Execute

The details are much more complicated than this, but we don't need to go that deep yet.

For now, the important thing to remember is:

A thread provides an execution path, and the CPU executes the instructions associated with that thread.

And this also explains why I don't want to think of a task and a thread as the same thing.

A task is the work that needs to be done.

A thread is an execution path through which the instructions for that work can be executed.

The thread gets instructions, the CPU executes them, and eventually the task is completed.

But what happens when a task takes some time to complete?

What if our program needs to:

• read a file

• query a database

• make a network request

• wait for some external operation

Does the thread just sit there and wait until everything is finished?

I don't want to get into that part just yet. For now, I think I have a much clearer picture of what happens when a program runs.

A program is a set of instructions. A process is a running instance of that program. A thread provides the execution path for those instructions, and the CPU executes them to get the work done.

This gives me the foundation I was missing before. Now I can move on to the next concept with a much better understanding of what's actually happening behind the code.