Types of Software & Interrupts

A visual, easy-to-follow study guide — with diagrams for every core idea

On this page
1. The Software Hierarchy
2. System vs Application Software
3. Application Software Types
4. System Software Types
5. Utility Programs
6. Operating System Functions
7. CLI vs GUI
8. Booting a Computer
9. Interrupts & Buffers
10. Glossary
11. One-Glance Summary

1. The Software Hierarchy

Every computer is built in three stacked layers. Each layer depends completely on the one beneath it.

APPLICATION SOFTWARE
Word Processor · Spreadsheet · Games · Browser · Database · CAD

SYSTEM SOFTWARE
Operating System · Utility Programs · Device Drivers

HARDWARE
CPU · RAM · HDD/SSD · Printer · Screen

Each layer only works because the layer below it is running

Fig 1. The three-layer software/hardware hierarchy

Real-life analogy: On your phone — the hardware is the physical chip and screen; the system software is
Android/iOS making the buttons and camera actually work; the application software is Instagram or
WhatsApp, the apps you actually open and use.

2. System Software vs Application Software

 SYSTEM SOFTWARE

Runs the machine

Controls & manages hardware, provides a platform for other software to run, gives you a way to interact with
the computer (HCI), and allocates hardware resources.

Example: Windows, macOS, a printer driver

APPLICATION SOFTWARE

Does the task you want

Lets the user perform a specific job. Can be a single program (Notepad) or a suite (Microsoft Office). The user
chooses when to run it.

Example: Excel, Chrome, Minecraft

3. Application Software — Types & Real-Life Examples

Spreadsheet
Numbers organised in cells (e.g. B6); formulas, graphs, "what-if" modelling.

Excel — forecasting a shop's monthly profit

Database
Tables of rows (records) & columns (fields); supports queries and reports.

A school database — "list all Grade 10 students"

Apps (mobile)
Downloaded from an App Store; games, streaming, GPS, banking, camera.

Google Maps, Spotify, Instagram

Control & Measuring

Reads sensor data & controls a real process by comparing to stored values.

Factory adding acid when a pH sensor detects imbalance

Video Editing
Rearranges clips, adds titles/transitions, colour correction, sound editing.

Adobe Premiere — editing a YouTube vlog

 Graphics Manipulation
Edits bitmap (pixels) or vector (lines/curves) images.

Photoshop (bitmap) vs Illustrator (vector) — logo design

Photo Editing
Brightness, contrast, saturation, red-eye removal, retouching.

Removing a photobomber from a holiday picture

Word Processor
Create/edit/format text, spellcheck, copy-paste, import images.

Microsoft Word — writing a CV or essay

4. System Software — Types & Real-Life Examples

COMPILER

Translates high-level language (HLL) source code into machine code (object code) the CPU can run directly.

Turning a Python program into an executable

LINKER

Joins separately-written object files (modules) into one final runnable program.

Combining a game's graphics + sound + physics modules into one .exe

OPERATING SYSTEM

Background software handling I/O, the user interface, error handling, and program execution.

Windows, macOS, Android, iOS

DEVICE DRIVER

Lets one hardware device "speak the same language" as the operating system.

Installing a driver so a new printer works with your laptop

UTILITY PROGRAMS

Small tools that manage, maintain and protect computer resources (see next section).

Antivirus, disk defragmenter, backup software

5. Utility Programs — In Depth

Virus Checkers (Anti-virus)

Yes Quarantine
(delete or user decides)

Compared to virus
File scanned Suspicious?
database + heuristics

No File runs normally

Fig 2. How anti-virus scanning decides a file's fate

Watch out — false positive: a completely safe file can sometimes get wrongly flagged as a virus.

Defragmentation Software

Over time, files get scattered ("fragmented") across disk sectors, forcing the read/write head to jump around
→ slower access. Defragmentation rearranges data into contiguous (side-by-side) sectors.

BEFORE — File 1 is scattered

0 1 2 3 4 5 6 7 8 9 10 11

↑ File 1 (navy) is split into two separate groups — extra head movement needed

AFTER — Defragmented (contiguous)

Fig 3. Navy = File 1, Orange = File 3, Beige = free sectors. Notice File 1 becomes one solid block after
defragmentation.

⚠ SSDs (solid state drives) do not need defragmenting — they have no moving read/write head, so scattered
data isn't a speed problem.

Backup Software — The Rule of 3 Copies

1. Working copy 2. Local backup 3. Remote backup

Internal HDD / SSD Portable / external SSD Off-site / cloud storage

Fig 4. For full safety, an important file should exist in all three places at once

