Definition
The operating system (OS) is referred to as the 'central controller' because it manages and coordinates every hardware and software resource on the computer — the CPU, memory, storage, input/output devices, and all running programs — making sure they work together without conflict.
The OS acts as a translator between the user and hardware because users and application programs interact with simple commands and interfaces, while hardware only understands low-level electrical signals — the OS converts high-level requests (like 'open this file' or 'print this document') into the precise low-level instructions the hardware needs, and translates hardware responses back into something the user/program can use.
In a multi-user environment, the OS ensures fair and secure resource sharing among users: each user's data and processes stay separate and protected, CPU time and memory are allocated fairly, and one user's actions can't improperly interfere with another's. Four responsibilities of an OS in a multi-user environment: user authentication/access control, fair CPU scheduling among users, memory protection between users' processes, and file/resource permission management.
Definition
The kernel is the core part of the OS that interacts directly with hardware, managing the CPU, memory, and devices at the lowest level.
The shell is the user-facing layer that lets a person interact with the OS — a graphical shell (GUI) allows the user to interact using visual elements like windows, icons, and menus (clicking and dragging), rather than typing text commands.
Kernel and shell differ in exactly this way: the kernel works directly with hardware and is normally hidden from the user, while the shell is the visible interface the user directly interacts with, which then passes the user's requests down to the kernel to actually carry out.
Definition
The layered/modular design of an OS organizes its functions into layers, each only interacting with the layers directly above and below it: the lower layer sits closest to hardware (handling device control and low-level operations), the middle layer handles core OS services (like process/memory/file management), and the upper layer provides the interface and services applications and users directly interact with (like the shell and system utilities) — this separation makes the OS easier to design, maintain, and update, since a change in one layer doesn't require rewriting the others.
Definition
A system call is a request an application program makes to the OS's kernel, asking it to perform a privileged operation the program itself isn't allowed to do directly (like reading a file, allocating memory, or creating a new process) — this controlled access keeps the system stable and secure. The system call used to create a new process is commonly called `fork()` (in Unix-like systems).
Three types of system calls: process control (e.g. creating/terminating processes), file management (e.g. opening/reading/writing files), and device management (e.g. requesting/releasing a device).
A system library is a collection of pre-written, reusable code that applications can call on to perform common tasks without writing that code themselves — e.g. a graphics library providing ready-made functions for drawing shapes on screen, saving every application from implementing that from scratch.
A device driver is specialized software that lets the OS communicate with a specific piece of hardware (like a printer or graphics card) — unlike a general-purpose system library used by many programs for common tasks, a device driver is narrowly written for one particular device's specific commands and behaviour.
Definition
Multitasking is a computer system's ability to run multiple processes (programs) seemingly simultaneously, by rapidly switching the CPU's attention between them.
Multitasking and concurrency are related but distinct: multitasking specifically refers to the OS-level management technique of interleaving multiple processes on available CPU(s); concurrency is the broader concept of multiple tasks making progress during overlapping time periods, which can happen through multitasking (rapid switching on one CPU) or true parallel execution (multiple CPU cores running different tasks genuinely simultaneously).
Threads are smaller units of execution within a single process; threads in the same process share that process's memory space and resources, letting them communicate and cooperate efficiently, unlike separate processes which normally have isolated memory.
Two benefits of multithreading: it can improve performance by letting independent parts of a program run concurrently (e.g. one thread handling user input while another loads data), and it makes efficient use of CPU idle time (when one thread is waiting, e.g. for disk access, another thread can use the CPU).
Definition
In FCFS (First-Come, First-Served) scheduling, processes are served strictly in the order they arrive, with no preemption once a process starts running.
One advantage of FCFS: it's simple to understand and implement, requiring no complex decision-making about which process to run next. One disadvantage: a long process arriving first can make every later process wait a long time (the 'convoy effect'), even if those later processes are much shorter.
Example 1 — FCFS scheduling calculation
Three processes arrive as: (arrival , burst ), (arrival , burst ), (arrival , burst ). Using FCFS, find each process's completion time, turnaround time, and waiting time.
- starts at (first to arrive), runs for , completes at .
- arrives at but must wait for ; starts at , runs for , completes at .
- arrives at but must wait for ; starts at , runs for , completes at .
- Turnaround time completion arrival: ; ; .
- Waiting time turnaround burst: ; ; .
Answer: Completion times: ; turnaround times: ; waiting times: (average waiting time )
Definition
RAM is fast, directly accessible memory the CPU uses for actively running programs and data. Virtual memory extends this by using space on a storage device (commonly a hard disk or SSD) as an overflow area when RAM becomes full, letting the system run more/larger programs than physical RAM alone would allow.
Virtual memory is slower than RAM because storage devices (even fast SSDs) have much longer access times than RAM chips — reading or writing data to disk-based virtual memory takes noticeably longer than accessing the same data directly in RAM, since RAM is built and connected specifically for very fast electronic access.
The file system is responsible for organizing, storing, naming, and retrieving files on a storage device, and for managing metadata about each file.
Metadata is data describing a file (rather than the file's actual content) — it usually includes information like the file's name, size, creation/modification date, file type, and access permissions.
NTFS (New Technology File System) is the file system commonly used by Windows operating systems.
Definition
A Real-Time Operating System (RTOS) is designed to respond to inputs within a strict, guaranteed deadline — used in critical systems like air traffic control, where a delayed response could be dangerous, not just inconvenient.
An Embedded Operating System is mainly used in dedicated, single-purpose devices (like washing machines, digital cameras, or car control systems) rather than general-purpose computers, typically built to be lightweight and reliable for that one specific task.
A Network Operating System (NOS) is mainly used to manage and coordinate shared resources (like files, printers, and network connections) across multiple computers connected in a network.
A Mobile Operating System is designed specifically for smartphones/tablets; key features it supports include touch-screen interaction, mobile app management, power/battery efficiency, and wireless connectivity (Wi-Fi, cellular, Bluetooth).
Definition
In Windows, a new user account can be created via the Settings app (Accounts section) or the Control Panel's User Accounts option.
Quick Recap
- ●OS central controller translator between user and hardware; manages fair/secure sharing in multi-user environments
- ●Kernel (core, talks to hardware) vs shell (user interface, e.g. GUI); layered design: lower (hardware) middle (core services) upper (user-facing)
- ●System calls: controlled requests to the kernel (process control, file management, device management); system library (reusable code) vs device driver (one specific device)
- ●Multitasking (interleaved processes) vs concurrency (broader, overlapping progress); threads share a process's memory, enabling multithreading benefits
- ●FCFS scheduling: serves in arrival order; simple but suffers from the convoy effect; turnaround completion arrival, waiting turnaround burst
- ●RAM (fast) vs virtual memory (disk-based, slower, extends RAM); file system manages files metadata; NTFS Windows's file system
- ●OS types: RTOS (strict deadlines, e.g. air traffic control), Embedded (single-purpose devices), NOS (shared network resources), Mobile (touch, apps, battery, wireless)
