Two kinds of software, and why the distinction matters
System software runs the computer. Application software runs for the user. That is the whole distinction, and every classification question comes back to it: ask who the software is serving.
A word processor exists because someone wants to write a letter — application. An operating system exists because a word processor cannot talk to a disk drive on its own — system. A disk defragmenter serves the machine rather than the user, so it is utility software, a sub-category of system software.
| Type | Purpose | Examples |
|---|---|---|
| Operating system | manages hardware and runs everything else | Windows, Linux, Android, iOS |
| Utility software | maintains and protects the system | antivirus, backup, disk cleanup, compression |
| Device drivers | translate OS requests for one device | printer driver, graphics driver |
| Translators | turn source code into machine code | compiler, interpreter, assembler |
| Application software | does the user's actual work | browser, spreadsheet, game, media player |
Select Application and then Hardware. An application never reaches the hardware directly — every file it opens and every pixel it draws is a request passed down through the operating system.
What an operating system actually does
The operating system is the layer everything else sits on, and the syllabus names five jobs it performs. Each one exists because programs would otherwise have to solve the same problem separately and would interfere with each other while doing so.
- Process management — deciding which program gets the CPU and for how long, so several appear to run at once on one core.
- Memory management — allocating RAM to each program and keeping them out of each other's space, so a crash in one does not corrupt another.
- File management — organising data into files and folders and controlling who may read or write them.
- Device management — talking to printers, disks and network cards through drivers, so applications do not need to know one printer model from another.
- User interface — providing a way in, whether a graphical desktop (GUI) or a command line (CLI).
GUI or command line?
A GUI is easier for a beginner, needs no memorised commands, and is what most users want. A CLI uses far fewer system resources, can be scripted so that a hundred files are processed with one line, and works over a slow remote connection where a desktop would not. Servers are usually run from a command line for exactly those reasons — the question is which suits the task, not which is more modern.
Translators: compiler, interpreter, assembler
A CPU understands only machine code — binary instructions. Anything written in a language a human can read must be translated, and there are three kinds of translator.
An assembler converts assembly language, which is a one-to-one symbolic version of machine code. A compiler translates the whole high-level program in one go, producing an executable file that can then be run repeatedly without the source. An interpreter translates and executes one line at a time, every time the program runs.
| Compiler | Interpreter | |
|---|---|---|
| Translates | the whole program at once | one statement at a time |
| Produces | an executable file | nothing saved — it runs directly |
| Speed of running | fast, already translated | slower, translated on every run |
| Error reporting | a list at the end of compilation | stops at the first error found |
| Source needed to run? | no | yes, every time |
| Better for | finished software being distributed | learning, testing and quick changes |
The error-reporting difference is the examinable one
A compiler reports every syntax error it can find before producing anything, so you fix them in batches. An interpreter runs happily until it reaches a bad line and only then stops — so a program can appear to work for a while and then fail. That is why interpreted languages are pleasant to learn in and why compiled ones are shipped to customers.
Open source and proprietary
Software also differs in how it is licensed, and the paper asks for advantages of each rather than a verdict.
Proprietary software is sold under a licence that keeps the source code secret. You get professional support, tested releases and someone to blame, but you cannot change it and you must pay. Open source software publishes its source code, so it is free to use, can be modified for a specific need, and is examined by many people. But support may be limited to community forums, and there is no guarantee anyone will fix a problem you report.
Before you leave this chapter
- System software serves the machine; application software serves the user. Utilities are system software.
- The OS manages processes, memory, files, devices and the user interface.
- A GUI is easier; a CLI is lighter, scriptable and works over slow links.
- Compiler = whole program at once, produces an executable, reports all errors together.
- Interpreter = line by line, needs the source every run, stops at the first error.
How the operating system shares one CPU
A single-core processor can execute only one instruction at a time, yet a dozen programs appear to run at once. The operating system achieves this by switching between them extremely quickly — giving each a few milliseconds of CPU time in turn, so that all of them appear to progress smoothly. That is multitasking, and the switch itself is called a context switch.
The same trick applies to memory. Each program is given the illusion of a large private address space, while the OS maps those addresses onto whatever physical RAM is actually free. When RAM runs out, less-used pages are written to disk in a process called paging — which is why a machine short of memory suddenly becomes very slow.
| Term | Meaning |
|---|---|
| Process | a program that is currently running, with its own memory |
| Scheduling | deciding which process gets the CPU next, and for how long |
| Context switch | saving one process's state and loading another's |
| Paging | moving memory pages between RAM and disk when RAM is full |
| Deadlock | two processes each waiting for something the other holds |
Multitasking is not the same as multiple cores
A single core running twenty programs is time-slicing — only one instruction is ever executing. A four-core processor genuinely runs four at once. Both look identical to the user, and questions asking "how can several programs run at the same time on one processor" want the time-slicing answer, not the cores one.
Integrated development environments
A translator turns source code into something the machine can run, but a programmer needs more than that. An integrated development environment gathers the tools into one application, and the syllabus expects its features by name.
The editor is where code is written, with syntax highlighting colouring keywords and strings so mistakes stand out, and auto-completion suggesting names as you type. Line numbering matters because every error message refers to one. A debugger lets execution be paused at a breakpoint so the variables can be inspected, or stepped one line at a time. And a built-in translator compiles or interprets the code without leaving the application.
| IDE feature | What it is for |
|---|---|
| Syntax highlighting | colouring keywords and strings so errors are visible |
| Auto-completion | suggesting names, reducing typing mistakes |
| Line numbering | locating the line an error message refers to |
| Breakpoints | pausing execution to inspect variables |
| Single stepping | running one line at a time to follow the logic |
| Variable watch | displaying values as they change |
| Built-in translator | compiling or running without leaving the IDE |
| Auto-indentation | laying out blocks consistently |
| Error diagnostics | reporting the fault and the line it is on |
A debugger finds logical errors, not syntax ones
Syntax errors are reported by the translator before anything runs, and the message names the line. A logical error produces a program that compiles and runs and is wrong, so nothing reports it. Stepping through with a debugger and watching the variables is how you find where the values first diverge from what you expected — which is the only reliable way to locate a fault the machine cannot detect.