System software (3.4)

An operating system (OS) is the most important piece of system software on a computer. It acts as a master controller, managing all the computer's hardware and software resources. Think of it as an intermediary: it sits between you (the user) and your applications, and the physical hardware components. Without an OS, you would need to manually control every aspect of the hardware, which is incredibly complex. The OS provides a user interface to interact with the computer, such as a Graphical User Interface (GUI) with icons and windows, or a Command-Line Interface (CLI) where you type commands. Its main jobs include managing memory, scheduling which programs get to use the processor (CPU), handling input and output devices, organising files on storage drives, and maintaining system security.

When you run a program, the operating system loads it into memory and it becomes a 'process'. A process is a program in execution. Modern operating systems are 'multitasking', meaning they can handle many processes at once (e.g., a web browser, a word processor, and a music player). Since there is usually only one CPU, it can only execute one instruction at a time. The OS creates the illusion of multitasking by rapidly switching the CPU's attention between different processes. This switching is managed by a part of the OS called the scheduler. The scheduler's job is to decide which process in the 'Ready' queue should be run next. A process can be in several states: 'New' (being created), 'Ready' (waiting for the CPU), 'Running' (currently being executed by the CPU), 'Blocked' (waiting for an event, like user input or a file to load), and 'Terminated' (finished execution). An 'interrupt' is a signal to the CPU (from hardware or software) that requires immediate attention, causing the current process to be paused so the interrupt can be handled.

Memory management is crucial for an OS. It must allocate memory fairly and protect processes from each other. 'Paging' is a common technique where memory is divided into fixed-size blocks. A program's logical address space is split into 'pages', and the physical RAM is split into 'frames' of the same size. A 'page table' is used to map the logical pages of a program to physical frames in RAM. This means a program's memory can be scattered non-contiguously throughout RAM, which makes allocation more flexible. 'Virtual memory' is a clever extension of paging. It uses a portion of the hard disk or SSD as if it were extra RAM. When RAM is full, the OS can move a 'page' of data that is not currently in use from RAM to the secondary storage (this is called 'swapping out'). When that page is needed again, it is swapped back into RAM, possibly replacing another page. This allows you to run larger programs or more programs than your physical RAM would normally allow. However, if the system spends too much time swapping pages back and forth, it can lead to a condition called 'disk thrashing', where the computer slows to a crawl because it is constantly accessing the slow hard disk instead of executing programs.

Beyond the core OS, system software also includes 'utility programs'. These are small applications designed to perform specific maintenance tasks to help manage, analyse, and optimise the computer system. Common examples include: 'Disk Defragmenter', which reorganises files on a hard disk to be stored in contiguous blocks, speeding up access; 'Backup Utility', which creates copies of data to protect against loss; 'File Compression', which reduces the size of files to save disk space or speed up transfer; and 'Disk Cleaner', which finds and removes unnecessary temporary files. Separately, in software development, programmers rely heavily on 'program libraries'. A library is a collection of pre-written, pre-compiled, and tested code (like functions or classes) that a developer can use in their own programs. Using libraries saves significant time and effort, as the programmer doesn't have to 'reinvent the wheel'. It also improves reliability, as library code is often written by experts and thoroughly tested. Libraries can be linked 'statically' (the library code is copied into the final executable) or 'dynamically' (the code is kept in a separate file, like a .dll in Windows, and loaded only when needed).

Computers understand only one language: machine code, which consists of binary 1s and 0s. Humans, however, write programs in high-level languages (like Python or Java) or low-level assembly language, which are easier to understand. 'Language translators' are system programs that bridge this gap. There are three main types:

1. Compiler: A compiler takes the entire source code of a program and translates it into machine code all at once. This process, called compilation, produces a standalone executable file (e.g., an .exe file on Windows). This executable can then be run independently without the original source code or the compiler. The translated code generally runs very fast.
2. Interpreter: An interpreter works differently. It reads the source code one line or statement at a time, translates that line into machine code, and then immediately executes it. It then moves to the next line. No separate executable file is created. This process is repeated every time the program is run.
3. Assembler: An assembler is a translator for assembly language. Assembly language is a very low-level language that has a strong one-to-one correspondence with the computer's machine code instructions. The assembler performs a relatively straightforward conversion of these mnemonics (like ADD, MOV) into their binary equivalents.

Compilation isn't a single step; it's a multi-stage process that transforms source code into machine code. The main stages are:

1. Lexical Analysis: The compiler scans the source code as a string of characters. It removes comments and whitespace and groups characters into a sequence of 'tokens'. A token is the smallest meaningful unit, like a keyword (`if`), an identifier (`myVariable`), an operator (`+`), or a number (`10`). Information about identifiers is stored in a 'symbol table'.
2. Syntax Analysis (Parsing): The stream of tokens is checked to see if it follows the grammar rules of the programming language. The parser builds a data structure, often an 'Abstract Syntax Tree' (AST), which represents the grammatical structure of the code. If the code violates a grammar rule (e.g., a missing semicolon), a syntax error is reported.
3. Semantic Analysis: This stage checks the AST for meaning. While the code might be grammatically correct, it might not make logical sense. This stage detects errors like using an undeclared variable, or trying to add a string to an integer (a type mismatch).
4. Intermediate Code Generation: The compiler generates a low-level, machine-independent representation of the program. This intermediate code is easier to optimise and can be more easily adapted to generate final code for different CPU architectures.
5. Code Optimisation: This optional but important stage analyses the intermediate code and transforms it to make the final program run faster or use less memory. It might remove redundant code or rearrange instructions.
6. Code Generation: The final stage. The optimised intermediate code is translated into the specific machine code for the target computer's architecture. This is the output executable file or object code.