A process does not have exclusive ownership of the processor. If it did, a single file download or input wait would freeze your entire system. To keep the computer responsive, the Operating System must constantly swap processes in and out of execution.
For the Kernel to coordinate this dance, it must know exactly what each process is doing at any given millisecond.
* Is it actively executing?
* Is it waiting for a key press?
* Is it ready to run, but waiting for its turn?
To track this, the Kernel manages every process through a formal Process Lifecycle.
The State Machine of Life
At any moment, a process exists in one of five primary states. The transitions between these states form a precise state machine managed entirely by the Kernel.
Tracing the States
Let's understand what happens inside each of these moments:
1. New
The process is being born. The Kernel reads your executable program from disk, allocates a memory space (Process Control Block), but has not yet loaded it into the main scheduling queue. It is a blueprint waiting to be registered.
2. Ready
The process is fully loaded in RAM. It has everything it needs to run—its variables are initialized, its memory structure is set—except CPU execution time. It stands in line (the Ready Queue) waiting for the Kernel to hand it the processor.
3. Running
The Kernel has dispatched the process. The CPU is actively executing its assembly instructions. Only one process can run on a single CPU core at any literal microsecond.
4. Waiting / Blocked
The process cannot execute, even if the CPU is free. It is waiting for an external event to complete.
* Disk Access: Waiting for a block of file data to load.
* Keyboard Input: Stalled until the user presses a key.
* Network Packet: Waiting for data to arrive over a socket.
* Timer: Sleeping for a specified number of milliseconds.
5. Terminated
The process has finished executing its code or was stopped by the system. The Kernel reclaims its memory space, releases its file descriptors, and cleans its tracking metrics. It is now a memory.
Why Do States Change?
A process never changes state arbitrarily. Transitions are driven entirely by hardware and software events.
Consider the typical journey of an application loading a file:
1. Running: The process starts reading a file. Because disk access takes millions of CPU cycles, continuing to sit on the CPU would stall the system.
2. Waiting: The process yields the CPU and enters the Waiting state. The Kernel parks it away. The CPU is now completely free to run other ready tasks.
3. Ready: Once the disk controller reads the file, it fires an interrupt. The Kernel realizes the data is ready, pulls the process out of the Waiting pool, and moves it to the Ready queue.
4. Running Again: The Kernel selects the process from the Ready queue and schedules it onto the CPU. The process picks up exactly where it left off, reading the loaded memory.
Why States Matter
Imagine a modern operating system running hundreds of processes simultaneously. Behind the scenes, the Kernel behaves like a coordinator in a chaotic theater. It must continuously maintain lists:
* Which process is currently using the processor? (Running)
* Which processes are locked, waiting for files, keys, or networks? (Waiting)
* Which processes are complete and need their resources cleaned up? (Terminated)
* Which processes are ready to run right now? (Ready)
This constant shifting is the heartbeat of a responsive system. But as processes stream into the Ready queue, a critical dilemma emerges.
If there are ten processes standing in the Ready line, but only one processor core available, they cannot all execute at once.
Who decides which process is pulled out of line and given the CPU next?
And how do we ensure that every process gets a fair turn without starvation?
Engineering concepts you don't just read — you experience.
Founded in 2026.
PrajnaEdge is a technology company exploring the space between understanding technology, experimenting with ideas, and turning them into things that can be experienced.
Our Mission
To make technology easier to explore, deeper to understand, and more exciting to experience.
Our Vision
To build a technology ecosystem where curiosity, experimentation and creation continuously lead to one another.
Where it began
Embedded Systems
PrajnaEdge began with Embedded Systems — exploring the foundations that connect hardware, software and intelligent computation.
The first technology universe is built around that foundation. The journey will expand as new ideas, experiments and products emerge.
I am the engineer behind the design, development, and content of PrajnaEdge. I build low-level systems where code directly controls hardware, bridging the gap between register-level silicon behavior and intelligent edge decision loops.
I am an Embedded Firmware Engineer focused on developing software for resource-constrained systems. My experience spans bare-metal firmware, device drivers, microcontroller peripherals, and communication protocols, working across the boundary between hardware and software.
My work has involved microcontroller-based systems, real-time behaviour, hardware interfaces, and communication technologies such as CAN, CAN FD, UART, SPI, and I²C. I am particularly interested in understanding systems from the lowest level upward—from registers and peripherals to intelligent edge systems.
ENGINEERING PHILOSOPHY
Engineering is not just about writing code; it is about managing constraints, timings, and physical hardware characteristics. True mastery of complex systems comes from understanding the interactions across different layers of the stack.
This conviction is why I built PrajnaEdge—to bridge the gap between conceptual theory and direct, register-level physical reality.
Open to collaborations, research, and interesting engineering conversations.
Help Improve PrajnaEdge
Found something to improve? I'd love to hear your thoughts.
Bare Metal
Software that runs directly on hardware without an operating system.
Applications
↑
Operating Systems
YOU ARE HERE
Bare Metal
Processor
↑
Hardware
"Every embedded application begins long before main()."
Operating Systems
An Operating System manages hardware and software resources so complex applications can work efficiently.
Applications
↑
YOU ARE HERE
Operating Systems
Bare Metal
↑
Processor
↑
Hardware
"When one loop is no longer enough to carry the burden."
Support PrajnaEdge
PrajnaEdge is an independent education platform built to make knowledge freely accessible.
If you find PrajnaEdge useful, you can support its continued development.
Your support helps fund the time, tools, infrastructure, and experimentation that go into building and maintaining PrajnaEdge.
Select Region
Select Amount
₹
Select an amount to support PrajnaEdge.
Legal Information
Product Terms & Licensing
1. Terms of Use
PrajnaEdge is an interactive learning platform designed for systems engineers, developers, and technology enthusiasts. The educational materials, simulation blocks, and visual code tracers are provided for instruction and concept validation. We make no warranty regarding their completeness or applicability to real-world industrial systems.
PrajnaEdge is committed to learning privacy. We do not sell user data. Analytical event tracking is used solely to study click telemetry and help improve visual guides.