OS Utility Behaviour
Windows File History Hourly snapshots to an external drive; keeps old versions forever unless changed

macOS Time Machine Hourly → daily (past month) → weekly (older); oldest deleted when drive fills up

Security Software & Screensavers

Security software manages user accounts/passwords, works with antivirus, runs firewalls, encrypts/decrypts
data, and verifies that updates come from a trusted source.

Screensavers originally stopped "phosphor burn" on old CRT screens. Today they mainly trigger auto-logout
for security, or run background tasks (like a virus scan) while the computer is idle.

6. Operating System — 9 Core Functions

HCI
CLI or GUI interface

App Platform Memory Management

Environment for apps to run Tracks & protects RAM use

Interrupt Handling OPERATING Security Mgmt

Pauses tasks to service signals SYSTEM Passwords, firewall, updates

Hardware/Peripheral
File Management Manages drivers, queues, buffers
Create, rename, move, delete
Multitasking
Shares CPU across processes

User Account Management

Fig 5. The nine core jobs of an Operating System, radiating out from its central role

Function Real-life example

Memory management Prevents Chrome and Word from corrupting each other's data in RAM

Security management Blocking repeated failed login attempts

Hardware/peripheral mgmt A printer holding multiple documents in a queue

File management Right-click → Rename on a file

Multitasking Listening to Spotify while browsing Chrome

 User account management A school computer where teachers get more access than students

7. Human Computer Interface: CLI vs GUI

>_

CLI — Command Line Interface

Type text commands to control the computer.
✅ Direct control, unrestricted options, uses little memory
❌ Must memorise commands, slow, error-prone typing

Used by: programmers, technicians, network admins

GUI — Graphical User Interface

Click icons/windows with a mouse or touch.
✅ User-friendly, no commands needed
❌ Uses far more memory, limited to icons provided

Used by: everyday end-users

GUI uses WIMP = Windows, Icons, Menus, Pointer. Touchscreens use post-WIMP gestures (pinch, swipe,
rotate).

A network engineer configuring a router types commands (CLI). A student opening Instagram just taps icons
(GUI).

8. Booting Up a Computer

Power ON Finds storage Loads OS into RAM OS running

BIOS activates device holding the OS ("bootstrap loading") Ready to load apps

Fig 6. The boot sequence, start to finish

Term Full form Role

BIOS Basic Input/Output System Firmware that starts the motherboard and finds the OS

EEPROM Electrically Erasable Stores the BIOS program; keeps data with no power, but can be updated
Programmable ROM

CMOS Complementary Metal- Stores BIOS settings (e.g. clock speed); needs constant battery power —
Oxide-Semiconductor resets to factory defaults if battery removed
9. Interrupts & Buffers

An interrupt is a signal sent to the CPU telling it to pause its current task and deal with something more
urgent.

Cause Real-life example

Timing signal A scheduled system clock tick

I/O process A printer or disk drive requesting more data

Hardware fault Paper jam in a printer

User interaction Pressing Ctrl+Alt+Break

Software error Divide by zero, missing .exe file, two processes clashing over memory

How an interrupt is serviced

1. Interrupt 2. Save status 3. Run ISR 4. Resume

signal received Program Counter + registers Interrupt Service Routine Restore registers, continue

Fig 7. PC = Program Counter, ISR = Interrupt Service Routine

Why buffers matter

A buffer is a temporary storage area that compensates for the speed mismatch between a fast CPU and a
slow device.

Streaming a movie: data downloads faster than you watch it, so it's held in a buffer to stop the video "freezing."

Flowchart: printing a document (buffer + interrupt working together)

 Any data to send
to the printer?

Yes

Data sent from memory

to the PRINTER BUFFER

Processor is FREE to do
other tasks while buffer empties
to the printer

Buffer empties → INTERRUPT

signal sent asking for more data
(current task is suspended while serviced)

No All data sent

to printer?

Yes

Printing complete ✔

Fig 8. The printer keeps looping back for more data until the whole document is printed — all while the CPU is free to
multitask

Without buffers and interrupts, the CPU would sit idle waiting for the (very slow) printer — a massive waste of
processing power. This is the same idea behind downloading a file while listening to music "at the same time."

10. Glossary of Abbreviations

OS Operating System — manages hardware & runs apps

HCI Human Computer Interface — CLI or GUI

CLI Command Line Interface — text-based

GUI Graphical User Interface — icon/window-based

WIMP Windows, Icons, Menus, Pointer — classic GUI model

HLL High-Level Language — e.g. Python, Java, C++

HDD Hard Disk Drive — mechanical magnetic storage

