COMPUTER SCIENCE

Chapter 4: Software
Complete Study Notes — Types of Software, Interrupts, Programming Languages, Translators & IDEs

✔ Simple explanations ✔ Key term definitions ✔ Real-life examples ✔ Diagrams & flowcharts
4.1 Types of Software and Interrupts
4.1.1 What is Software? — The Big Picture
Every computer is really just a collection of physical parts (hardware) — a processor, memory, a hard disk, a screen, and so
on. On its own, hardware can do nothing. Software is the set of instructions that tells this hardware what to do. Software is
broadly divided into two categories, arranged in a hierarchy — hardware at the bottom, then system software, then
application software on top.

Figure A: Software & Hardware Hierarchy — application software sits on top of system software, which controls the
hardware.

● System software: programs that manage and control the hardware, and provide a platform on which other software can
run.
● Application software: programs that let the user carry out specific, real-world tasks (e.g. writing a letter, editing a
photo).
Real-life example: Think of it like a building: hardware is the foundation and bricks, system software is the
plumbing/electrical wiring that makes the building usable, and application software is the furniture and appliances you
actually use every day.

System Software — Key Features

● Controls and manages the operation of computer hardware.
● Provides a platform (foundation) on which other software can run.
● Required to let hardware and software run without problems.
● Provides a Human Computer Interface (HCI) — the screen/menu system a person uses to talk to the computer.
● Controls how hardware resources (memory, CPU time, printers, etc.) are allocated and used.

Application Software — Key Features

● Used to perform specific tasks/applications (often just called 'apps') for the user.
● Lets a user use the computer's resources to do a real job — e.g. typing an essay.
● May be a single program (e.g. NotePad) or a suite/bundle of programs (e.g. Microsoft Office).
● The user chooses to open and run it whenever they need it.
 Figure B: Types of Software — System software runs the machine; application software does the user's tasks.

Examples of Application Software

Application software is designed for the end-user to complete real tasks. Below are the common types explained simply.

📌withSpreadsheet software: Organises numbers into a grid of rows and columns (cells like B6). Used for calculations
formulas, 'what-if' modelling, and creating graphs.
Real-life example: Microsoft Excel or Google Sheets used by a shopkeeper to calculate monthly profit and loss.

📌(calledDatabase software: Organises, stores and analyses data using tables made of rows (called records) and columns
fields). You can search/query the data and produce reports.
Real-life example: A school using a database to store student records — each student is a 'record', and 'Name', 'Age',
'Class' are 'fields'.

📌 Apps: Short for 'applications' — usually refers to software for phones/tablets, downloaded from an App Store.
Real-life example: Instagram, Google Maps (uses GPS — Global Positioning System — to find your location), or a
mobile banking app.

📌quantities
Control and measuring software: Lets a computer/microprocessor connect with sensors to measure real-world
(like temperature) and control devices (like opening a valve).
Real-life example: A smart thermostat that measures room temperature and automatically turns the heater on/off.

📌transitions.
Video editing software: Used to rearrange, cut, or combine video/audio clips, add colour correction, filters, and

Real-life example: A YouTuber using Adobe Premiere Pro or CapCut to edit a vlog.

📌 Graphics manipulation software: Edits images. Bitmap editors change individual pixels (tiny coloured dots); vector
 editors manipulate lines, curves and shapes instead of pixels.
Real-life example: Adobe Photoshop (bitmap/pixel-based) vs. Adobe Illustrator or Canva (vector-based logos).

📌photographs.
Photo editing software: Lets you adjust brightness, contrast, colour, remove red-eye, or do complex touch-ups on

Real-life example: Using Snapseed or Lightroom to enhance a photo before posting it on social media.

📌imageWord processor: Software to create, edit, and format text documents — includes spell-checkers, copy-paste, and
insertion.
Real-life example: Microsoft Word or Google Docs used to write a school assignment.

Examples of System Software

System software works quietly in the background to keep the whole computer running smoothly.

