Cambridge 9618 · International A Level Computer Science · ~12 min read
Notes
Video
Slides
Quiz
Worksheet
What is a Programming Language Level?
Programming languages are described as high-level or low-level based on how close they are to human-readable language versus machine code. This affects how easy they are to write and debug, how portable they are, and how efficiently they use hardware resources.
🔵 High-Level Languages
Close to natural language — easier to read and write
Portable — runs on different hardware with little/no modification
Requires a compiler or interpreter to convert to machine code
Abstracted from hardware details
Examples: Python, Java, C++, C#, Pascal
🟣 Low-Level Languages
Close to machine code — harder to read and write
Machine/platform specific — not portable
Assembly uses mnemonics; machine code is binary
Direct control over hardware registers and memory
Examples: Assembly language, machine code
High-Level Languages
High-level languages use English-like statements, variables with meaningful names, and built-in data structures. The programmer does not need to know which CPU registers are being used — the compiler or interpreter manages this automatically.
Python (high-level)
total = 0for i in range(5): total = total + iprint(total)
Cambridge 9618 Assembly (low-level)
; Sum 0+1+2+3+4LDM#0; total = 0STOTOTALLDR#0; i = 0 (in IX)LOOP: LDDTOTALADDIXSTOTOTALINCIXCMP#5JPNLOOP
Low-Level Languages
Low-level languages give the programmer direct control over the computer's hardware:
Machine code: binary instructions directly understood by the CPU; fastest possible execution; extremely difficult for humans to write or read
Assembly language: uses mnemonics (e.g., LDD, ADD, STO) as human-readable representations of machine code instructions; each mnemonic maps 1-to-1 to a machine code instruction; still processor-specific
Comparison Table
Feature
High-Level
Assembly
Machine Code
Readability
High — close to English
Medium — uses mnemonics
Very low — binary patterns
Portability
High — cross-platform
Low — CPU-specific
Very low — CPU-specific
Execution speed
Slower (abstraction overhead)
Fast
Fastest
Memory efficiency
Less efficient
Very efficient
Most efficient
Development time
Fast
Slow
Very slow
Translator needed
Compiler/interpreter
Assembler
None
Hardware control
Indirect
Direct
Direct
Examples
Python, Java, C++
Cambridge 9618 assembly
10110000 01100001…
When to Choose Each
Choose high-level when:
Developing large applications (business software, websites, games)
Portability across different hardware is important
Development speed and maintainability matter
The team includes non-specialist programmers
Choose low-level (assembly) when:
Maximum performance is required (e.g., real-time embedded systems, device drivers)
Direct hardware control is needed (e.g., writing an interrupt handler)
Memory is extremely limited (e.g., microcontrollers with tiny RAM)
Writing operating system components that interact directly with hardware
Exam tip: Cambridge 9618 often asks you to state advantages and disadvantages of high-level vs low-level languages. Key points: high-level = portable, readable, faster development but slower execution and less hardware control; low-level = fast execution, direct hardware access, efficient memory use but hard to write, not portable, slow development.
⚠️ Common Mistakes
Saying high-level languages are "better" — they are better for most applications; low-level is better for real-time systems, device drivers, and memory-constrained environments
Saying assembly is portable — assembly code is processor-specific; code written for Cambridge 9618 assembly won't run on an x86 CPU
Confusing "high-level" with "better quality code" — the terms only refer to how close the language is to machine code vs human language
Saying machine code needs a translator — machine code IS binary and is executed directly by the CPU; no translator is needed
✅ Notes completed!
▶
Video coming soon
Click slide or press arrow keys to navigate
Worksheet — 1.5.4 High-Level vs Low-Level Languages
6 questions · instantly marked · Cambridge 9618 standard
Q1Explain the difference between a high-level language and a low-level language.[4]
✅ Mark scheme
High-level languages are close to human/natural language [1]; they are portable — can run on different hardware platforms [1]; low-level languages are close to machine code [1]; they are processor-specific / not portable [1].
Q2Give two reasons why a programmer might choose to write a device driver in assembly language rather than a high-level language.[2]
✅ Mark scheme
Any two from: assembly gives direct control over hardware registers and memory [1]; assembly code executes faster than high-level code (important for real-time hardware interaction) [1]; device drivers need to interact directly with hardware at a low level which high-level abstraction prevents [1].
Q3State three advantages of using a high-level language over assembly language for writing a large business application.[3]
✅ Mark scheme
Any three from: programs are easier to write and read (more like natural language) [1]; portable — same code runs on different hardware platforms [1]; faster development time [1]; easier to maintain and debug [1]; programmer does not need to know CPU architecture details [1].
Q4Why does machine code not require a translator?[2]
✅ Mark scheme
Machine code is already in binary (the format the CPU directly understands) [1]; no translation is needed — the CPU can fetch and execute machine code instructions without any intermediate step [1].
Q5A company writes stock-control software in Python. Explain why the same Python code would run on both Windows and Linux systems, but Cambridge 9618 assembly code would not.[3]
✅ Mark scheme
Python is a high-level language; Python source code is portable — the Python interpreter translates it on each platform [1]; assembly language is processor-specific — mnemonics and instruction sets differ between CPU architectures [1]; Cambridge 9618 assembly uses the 9618 instruction set which does not match x86 or ARM processors used in typical computers [1].
Q6Compare the development time and execution speed of high-level vs assembly language programs, explaining the trade-off.[4]
✅ Mark scheme
High-level programs are faster to develop — one statement may replace many assembly instructions [1]; but compiled high-level code is generally slower to execute than hand-optimised assembly due to compiler overhead and abstraction [1]; assembly programs take much longer to write (more instructions needed) [1]; but execute very quickly because the programmer can optimise precisely for the hardware [1].
Q7Explain why a program written in assembly language for one processor architecture (e.g. ARM) cannot run directly on a processor with a different instruction set (e.g. x86), whereas a Python program can run on both. Include reference to machine code, mnemonics, and interpreters.[5]
✅ Mark scheme
Assembly language uses mnemonics that map directly to a specific processor's machine code instruction set — 1 mark; different processors have different binary opcodes for the same operation — 1 mark; assembly must be assembled into machine code for a specific architecture — not portable — 1 mark; Python is interpreted: source code is translated at runtime by a Python interpreter installed on the machine — 1 mark; the interpreter itself is compiled for each architecture, so the same Python source code can run anywhere a compatible interpreter exists — 1 mark.
Q8Describe two advantages of using a high-level language over assembly language for a large business application. Describe one advantage of using assembly language over a high-level language for a time-critical embedded system.[4]
✅ Mark scheme
HLL advantage 1: code is more readable and maintainable; easier for large teams to collaborate — 1 mark; HLL advantage 2: code is portable across different hardware platforms without rewriting — 1 mark; Assembly advantage: precise control over memory and CPU registers allows tighter, faster code that meets strict timing requirements in embedded systems (e.g. anti-lock braking, pacemaker) — 1 mark; (valid additional detail) — 1 mark.
Topic Quiz
Question 1 of 10
You scored
out of 10
Card 1 of 6
Click to reveal definition
🎉
All cards reviewed!
Term
Definition
🎯
Mini Test — 1.5.4 High vs Low Level
10 questions · 10 marks · 10 minutes
⏱ 10:00
Section A — Multiple Choice [5 marks]
Q1Which is an advantage of high-level languages over assembly?
Q2Machine code requires which translator?
Q3Which scenario is best suited for assembly language?
Q4Assembly language is NOT portable because:
Q5Which executes fastest?
Section B — Short Answer [5 marks]
Q6State two advantages of assembly language over high-level languages.
Mark schemeFaster execution [1]; more direct control over hardware (registers, memory) [1]; more memory efficient [1]. (Any 2)
Q7Explain what is meant by "portability" in the context of programming languages.
Mark schemeA portable program can run on different hardware platforms / operating systems with little or no modification [1]; high-level language programs are portable because their source code is translated by a platform-specific compiler or interpreter [1].
Q8Why does writing programs in assembly language take longer than in a high-level language?
Mark schemeEach assembly instruction does only one very simple operation [1]; many assembly instructions are needed to perform what a single high-level statement achieves, making programs longer and more tedious to write [1].
Q9Give one example of a situation where the slower execution of a high-level language would be unacceptable.
Mark schemeReal-time embedded systems (e.g., airbag controller, cardiac pacemaker firmware) [1] — where a timing delay could cause failure. Also accept: device drivers, OS kernel code, microcontroller code with tiny memory.
Q10Explain why assembly language is described as a low-level language.
Mark schemeAssembly language is close to machine code — each mnemonic maps directly to one machine code instruction (1-to-1) [1]; it works at the level of individual CPU registers and memory addresses, with no abstraction of hardware details [1].