What you'll learn
This revision guide covers the essential software concepts required for CIE IGCSE Computer Science. You will understand the distinction between system and application software, explore operating system functions, examine utility programs, and learn about different types of language translators. These topics form a core component of Paper 1 and require both factual knowledge and the ability to apply concepts to scenarios.
Key terms and definitions
System software — programs that manage and control the computer hardware, providing a platform for application software to run (includes operating systems, utility programs, and translators).
Application software — programs designed to perform specific tasks for the user, such as word processors, spreadsheets, web browsers, and games.
Operating system (OS) — system software that manages computer hardware and software resources, providing common services for application programs.
Utility program — system software designed to perform specific maintenance or housekeeping tasks on a computer system.
Compiler — a translator that converts high-level language source code into machine code in one complete process, creating an executable file.
Interpreter — a translator that converts and executes high-level language source code line-by-line, without creating a standalone executable file.
Assembler — a translator that converts assembly language (low-level language using mnemonics) into machine code.
Integrated Development Environment (IDE) — software application that provides comprehensive facilities to programmers for software development, typically including a code editor, debugger, and compiler/interpreter.
Core concepts
System software vs application software
Software is divided into two main categories based on its purpose and function.
System software manages the computer's resources and provides a platform for other software to run. It includes:
- Operating systems (Windows, macOS, Linux, Android, iOS)
- Utility programs (antivirus, disk defragmenter, backup software)
- Library programs (pre-written code modules)
- Language translators (compilers, interpreters, assemblers)
Application software is designed to help users complete specific tasks. Examples include:
- Word processors (Microsoft Word, Google Docs)
- Spreadsheet software (Excel, Google Sheets)
- Database management systems (Access, MySQL)
- Graphics and video editing software (Photoshop, Premiere)
- Web browsers (Chrome, Firefox, Safari)
- Games and entertainment software
The key distinction: system software runs in the background managing the computer, whilst application software directly serves user needs and requires system software to function.
Functions of an operating system
The operating system is the most important piece of system software. It performs several critical functions:
Memory management
- Allocates RAM to programs when they run
- Deallocates memory when programs close
- Uses virtual memory (hard disk space) when RAM is full
- Prevents programs from accessing each other's memory space
Processor management
- Allocates CPU time to running programs using scheduling algorithms
- Manages multitasking, allowing multiple programs to run simultaneously
- Prioritises processes based on importance
- Handles interrupts from hardware and software
Backing store management
- Organises files and folders on storage devices
- Manages file permissions and security
- Allocates disk space efficiently
- Handles file operations (create, read, update, delete)
Input/output management
- Controls data transfer between the computer and peripheral devices
- Manages device drivers (software that communicates with specific hardware)
- Handles print queuing
- Manages data buffers for smooth data flow
User interface provision
- Provides the means for users to interact with the computer
- Command Line Interface (CLI): text-based, uses typed commands, efficient for experts
- Graphical User Interface (GUI): visual, uses windows/icons/menus/pointers (WIMP), intuitive for beginners
Security and access control
- Manages user accounts and passwords
- Controls user permissions and file access rights
- Implements firewall protection
- Logs system events for security auditing
Utility programs
Utility programs are specialised system software tools that maintain and optimise computer systems.
Antivirus software
- Scans files and memory for known viruses and malware
- Uses virus definitions (database of known threats) updated regularly
- Quarantines or removes infected files
- Provides real-time protection against threats
Disk defragmenter
- Reorganises fragmented files on a hard disk drive
- Places file parts contiguously (next to each other) for faster access
- Improves read/write performance
- Less relevant for SSDs which don't suffer from fragmentation issues
Backup software
- Creates copies of files and data for disaster recovery
- Can perform full backups (entire system) or incremental backups (only changed files)
- Schedules automatic backups
- Compresses data to save storage space
Compression software
- Reduces file sizes to save storage space and reduce transmission time
- Lossless compression: original file can be perfectly restored (ZIP, PNG for text/programs)
- Lossy compression: some data is permanently lost for greater reduction (JPEG, MP3 for media)
Disk cleanup and file management utilities
- Remove temporary files and unnecessary data
- Identify duplicate files
- Manage disk space allocation
- Repair file system errors
Language translators
High-level programming languages must be translated into machine code (binary instructions) for the processor to execute. Three types of translator exist:
Compilers
Characteristics:
- Translate the entire source code in one process
- Create a standalone executable file
- Report all errors after complete translation
- Do not need to be present when the program runs
Advantages:
- Executable runs faster (already fully translated)
- Source code remains confidential (only executable distributed)
- No translator needed on target computer
Disadvantages:
- Compilation process can be time-consuming for large programs
- Errors must be fixed before any code executes
- Platform-specific executable files required
Interpreters
Characteristics:
- Translate and execute source code line-by-line
- Do not create a separate executable file
- Stop and report errors as soon as encountered
- Must be present every time the program runs
Advantages:
- Easier for beginners to test and debug code
- Errors identified immediately during execution
- Platform-independent (interpreter handles compatibility)
Disadvantages:
- Programs run more slowly (translation happens during execution)
- Source code must be distributed (less secure)
- Interpreter required on every computer running the program
Assemblers
Characteristics:
- Translate assembly language into machine code
- Assembly language uses mnemonics (e.g., LDA for "load", STO for "store")
- One-to-one translation (each instruction becomes one machine code instruction)
- Platform-specific (different processors have different instruction sets)
Assembly language is considered a low-level language because it relates closely to machine code and specific processor architectures, unlike high-level languages which are more abstracted and human-readable.
Integrated Development Environments (IDEs)
An IDE combines multiple programming tools into a single application, making software development more efficient.
Key features of an IDE:
Code editor
- Provides a text editor specifically for writing program code
- Syntax highlighting (colours keywords, variables, strings differently)
- Auto-completion suggests code as you type
- Auto-indentation formats code structure
- Line numbering for easy reference
Error diagnostics
- Identifies syntax errors before compilation/execution
- Highlights problematic code sections
- Provides error messages and suggestions for fixes
Run-time environment
- Executes programs within the IDE
- Captures program output
- Allows testing without leaving the development environment
Debugging tools
- Breakpoints: pause program execution at specific lines
- Stepping: execute code line-by-line to observe behaviour
- Variable watching: monitor variable values during execution
- Call stack: shows the sequence of function calls
Translator
- Built-in compiler or interpreter
- Converts source code to executable form
- Integrated with other IDE features
Examples of IDEs:
- Python: IDLE, PyCharm, Thonny
- Visual Basic: Microsoft Visual Studio
- Java: Eclipse, NetBeans, IntelliJ IDEA
Types of programming language
High-level languages
- Use English-like syntax and mathematical notation
- Platform-independent (can run on different systems with appropriate translator)
- One statement may generate many machine code instructions
- Easier to learn, read, and maintain
- Examples: Python, Visual Basic, Java, C++
Low-level languages
- Assembly language and machine code
- Platform-specific (written for particular processor architecture)
- Difficult for humans to read and write
- Provides direct hardware control
- Used when speed and efficiency are critical (device drivers, embedded systems)
- Each instruction corresponds directly to processor operations
Worked examples
Example 1: Distinguishing translators (4 marks)
A programmer is developing a large commercial application that will be sold to thousands of users.
(a) State which type of translator would be most appropriate. [1]
(b) Give three reasons for your choice. [3]
Model answer:
(a) Compiler [1]
(b)
- The compiled executable will run faster because the translation has already been completed [1]
- The source code is kept confidential, protecting intellectual property when distributing to customers [1]
- Users do not need the translator installed on their computers to run the application [1]
- The executable can be optimised during compilation for better performance [1]
[Any three reasons, 1 mark each]
Example 2: Operating system functions (6 marks)
Describe how the operating system manages memory when multiple applications are running simultaneously. [6]
Model answer:
- The operating system allocates sections of RAM to each application when it is opened [1]
- It ensures that applications cannot access memory allocated to other applications [1], preventing conflicts and maintaining security [1]
- When an application closes, the OS deallocates its memory, making it available for other programs [1]
- If RAM becomes full, the OS uses virtual memory [1], which is hard disk space used as additional RAM [1]
- The OS swaps data between RAM and virtual memory as needed, though this slows performance [1]
[Award up to 6 marks for valid points about memory management]
Example 3: Utility program selection (3 marks)
A user notices their computer is running slowly and disk access seems particularly sluggish.
Recommend a utility program that could help and explain how it would improve performance. [3]
Model answer:
- Use a disk defragmenter [1]
- Files on the hard disk have become fragmented (stored in non-contiguous sections) [1]
- Defragmentation reorganises files so their parts are stored together, reducing the time needed to read them and improving disk access speed [1]
Common mistakes and how to avoid them
Confusing compilers and interpreters: Remember that compilers create executable files and translate all code at once, whilst interpreters translate line-by-line and require the source code each time. Use the mnemonic: Compilers Create Complete executables.
Vague operating system functions: Avoid saying the OS "controls everything" or "manages the computer". Be specific: name the exact function (memory management, processor management, etc.) and describe how it works with concrete details.
Mixing up system and application software: Antivirus, backup, and defragmentation programs are system software (utilities), not application software, because they maintain the system rather than accomplish user tasks. If unsure, ask: "Does this help the computer run, or does it help me do my work?"
Incomplete IDE feature descriptions: Don't just list features like "debugger" or "editor". Explain what they do and how they help programmers. For example: "A debugger allows the programmer to pause execution at breakpoints and inspect variable values to identify logical errors."
Forgetting that assemblers exist: Many students only remember compilers and interpreters. Assemblers are equally important as they translate assembly language (low-level language using mnemonics) into machine code.
Assuming all language translators work the same way: Each translator type has distinct characteristics, advantages, and use cases. Learn the specific differences and be prepared to justify which translator suits a particular scenario.
Exam technique for "Software"
Command word precision: "State" requires a brief answer with no explanation (1 mark). "Describe" requires details of how something works (2-3 marks per point). "Explain" requires reasons or causes with justification (2-3 marks per point). "Compare" requires similarities and differences between two things.
Use technical terminology accurately: Examiners expect precise vocabulary. Use "allocate memory" not "give memory", "executable file" not "program file", "syntax highlighting" not "coloured text". Correct terminology often earns marks even if your explanation is incomplete.
Structure longer answers logically: For 4+ mark questions, number your points and ensure each makes a distinct valid statement. Avoid repetition using different words—each point must add new information. If asked for three reasons, give exactly three distinct reasons.
Relate answers to the scenario: When questions provide context (e.g., "a school network", "commercial software"), tailor your answer to that situation. Generic responses may not earn full marks if they don't address the specific context given.
Quick revision summary
Software divides into system software (managing hardware and providing a platform) and application software (performing user tasks). Operating systems handle memory, processor scheduling, file management, input/output, user interfaces, and security. Utility programs maintain system performance through antivirus protection, disk defragmentation, backups, and compression. Compilers translate entire programs into executables; interpreters translate line-by-line; assemblers convert assembly language to machine code. IDEs provide integrated tools including editors, debuggers, and translators to streamline programming. Understanding when to use each software type and translator is essential for exam success.