📌operating
Device drivers: Special software that lets a specific hardware device (like a printer or mouse) communicate with the
system. Without the right driver, the device won't work and you'll see an error like 'device not recognised'.
Real-life example: When you plug in a new wireless mouse, Windows automatically installs its driver so the mouse
starts working.

📌anti-virus,
Utility programs (utilities): Small system programs that manage, maintain, and protect computer resources — e.g.
back-up, disk repair, file compression.
Real-life example: Windows Defender running quietly in the background to check for viruses.

📌computer,
Operating System (OS): The master system software that manages input/output, lets the user communicate with the
handles errors, loads/runs programs, and manages security.
Real-life example: Microsoft Windows, Apple macOS, Android, Apple iOS.

📌computer's
Compiler: Translates an entire program written in a High-Level Language (HLL) into machine code (binary) that the
processor can run directly. The original code is called source code; the translated code is called object code.
Real-life example: A programmer writing an app in C++ uses a compiler to turn it into a runnable .exe file.

📌 Linker: Combines several separately-compiled object files (modules) into one single runnable program.
Real-life example: A large game is built from many small code modules (graphics, sound, physics) — the linker joins
them into the final game executable.

Utility Software (Utilities) — In Detail

Utility programs are part of the system software. Some run only when the user starts them; others (like anti-virus) run
constantly in the background without you noticing.

1. Virus Checkers (Anti-Virus Software)

📌illegally.
Malware: Malicious software (viruses, worms, Trojan horses) installed on a computer to delete, corrupt, or steal data
Anti-virus software protects a computer against malware. All anti-virus programs share these common features:
● They check files/software before they run or load.
● They compare suspicious files against a database of known viruses.
● Heuristic checking: checking software behaviour for virus-like patterns, useful for catching brand-new viruses not yet
in the database.
● Quarantine: isolating a suspected infected file so it can be deleted, or reviewed by the user (a 'false positive' is when a
safe file is wrongly flagged as a virus).
● Anti-virus databases must be updated regularly, as new viruses appear constantly.
● A full system scan should be done periodically (e.g. weekly) to catch dormant viruses.
Real-life example: Norton, McAfee, or Windows Defender scanning your downloads folder automatically.

2. Defragmentation Software
📌 Contiguous: Means 'next to each other' — i.e. stored in neighbouring/adjacent memory locations.
Over time, as files on a Hard Disk Drive (HDD) are created, deleted, and resized, their data becomes scattered across
different, non-contiguous sectors. This is called fragmentation. It slows down the disk because the read-write head must
move around more to gather all the pieces of a file.
A defragmentation utility rearranges these scattered blocks so each file's data is stored in contiguous (neighbouring) sectors,
which speeds up file access. Note: this problem does not apply to Solid State Drives (SSDs), because they access data
electronically rather than mechanically.
Real-life example: Windows' built-in 'Optimise Drives' tool tidying up an old laptop's HDD to make it run faster.

3. Back-Up Software
Good practice is to keep three versions of an important file:
● 1. The current working copy on the internal HDD/SSD.
● 2. A local back-up copy (e.g. on a portable SSD).
● 3. A remote back-up copy stored elsewhere (e.g. cloud storage).
Windows File History: takes hourly snapshots of files onto an external drive, and keeps old versions until the user deletes
them.
Mac Time Machine: backs up hourly, keeps daily back-ups for a month, and weekly back-ups beyond that; oldest back-ups
are deleted first when storage runs out.
Real-life example: Automatically backing up your phone's photos to Google Photos or iCloud, so nothing is lost if the
phone breaks.

4. Security Software
An umbrella utility that:
● Manages user accounts and access (user IDs/passwords).
● Works with anti-virus and anti-spyware tools.
● Protects network connections using firewalls.
● Uses encryption/decryption so intercepted data is meaningless without the key.
● Checks that software updates come from a legitimate/trusted source.

