DEV Community: Shankar L

Compilation vs Interpretation

Shankar L — Tue, 11 Aug 2026 04:30:00 +0000

Compilation vs Interpretation

Why should you care?

You write code in a programming language such as Java, Python, C, or JavaScript.

But the CPU does not understand these languages directly.

Something has to translate your human-readable code into instructions the computer can execute.

That translation can happen in different ways.

Two of the most important concepts are:

Compilation
Interpretation

Understanding the difference helps you understand why programming languages behave differently, why some programs start quickly, why some run faster, and where tools such as the JVM and JIT compiler fit into the picture.

The Problem

Consider this simple program:

print("Hello World")

The CPU cannot directly execute:

print("Hello World")

It needs instructions that match the CPU's instruction set.

So we need a translation process.

There are two traditional approaches:

Source Code
    ↓
Compiler
    ↓
Machine Code
    ↓
CPU

and:

Source Code
    ↓
Interpreter
    ↓
Execution

But modern programming languages are more complicated than this simple distinction suggests.

The Concept

Compilation

A compiler translates source code into another form before the program runs.

A simplified C compilation process looks like:

C Source Code
      ↓
Compiler
      ↓
Machine Code
      ↓
Executable
      ↓
CPU

For example:

int result = 10 + 20;

A compiler can translate this into machine instructions appropriate for the target CPU.

The resulting executable can then be run without recompiling the source code every time.

Interpretation

An interpreter executes a program by reading and processing its instructions at runtime.

A simplified model is:

Source Code
      ↓
Interpreter
      ↓
Execute
      ↓
Next instruction
      ↓
Execute

Python is commonly described as an interpreted language, although modern Python implementations first compile source code into bytecode before executing it.

This is an important distinction:

"Compiled" and "interpreted" describe execution strategies, not permanent categories that every language fits into perfectly.

Simple Explanation

Think about translating a book.

Compilation

Imagine translating the entire book into another language before giving it to the reader.

Entire book
    ↓
Translator
    ↓
Translated book
    ↓
Reader

The translation happens beforehand.

Interpretation

Now imagine a translator sitting next to the reader and translating each sentence as the reader encounters it.

Sentence
   ↓
Translator
   ↓
Reader
   ↓
Next sentence

The translation happens during reading.

That is the basic difference.

Real-world Analogy

Imagine a restaurant menu written in French.

Compilation

You translate the entire menu into English before customers arrive.

Every customer can immediately read the translated version.

Interpretation

A translator stands beside each customer and translates each item when they ask about it.

The first approach requires preparation.

The second approach performs translation during interaction.

Programming language execution has similar trade-offs.

Code Example

Consider this simple C program:

#include <stdio.h>

int main() {
    int a = 10;
    int b = 20;

    printf("%d\n", a + b);

    return 0;
}

With a compiler such as GCC, you can compile it:

gcc main.c -o main

This produces an executable.

You can then run:

./main

The general process is:

main.c
  ↓
GCC
  ↓
Executable
  ↓
CPU

Now consider Python:

a = 10
b = 20

print(a + b)

You normally run it with:

python main.py

The Python runtime handles the execution process.

The important point is that the details are more nuanced than simply saying:

C = compiled
Python = interpreted

Modern language implementations often combine several techniques.

Java Is Different

Java provides one of the clearest examples of a hybrid execution model.

When you write:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

You compile it with:

javac Main.java

The compiler produces:

Main.class

This contains Java bytecode.

The process becomes:

Java Source
    ↓
javac
    ↓
Bytecode
    ↓
JVM
    ↓
Machine Code
    ↓
CPU

The JVM can interpret bytecode and can also use a Just-In-Time compiler, commonly called a JIT compiler, to compile frequently executed code into native machine instructions at runtime.

This gives Java a mixture of compilation and interpretation techniques.

Common Mistakes

Mistake 1: "Compiled languages are always faster"

Not necessarily.

Performance depends on:

Compiler optimizations
Runtime behavior
CPU architecture
Memory access
Garbage collection
Algorithms
Data structures
Workload

A language's execution model is only one part of performance.

Mistake 2: "Python is purely interpreted"

This is an oversimplification.

For example, CPython typically performs:

Python Source
     ↓
Bytecode
     ↓
Python Virtual Machine
     ↓
Execution

So even Python involves a compilation step.

Mistake 3: "Java is interpreted"

Saying Java is simply interpreted is also incomplete.

Java uses:

Source
  ↓
Bytecode
  ↓
JVM
  ↓
Interpreter and/or JIT Compiler
  ↓
Machine Code

The JVM can dynamically optimize frequently executed code.

Mistake 4: "Compilation happens only once"

It depends on the language and execution environment.

Traditional compiled programs may be compiled before distribution.

JIT compilation happens while the program is running.

Therefore, compilation can happen both before and during execution.

Advanced Notes

Ahead-of-Time Compilation

AOT compilation means code is compiled before execution.

The general process is:

Source
  ↓
Compiler
  ↓
Native Machine Code
  ↓
Execution

C and C++ commonly use this model.

Advantages include:

Fast startup
Strong compile-time optimization
Direct native execution

Just-In-Time Compilation

JIT compilation happens while the program is running.

A simplified process is:

Source
   ↓
Intermediate Representation
   ↓
Runtime
   ↓
JIT Compiler
   ↓
Machine Code

The runtime can observe how the program behaves and optimize frequently executed code.

This is used by technologies such as:

JVM
.NET runtime
JavaScript engines

Bytecode

Bytecode is an intermediate representation.

It sits between source code and machine code.

For Java:

Java Source
    ↓
Java Bytecode
    ↓
JVM
    ↓
Machine Code

The advantage is portability.

The same Java bytecode can run on different operating systems and CPU architectures as long as a compatible JVM exists.

This is the idea behind:

Write once, run anywhere.

Compilation vs Interpretation

