Operating System

An operating system (OS) is the master program that sits between you and the hardware — the manager the first topic in this series named in passing — and its job is to run all the other programs, share the computer's hardware fairly among them, and give both you and those programs a simple, consistent way to use the machine instead of dealing with raw hardware directly. Windows, macOS, Linux (including the Ubuntu system the working-with-a-computer topic used for its examples), Android, and iOS are all operating systems; the device looks very different in each case, but the underlying responsibilities are the same. The first responsibility is process management: as the how-programs-run topic described, each running program is a process, and because the computer has far more programs open than it has CPU cores, the OS decides which process gets to use a core and for how long, switching between them many times a second so that everything appears to run at once. The second is memory management: the OS hands each process its own private region of the RAM introduced in the first topic, keeps one program from reading or corrupting another's memory, and uses a trick called virtual memory to let the total memory programs think they have exceed the physical RAM actually installed, by temporarily parking rarely-used data on the slower storage drive. The third is the file system: the files and directories from the working-with-a-computer topic are not physically laid out on the disk as neat folders — the OS maintains that tidy tree as a convenient illusion on top of raw numbered storage blocks, so that you and your programs can open `report.txt` by name without ever knowing where its bytes actually sit. The fourth is device management through drivers: a device driver is a small piece of OS software that knows how to talk to one specific kind of hardware — a particular printer, keyboard, or graphics card — so that ordinary programs can say "print this" or "draw this" in a general way and let the OS translate that into the exact signals the attached device needs. Tying these together is a boundary between two modes: your programs run in a restricted user mode and cannot touch hardware directly, while the core of the OS, the kernel, runs in a privileged kernel mode; whenever a program needs something only the OS may do — open a file, send data over the network, allocate memory — it makes a system call, a controlled request that crosses from user mode into the kernel and back. This design is what lets a single computer safely run many programs written by many different people at once: the OS is the referee that enforces the rules, shares the hardware, and keeps one misbehaving program from taking down the whole machine.

You and your programs
open files, print, browse — without touching hardware directly
Operating system
the manager and referee that shares the hardware fairly
Processes
decides which program uses a CPU core, and when
Memory
gives each program its own private slice of RAM
Files
maintains the folder tree on top of raw storage blocks
Devices
drivers translate general requests into hardware signals
Hardware
CPU, RAM, storage, and attached devices
The OS Sits Between Programs and Hardware a layered stack, with the kernel as the privileged middle Your programs (user mode) browser, editor, music player — restricted, no direct hardware access system call crosses the boundary Operating system kernel (kernel mode) Schedulerprocesses Memory mgrRAM + virtual File systemthe folder tree Driverstalk to devices Hardware CPU, RAM, storage, keyboard, screen, network card
Sharing One Core Among Many Programs the scheduler gives each process a short turn, then switches time -> Browser Music Editor Browser Music switch switch switch switch each turn is a tiny fraction of a second, so to you all three programs appear to run at the same time on a single core

Take operating system further

Ask the copilot about this term, or have our engineers assess it against your process.