5. Screensavers
Originally created to prevent 'phosphor burn' on old CRT (Cathode Ray Tube) monitors caused by a static image staying too
long. Modern LCD/OLED screens don't have this problem, so screensavers today mainly customise the look of idle screens,
or add security (auto-locking after inactivity), or trigger background tasks (like a virus scan) while the computer is idle.
Real-life example: An office computer's screen locking itself and showing a company logo after 5 minutes of inactivity.
Device Drivers — More Detail
📌it isDescriptor: Information a USB device gives to the computer when plugged in, so the OS knows what kind of device
— includes Vendor ID (VID), Product ID (PID), and a serial number.
If a device has no serial number, the OS treats it as a brand-new device every single time it's plugged in.
4.1.2 Operating Systems (OS)
An Operating System (OS) provides the environment in which application software runs, and a usable interface between the
human and the computer. It hides the complexity of the underlying hardware from the user.
Real-life example: Microsoft Windows, Apple macOS, Google Android, Apple iOS.
Most computers store the OS on an HDD or SSD (Solid State Drive), since it is a large program. Phones/tablets store it on
solid-state memory since they're too small for an HDD.

Figure C: The Nine Main Functions of an Operating System.

1. Human Computer Interface (HCI)

📌 HCI: The part of the OS that lets a human communicate with the computer. Comes in two main forms: CLI and GUI.
📌 CLI (Command Line Interface): The user types text commands to control the computer.
📌 GUI (Graphical User Interface): The user interacts using icons/pictures, usually via a mouse or touch.
📌 WIMP: Windows, Icons, Menu, Pointing device — the classic desktop-style GUI.
📌 Post-WIMP: Modern touchscreen interaction style allowing gestures like pinching and rotating.
Interface Advantages Disadvantages
CLI Direct control; not limited to preset Must memorise commands; slow to
options; can change deep settings; uses type; typos cause errors
little memory
GUI No commands to learn; user-friendly Uses much more memory; limited to
icons; easy mouse/touch control icons provided; needs a full OS to
run
Who uses which? CLI suits programmers, analysts and technicians who need direct, precise control. GUI suits everyday
end-users who just want to run software easily.

2. Memory Management
This function of the OS:
● Manages RAM (Random Access Memory) and moves data between RAM and HDD/SSD as programs run.
● Keeps track of which memory locations are in use.
● Memory protection: stops two applications from using the same memory location at the same time. Without this: data
could be lost, results could be wrong, security could be compromised, or the computer could crash.

3. Security Management
Ensures the integrity (accuracy), confidentiality (privacy) and availability of data, by:
● Applying OS updates.
● Keeping anti-virus software current.
● Working with firewalls to check network traffic.
● Using user accounts/passwords to block unauthorised access to private areas.
● Maintaining access rights for each user.
● Providing data recovery/system restore.
● Preventing illegal intrusion into the system.

4. Hardware / Peripheral Management

Controls all input/output devices via device drivers, prioritises hardware resources, and manages queues and buffers.
Example — printing a document:
● The printer driver is located and loaded into memory.
● Data is sent to a printer buffer, ready to print.
● If the printer is busy, data waits in a printer queue first.
● Control commands are sent to the printer throughout printing.
● Error messages/interrupts from the printer are received and handled.

5. File Management
Handles file naming (e.g. [Link]), and tasks like create, open, close, delete, rename, copy and move. It maintains
folder/directory structures, enforces access rights (e.g. passwords/locking), and loads files from disk into memory when
needed.

6. Multitasking
📌between
Multitasking: Letting a computer run more than one process (task) at the same time, sharing hardware resources
them.
To multitask safely, the OS:
● Allocates resources to each process for a limited time.
● Can interrupt a running process.
● Gives each process a priority (risk: a low-priority process may be starved of resources).
(These three points together are known as pre-emptive multitasking.)
Real-life example: Listening to Spotify, downloading a file, and typing an email all at once on the same laptop.
7. Management of User Accounts
Each user gets their own protected user account (username + password), keeping their data and settings separate for security.
An administrator typically creates/deletes accounts and sets access levels — e.g. an office clerk may access stationery orders
but not confidential HR files.

8. Interrupt Handling & 9. Platform for Applications

These two functions are explained fully in the sections below (Running of Applications, and Interrupts).

4.1.3 Running of Applications — Booting Up