Feature	Compilation	Interpretation
Translation	Before or during build	During execution
Typical output	Machine code or intermediate code	Runtime execution
Startup	Often faster after compilation	Can have runtime overhead
Optimization	Can happen before execution	Can happen dynamically
Examples	C, C++	Traditional interpreters
Modern reality	Often combined with other techniques	Often combined with bytecode/JIT

The table is intentionally simplified because modern runtimes frequently combine compilation, interpretation, bytecode, and JIT techniques.

The Bigger Picture

The most useful mental model is not:

Compiled vs Interpreted

Instead, think:

How does this language implementation
transform source code into executable work?

Different languages can choose different strategies.

For example:

C
Source
  ↓
Compiler
  ↓
Native Machine Code

Java
Source
  ↓
Bytecode
  ↓
JVM
  ↓
JIT
  ↓
Machine Code

Python
Source
  ↓
Bytecode
  ↓
Python Runtime
  ↓
Execution

JavaScript
Source
  ↓
JavaScript Engine
  ↓
Interpretation + JIT
  ↓
Machine Code

The exact implementation depends on the runtime and version.

Summary

Compilation and interpretation are two different approaches for turning source code into executable behavior.

Compilation

Source
  ↓
Compiler
  ↓
Machine Code
  ↓
CPU

Interpretation

Source
  ↓
Interpreter
  ↓
Execution

But modern systems are more sophisticated.

Java uses bytecode and the JVM.

Python implementations may compile source into bytecode.

JavaScript engines commonly combine interpretation and JIT compilation.

The most important lesson is:

Programming languages are not simply "compiled" or "interpreted." Their implementations can use multiple execution techniques.

Understanding this distinction gives you a much better foundation for learning compilers, virtual machines, programming language runtimes, and performance optimization.

Registers, Cache, RAM Explained

Shankar L — Mon, 10 Aug 2026 04:30:00 +0000

Why should you care?

Your CPU can process instructions incredibly quickly.

But there is a problem.

The data the CPU needs is not always immediately available.

Different types of memory exist because speed, capacity, and cost are trade offs.

Understanding registers, cache, and RAM helps explain:

Why CPUs are so fast.
Why RAM is slower than cache.
Why cache has multiple levels.
Why memory locality matters.
Why some programs are much faster than others.
How the CPU gets the data it needs.

The key idea is simple:

The closer memory is to the CPU, the faster it generally is.

The Problem

Imagine the CPU needs this value:

Where should it get it from?

It could be stored in:

Register
Cache
RAM
SSD

These are not equally fast.

A CPU that had to wait for RAM every time it needed a value would spend a significant amount of time waiting.

Instead, computers use a memory hierarchy.

Fastest
   ↓
Registers
   ↓
L1 Cache
   ↓
L2 Cache
   ↓
L3 Cache
   ↓
RAM
   ↓
SSD
   ↓
Slowest

As we move downward:

Capacity generally increases.
Cost per byte generally decreases.
Access latency generally increases.

The Concept

Let's understand the three important levels.

Registers

Registers are tiny storage locations located directly inside a CPU core.

They hold values that the CPU is actively working with.

For example:

Register A = 10
Register B = 20

The CPU can perform:

10 + 20

using those values.

Registers are extremely fast, but there are very few of them compared with RAM.

Cache

CPU cache sits between registers and RAM.

Its job is to keep frequently or recently used data close to the CPU.

Modern processors commonly have:

L1 Cache
L2 Cache
L3 Cache

L1 is generally the smallest and fastest.

L3 is generally larger and slower than L1.

A simplified hierarchy looks like:

CPU Core
   |
  L1
   |
  L2
   |
  L3
   |
  RAM

RAM

RAM stands for Random Access Memory.

It holds programs and data that the operating system is currently using.

For example, when you open a browser:

SSD
 ↓
RAM
 ↓
CPU Cache
 ↓
Registers
 ↓
CPU

The program is stored permanently on the SSD, but the CPU works with data loaded into RAM and then brought closer through the cache hierarchy.

RAM is much larger than cache, but significantly slower.

Simple Explanation

Think about working at a desk.

Your hand
    ↓
Desk
    ↓
Drawer
    ↓
Cupboard
    ↓
Storage room

If you need a pen:

In your hand: extremely fast.
On the desk: very fast.
In the drawer: slower.
In the cupboard: slower.
In the storage room: much slower.

The CPU works in a similar way.

Registers → Cache → RAM → Storage

The CPU tries to keep the data it needs as close as possible.

Real-world Analogy

Imagine a restaurant kitchen.

The chef is the CPU.

Ingredients being actively used are registers.

Ingredients placed on the kitchen counter are cache.

Ingredients inside the refrigerator are RAM.

Ingredients stored in the warehouse are storage.

The chef does not want to walk to the warehouse every time an ingredient is needed.

Instead:

Warehouse
    ↓
Refrigerator
    ↓
Kitchen Counter
    ↓
Chef's Hands

The same principle applies to computer memory.

Code Example

Consider this loop:

public class Main {
    public static void main(String[] args) {

        long sum = 0;

        for (int i = 0; i < 1_000_000; i++) {
            sum += i;
        }

        System.out.println(sum);
    }
}

At a high level, the program repeatedly accesses:

i
sum

The CPU needs these values repeatedly.

The exact behavior depends on the compiler, JVM, CPU architecture, and optimization level, but frequently accessed values may spend time in CPU registers and cache rather than requiring a trip to RAM for every operation.

This is one reason data locality matters.

Common Mistakes

Mistake 1: Thinking cache is just another type of RAM

Cache and RAM are both memory, but they serve different roles.

Cache is much smaller and designed to provide very fast access close to the CPU.

Mistake 2: Thinking more cache always means a faster CPU

More cache can help, but performance depends on the workload.

A larger cache does not automatically make every program faster.

Mistake 3: Thinking registers are the same as variables

A programming language variable is an abstraction.

The compiler may keep a value in a register, place it on the stack, optimize it away, or store it elsewhere depending on the program and optimization.

You should not assume:

int x = 10;

means there is literally a hardware register called x.

