1. Levels of Programming Languages
What is a programming language, really?
Think of a programming language as a translator between two very different minds. You think in
words, logic, and intentions ("if the user is under 18, don't let them in"). The processor inside your computer
only understands electrical signals that we represent as binary — long strings of 0s and 1s.
A programming language exists purely to bridge that gap.
In the earliest days of computing, there was no bridge at all — programmers wrote raw binary by hand. This was
brutally slow; a task that takes a few minutes in Python today could take days to hand-code in
pure binary, and one misplaced digit could break everything. Over time, new "generations" of languages were
invented that let humans write in something closer and closer to natural language, while a piece of software
did the tedious job of converting it down to binary.
🧠 Analogy: Ordering food in a country where you don't speak the language
Machine code is like pointing at ingredients on shelves yourself and cooking the meal — total control, but
exhausting and slow. Assembly is like using a very literal phrasebook where every phrase maps to exactly
one thing you can say to the chef. A high-level language is like having a fluent friend translate your
sentence "I'd like something spicy and vegetarian" — one sentence from you turns into several precise
instructions for the chef.
The Generation Ladder
Low-level → 1st Generation: Machine Code | 2nd Generation: Assembly Code
High-level → 3rd Generation: Languages like Python, Java, C++, BASIC
Low-Level Languages
A low-level language is one that directly translates to (or literally is) machine
code — the exact binary instructions a specific processor understands. Because it's so close to the hardware,
it gives the programmer direct control over things like memory addresses and registers. The
catch: these languages are written for a specific processor's architecture, so code written
for one type of chip won't necessarily run on another.
First Generation: Machine Code
Machine code is pure binary — the instructions are directly executable by the
processor with zero translation needed, because it literally is the processor's native
language. There's nothing "between" your code and the hardware.
Quick Memory Hook
Machine code = binary = 1st generation = no translation required (it's already in the processor's language).
Second Generation: Assembly Code
Covered in full detail in Section 2 below — but as a quick preview: assembly code replaces confusing strings
of binary with short, readable text commands called mnemonics (like LDA for
"load" or STA for "store"). It's a small but massive readability upgrade over raw binary, while
still keeping a 1-to-1 relationship with machine code instructions.
Practice Question 1
Explain why early computers required instructions to be written directly in binary, and state one problem this caused for programmers.
| Advantages (Low-level) | Disadvantages (Low-level) |
|---|
| Complete control over the system components | Difficult to write and understand |
| Occupies less memory and executes faster | Machine (processor) dependent — won't run on other hardware |
| Direct manipulation of hardware | More prone to errors |
| Requires deep knowledge of computer architecture to program effectively |
Examiner Tip
Don't just write "low-level languages are faster" in an exam — that's vague and won't earn full marks. Say
exactly
why: they allow
direct control over hardware or memory, which cuts out
translation overhead and lets the programmer optimise for that exact chip.
High-Level Languages
A high-level programming language uses English-like statements
(e.g. print, if, for) so that programmers can write code that's easy to
read, write, and — crucially — debug and maintain long after it was first written. High-level
languages became necessary as processors got faster and memory capacity increased, because the extra
"overhead" of translating the code became affordable in exchange for huge gains in programmer productivity.
The defining feature: one line of high-level code can translate into many machine code
instructions — the complete opposite of assembly's strict 1-to-1 rule. This is exactly why it needs to
be translated before a processor can run it (more on this in Section 3).
name = input("Enter your name: ")
Common examples of high-level languages: Python, Java, BASIC, C++.
| Advantages (High-level) | Disadvantages (High-level) |
|---|
| Easier to read and write | User cannot directly manipulate the hardware |
| Easier to debug | Needs to be translated to machine code before running |
| Portable — can be used on any computer | The resulting program may be less efficient |
| One line of code can perform multiple commands | |
Practice Question 2
A programmer needs to write software that will run on many different types of computer with minimal changes. Would a low-level or high-level language be more suitable? Justify your answer.
Common Misconception
Students often think "high-level" means "more advanced/complicated" — it's actually the opposite. High-level
means
further away from the hardware, closer to human language. "Low-level" doesn't mean
"worse" either — it means closer to the raw machine.
2. Assembly Language
Assembly language is a second-generation, low-level language designed to make writing machine
code instructions less painful for humans, while still keeping the programmer extremely close to the
hardware.
Why would a programmer choose assembly language?
- They need to make use of specific hardware or parts of the hardware directly
- They need to complete machine-dependent instructions unique to that processor
- They want to make sure too much space isn't taken up in RAM (very memory-efficient)
- They want the code to run as fast as possible — no translation overhead at runtime
Mnemonics — the heart of assembly language
Instead of memorising binary patterns, assembly programmers use short abbreviated text commands called
mnemonics. Each mnemonic is a stand-in for one specific machine code instruction.
LDA
ADD
STO
The Golden Rule of Assembly
One assembly language instruction always translates to exactly one machine code instruction. (Compare this to high-level languages, where one line can become many instructions!)
How does a mnemonic actually become machine code?
- The computer receives a mnemonic (e.g.
STO).
- An assembler (the translator for assembly language) looks the word up in a specific lookup table.
- If a match is found, the mnemonic is replaced with the exact binary code that matches that instruction.
- The resulting binary is what the processor actually executes.
🧠 Analogy: A phrasebook, not a full translator
Imagine you're using a phrasebook with a fixed list of exact phrases and their translations — no
interpretation, no flexibility, just a strict lookup. That's an assembler: it doesn't "understand" your
code the way a human translator understands a sentence; it just matches each mnemonic to its one binary
equivalent and swaps it in.
Practice Question 3
A student writes the following code: 10110111. Is this machine code, assembly code, or a high-level language? Then classify: INP X / STA X / LDA Y. Explain your reasoning for both.
Examiner Tip
Students often confuse machine code and assembly. Remember this simple rule:
Machine code = binary (1st generation, no translator needed).
Assembly = mnemonics (2nd generation, needs an assembler).
3. Translators, Compilers & Interpreters
What is a translator?
A translator is any program that converts source code into machine code so a processor can
execute it directly. Which translator you use depends on which kind of language you wrote your code in:
- Low-level languages (assembly code) → translated by an assembler
- High-level languages (Python, Java, C++) → translated by a compiler or an interpreter
Compilers
A compiler takes the entire high-level source code and translates it into machine code
all in one go, before the program is ever run. Compilers are typically used once a program is
finished and has already been checked for syntax errors. The output is a standalone
executable file that can be distributed and run on a compatible machine
without needing the original translation software installed.
If an error is found and fixed afterwards, the entire program must be recompiled from
scratch — there's no "patching" a single line.
🧠 Analogy: Translating a whole book before publishing it
A compiler is like a translator who reads your entire novel, translates every single page into another
language, and only then hands you the finished, printed book. If you spot a typo on page 200 afterwards,
you can't just fix that page — you have to send the whole manuscript back through translation again.
| Advantages (Compiler) | Disadvantages (Compiler) |
|---|
| Speed of execution (already translated, runs instantly) | Can be memory intensive |
| Optimises the code as it translates | Difficult to debug (errors reported after the whole thing runs) |
| Original source code isn't revealed to the end user | Any change means the whole program must be recompiled |
| Designed solely for one specific processor/platform |
Interpreters
An interpreter translates high-level code into machine code one line at a time,
executing each line immediately after it's translated. If it hits a line with an error, it
stops immediately — the rest of the program never even gets translated. Interpreters are
typically used while a program is still being written and tested (the development stage),
because they make it fast to test small changes.
Unlike compiled code, interpreted code is harder to distribute, since the receiving computer
needs the translation software (the interpreter) installed to run it at all.
🧠 Analogy: A live interpreter at a conference
An interpreter is like the person standing beside a speaker, translating each sentence into another
language the moment it's spoken, live, to the audience. If the speaker says something garbled or
nonsensical, the interpreter stops right there — they don't skip ahead and translate the rest of the
speech first.
| Advantages (Interpreter) | Disadvantages (Interpreter) |
|---|
| Stops immediately at the specific syntax error, pinpointing it | Slower overall execution |
| Easier to debug (errors caught line-by-line) | Every time the program runs, it must be translated again |
| Requires less RAM to process the code | Executed as-is — no optimisation of the code |
Practice Question 4
(a) State why a computer needs to translate high-level code before it is executed. [1]
(b) Describe two differences between how a compiler and an interpreter translate code. [2]
Common Mistake
Don't say "a compiler is always better than an interpreter" — they suit
different stages.
Interpreters shine during development (fast feedback, easy debugging); compilers shine for the finished,
distributed product (fast execution, no exposed source code).
4. Tools & Facilities in IDEs
An Integrated Development Environment (IDE) is software designed to make writing high-level
code as smooth and efficient as possible. Rather than juggling a plain text editor, a separate translator, and
a separate program to run your code, an IDE bundles all of that — plus helpful extras — into one application.
The 4 Core Components of an IDE
Editor → Error Diagnostics → Run-time Environment → Translator
Editor
Basic code formatting tools
Changing font, font size, making text bold, etc — just like a word processor for code.
Prettyprint (syntax highlighting)
Uses colour to make keywords instantly recognisable — e.g. print, input, and if shown in different colours in Python.
Code editing tools
Auto-completion and auto-correction of code, automatic bracket matching, and live syntax checks as you type.
Commenting code
Lets you quickly "comment out" sections of code so they don't run — useful for testing or leaving notes about what the program is doing.
Error Diagnostics
Identifying errors
Highlights the exact area of code with the issue, or shows a direct error message explaining what went wrong (e.g. indentation errors).
Debugger
Provides a "step through" command that runs the program one line at a time, showing exactly what's happening at each step — extremely useful for tracking down logic errors that don't cause a crash but still produce wrong results.
Run-time Environment
Gives the programmer the ability to actually run the program and immediately see the
corresponding output, all inside the same window — no need to switch to a separate application.
Translator (built-in)
Modern IDEs have a compiler or interpreter built directly into the software, so you don't
need to install or run a separate translation program — you just hit "Run."
Why This Matters
Without an IDE, a programmer would need a plain text editor, a completely separate compiler/interpreter
program, and yet another tool to check for errors — all disconnected. An IDE removes that friction, which
is exactly why almost every professional programmer uses one.
Practice Question 5
A student's Python program runs without crashing, but keeps producing the wrong output. Which IDE tool is best suited to help them find the problem, and why?