📌 Booting up / Bootstrap loader: The process of loading part of the OS into RAM when the computer is switched on.
📌loads/executes
BIOS (Basic Input/Output System): Firmware that starts the motherboard, finds where the OS is stored, and
the needed part of it.

📌 Firmware: A program that gives low-level control for a device — sits between hardware and higher-level software.
📌survive
EEPROM (Electrically Erasable Programmable ROM): A flash memory chip storing the BIOS program; contents
power-off, but can be rewritten/updated by the user.

📌clockCMOS (Complementary Metal Oxide Semiconductor): A battery-powered chip storing the BIOS settings (like
speed). If the battery is removed, these settings reset to factory defaults.

Boot sequence in simple steps:

● 1. Computer is switched on → BIOS (in EEPROM) starts running.
● 2. BIOS checks BIOS settings (stored in CMOS, kept alive by a small battery).
● 3. BIOS locates the storage device holding the Operating System.
● 4. The needed part of the OS is loaded into RAM and executed — the computer is now ready to run applications.
Real-life example: If you remove a desktop computer's small round 'CMOS battery' for too long, the system clock resets
to a default date — this happens because CMOS lost power.

4.1.4 Interrupts
📌its current
Interrupt: A signal sent from a device or from software to the microprocessor (CPU), causing it to temporarily pause
task in order to deal with (service) something urgent.
Interrupts can be caused by:
● A timing signal (a regular clock 'tick').
● An input/output process — e.g. a disk drive or printer needing more data.
● A hardware fault — e.g. a paper jam in the printer.
● User interaction — e.g. pressing Ctrl+Alt+Break on the keyboard.
● Software errors — e.g. a missing .exe file, two processes fighting over the same memory, or dividing by zero.
Once an interrupt signal arrives, the CPU checks the interrupt's type and its interrupt priority (how urgent it is) — deciding
whether to service it immediately or continue what it was doing.

Why Interrupts Matter — Multitasking Made Possible

Interrupts let a computer appear to do several things simultaneously — e.g. downloading a file while playing music — even
though in reality, the CPU is just switching rapidly between tasks. This works alongside something called a buffer.

📌devices
Buffer: A temporary storage area in memory that holds data briefly to smooth out speed differences between two
(e.g. a fast CPU and a slow printer).
 Real-life example: When streaming a movie, your internet connection downloads data into a buffer faster than the media
player displays it — this stops the video from constantly freezing.

How the CPU Services an Interrupt

● 1. The status of the current task is saved — including the Program Counter (PC) and other CPU registers.
● 2. The Interrupt Service Routine (ISR) — special software written to handle that specific interrupt — is executed.
● 3. Once servicing is complete, the saved status is reloaded, and the original task resumes exactly where it left off.

📌 Program Counter (PC): A CPU register that holds the memory address of the next instruction to be executed.
📌the printer
Interrupt Service Routine (ISR): Software that handles/responds to a specific interrupt request, e.g. telling the CPU
is out of paper.

Worked Example: Printing a Document Using Buffers & Interrupts

Printing is much slower than the CPU sending data, so without buffers and interrupts the CPU would sit idle waiting for the
printer. Instead:

Figure D: Flowchart — Use of Buffer + Interrupt when Printing a Document.

In short: data goes from memory → buffer → printer. When the buffer runs low, an interrupt tells the CPU 'send more data'.
While waiting, the CPU is freed up to do other jobs — nothing is wasted.

Activity Recap — Section 4.1

Software System Software? Application Software?
Screensaver ✔
Anti-virus software ✔
Control & measurement software ✔
Printer driver ✔
Video editing software ✔
Compiler ✔
QR code reader ✔
On-screen calculator ✔
Operating system software ✔
4.2 Programming Languages, Translators & IDEs
Just as people need a shared language (or a human interpreter) to communicate, programmers need a way to 'speak' to
computers. Computers only truly understand one language: machine code (pure binary — 0s and 1s). Any program must
eventually be translated into machine code before the computer can run it.

📌 Computer program: A list of instructions that enables a computer to perform a specific task.
4.2.1 High-Level and Low-Level Languages