Mistake 4: Thinking the CPU always reads RAM

The CPU normally checks the cache hierarchy first.

A simplified model is:

CPU needs data
      ↓
L1 Cache?
      ↓
L2 Cache?
      ↓
L3 Cache?
      ↓
RAM

If the data is found in cache, it is called a cache hit.

If it is not found, it is a cache miss.

Advanced Notes

Cache Hit

Suppose the CPU requests data and it is already in cache.

CPU
 ↓
Cache
 ↓
Data found

This is a cache hit.

The CPU can continue quickly.

Cache Miss

If the requested data is not in the cache:

CPU
 ↓
L1 Miss
 ↓
L2 Miss
 ↓
L3 Miss
 ↓
RAM

The processor must obtain the data from a lower level.

This takes longer.

Cache Locality

Programs often access data in predictable patterns.

There are two important types of locality.

Temporal Locality

If a program accesses something now, it is likely to access it again soon.

Example:

sum = sum + value;

The variable sum is repeatedly used inside a loop.

Spatial Locality

If a program accesses one memory location, it is likely to access nearby locations.

For example:

for (int i = 0; i < array.length; i++) {
    sum += array[i];
}

The program accesses array elements sequentially.

This pattern is generally cache-friendly.

Registers vs Cache vs RAM

Feature	Registers	Cache	RAM
Location	CPU core	CPU	Main memory
Size	Tiny	Small	Large
Speed	Fastest	Very fast	Slower
Main purpose	Active calculations	Frequently used data	Running programs and data
Managed by	Compiler/CPU	Hardware	Operating system + hardware

The important trade-off is:

More Speed
    ↓
Less Capacity
    ↓
Higher Cost per Byte

And generally:

More Capacity
    ↓
Lower Speed
    ↓
Lower Cost per Byte

One Important Detail

You may see diagrams like:

Registers
   ↓
Cache
   ↓
RAM

But modern CPUs are more complicated.

There are multiple cache levels, memory controllers, translation lookaside buffers, hardware prefetchers, out-of-order execution, and other mechanisms.

The simplified hierarchy is useful because it gives you the correct mental model without overwhelming you with implementation details.

Summary

Registers, cache, and RAM are different layers of the computer's memory hierarchy.

Remember:

Registers hold values the CPU is actively working with.
Cache keeps frequently needed data close to the CPU.
RAM holds programs and data currently being used.
Cache hits are faster than cache misses.
Locality is important for performance.
Faster memory is generally smaller and more expensive per byte.

The next time your program runs a loop over an array, remember that the CPU is not simply "reading memory."

It is constantly moving data through a carefully designed hierarchy to keep the processor busy.

CPU Architecture Simplified

Shankar L — Sun, 09 Aug 2026 07:16:22 +0000

Why should you care?

You write code.

The compiler translates it.

But who actually executes it?

The answer is the CPU.

Every program you run eventually becomes a sequence of instructions that the CPU executes.

Understanding CPU architecture helps explain why:

Some programs are faster than others.
RAM is slower than CPU cache.
Your CPU has multiple cores.
A program can use multiple threads.
Low-level optimizations sometimes matter.
Programming concepts like loops, function calls, and variables eventually become CPU instructions.

You don't need to become a hardware engineer to understand CPU architecture.

You just need to understand the main components and how they work together.

The Problem

Consider this simple Java code:

int a = 10;
int b = 20;

int result = a + b;

It looks extremely simple.

But the CPU doesn't understand:

int
a
b
result
+

The compiler and JVM eventually translate your program into instructions that the processor can execute.

At the hardware level, the CPU performs operations such as:

Load data
Perform calculation
Store result

So what exactly exists inside a CPU that allows it to do this?

The Concept

A CPU contains several important components.

The most important ones to understand initially are:

              CPU
               |
      +--------+--------+
      |                 |
 Control Unit          ALU
      |                 |
      +--------+--------+
               |
            Registers
               |
             Cache
               |
              RAM

Each component has a different responsibility.

The main components are:

Control Unit
ALU
Registers
CPU Cache
Clock
CPU Cores

Let's understand them one by one.

Simple Explanation

Control Unit

The Control Unit coordinates the CPU.

It determines:

Which instruction should be executed.
What operation needs to happen.
Where data should come from.
Where the result should go.

You can think of it as the CPU's coordinator.

ALU

ALU stands for Arithmetic Logic Unit.

It performs operations such as:

Addition
Subtraction
AND
OR
XOR
Comparisons

For example:

10 + 20

The ALU performs the actual arithmetic operation.

Registers

Registers are extremely small and extremely fast storage locations inside the CPU.

They temporarily hold:

Numbers
Addresses
Instructions
Intermediate results

For example:

Register A = 10
Register B = 20

The ALU can then operate on these values.

Registers are much faster than RAM because they are located directly inside the processor.

Cache

CPU cache stores frequently used data and instructions close to the CPU.

Modern processors typically have multiple cache levels:

L1 Cache
   ↓
L2 Cache
   ↓
L3 Cache
   ↓
RAM
   ↓
SSD

As you move downward, capacity generally increases while access becomes slower.

L1 cache is extremely fast but very small.

L3 cache is larger but slower than L1.

Real-world Analogy

Imagine a chef preparing a meal.

The chef is the CPU.

The ingredients stored in the refrigerator are like data in storage.

The kitchen counter is like RAM.

A small plate beside the chef is like the CPU cache.

The chef's hands are like registers.

The cooking instructions are like CPU instructions.

The chef doesn't repeatedly walk to the refrigerator for every ingredient.

Instead:

Refrigerator
     ↓
Kitchen Counter
     ↓
Small Plate
     ↓
Chef's Hands
     ↓
Cooking

The closer something is to the chef, the faster it can be accessed.

This is similar to the CPU's memory hierarchy.

Fetch, Decode, Execute

One of the most important concepts in CPU architecture is the instruction cycle.

The CPU repeatedly performs three fundamental steps:

