You are viewing a free preview of this lesson.
Subscribe to unlock all 10 lessons in this course and every other course on LearningBro.
This lesson establishes what system software is and surveys its four major categories — operating systems, utility software, libraries and translators — explaining the role each plays in keeping a computer usable. It gives the systems-level overview; the deep mechanics of the OS, memory management, scheduling and translators each have their own dedicated lessons that this one points you towards.
This lesson develops OCR H446 section 1.2.1 (Systems Software). It introduces the categories of system software and the distinction between system software and application software, then frames the operating system as the central piece — work that is expanded in the Operating System Functions, Memory Management and Scheduling Algorithms lessons. It also names libraries and translators as system software; translators themselves are developed fully in the dedicated Translators lesson, and language levels in Types of Programming Language. Keep this lesson as your map of the territory and follow the cross-references for depth.
System software is any software whose job is to manage the computer's hardware, control the machine itself, and provide a stable platform on which application software can run. It sits between the user and the bare metal: when you double-click an icon, system software is what loads the program into memory, gives it CPU time, lets it read a file, and paints its window on the screen. The user is often unaware of it because it works in the background — but nothing else runs without it.
It is helpful to think in layers. Hardware sits at the bottom. System software wraps the hardware and exposes it through a controlled interface. Application software sits on top and never touches the hardware directly — it asks the operating system to do hardware work on its behalf.
flowchart TB
U["User"]
APP["Application Software<br/>(browser, word processor, game)"]
OS["Operating System<br/>(kernel + services)"]
LIBUTIL["Libraries & Utility Software"]
HW["Hardware<br/>(CPU, RAM, disk, peripherals)"]
U --> APP
APP --> OS
APP --> LIBUTIL
LIBUTIL --> OS
OS --> HW
| Feature | System Software | Application Software |
|---|---|---|
| Purpose | Manages hardware and provides services for applications | Performs specific tasks for the user |
| Examples | Operating system, device drivers, utilities, libraries, compilers | Word processor, web browser, games, spreadsheet |
| User interaction | Often runs in the background; user may not interact directly | User interacts directly |
| Installed by | Usually pre-installed or installed as part of setup | Installed by the user as needed |
| Dependency | Runs without application software present | Cannot run without system software underneath |
| Generality | General-purpose — serves all applications | Special-purpose — solves one problem domain |
A useful test in the exam: ask "is this software here to make the machine work, or to do a job for the human?" A compiler turns your source into a runnable program, so it serves the machine's role of being programmable — it is system software. A spreadsheet helps a human do accounts — it is application software. The boundary is occasionally blurry (a file manager is arguably both), but the purpose test resolves almost every case examiners set.
OCR groups system software into four families. The rest of this lesson takes each in turn at overview level.
| Category | One-line role | Where it is developed in depth |
|---|---|---|
| Operating system | Manages all hardware resources and provides a platform and interface | Operating System Functions, Memory Management, Scheduling Algorithms |
| Utility software | Small maintenance and optimisation tools that keep the system healthy | This lesson |
| Libraries | Pre-written, reusable, tested code that programs link to instead of re-writing | This lesson |
| Translators | Convert source code (assembly or high-level) into machine code | Translators, Types of Programming Language |
The operating system is the most important piece of system software. It manages all the hardware resources and provides an environment in which application software can run. Without an OS, every application would have to contain its own code to talk to every possible model of disk, network card and graphics chip — an impossible duplication of effort. The OS solves this by owning the hardware and offering applications a clean, consistent set of services through system calls (requests like "open this file" or "give me 4 MB of memory").
A second way to see the OS is as a referee and illusionist. As referee it arbitrates between competing programs so that none can crash or starve the others. As illusionist it gives every running program the convincing impression that it has the whole CPU and a large private memory to itself, when in reality dozens of programs are sharing one (or a few) processors and a finite RAM. Maintaining those illusions is what the core OS functions below are for.
| Role | Description |
|---|---|
| Resource management | Manages and allocates CPU time, memory, storage and I/O devices among competing processes |
| Process management | Creates, schedules, suspends and terminates processes. Handles multi-tasking |
| Memory management | Allocates RAM to processes, manages virtual memory, handles paging and segmentation |
| File management | Organises files into a directory structure, handles read/write operations, manages permissions |
| I/O management | Controls communication between the CPU and peripheral devices using device drivers |
| Interrupt handling | Responds to hardware and software interrupts so the CPU can react to urgent events |
| Security | Manages user accounts, passwords, access permissions and encryption |
| User interface | Provides a way for users to interact with the computer (GUI, CLI) |
| Error handling | Detects and handles errors (e.g. division by zero, missing files, hardware failures) |
| Networking | Manages network connections, protocols and data transfer |
Each of these roles is a topic in its own right. Memory management (paging, segmentation, virtual memory) is covered in the Memory Management lesson, processor scheduling (round robin, SJF, etc.) in the Scheduling Algorithms lesson, and the remaining functions in detail in the Operating System Functions lesson. Here you only need to be able to name them and say one sentence about each.
The same core functions are tuned very differently depending on the device. A washing machine controller and a bank's mainframe are both "running an OS", but the priorities are worlds apart.
| Type | Description | Example |
|---|---|---|
| Multi-tasking | Can run multiple processes apparently simultaneously by switching between them rapidly | Windows, macOS, Linux |
| Multi-user | Multiple users can use the system simultaneously, each with their own session and permissions | Unix, Linux servers |
| Real-time | Guarantees responses within strict time limits; used in safety-critical embedded systems | FreeRTOS, VxWorks |
| Distributed | Manages a group of separate computers so they appear as a single system | Large cluster and cloud platforms |
| Embedded | Lightweight OS for dedicated hardware with limited resources | Embedded Linux, Zephyr, RTOS |
| Mobile | Optimised for touchscreen devices with limited battery and processing power | Android, iOS |
The full treatment of these types — and exactly what "real-time" guarantees mean — sits in the Operating System Functions lesson.
Utility software consists of small programs that perform specific maintenance or optimisation tasks to keep the computer running efficiently. Utilities are system software — they support the OS and manage hardware, rather than performing tasks for the end user. They are sometimes bundled with the OS and sometimes installed separately, but their purpose is always the health, security or efficiency of the system rather than a user's productivity task.
| Aspect | Detail |
|---|---|
| What it does | Rearranges fragmented data on a hard disk so that files are stored in contiguous (adjacent) sectors |
| Why it is needed | Over time, as files are created, modified and deleted, data becomes scattered across the disk (fragmentation). The read/write head must move more, increasing seek time and slowing performance |
| How it works | The utility reads fragmented files, copies them to temporary space, and rewrites them in contiguous blocks. It also consolidates free space into a single block |
| Not needed for SSDs | SSDs have no moving parts and access any location equally fast. Defragmentation provides no benefit for SSDs and can actually reduce their lifespan by causing unnecessary writes |
Fragmentation arises because the OS allocates whatever free sectors are available when a file grows; on a busy disk those sectors are rarely next to each other. Each non-contiguous chunk forces the read/write head to physically reposition, and that mechanical seek time is the slowest part of using a hard disk. Defragmentation pays a one-off cost (lots of reading and rewriting) to buy faster future reads.
Before defragmentation (_ marks a free sector; A, B, C are fragments of three files):
| Sector 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
|---|---|---|---|---|---|---|---|---|---|
| A | B | A | _ | C | A | B | _ | C | _ |
After defragmentation — files A, B, C now occupy contiguous runs and free space is consolidated:
| Sector 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
|---|---|---|---|---|---|---|---|---|---|
| A | A | A | B | B | C | C | _ | _ | _ |
| Aspect | Detail |
|---|---|
| What it does | Reduces the file size of one or more files |
| Why it is needed | Smaller files use less storage space, transfer faster over networks, and can be attached to emails within size limits |
| Types of compression | Lossless — the original data can be perfectly reconstructed (e.g. ZIP, PNG, FLAC). Lossy — some data is permanently discarded to achieve greater compression (e.g. JPEG, MP3, MP4) |
| Type | How It Works | Use Case |
|---|---|---|
| Lossless | Identifies and removes redundancy (e.g. run-length encoding, Huffman coding, dictionary compression). The original file can be perfectly restored | Text files, executables, archives, medical images |
| Lossy | Removes data that is less perceptible to humans (e.g. high-frequency sounds, subtle colour variations). Original cannot be fully restored | Photos (JPEG), music (MP3), video (MP4) |
Compression as a utility (e.g. a ZIP archiver) is system software because it maintains the efficient use of storage and bandwidth. The same algorithms appear elsewhere on the spec under data representation — here the focus is the tool's role, not the maths of Huffman coding.
| Aspect | Detail |
|---|---|
| What it does | Creates copies of files and data so they can be restored if the originals are lost, corrupted or accidentally deleted |
| Why it is needed | Hardware failure, malware, accidental deletion, natural disasters and theft can all cause data loss |
| Backup Type | Description | Advantages | Disadvantages |
|---|---|---|---|
| Full backup | Copies ALL files every time | Simple to restore — everything is in one backup | Takes the longest time and most storage space |
| Incremental backup | Copies only files that have changed since the last backup (full or incremental) | Fast; uses least storage | Restoring requires the last full backup PLUS every subsequent incremental backup |
| Differential backup | Copies all files that have changed since the last full backup | Faster than full; restoring needs only the last full backup + last differential | Takes more space than incremental; gets larger over time |
A common exam scenario asks you to choose a backup strategy. A typical real answer combines them: a weekly full backup plus daily incrementals gives small daily backups but a longer restore, whereas a weekly full plus daily differentials gives larger daily backups but a quick two-step restore.
| Aspect | Detail |
|---|---|
| What it does | Converts readable data (plaintext) into an unreadable format (ciphertext) using an encryption algorithm and a key |
| Why it is needed | Protects sensitive data from unauthorised access if a device is lost, stolen or intercepted during transmission |
| Decryption | The process of converting ciphertext back to plaintext using the correct key |
| Encryption Type | Description |
|---|---|
| Symmetric | The same key is used to encrypt and decrypt. Fast but the key must be shared securely (e.g. AES) |
| Asymmetric | Uses a key pair — a public key (to encrypt) and a private key (to decrypt). Slower but solves the key distribution problem (e.g. RSA) |
Disk-encryption utilities (the kind that encrypt a whole drive at rest) are clearly system software: their purpose is to protect the platform's data, not to do a user task.
| Utility | Purpose |
|---|---|
| Antivirus / anti-malware | Scans files and processes for known malware signatures and suspicious behaviour; quarantines or removes threats |
| Disk cleanup | Removes temporary files, cache data and other unnecessary files to free up storage space |
| File manager | Provides a graphical interface for navigating, copying, moving, renaming and deleting files |
| System monitor / task manager | Displays running processes, CPU usage, memory usage and network activity; allows processes to be terminated |
| Disk formatter | Prepares a storage device for use by creating a file system structure |
Antivirus is a frequent exam subject, so it is worth knowing how it detects threats rather than just that it does. It combines two complementary techniques:
Most antivirus utilities also run on access (scanning a file the moment it is opened) as well as on a schedule, and quarantine suspected files (isolating them so they cannot run) rather than deleting them outright, in case the detection was a false positive. The reason antivirus counts as system software is that its job is to protect the integrity of the whole platform, not to perform a task for the user.
Exam Tip: When asked to describe utility software, always state: (1) what the utility does, (2) why it is needed, and (3) how it benefits the user or system. A one-sentence answer will not score full marks. If the question gives a scenario, tie your "why" to that scenario rather than reciting a generic definition.
A library is a collection of pre-written, pre-compiled and tested code — typically subroutines, classes or constants — that a programmer can reuse instead of writing the same functionality from scratch. Libraries are system software because they extend the platform's capabilities and are shared across many applications.
| Aspect | Detail |
|---|---|
| What they provide | Ready-made, reliable code for common tasks: maths functions, string handling, data structures, graphics, networking, file formats |
| Why use them | Saves development time, reduces bugs (the code is already tested), encourages a consistent approach, and lets specialists' code be reused by everyone |
| How they are used | A program imports or links to the library and calls its routines; the library's internals are abstracted away behind a documented interface |
| Trade-offs | You depend on someone else's code, must trust its correctness and security, and may include more than you need (code bloat) |
Libraries can be linked in two ways, which connects directly to the Translators lesson:
.dll on Windows, a .so on Linux) that is loaded at run time. Executables stay small, one copy in memory can be shared by many programs, and the library can be updated independently — but the program will fail if the right version of the library is missing.# A high-level program reusing library code rather than re-implementing it
import math # standard maths library
import statistics # standard statistics library
readings = [4.0, 9.0, 16.0]
roots = [math.sqrt(x) for x in readings] # library does the hard work
print(roots) # [2.0, 3.0, 4.0]
print(statistics.mean(roots)) # 3.0
Without the library, the programmer would have to implement a square-root algorithm and a mean calculation by hand — more code, more chances for bugs, and no benefit over the well-tested standard versions.
Laid side by side, the two linking strategies trade the same things in opposite directions:
| Aspect | Static linking | Dynamic linking |
|---|---|---|
| When the library is combined | At compile/link time | At run time |
| Executable size | Larger (library code is baked in) | Smaller (just a reference to the shared file) |
| Memory use across programs | Each program holds its own copy | One copy can be shared in RAM by many programs |
| Updating the library | Must recompile every program | Replace the shared file once; all programs benefit |
| Run-time dependency | None — self-contained | Will fail if the correct version is missing |
| Best when | Distributing a standalone executable | Many programs share common code that is patched centrally |
This is why operating systems ship with large collections of shared libraries: dozens of applications can rely on a single, centrally-updated copy rather than each carrying its own.
A neat way to see how the categories fit together is to watch a machine start up. The layering is built from the bottom up:
The order is itself the argument for why each piece is system software: every layer exists to make the layer above it possible, and nothing the user actually wants to do can happen until all of them are in place.
A translator is system software that converts program source code into a form the CPU can execute. The CPU only understands machine code (binary), so any program written in assembly or a high-level language must be translated first. There are three kinds:
| Translator | Source | Output / behaviour |
|---|---|---|
| Assembler | Assembly language | Machine code, one mnemonic to one instruction |
| Compiler | High-level language | A complete machine-code executable, produced once before running |
| Interpreter | High-level language | Executes the source statement by statement, translating as it goes |
That is all you need from this lesson — enough to recognise translators as a category of system software. The detailed mechanics (the stages of compilation, two-pass assembly, the trade-offs between compilers and interpreters) are developed fully in the dedicated Translators lesson, and the classification of languages by level is in Types of Programming Language.
A school is buying laptops for students. Each laptop will run an operating system, anti-malware software and a suite of office applications. (a) State what is meant by system software and give two examples from this scenario. [3] (b) Explain two distinct roles the operating system performs that allow the office applications to run. [4] (c) The IT technician argues that installing a shared code library on each laptop will speed up future in-house software development. Discuss whether this is a sound decision. [6]
AO breakdown
Mid-band answer (parts a–b) (a) System software is software that manages the computer's hardware and lets other software run. Two examples are the operating system and the anti-malware software. (b) The operating system manages memory by giving each application some RAM to use. It also manages the CPU by deciding which program runs, so several applications can appear to run at once.
Top-band answer (a) System software is software whose purpose is to control and manage the computer's hardware and to provide a platform of services on which application software runs, rather than performing a task directly for the user. In this scenario the operating system is system software, and the anti-malware utility is system software (a utility program that maintains the security of the system).
(b) First, the OS performs memory management: it allocates a region of RAM to each office application as it launches, keeps each one's memory protected from the others, and uses virtual memory so the laptops can run more applications at once than would fit in physical RAM — without this an application would have nowhere to load its code and data. Second, the OS performs processor scheduling: because the office suite, the anti-malware scanner and the OS itself all compete for the CPU, the scheduler rapidly switches the CPU between their processes, giving the user the impression that they run simultaneously and keeping the interface responsive while a background scan runs.
(c) A shared, pre-written code library brings real benefits to in-house development. It supplies tested, reliable routines, so developers reuse proven code instead of re-implementing common tasks, which reduces development time and the number of bugs and encourages a consistent approach across the school's tools. If the library is dynamically linked, a single copy can be shared in memory and updated centrally, so a fix or security patch propagates to every program without rebuilding them.
However, there are drawbacks. The library must be kept up to date and trusted: a security flaw in a widely shared library exposes every program that uses it, and dynamic linking means a missing or wrong-version library file will stop programs running (the "dependency" problem). There is also a learning and maintenance cost, and the library may include far more than the school needs (code bloat), consuming disk space on every laptop.
On balance the decision is sound provided the chosen library is well maintained and the school controls which version is deployed: the time saved and the reduction in bugs outweigh the manageable risks. If instead the library were obscure or unmaintained, the dependency and security risks would make it a poor choice. The judgement therefore depends on the quality and support of the specific library, not on the idea of shared libraries in general.
Examiner-style commentary: The Mid-band response is correct but thin — part (b) names the right functions yet does not tie them to letting the applications run, capping the AO2 credit. The Top-band response defines purpose precisely, links each OS role explicitly to the scenario, and for part (c) presents benefits, drawbacks and a conditional judgement rather than a one-sided list, which is what AO3 rewards. Note how the strong answer earns marks by evaluating ("on balance… provided…") rather than merely listing pros and cons.
| Term | Definition |
|---|---|
| System software | Software that manages hardware and provides a platform for application software |
| Operating system | The main system software that manages hardware resources and provides an interface for applications |
| Utility software | Small programs that perform maintenance and optimisation tasks |
| Library | A collection of pre-written, tested, reusable code that programs link to or import |
| Translator | System software that converts source code into machine code (assembler, compiler or interpreter) |
| Static linking | Copying library code into the executable at compile time |
| Dynamic linking | Loading shared library code at run time from a separate file |
| Fragmentation | When files are stored in non-contiguous sectors, reducing performance on HDDs |
| Defragmentation | Rearranging data so files are stored in contiguous sectors |
| Lossless compression | Compression that allows perfect reconstruction of the original data |
| Lossy compression | Compression that permanently removes some data for greater file size reduction |
| Encryption | Converting plaintext into ciphertext using an algorithm and key |