SSD Solid State Drive — flash storage, no moving parts

BIOS Basic Input/Output System — boots the computer

EEPROM Electrically Erasable Programmable ROM — stores the BIOS

CMOS Complementary Metal-Oxide-Semiconductor — stores BIOS settings

PC Program Counter — register holding the next instruction's address

ISR Interrupt Service Routine — code that handles an interrupt

VID/PID Vendor ID / Product ID — identify USB devices

RAM Random Access Memory — temporary working memory

11. One-Glance Summary

Software = System (runs the machine) + Application (does the task)

Utilities = antivirus, defrag, backup, security, screensavers — all maintain the computer
OS = the "manager" — memory, security, files, multitasking, hardware, interrupts, user accounts,
HCI
CLI = power & control (techies) · GUI = ease of use (everyday users)
Booting = BIOS (in EEPROM) → finds OS → loads it into RAM

Interrupts = an "urgent tap on the shoulder" for the CPU; buffers stop the CPU wasting time
waiting on slow devices
 ​ Programming Languages, Translators
& IDEs
A visual, easy-to-follow study guide — with diagrams for every core idea

On this page
1. What Is a Program?
2. High-Level vs Low-Level Languages
3. Machine Code
4. Assembly Language
5. Translators: Compiler, Interpreter, Assembler
6. Compiler vs Interpreter
7. Integrated Development Environments (IDEs)
8. Extension: Interrupts in the Fetch–Execute Cycle
9. Glossary
10. One-Glance Summary

1. What Is a Program?

A computer only understands one language natively: machine code (binary). Everything a
programmer writes eventually has to become machine code before the computer can run it — just like
two people who speak different languages need a translator.

​ TRANSLATOR
Compiler / Interpreter / Assembler
Programmer Computer
writes HLL code runs machine code

01001100 01000100 01000001 ...

Fig 1. Every program must be translated into binary machine code before the CPU can run it

2. High-Level Languages vs Low-Level Languages

HIGH-LEVEL LANGUAGE (HLL)

Written for humans

Close to English, hardware-independent, portable across different computers. Faster to write, read, debug and
maintain.

Sum := FirstNumber + SecondNumber

 Examples: Python, Java, C++, Pascal, Visual Basic

LOW-LEVEL LANGUAGE

Written for the machine

Tied to a specific computer's hardware/architecture. Includes machine code (binary) and assembly language.

0001 00010010
0100 00010011
0000 00011010

Used when speed or hardware control matters most

Advantages Disadvantages

High- Independent of computer type · Easier to Programs can be larger · Can take
level read/write/understand · Quicker to write · Easier & quicker to longer to execute
debug · Easier to maintain

Low- Can use special hardware · Uses machine-dependent May not use special hardware portably ·
level instructions · Small memory footprint · Executes a task very Longer to write & debug · Harder to
quickly understand

3. Machine Code

The computer's native language — pure binary instructions. Programmers rarely write it directly because it's
extremely hard to read, so it's usually shown in hexadecimal for convenience.

Hexadecimal Binary

1 12 0001 00010010
4 13 0100 00010011
0 1A 0000 00011010

The same "Sum := FirstNumber + SecondNumber" instruction, written in machine code

4. Assembly Language

A step up from machine code — uses short memorable mnemonics instead of binary/hex. Still tied to specific
hardware, so must be translated by an assembler before running.

LDA First ; load value of First into accumulator

ADD Second ; add value of Second to accumulator
STO Sum ; store accumulator's value into Sum

Fig 2. Assembly language for "Sum := First + Second" — one mnemonic per operation
 Why would anyone still write assembly? To use special hardware, use machine-dependent instructions,
save memory space, or make code run as fast as possible.

5. Translators: Compiler, Interpreter, Assembler

A translator is a utility program that turns human-written code into machine code. There are three types:

COMPILER

Translates an entire HLL program into machine code all in one go, producing an executable file. If errors exist,
no program is produced — just an error report.

Runs without the compiler afterwards

INTERPRETER

Translates and runs one statement at a time. Stops immediately at the first error, often suggesting a fix.
Must re-translate the program every time it's run.

Needs the interpreter every time it runs

ASSEMBLER

Translates assembly language into machine code. Usually one assembly statement → one machine code
instruction. Produces a reusable executable.

Runs without the assembler afterwards

How a compiler works

Entire HLL program Executable machine code file

COMPILER
Sum := First + Second Runs anytime — no compiler needed again

If errors found → an error report is produced instead

Fig 3. A compiler translates everything up-front, once

How an interpreter works

Read one Translate Execute Error found?