Fetch
  ↓
Decode
  ↓
Execute
  ↓
Fetch
  ↓
Decode
  ↓
Execute

1. Fetch

The CPU retrieves the next instruction from memory.

2. Decode

The CPU determines what that instruction means.

For example:

ADD

might tell the processor to perform an addition.

3. Execute

The CPU performs the operation.

This cycle happens extremely quickly.

A modern CPU can perform billions of clock cycles per second.

Code Example

Consider:

int result = 10 + 20;

Conceptually, the CPU may perform operations similar to:

LOAD 10
LOAD 20
ADD
STORE result

The actual instructions depend on the processor architecture, compiler, JVM, and optimization level.

The important idea is that high-level code eventually becomes low-level instructions.

You can see this more clearly with C.

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

A compiler may translate this into assembly instructions similar to:

mov eax, edi
add eax, esi
ret

The exact assembly depends on the CPU architecture and compiler.

But the underlying idea is simple:

Get values
   ↓
Perform addition
   ↓
Return result

CPU Cores

Modern CPUs usually contain multiple cores.

For example:

CPU
├── Core 1
├── Core 2
├── Core 3
└── Core 4

Each core can execute its own stream of instructions.

This allows multiple tasks to make progress concurrently.

For example:

Core 1 → Browser
Core 2 → Music Player
Core 3 → Code Compilation
Core 4 → Background Tasks

This is one reason modern operating systems can run many applications at the same time.

Common Mistakes

Mistake 1: Thinking GHz means performance

A CPU running at 4 GHz is not automatically twice as fast as one running at 2 GHz.

Performance also depends on:

CPU architecture
Instructions per cycle
Cache
Number of cores
Memory performance
Compiler optimizations
Workload

Clock speed is only one factor.

Mistake 2: Thinking more cores always means faster

More cores help when the workload can be divided into multiple tasks.

A single-threaded program may not benefit significantly from additional cores.

For example:

4 cores ≠ automatically 4× performance

Parallelism has overhead and depends heavily on the workload.

Mistake 3: Thinking RAM is inside the CPU

RAM is normally outside the CPU package and connected through the memory subsystem.

Registers and CPU caches are much closer to the processor execution units.

Mistake 4: Thinking the CPU directly executes Java or Python

It doesn't.

High-level languages use compilers, interpreters, virtual machines, or combinations of these mechanisms to eventually produce instructions the processor can execute.

Advanced Notes

Instruction Set Architecture

A CPU doesn't just execute arbitrary instructions.

It follows an Instruction Set Architecture, commonly called an ISA.

Examples include:

x86-64
ARM64
RISC-V

The ISA defines things such as:

Available instructions
Registers
Data types
Memory operations
Instruction formats

This is why software compiled for one architecture may not directly run on another architecture.

Pipeline

Modern CPUs don't necessarily wait for one instruction to completely finish before starting the next.

They use instruction pipelining.

Conceptually:

Instruction 1 → Fetch → Decode → Execute
Instruction 2          → Fetch → Decode → Execute
Instruction 3                   → Fetch → Decode → Execute

This allows different stages of multiple instructions to be processed simultaneously.

Branch Prediction

Consider:

if (x > 10) {
    doSomething();
}

The CPU may need to determine which path the program will take.

Modern CPUs use branch prediction to guess the likely path.

If the prediction is correct, execution can continue efficiently.

If it is wrong, the CPU may need to discard speculative work and recover.

Cache Hierarchy

A simplified memory hierarchy looks like this:

        CPU Registers
             ↓
          L1 Cache
             ↓
          L2 Cache
             ↓
          L3 Cache
             ↓
            RAM
             ↓
           SSD

The closer the data is to the execution units, the faster it can generally be accessed.

This is one reason algorithms and data structures that have good cache locality can perform significantly better.

Summary

A CPU is much more than a component that "does calculations."

It contains multiple systems working together.

              CPU
               |
      +--------+--------+
      |                 |
 Control Unit          ALU
      |                 |
      +--------+--------+
               |
           Registers
               |
             Cache
               |
              RAM

The CPU repeatedly performs:

Fetch
  ↓
Decode
  ↓
Execute

The most important concepts to remember are:

Control Unit coordinates instruction execution.
ALU performs arithmetic and logical operations.
Registers provide extremely fast temporary storage.
Cache keeps frequently accessed data close to the CPU.
Cores allow multiple instruction streams to execute concurrently.
ISA defines the instructions a processor understands.
Pipelining allows multiple instructions to be processed at different stages simultaneously.

When you write:

int result = a + b;

there is an enormous amount of engineering happening underneath that single line.

The more you understand that hidden layer, the easier it becomes to reason about performance, operating systems, compilers, and low-level programming.

How Memory Works (RAM vs Storage)

Shankar L — Sat, 08 Aug 2026 04:30:00 +0000

Why should you care?

If you've ever bought a laptop or smartphone, you've probably seen specifications like:

8 GB RAM
512 GB SSD
1 TB Storage

Many beginners assume RAM and storage are the same thing because both are measured in gigabytes.

They are not.

Understanding the difference between RAM and storage helps you:

Choose the right computer for your needs.
Understand why applications become slow.
Learn how operating systems manage programs.
Build a strong foundation for operating systems and computer architecture.

The Problem

Imagine you have a laptop with:

16 GB RAM
512 GB SSD

A common question is:

"If my SSD is much larger, why can't the computer use it as RAM?"

Another question is:

"Why do applications close when the computer loses power, but my files remain?"

To answer these questions, we need to understand what RAM and storage actually do.

The Concept

A computer has two main places where data is kept.

RAM (Random Access Memory)

RAM is the computer's temporary working memory.

When you open an application:

The operating system loads it from storage into RAM.
The CPU executes instructions from RAM.
Data stays there only while the computer is running.

When power is turned off:

RAM → Everything is erased.

Storage (SSD/HDD)

Storage is the computer's permanent memory.

It stores:

Operating system
Applications
Photos
Videos
Documents
Games