Figure F: High-Level vs Low-Level Languages.

High-Level Languages (HLL)

📌closeHigh-Level Language (HLL): A programming language independent of computer hardware — written in a style
to English, so it must be translated into machine code before it runs.
HLLs let a programmer focus on solving the problem, without needing to know the computer's internal hardware or
instruction set. Being 'portable' means the same HLL code can often run on different types of computers. Programs written in
a HLL are:
● Easier to read/understand (closer to English).
● Quicker to write.
● Easier and quicker to debug.
● Easier to maintain.
Example statement in a high-level language:
Sum := FirstNumber + SecondNumber
Real-life example: Python, Java, C++, Visual Basic — used to build websites, apps, and games.

Low-Level Languages (LLL)

📌Includes
Low-Level Language (LLL): A programming language tied closely to a specific computer's hardware/architecture.
machine code and assembly language.

📌withMachine code: The actual binary (0s and 1s) instructions a computer's processor understands and can run directly,
no translation needed.
Example — the same 'add two numbers' instruction shown in machine code (hexadecimal and binary):
1 12 → 0001 00010010
4 13 → 0100 00010011
0 1A → 0000 00011010
As you can see, machine code is very hard for humans to read — which is exactly why high-level languages were invented!

Comparing High-Level and Low-Level Languages

Language Advantages Disadvantages
High-level Independent of computer type; easy to Programs can be larger; may run
read/write/understand; quick to write; slower; may not use special hardware
quick to debug; easy to maintain features
Low-level Can use special hardware; machine- Takes longer to write and debug; harder
specific instructions; compact code; very to understand
fast execution

4.2.2 Assembly Language

