Process

Definitions

Process is an instance of a program in execution, representing one of the fundamental concepts in operating systems. When you launch an application, the OS creates a process that includes the program's code, its current activity (represented by the program counter and registers), a stack for function calls and local variables, a heap for dynamic memory allocation, and the process's own virtual address space. Each process is isolated from others by the OS's memory protection, preventing one process from accidentally or maliciously accessing another's memory. Processes are managed by the operating system's scheduler, which allocates CPU time to each process and handles context switching between them. Processes can spawn child processes using system calls like fork() on Unix. Inter-process communication (IPC) mechanisms including pipes, shared memory, message queues, and sockets allow processes to exchange data despite their isolation. A process contains one or more threads that share its address space but maintain their own execution stacks, enabling concurrency within a single process.
In plain English: A running copy of a program with its own private workspace in memory. Your computer runs hundreds of them simultaneously, each isolated so one crashing does not take down the rest.
Example: "Each request spawns a new process — slow to start but impossible for one bad request to crash the others."

1960s: The Multics operating system introduced the concept of a 'process' as an instance of a running program with its own address space, program counter, and system resources.
1970s: Unix refined the process model with fork() and exec(). Each process had a PID, environment, file descriptors, and a parent-child hierarchy rooted at init (PID 1).
1990s: Lightweight processes (threads) emerged as a way to share memory within a process. The distinction between processes (isolated) and threads (shared) became fundamental OS knowledge.
2010s-Present: Containers (cgroups, namespaces) created isolated process groups. Modern systems manage millions of processes across orchestrators like Kubernetes, but the 1960s abstraction remains the core unit.