Unlike RAM, storage keeps data even when the computer is turned off.

SSD/HDD → Data remains.

Simple Explanation

Think of your computer like a student studying for an exam.

The bookshelf contains all the books.

The study table is where the student actually works.

In this analogy:

Bookshelf = Storage

Study Table = RAM

You don't study directly from the bookshelf.

You first bring the required books to the table.

Similarly:

Storage

↓

RAM

↓

CPU

↓

Output

Programs must be loaded into RAM before the CPU can execute them.

Real-world Analogy

Imagine you're cooking dinner.

The refrigerator stores all your ingredients.

The kitchen counter is where you prepare the meal.

The chef works on the counter, not inside the refrigerator.

In this analogy:

Refrigerator = Storage
Kitchen Counter = RAM
Chef = CPU

When you're finished cooking, you can:

Put unused ingredients back into the refrigerator.
Clean the counter.

The counter becomes empty.

Likewise, RAM is cleared when the computer shuts down.

Code Example

Consider this simple Java program.

public class Main {
    public static void main(String[] args) {

        int number = 100;

        System.out.println(number);
    }
}

What happens internally?

The Java program is stored on the SSD.
When you run it, the operating system loads it into RAM.
The JVM starts executing the program from RAM.
The CPU performs the calculations.
The output appears on the screen.
When the program closes, its memory is released.

The file remains on the SSD even after execution.

Common Mistakes

Mistake 1

Thinking RAM stores files permanently.

It doesn't.

Anything stored only in RAM disappears after power is lost.

Mistake 2

Believing more storage makes the computer faster.

A larger SSD gives you more space.

It does not necessarily improve performance.

Performance depends on factors such as:

CPU
RAM
SSD speed
Software optimization

Mistake 3

Thinking RAM and storage perform the same job.

They serve completely different purposes.

RAM

Temporary
Fast
Working Memory

Storage

Permanent
Slower
File Storage

Mistake 4

Closing an application does not delete it.

Closing an application removes it from RAM.

The application itself still exists on storage.

Advanced Notes

Why Is RAM Faster?

RAM is designed for extremely fast access.

Typical access times:

Device	Approximate Access Time
CPU Cache	Few nanoseconds
RAM	Tens of nanoseconds
SSD	Tens to hundreds of microseconds
HDD	Several milliseconds

Because RAM is much faster than storage, the CPU can execute programs efficiently.

What Happens When RAM Is Full?

If RAM becomes full:

The operating system moves less frequently used data to storage.
This process is called paging or swapping.
Because storage is much slower than RAM, the computer becomes noticeably slower.

RAM Is Volatile

RAM is volatile memory.

This means:

Power Off

↓

Data Lost

Storage is non-volatile, meaning it keeps data without electricity.

SSD vs HDD

SSD	HDD
No moving parts	Mechanical disks
Faster	Slower
Silent	Makes noise
More durable	More fragile
Lower access time	Higher access time

Most modern computers use SSDs because they significantly reduce application and boot times.

Summary

RAM and storage work together but serve different purposes.

Application Stored on SSD

↓

Operating System Loads It

↓

RAM

↓

CPU Executes Instructions

↓

Program Runs

Remember these key differences:

RAM	Storage
Temporary	Permanent
Very Fast	Slower
Stores running programs	Stores files and applications
Data lost when power is off	Data remains after shutdown

A good way to remember:

Storage remembers everything. RAM remembers only what the computer is using right now.

Bits, Bytes, KB, MB, GB, TB Explained Simply

Shankar L — Fri, 07 Aug 2026 04:30:00 +0000

Why should you care?

Have you ever wondered why:

A photo is 3 MB
A movie is 2 GB
Your laptop has 16 GB RAM
An SSD is 512 GB
Internet speed is advertised as 100 Mbps instead of 100 MBps

These units appear everywhere in computing, yet they're often misunderstood.

Understanding the difference between bits, bytes, and larger storage units will help you understand how computers store data, measure memory, and transfer information over networks.

The Problem

Suppose someone tells you:

This file is 8000 bits.

Another person says:

This file is 1000 bytes.

Are they different?

No.

They represent the same amount of data.

Many beginners confuse bits and bytes, leading to mistakes when comparing storage sizes and internet speeds.

Let's fix that once and for all.

The Concept

Everything inside a computer is stored as binary.

The smallest unit of information is a bit.

Bit

0
or
1

A single bit can represent only one of two values.

To store useful information, computers group bits together.

The most common group is called a byte.

1 Byte = 8 Bits

A byte can represent:

2⁸ = 256

different values.

This is enough to store one ASCII character.

Example:

'A' → 01000001

Simple Explanation

Think of bits as individual LEGO bricks.

One brick alone cannot build much.

When you combine eight bricks, you can build something useful.

Similarly:

1 Bit

↓

8 Bits

↓

1 Byte

Larger groups of bytes are used to measure storage.

Unit	Size
1 Byte (B)	8 Bits
1 Kilobyte (KB)	1024 Bytes
1 Megabyte (MB)	1024 KB
1 Gigabyte (GB)	1024 MB
1 Terabyte (TB)	1024 GB

Every step is multiplied by 1024, not 1000, because computers use binary.

Real-world Analogy

Imagine you're transporting books.

One page is like a bit.
One book is like a byte.
A bookshelf is like a kilobyte.
A library is like a gigabyte.

As the amount of information grows, we use larger units to avoid writing huge numbers.

Instead of saying:

1,073,741,824 Bytes

we simply say:

1 GB

Much easier to read.

Code Example

Java provides constants that make it easy to calculate storage sizes.

public class Main {
    public static void main(String[] args) {

        long KB = 1024;
        long MB = KB * 1024;
        long GB = MB * 1024;
        long TB = GB * 1024;

        System.out.println("1 KB = " + KB + " Bytes");
        System.out.println("1 MB = " + MB + " Bytes");
        System.out.println("1 GB = " + GB + " Bytes");
        System.out.println("1 TB = " + TB + " Bytes");
    }
}