📌binary,
Assembly language: A low-level language using short mnemonic codes (like LDA, ADD, STO) instead of pure
but still tied to specific hardware. Must be translated into machine code by an assembler before it can run.
Programmers use assembly language when they need to:
● Use special hardware features.
● Use machine-specific instructions.
● Write compact code that uses little memory.
● Write code that runs extremely fast.
Example — adding two numbers in assembly language:
LDA First (Load value of 'First' into the accumulator)
ADD Second (Add value of 'Second' to the accumulator)
STO Sum (Store the accumulator's value into 'Sum')

📌 Accumulator: A special CPU register used to hold the results of calculations temporarily while a program runs.
4.2.3 Translators
📌can Translator: A utility program that converts human-written program code into the binary machine code a computer
execute. There are three types: compiler, interpreter, and assembler.

Figure E: How Compilers, Interpreters and Assemblers Work.

Compiler
📌[Link]: Translates an ENTIRE high-level language program into machine code in one go, producing a runnable
If errors exist, an error report is produced instead.
● Produces an executable file that can run again and again without needing the compiler.
● One HLL statement often becomes several machine code instructions.
Real-life example: A finished mobile game app you download and install — it was compiled once by the developer and
now just runs directly.

Interpreter
📌it, then
Interpreter: Translates and executes a high-level language program ONE statement at a time — translate a line, run
move to the next line. If an error is found, execution stops immediately.
● No separate executable file is produced — the program must be re-interpreted every time it runs.
● Cannot be run without the interpreter present.
Real-life example: Python code run directly through the Python interpreter each time, rather than being compiled into a
stand-alone .exe.

Assembler
📌likeAssembler: Translates a program written in assembly language into machine code, producing a runnable file, just
a compiler does for high-level languages.
● One assembly language instruction usually becomes exactly one machine code instruction (unlike a compiler, which
may need several).

Summary Table — Compiler vs Interpreter vs Assembler

Compiler Interpreter Assembler
Translates a high-level program Executes a high-level program one Translates a low-level assembly
into machine code statement at a time program into machine code
Produces an executable file No executable file produced Produces an executable file
1 HLL statement → several 1 HLL statement may need several 1 assembly statement → usually 1
machine code instructions machine code instructions to machine code instruction
execute
Runs without the compiler Cannot run without the interpreter Runs without the assembler
afterwards afterwards
Usually distributed for general use Often used during development Usually distributed for general use

4.2.4 Advantages & Disadvantages: Compiler vs Interpreter

Translator Advantages Disadvantages
Interpreter Easier/quicker to debug and edit during Cannot run without the interpreter;
development slower execution
Compiler Compiled program can be stored, run without Takes longer to write/test/debug
the compiler, uses less memory, and runs faster during development

4.2.5 Integrated Development Environment (IDE)

📌programmer
IDE (Integrated Development Environment): A single software suite that bundles together all the tools a
needs to write, test, and fix a program.
Real-life example: PyCharm (Python), Visual Studio (Visual Basic/C#), BlueJ (Java).
A typical IDE includes these features:

📌separate
Code editor: A built-in text editor made specifically for writing and editing program code, avoiding the need for
software.

📌 Translator: Most IDEs include a compiler and/or interpreter, so code can be tested/run directly inside the IDE.
📌valuesDebugger: Lets a programmer run code step-by-step (single stepping) or pause at a breakpoint, to inspect variable
and find logic errors.

📌beforeErrorthe diagnostics / auto-correction: Flags likely errors as code is typed (often underlined in red) and suggests fixes
program is even run.

📌avoiding
Auto-completion: Suggests/completes variable names and reserved words as the programmer types, saving time and
typos.

📌 Auto-documenter: Automatically generates explanatory notes describing what pieces of code do.
📌 Prettyprinting: Automatically colour-codes and neatly formats/indents source code, making it far easier to read.
Extension: Interrupts in the Fetch-Execute Cycle
(For students continuing to more advanced study.) The CPU has a special interrupt register that tracks whether any interrupt
has occurred. During each Fetch-Decode-Execute cycle:
● The interrupt register is checked, bit by bit, at the end of the Execute stage.
● If an interrupt is waiting, the CPU decides — based on priority — whether to service it now.
● If serviced: the current task is suspended, its registers are saved, and control passes to the Interrupt Service Routine
(ISR).
● Once the ISR finishes, the interrupt register resets and the saved registers are restored, so the original task continues.

Complete Glossary — Key Terms & Abbreviations

Term / Abbreviation Meaning
OS Operating System — manages hardware and provides the platform for
applications and the HCI.
HCI Human Computer Interface — how a person communicates with a computer.
CLI Command Line Interface — text-based control by typing commands.
GUI Graphical User Interface — icon/picture-based control.
WIMP Windows, Icons, Menu, Pointing device — classic desktop GUI style.
HDD Hard Disk Drive — mechanical magnetic storage device.
SSD Solid State Drive — electronic (no moving parts) storage device.
RAM Random Access Memory — temporary working memory used while programs
run.
ROM Read Only Memory — permanent memory, cannot normally be changed.
BIOS Basic Input/Output System — firmware that boots the computer.
EEPROM Electrically Erasable Programmable ROM — stores the BIOS program.
CMOS Complementary Metal Oxide Semiconductor — stores BIOS settings, powered
by a small battery.
VID / PID Vendor ID / Product ID — identify a USB device's maker and model.
ISR Interrupt Service Routine — code that handles/services a specific interrupt.
PC (register) Program Counter — holds the address of the next instruction to execute.
HLL High-Level Language — programmer-friendly, hardware-independent code
(e.g. Python).
LLL Low-Level Language — hardware-dependent code (machine code or
assembly).
IDE Integrated Development Environment — a toolkit for writing/testing/debugging
programs.
GPS Global Positioning System — satellite-based location technology used by apps.
CRT Cathode Ray Tube — old type of bulky television/monitor screen.

Chapter Summary — What You Should Now Know

● The difference between system software and application software, with examples of each.
● The role of common utility programs: anti-virus, defragmentation, back-up, security, and screensavers.
● The nine key functions of an Operating System.
● How a computer boots up using BIOS, EEPROM, and CMOS.
● What an interrupt is, why it's needed, and how buffers work alongside interrupts.
● The difference between high-level and low-level (machine code / assembly) languages.
● How compilers, interpreters, and assemblers each translate code differently.
● The features of an Integrated Development Environment (IDE).