SLIDE 1
CSZone.co.uk
Click to advance · Arrow keys also work
CAIE 9618 · Paper 1 · Topic 1.5.4

High-Level vs
Low-Level Languages

Generations · Features · Comparison · Programming Paradigms

CSZone Cambridge International AS & A Level Computer Science 9618
Low-Level Languages

Close to the Hardware

MACHINE CODE (1st GENERATION)
Pure binary (0s and 1s). Directly executed by CPU. No translation needed. Extremely difficult for humans to read or write. Platform-specific.
ASSEMBLY LANGUAGE (2nd GENERATION)
Mnemonics represent machine code (LDM, ADD, STO). Requires assembler. Near 1-to-1 with machine code. Still CPU-specific. Gives direct hardware access. More readable than machine code.
Uses of low-level: device drivers, OS kernels, embedded systems, real-time systems, where maximum performance and hardware control are essential
High-Level Languages

Closer to Human Thought

High-level languages (3rd generation and above) use English-like syntax, abstract away hardware details, and are portable across different platforms. They require a compiler or interpreter to translate to machine code.
ADVANTAGES
Easier to write and understand. Portable — same code runs on different hardware (after recompiling). Better for large, complex programs. Richer features (OOP, recursion, libraries).
DISADVANTAGES
Slower execution than low-level. Less direct hardware control. Compiled code may be less optimal than hand-written assembly for time-critical applications.
Generations of Languages

1GL to 5GL

GenerationTypeExampleNotes
1GLMachine Code10110000 01100001Binary, directly executable, no translator
2GLAssemblyLDM #5, ADD 100Mnemonics, assembler required
3GLHigh-Level ProceduralPython, Java, C++Compiler/interpreter, portable
4GLVery High-LevelSQL, MATLABDomain-specific, declarative, less code
5GLAI / Logic BasedPrologDescribe problem, let computer find solution
Programming Paradigms

Different Ways to Write Programs

PROCEDURAL
Sequence of instructions, procedures/subroutines. Step-by-step. Examples: Pascal, C, early Python. Most common paradigm at A-Level.
OBJECT-ORIENTED
Data and methods in classes/objects. Encapsulation, inheritance, polymorphism. Examples: Java, C++, Python (OOP features).
DECLARATIVE
Describe WHAT you want, not HOW to get it. Examples: SQL (queries), HTML. Computer works out the steps.
FUNCTIONAL
Functions as first-class objects. No side effects. Examples: Haskell, Erlang. Mathematical approach to programming.
Exam Practice

Cambridge-style questions

Question 1
A developer needs to write a device driver for a new graphics card. Explain why they would choose assembly language over a high-level language. Give two reasons.
4 marks
1 mark
Direct hardware control — assembly language allows manipulation of specific memory addresses and CPU registers; device drivers need to control hardware directly at a low level
1 mark
Maximum efficiency/performance — assembly code executes faster than compiled high-level code; device drivers need to be extremely fast to avoid bottlenecking the system
1 mark
Smaller code size — assembly produces compact machine code; important for embedded/firmware contexts where storage may be limited
1 mark
No abstraction overhead — high-level languages add runtime overhead from garbage collection, type checking, etc., which is unacceptable for time-critical driver code
Common Mistakes

Don't lose easy marks

1
Saying high-level languages are always better — it depends on context. For device drivers, embedded systems, and OS components, low-level languages give essential control and speed. High-level is better for application development and productivity.
2
Saying "high-level language is easier" without specifying easier for what — write more precisely: "easier to read and write," "easier to debug," "requires fewer instructions to accomplish the same task." General statements earn fewer marks.
3
Confusing portable and platform-independent — high-level source code is portable (the same source file can be compiled on different platforms). But the compiled executable is platform-specific. The source is portable; the binary usually isn't.
Topic Summary — 1.5.4

What You Need to Know

LOW-LEVEL (1GL + 2GL)
Machine code (binary) + Assembly (mnemonics)
Direct hardware control, maximum speed
Platform-specific, hard to write
Use for: drivers, OS, embedded, firmware
HIGH-LEVEL (3GL+)
English-like, abstract, portable
Easier to write/debug, rich features
Compiler or interpreter needed
Use for: applications, web, AI, databases
PARADIGMS
Procedural: step-by-step instructions
OOP: classes, objects, encapsulation
Declarative: describe what, not how
Functional: mathematical, pure functions
CSZone

Next Video

1.5.5
RISC vs CISC
Architecture Comparison · Pipelining · Trade-offs
Head to CSZone.co.uk for the complete worksheet, quiz, and interactive tools