Output:

1 KB = 1024 Bytes
1 MB = 1048576 Bytes
1 GB = 1073741824 Bytes
1 TB = 1099511627776 Bytes

Common Mistakes

Mistake 1

Confusing bits with bytes.

Remember:

b = bit
B = Byte

Example:

100 Mbps

is not the same as

100 MB/s

Mistake 2

Thinking internet speed and file size use the same units.

Storage devices usually use bytes.

Network speeds usually use bits.

Example:

Download Speed

100 Mbps

↓

Actual Maximum Speed

About 12.5 MB/s

Because:

8 bits = 1 byte

Mistake 3

Believing KB always means exactly 1000 bytes.

Traditionally in computing:

1 KB = 1024 Bytes

However, storage manufacturers sometimes use:

1 KB = 1000 Bytes

This is why the available storage on a new hard drive may appear slightly smaller than advertised.

Mistake 4

Thinking one character always uses one byte.

Not always.

ASCII uses one byte.

Unicode encodings like UTF-8 may use one to four bytes depending on the character.

Advanced Notes

Binary Prefixes

To avoid confusion, international standards introduced binary prefixes.

Decimal Prefix	Binary Prefix
KB = 1000 Bytes	KiB = 1024 Bytes
MB = 1000 KB	MiB = 1024 KiB
GB = 1000 MB	GiB = 1024 MiB
TB = 1000 GB	TiB = 1024 GiB

Operating systems and manufacturers do not always display these prefixes consistently.

RAM

When you buy:

16 GB RAM

it means your computer can temporarily store roughly sixteen billion bytes of data while programs are running.

RAM is temporary storage.

Its contents disappear when the computer is turned off.

Storage Devices

Typical storage sizes:

Device	Capacity
USB Drive	16 GB to 256 GB
SSD	256 GB to 4 TB
HDD	1 TB to 20 TB

These values represent how much data can be stored.

Why 1024?

Since computers work in binary:

2¹⁰ = 1024

This is the closest binary value to 1000, making it a natural choice for measuring memory.

Summary

Everything stored inside a computer is ultimately made of bits.

Those bits are grouped into bytes, and bytes are grouped into larger storage units.

1 Bit

↓

8 Bits

↓

1 Byte

↓

1024 Bytes

↓

1 KB

↓

1024 KB

↓

1 MB

↓

1024 MB

↓

1 GB

↓

1024 GB

↓

1 TB

Remember these key facts:

A bit is the smallest unit of data.
One byte contains eight bits.
Storage is usually measured in bytes.
Internet speed is usually measured in bits.
Larger units help us represent huge amounts of data more conveniently.

Understanding these units makes it much easier to compare storage devices, estimate download times, and understand how computers manage information.

Hexadecimal and Why Programmers Use It

Shankar L — Thu, 06 Aug 2026 04:30:00 +0000

Why should you care?

After learning binary, you'll quickly notice a problem.

Binary numbers become very long and difficult to read.

For example:

1111111111111111

Can you tell what number that is at a glance?

Probably not.

This is why programmers often use Hexadecimal (Hex). It is much shorter, easier to read, and maps perfectly to binary.

You'll encounter hexadecimal in many places:

Memory addresses
Colors in web development
Debugging tools
Machine code
Network protocols
Cryptography
File formats

Understanding hexadecimal is an essential skill for every programmer.

The Problem

Computers store everything in binary.

Humans, however, struggle to read long binary numbers.

Consider this binary value:

1111000010101101

It is correct, but not very readable.

Now look at the same value in hexadecimal.

F0AD

Much shorter.

Both represent exactly the same data.

Hexadecimal exists to make binary easier for humans to work with.

The Concept

Hexadecimal is a Base 16 number system.

Instead of using ten symbols like decimal, it uses sixteen.

Decimal	Hex
0	0
1	1
2	2
3	3
4	4
5	5
6	6
7	7
8	8
9	9
10	A
11	B
12	C
13	D
14	E
15	F

After 9, hexadecimal continues with letters.

A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

Simple Explanation

The reason hexadecimal is so useful is simple.

One hexadecimal digit represents exactly 4 binary bits.

Binary	Hex
0000	0
0001	1
0010	2
0011	3
0100	4
0101	5
0110	6
0111	7
1000	8
1001	9
1010	A
1011	B
1100	C
1101	D
1110	E
1111	F

Example:

Binary

1111 0000 1010 1101

Split into groups of four bits.

1111   0000   1010   1101
  F      0      A      D

Result:

1111000010101101₂ = F0AD₁₆

No complicated calculations are required.

Real-world Analogy

Imagine writing a phone number.

Which is easier to remember?

9876543210

Or:

9 876 543 210

Both contain the same information.

The second version is easier to read because it is grouped.

Hexadecimal does something similar for binary.

Instead of looking at sixteen individual bits, programmers look at four hexadecimal digits.

The information is identical, but the representation is much cleaner.

Code Example

Convert a decimal number to hexadecimal in Java.

public class Main {
    public static void main(String[] args) {

        int number = 255;

        System.out.println(Integer.toHexString(number));
    }
}

Output:

ff

Convert hexadecimal back to decimal.

public class Main {
    public static void main(String[] args) {

        String hex = "FF";

        int decimal = Integer.parseInt(hex, 16);

        System.out.println(decimal);
    }
}

Output:

You can also display hexadecimal values with the common 0x prefix.

int value = 0xFF;

System.out.println(value);

Output:

Common Mistakes

Mistake 1

Thinking hexadecimal is another way of storing data.

It is not.

Computers still store everything in binary.

Hexadecimal is simply a human-friendly representation of binary.

Mistake 2

Treating A through F as characters.

In hexadecimal:

A = 10
B = 11
C = 12
D = 13
E = 14
F = 15

They are digits, not letters.

Mistake 3

Forgetting the base.

The number:

has different meanings depending on its base.

10₂  = 2
10₁₀ = 10
10₁₆ = 16

