Operating Systems

Modern computer hardware is complicated: a processor, banks of memory, storage devices and dozens of peripherals all have to work together. Writing every application to control that hardware directly would be impossible. The operating system (OS) solves this by acting as a layer between the hardware and everything above it.

A useful way to picture it is as layers:

The OS does two big jobs:

1. It manages the computer's resources — the CPU, the memory, the storage and the peripherals — sharing them between programs and the user.
2. It provides an interface (a platform) so the user can interact with the machine and applications can run, without having to deal with the hardware directly. This hiding of detail is sometimes called abstraction.

Without an OS, an ordinary computer could not load programs, manage files, share the processor between tasks, or let you use a keyboard and screen in the way you expect.

The syllabus expects you to describe five key management tasks. Learn each one with a short example — the example is usually what secures the mark.

Task	What it does	Example
Memory management	Allocates and reclaims RAM; keeps processes' memory separate	Gives a program space in RAM when it loads
Process management	Schedules CPU time between running programs	Decides which process runs next
File management	Organises files into folders; controls save/open/delete	Builds the folder structure on a disk
Security management	Controls who can access the computer and its data	User accounts, passwords, access rights
Hardware management	Controls input/output devices and peripherals	Uses a device driver to print a document

Two of these are very commonly confused, so pin them down:

• Memory management is about SPACE — handing out and reclaiming areas of RAM.
• Process management is about TIME — sharing the single processor's time so that many programs appear to run at once.

Why keep processes' memory separate? If one program could write over another program's memory, a single faulty (or malicious) program could crash or corrupt others. Memory management enforces separation, which makes the system more stable and more secure.

Memory management in detail. When you open a program, it must be loaded into main memory (RAM) to run. The OS:

• allocates an area of RAM to the program,
• deallocates (reclaims) that memory when the program closes so it can be reused,
• keeps each process's memory separate so they cannot corrupt one another, and
• keeps track of which memory is free and which is in use.

This careful tracking lets the computer run more programs efficiently and share a limited resource fairly.

Process management in detail. A computer with a single processor core can only execute one instruction at a time. Yet you can have a browser, a music player and a word processor open together. The OS achieves this by scheduling:

• it decides which process runs next and for how long,
• it switches rapidly between processes, and
• it keeps track of each process's state (e.g. running, ready, waiting).

The switching is so fast that, to the user, the programs seem to run simultaneously — this is called multitasking.

Utility software is system software that performs a specific maintenance or housekeeping task to keep the computer running well. It is not application software (it is not the user's task, like writing a document) — it looks after the system itself.

You need to know the purpose of each of these utilities from the syllabus:

Utility	Purpose
Disk formatter	Prepares a disk for use by setting up its file system / erasing existing data
Virus checker (anti-virus)	Detects, quarantines and removes malware to protect the system
Defragmentation software	Reorganises fragmented files into contiguous blocks (magnetic disks) to speed up access
Disk contents analysis / disk repair	Analyses how disk space is used and finds/fixes errors on the disk
File compression	Reduces file size to save storage and speed up transfer
Back-up software	Copies files to another medium/location so they can be restored if lost

Defragmentation — how it works. Over time, as files are saved and deleted, free space gets broken up and files end up split into fragments stored in non-adjacent sectors. The read/write head then has to move to several places to read one file, slowing things down. Defragmentation gathers each file's fragments back together (and groups the free space), so the head moves less and access is faster.

Important condition: defragmentation helps magnetic hard disk drives (HDDs), which have a moving head. Solid-state drives (SSDs) have no moving head, so defragmenting them gives no speed benefit and only adds unnecessary wear.

Software is rarely written entirely from scratch. Developers reuse program libraries — collections of pre-written, pre-tested code (routines, functions or classes) that perform common tasks. Instead of re-writing, say, code to draw graphics or do encryption, a developer can pull in a library that already does it.

Benefits of using a library:

• Faster development — the work is already done, so the program is finished sooner.
• Fewer bugs / higher reliability — the library code has already been tested and used by many others.
• Consistency — the same well-understood code is reused across programs.

A library is not a finished program that an end user runs on its own — it is a building block that developers incorporate into their own programs.

A Dynamic Link Library (DLL) is a special kind of library. The key idea is when the linking happens:

• With code compiled into a program (statically), the library code becomes part of the executable file.
• With a DLL, the library is linked to the program at run time — kept as a separate file and connected only when the program actually runs.

Because of run-time linking, DLLs give the developer clear benefits:

• Smaller executables — the library code is not built into the program file.
• Shared between programs — several programs can use the same single copy of the DLL on disk and in memory, saving space.
• Easier updating/maintenance — if the shared code needs fixing or improving, only the DLL is replaced; the programs that use it don't need to be recompiled or reinstalled and automatically benefit from the update.

Exam tip: start a DLL answer with the fact 'a DLL is linked at run time'. Every benefit (smaller executable, shared copy, update without recompiling) flows from that one idea.