statement it it immediately Stop + show message

Repeat for the next statement (no error = keep going)

 Fig 4. An interpreter works statement-by-statement, and must be present every time the program runs

Compiler Interpreter Assembler

Translates Whole HLL program at once One HLL statement at a time Assembly language program

Output Executable machine code file No executable file produced Executable machine code
file

Needed No Yes, every time No

again to run?

Typical use Distributing finished software Developing/testing a program Distributing finished

software

Statement 1 HLL statement → several 1 HLL statement → several 1 statement → usually 1

ratio machine instructions machine instructions machine instruction

6. Compiler vs Interpreter — Advantages & Disadvantages

INTERPRETER

✅ Easier & quicker to debug/test while developing · Easier to edit during development
❌ Can't run without the interpreter · Slower to execute

COMPILER

✅ Runs without the compiler · Compiled program stored ready-to-use · Takes up less memory when running ·
Executes faster
❌ Takes longer to write, test and debug during development

Many real IDEs use both: an interpreter while you're writing/testing code, then a compiler to produce the final,
fast, distributable version.

7. Integrated Development Environments (IDEs)

An IDE bundles everything a programmer needs into one piece of software — e.g. PyCharm (Python),
Visual Studio (Visual Basic/C#), BlueJ (Java).
 Code Editor
Write & edit code in one place

Prettyprinting Translator
Colour-codes & formats code Compiler and/or interpreter

IDE Runtime + Debugger

core features Single-step, breakpoints

Auto-documenter Error Diagnostics

Explains code + prettyprinting Flags errors live, suggests fixes

Auto-completion
Suggests variables, keywords

Fig 5. The core features bundled inside a typical IDE

Code editor
Write and edit code without switching to a separate text editor — speeds up development.

Translator
Usually offers both a compiler and interpreter — interpreter for development, compiler for the final release
version.

Runtime + Debugger
Single-stepping runs one line at a time; breakpoints pause execution so a report window can show variable
contents — helps find logic errors.

⚠ Error diagnostics & auto-correction

Underlines errors (often in red) as you type, and suggests fixes before you even run the program.

⌨ Auto-completion
Context-sensitive prompts for variable names and reserved words as you type.

Auto-documenter & prettyprinting

Auto-documenter explains what a piece of code does; prettyprinting colour-codes and neatly lays out the
program (e.g. strings shown in red).

8. Extension: Interrupts in the Fetch–Execute Cycle

A special interrupt register tracks whether an interrupt has occurred while the CPU is mid-cycle. For
example, its status might change from 0000 0000 to 0000 1000 if a fault occurs writing to the hard drive.

1. At the next Fetch–Execute cycle, the interrupt register is checked bit by bit
2. A non-zero pattern means an interrupt is waiting to be serviced (or ignored, based on priority)
3. The CPU stops its current task and saves its register contents
4. Control transfers to the Interrupt Service Routine (ISR), aka the interrupt handler
5. Once serviced, the register is reset and the saved register contents are restored

START

No
Any
Fetch the next instruction Decode and execute instruction interrupts?

Yes

No
End of
(ISR services the interrupt, then loops back)
program? Interrupts are disabled
Yes

END
Fig 6. Interrupt checking happens once per Fetch–Execute cycle — right after an instruction is decoded and executed

Key idea: Interrupts are only checked at fixed points in the cycle (not mid-instruction), and can be temporarily
disabled while one is already being serviced so a second interrupt can't interrupt the interrupt.

9. Glossary of Abbreviations

HLL High-Level Language — e.g. Python, Java, C++, Pascal

IDE Integrated Development Environment — e.g. PyCharm, Visual Studio, BlueJ

ISR Interrupt Service Routine — code that handles an interrupt (aka interrupt handler)

LDA LoaD Accumulator — assembly mnemonic to load a value into the accumulator

ADD Assembly mnemonic to add a value to the accumulator

STO STOre — assembly mnemonic to save the accumulator's value to a variable

10. One-Glance Summary

Computers only understand machine code — everything else must be translated

High-level languages = easy for humans, portable · Low-level languages (machine code &
assembly) = hardware-specific, fast, compact
Compiler = translates the whole program once, produces a standalone executable, runs fast

Interpreter = translates & runs one line at a time, needed every run, great for
development/debugging

Assembler = turns assembly mnemonics (LDA/ADD/STO) into machine code, usually 1:1
IDEs bundle a code editor, translator, debugger, error diagnostics, auto-completion, and auto-
documenter/prettyprinting into one tool
Fetch–Execute cycle checks the interrupt register once per cycle; interrupts are disabled while one
is already being serviced