Always know which number system you are working with.

Mistake 4

Ignoring the 0x prefix.

Many programming languages write hexadecimal numbers like this:

0x1A
0xFF
0xABC

The prefix tells the compiler that the value is hexadecimal.

Advanced Notes

Memory Addresses

Most debuggers display memory addresses in hexadecimal.

Example:

0x7FFE9A34

Hexadecimal makes addresses much shorter than binary.

Web Colors

Every color on a web page is written in hexadecimal.

#FFFFFF

White

#000000

Black

#FF0000

Red

Each pair represents the intensity of:

Red
Green
Blue

Bytes and Hex

One byte contains 8 bits.

Since one hexadecimal digit represents 4 bits:

8 Bits = 2 Hex Digits

Example:

This relationship makes hexadecimal ideal for representing bytes.

Debugging

When debugging applications, you will often see:

Error codes
Memory dumps
CPU registers
Machine instructions

These are usually displayed in hexadecimal because it is compact while still maintaining a direct relationship with binary.

Summary

Binary is the language computers understand.

Hexadecimal is the language programmers use to read binary more easily.

Decimal

255

↓

Binary

11111111

↓

Hexadecimal

FF

Remember these key facts:

Hexadecimal is Base 16.
It uses digits 0 to 9 and letters A to F.
One hexadecimal digit equals four binary bits.
Two hexadecimal digits equal one byte.
Computers store binary, not hexadecimal.

Once you understand hexadecimal, topics like memory, networking, operating systems, and low-level programming become much easier to explore.

Suggested additions:

Programs for converting between decimal, binary, and hexadecimal.
Practice problems with solutions.
A cheat sheet showing every 4-bit binary group and its hexadecimal equivalent.
Diagrams explaining how bytes map to hexadecimal values.

Binary Numbers Explained Without Confusion

Shankar L — Wed, 05 Aug 2026 04:30:00 +0000

Why should you care?

Every piece of data inside a computer is stored using binary. Whether it is a photo, a video, a game, a document, or the program you wrote yesterday, everything eventually becomes a sequence of 0s and 1s.

Understanding binary is one of the first steps toward learning how computers really work. It also makes topics like memory, networking, data structures, operating systems, and computer architecture much easier to understand.

If you have ever wondered why computers use only two numbers instead of ten, this article is for you.

The Problem

Humans naturally count using decimal numbers.

0 1 2 3 4 5 6 7 8 9

Computers, however, use only:

0 1

This raises a few obvious questions.

Why only two numbers?
How can a computer represent large numbers with only 0 and 1?
How can letters, images, music, and videos all be represented using binary?

The answer starts with understanding how computer hardware works.

The Concept

A computer is built from billions of tiny electronic switches called transistors.

Each transistor has only two stable states.

OFF
ON

We represent these states as:

OFF = 0
ON  = 1

Because hardware naturally works with two states, computers use the Binary Number System, also known as Base 2.

Unlike our decimal system, which has ten digits, binary has only two.

Simple Explanation

Think of binary as another way of counting.

Decimal uses powers of 10.

10³ 10² 10¹ 10⁰

Binary uses powers of 2.

2⁷ 2⁶ 2⁵ 2⁴ 2³ 2² 2¹ 2⁰

Every position represents a power of two.

For example:

Binary: 1011

Position: 2³ 2² 2¹ 2⁰
Values:     8  4  2  1
Digits:     1  0  1  1

Now multiply each digit by its value.

1 × 8 = 8
0 × 4 = 0
1 × 2 = 2
1 × 1 = 1

Total = 11

So:

1011₂ = 11₁₀

The small numbers indicate the number system being used.

Real world Analogy

Imagine four light switches.

Each switch can only be:

OFF
ON

Suppose each switch has a value.

8 4 2 1

Now turn on only the switches worth 8, 2, and 1.

ON  OFF  ON  ON

1    0    1    1

The total becomes:

8 + 2 + 1 = 11

This is exactly how binary numbers work.

Every bit is simply another switch.

Code Example

Java makes it easy to work with binary numbers.

public class Main {
    public static void main(String[] args) {

        int decimal = 13;

        System.out.println(Integer.toBinaryString(decimal));
    }
}

Output:

To convert a binary string back into a decimal number:

public class Main {
    public static void main(String[] args) {

        String binary = "1101";

        int decimal = Integer.parseInt(binary, 2);

        System.out.println(decimal);
    }
}

Output:

Common Mistakes

Mistake 1

Reading binary like a decimal number.

For example:

This is not one thousand and ten.

It represents:

8 + 2 = 10

Mistake 2

Ignoring place values.

Each position in binary represents a power of two, not a power of ten.

128 64 32 16 8 4 2 1

Always start counting from the rightmost bit.

Mistake 3

Thinking more digits always mean a larger decimal number.

Compare:

1111 = 15

10000 = 16

Adding one more bit increases the range dramatically.

Mistake 4

Confusing bits and bytes.

A bit is a single binary digit.

A byte contains 8 bits.

Example:

11001010

Advanced Notes

Binary Prefixes

Computers group binary digits into larger units.

Unit	Size
1 Bit	0 or 1
1 Nibble	4 Bits
1 Byte	8 Bits
1 Kilobyte	1024 Bytes
1 Megabyte	1024 KB
1 Gigabyte	1024 MB

Why 8 Bits?

Eight bits can represent:

2⁸ = 256

different values.

That is enough to store characters, colours, and many small numbers efficiently.

Signed Numbers

Computers also represent negative numbers.

Most modern systems use Two's Complement, allowing positive and negative numbers to be stored efficiently using the same binary representation.

This is a topic worth learning once you are comfortable with basic binary.

Binary Beyond Numbers

Binary is not just used for integers.

Everything eventually becomes binary.

For example:

Characters use ASCII or Unicode.
Images store colour values as binary.
Audio stores sound samples as binary.
Videos are sequences of binary encoded frames.
Programs themselves are binary instructions executed by the CPU.

Binary is the universal language of computers.

Summary

Binary may look unfamiliar at first, but it is simply another number system.

Instead of using ten digits, it uses only two.

Decimal
0 1 2 3 4 5 6 7 8 9

Binary
0 1

Each binary digit represents a power of two.

128 64 32 16 8 4 2 1

Understanding binary helps explain:

How computers store numbers.
How memory works.
How processors execute instructions.
How files and programs are represented internally.

Master binary once, and many advanced computer science topics become much easier to understand.

Topics to explore next

Decimal to Binary Conversion
Binary to Decimal Conversion
Hexadecimal Numbers
Octal Number System
Bits vs Bytes
ASCII and Unicode
Two's Complement
Bitwise Operators

How a Computer Actually Runs Your Code

Shankar L — Sun, 19 Jul 2026 04:30:00 +0000

Why should you care?

Every developer writes code every day, but very few understand what actually happens after pressing the Run button.

Whether you write Java, Python, C++, or JavaScript, your code does not magically execute. It goes through several transformations before the CPU can understand it.

Understanding this process helps you:

Write better and more efficient code.
Debug errors more effectively.
Learn programming languages faster.
Understand compilers, interpreters, virtual machines, and operating systems.
Build a strong foundation for system design, operating systems, and computer architecture.

Programming becomes much easier when you know what is happening behind the scenes.

The Problem

Imagine writing the following Java program.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

You click Run.

A second later, your terminal prints:

Hello World

But how?

Your computer only understands electrical signals represented as binary instructions consisting of 0s and 1s.

It does not understand words like:

System.out.println()

print()

cout

So who translates your code into something the processor can execute?

The Concept

Every program follows a pipeline before it reaches the CPU.

Source Code
      ↓
Compiler / Interpreter
      ↓
Machine Instructions
      ↓
Operating System
      ↓
CPU Execution
      ↓
Output

Each stage has a specific responsibility.

Step 1: You write source code

This is the human readable program.

Example:

print("Hello")

System.out.println("Hello");

Humans understand this language.

Computers do not.

Step 2: Translation

This stage depends on the programming language.

Compiled languages like C++ convert the entire program into machine code before execution.

C++ Code
      ↓
Compiler
      ↓
Executable (.exe)

Interpreted languages like Python execute the program one statement at a time.

Python Code
      ↓
Interpreter
      ↓
Execution

Languages like Java use a hybrid approach.

Java Code
      ↓
Java Compiler
      ↓
Bytecode
      ↓
JVM
      ↓
Machine Code

Step 3: Operating System

The operating system loads the program into memory.

It provides the program with resources such as:

RAM
CPU time
File access
Keyboard input
Display output

Without an operating system, most applications would not know how to communicate with hardware.

Step 4: CPU Execution

The CPU executes instructions using a continuous cycle.

Fetch
Decode
Execute
Repeat

For every instruction, the processor:

Fetches the next instruction from memory.
Decodes what the instruction means.
Executes it.
Moves to the next instruction.

This cycle repeats billions of times every second.

Simple Explanation

Think of programming languages as different spoken languages.

You may speak English.

Someone else speaks Japanese.

The CPU speaks only one language.

Machine code.

Every programming language must eventually be translated into machine instructions before execution.

No exceptions.

Real world Analogy

Imagine ordering food at a restaurant.

You tell the waiter:

"I want a pizza."

The waiter writes your order in a format the kitchen understands.

The chef prepares the pizza.

The waiter brings it back to you.

In this analogy:

You are the programmer.
Your source code is your order.
The compiler or interpreter is the waiter.
The CPU is the chef.
The finished dish is the program output.

You never communicate directly with the chef.

Similarly, your code never communicates directly with the CPU.

A translator is always involved.

Code Example

Consider this simple C program.

#include <stdio.h>

int main() {
    int a = 5;
    int b = 3;

    printf("%d", a + b);

    return 0;
}

The compiler converts this into thousands of machine instructions.

Conceptually, the CPU performs operations similar to:

LOAD 5
LOAD 3
ADD
STORE RESULT
PRINT RESULT

The actual machine instructions are much more complex, but the idea remains the same.

Every high level instruction eventually becomes low level CPU instructions.

Common Mistakes

Mistake 1

Believing the CPU understands Java, Python, or C++ directly.

Reality:

The CPU only understands machine code.

Mistake 2

Thinking compiled languages are always faster.

Reality:

Performance depends on many factors including compiler optimizations, runtime environment, memory management, and the algorithm itself.

Mistake 3

Confusing the compiler with the operating system.

The compiler translates code.

The operating system manages resources and executes programs.

They solve different problems.

Mistake 4

Assuming one line of code equals one CPU instruction.

In reality, one line of source code may become dozens or even hundreds of machine instructions.

Advanced Notes

Once you understand the basic pipeline, you can explore what happens internally.

Compiler Optimizations

Modern compilers rewrite your program to make it faster without changing its behavior.

Examples include:

Dead code elimination
Function inlining
Constant folding
Loop unrolling

Virtual Machines

Java and C# use virtual machines.

Instead of producing machine code immediately, they generate intermediate code.

The virtual machine later converts this into optimized machine instructions during execution.

This technique is known as Just In Time compilation.

CPU Cache

The processor stores frequently used instructions and data in small, high speed memory called cache.

Accessing cache is much faster than accessing RAM.

Understanding cache becomes important when optimizing performance.

System Calls

Whenever your program reads a file, accesses the internet, or prints text to the terminal, it requests the operating system to perform those tasks through system calls.

User programs cannot directly control hardware.

Summary

Every program follows a journey before producing output.

You write code
        ↓
Compiler or Interpreter translates it
        ↓
Operating System loads it
        ↓
CPU executes machine instructions
        ↓
Output appears

Once you understand this pipeline, many advanced topics become easier to learn, including operating systems, compilers, computer architecture, memory management, and system design.

Every programming language may look different on the surface, but underneath they all follow the same fundamental path to reach the CPU.