AQA A-Level Computer Science (7517)

## Learning Outcomes

- Distinguish clearly between **low-level** and **high-level** programming languages
- Explain the difference between **machine code** and **assembly language**
- Understand what **imperative** and **declarative** languages mean, and why these are separate from low-level/high-level classification
- Compare the roles of an **assembler**, **compiler**, and **interpreter**
- Apply these ideas to exam questions that ask for comparisons, examples, advantages, disadvantages, and suitable use cases
- Avoid common misconceptions, such as treating assembly language as machine code or assuming all high-level languages are interpreted

## AQA A-Level Computer Science (7517) Syllabus

For the AQA A-Level Computer Science (7517), you are expected to understand programming language classification, with a focus on the following syllabus points:

- Know that programming languages can be classified as **low-level** or **high-level**
- Identify **machine code** and **assembly language** as the two main low-level languages
- Explain the meaning of an **imperative high-level language**
- Understand the distinction between **imperative** and **declarative** languages
- Explain how **assemblers**, **compilers**, and **interpreters** translate source code
- Understand the relationship between **source code**, **object code**, and executable machine code
- Compare the practical advantages and disadvantages of low-level and high-level programming
- Recognise suitable examples, such as **Python**, **Java**, **C#**, **SQL**, **Prolog**, machine code, and assembly language

## Test Your Knowledge

_Attempt these questions before reading this article. If you find some difficult or cannot remember the answers, look more closely at that area during your revision._

1. What is the difference between **machine code** and **assembly language**?
2. Why is a language such as Python described as **high-level**?
3. How is **imperative** classification different from **high-level/low-level** classification?
4. What does an **assembler** do, and how is that different from a compiler?
5. Why might a programmer choose a low-level language instead of a high-level one?

## Introduction

Programming languages are not all the same. Some are very close to the hardware of the computer, while others are designed to make problem-solving easier for humans. In exam questions, AQA often tests whether you can classify a language correctly and explain the consequences of that classification.

This topic matters because it links directly to how programs actually run. A student may be able to write Python, but the processor does not execute Python directly. The CPU only executes machine code, so every language above that level must somehow be translated. To answer exam questions well, you need to know not just the labels, but why those labels matter for portability, debugging, speed, hardware control, and maintenance.

> **Key Term: programming language classification**
> The grouping of programming languages according to features such as their level of abstraction from hardware or the way programs express solutions.

### Low-level and high-level languages

The first major way to classify languages is by how close they are to the hardware.

A **low-level language** is close to the architecture of the computer. It describes operations in a form that closely matches what the processor actually does: loading data, storing data, adding values, comparing values, and branching to another instruction. Because of this closeness, low-level code gives more direct control over the hardware.

A **high-level language** is much further from the hardware. It uses structures such as `IF`, `WHILE`, procedures, functions, variables, parameters, and objects. Instead of focusing on registers and exact memory operations, the programmer focuses on the algorithm and the problem being solved.

> **Key Term: low-level language**
> A programming language that is close to the hardware and describes operations in a machine-oriented way.
>
> **Key Term: high-level language**
> A programming language that is more abstract from the hardware and uses English-like keywords and structured constructs.

The two low-level languages you must know are **machine code** and **assembly language**.

**Machine code** is the binary instruction set directly acted on by the processor. Every CPU executes machine code only. That is why machine code is the true final form of executable instructions for the processor. If a question asks what language the CPU understands directly, the answer is machine code.

> **Key Term: machine code**
> Binary instructions that are executed directly by the CPU.

Machine code is hard for humans to read and write. A binary instruction may contain an **opcode** and an **operand**. The opcode tells the CPU what to do, such as add or load. The operand gives the data or address to use.

For example, imagine a simple 8-bit instruction where the first 4 bits are the opcode and the last 4 bits are the operand:

- `0000 1000` might mean load the value from address 8
- `0010 1001` might mean add the value from address 9
- `0001 1010` might mean store the result in address 10

With 4 bits for the opcode, the number of possible different instructions is:

- Number of combinations = `2^4`
- `2^4 = 16`

So this system could represent **16 different opcodes**.

This kind of question is a good example of AQA AO2 application: you must apply bit knowledge to a programming context.

**Assembly language** improves readability by replacing binary opcodes with short text commands called **mnemonics**.

> **Key Term: assembly language**
> A low-level language that uses mnemonic instructions as a symbolic representation of machine code.

A statement such as:

`ADD R3, R1, R2`

is much easier for a human to understand than a binary instruction string. It tells you that values in registers 1 and 2 are added and the result is stored in register 3. However, assembly is still low-level because each instruction usually corresponds to a single machine code instruction. This is often described as a **one-to-one relationship**.

That point matters. Students often think assembly is just “slightly more readable high-level code”. It is not. It is still machine-oriented. The programmer must still think in terms of exact operations and hardware resources.

Why does low-level code have advantages? Because the programmer can optimise directly for a specific processor. That can make execution faster, memory use smaller, and hardware control more precise. This is useful in cases such as embedded systems, device drivers, or very performance-sensitive routines.

But those benefits come with costs:

- harder to write
- harder to debug
- harder to maintain
- less portable
- dependent on the processor and often the platform

A program written for one processor’s instruction set will not automatically run on a different processor. That is because the machine code instruction sets differ.

By contrast, high-level languages are **problem-oriented**. They let the programmer express the solution in a clearer, more structured way. For example, swapping two values in Python can be written simply as:

`x, y = y, x`

At machine level, the processor still has to perform several steps. High-level code hides those details through **abstraction**. This makes it much easier to design and maintain larger software systems.

Common high-level examples for this course include **Python**, **Java**, **C#**, and **VB.Net**.

The main advantages of high-level languages are:

- easier to read and write
- easier to debug
- easier to maintain
- portable across systems when translated appropriately
- better suited to large and complex programs

The main disadvantages are:

- less direct hardware control
- may be less efficient than carefully written low-level code
- require translation before execution
  > **Test Tip:** In compare questions, do not just write “high-level is easier” or “low-level is faster”. State what each is easier or faster than, and explain why. Marks usually come from the reason, not just the label.

### Machine code, assembly, and translation

A key exam distinction is that **machine code does not need translation for the CPU to execute it**, but assembly and high-level languages do.

Assembly language needs an **assembler**.

> **Key Term: assembler**
> A program translator that converts assembly language into machine code.

The assembler takes each mnemonic and converts it into the corresponding binary instruction. Because assembly and machine code have a near one-to-one relationship, this translation is direct. If the assembly instruction is invalid for that processor’s instruction set, the assembler will reject it.

High-level languages need either a **compiler** or an **interpreter**.

> **Key Term: compiler**
> A translator that converts a whole high-level source program into object code or machine code before execution.
>
> **Key Term: interpreter**
> A translator that reads, translates, and executes source code statement by statement during runtime.

A compiler works on the whole program before running it. It produces **object code**, which is low-level code produced from the source code. In exam answers, object code is often accepted as machine code for this level, though strictly object code may still need linking before becoming a full executable.

> **Key Term: source code**
> Program code written by the programmer in a high-level language or assembly language.
>
> **Key Term: object code**
> Low-level code produced by translating source code.

Why compile a program? Because once compiled, the object code can be saved and run again without recompiling every time. Compiled programs also usually run faster than interpreted ones, because translation has already happened.

Why interpret a program? Because it is useful during development. If you are testing code and find an error, you can often fix the line and run again without recompiling the whole program. This makes debugging and partial testing easier.

A clear comparison helps:

- **Assembler**: assembly language to machine code
- **Compiler**: whole high-level program to object code before execution
- **Interpreter**: translates and executes high-level code line by line at runtime

Students often mix up classification and translation. A language being high-level does **not** mean it must be interpreted. Some high-level languages are commonly compiled, some interpreted, and some use both approaches depending on implementation.

> **Test Tip:** If an exam asks “what translator is required?”, answer with the specific translator name. Assembly language uses an **assembler**, not a compiler.

### Imperative and declarative languages

The second major classification method is by **programming style**, not by hardware closeness. This is where many students lose marks.

A language can be classified in more than one way at once. For example, Python can be described as **high-level** and **imperative**. These labels answer different questions:

- **high-level/low-level** asks: how close is the language to hardware?
- **imperative/declarative** asks: how does the programmer express the solution?
  > **Key Term: imperative language**
  > A language in which the programmer specifies how a task should be carried out through a sequence of commands.

In an imperative language, the programmer gives explicit instructions in an order. The program changes state step by step. Typical features include assignment, loops, conditionals, and procedures. Languages such as **Python**, **Java**, and **C#** are commonly treated as imperative in this context.

For example, an imperative approach to summing a list tells the computer exactly what to do:

1. set total to 0
2. repeat for each value
3. add the value to total
4. output total

The programmer is controlling the process.

A **declarative language** focuses on the required result instead.

> **Key Term: declarative language**
> A language in which the programmer states what result is required rather than the exact sequence of steps to achieve it.

For example, in **SQL**, you can ask for records that meet a condition without writing the loop that checks each row one by one. You state what data you want, not the low-level control flow for retrieving it.

Similarly, **Prolog** is declarative because the programmer writes facts and rules, and the system works out how to apply them to answer a query.

This means declarative code is often shorter for suitable tasks. However, students must not say that declarative languages involve “no processing steps”. They do. The difference is that the programmer does not specify those steps in the same explicit way.

A common exam phrase is **imperative high-level language**. This means a language that is both:

- high-level: abstracted away from the hardware
- imperative: describes how to carry out the task

That is why “imperative” is not the opposite of “high-level”. The opposite pair is imperative/declarative.

There is also a link to **functional programming**, which AQA covers separately. Functional programming is usually treated as a form of declarative programming, because it focuses on functions and expressions rather than explicit state-changing command sequences. For this subtopic, you only need that connection at a simple level.

> **Key Term: functional programming**
> A style of declarative programming based on functions and expressions rather than step-by-step state changes.

### Choosing the right language and structuring exam answers

In real systems, the best language depends on the job.

A programmer may prefer a **low-level language** when they need:

- direct hardware control
- tight memory usage
- very efficient execution
- code for a specific processor or embedded system

A programmer may prefer a **high-level language** when they need:

- quicker development
- easier maintenance
- readability for teams
- portability across platforms
- support for complex software structures

A declarative language may be best when the task is about describing required outcomes, such as querying a database. An imperative language may be best when the programmer needs clear control over the sequence of operations.

For longer exam responses, a useful structure is:

1. define both terms clearly
2. compare them directly
3. give at least one example of each
4. explain a practical consequence
5. state when each would be appropriate

For example, if asked to compare low-level and high-level languages, weak answers only list features. Strong answers build a cause-and-effect chain:

- low-level code is close to hardware
- therefore it gives direct control of registers and memory
- therefore it can be optimised for a specific processor
- therefore it may execute more efficiently
- however, this makes it harder to write, debug, and port to other systems

That kind of linked reasoning is what examiners want.

Common student errors include:

- saying assembly language is machine code
- saying the CPU can execute Python directly
- assuming all high-level languages are interpreted
- confusing imperative/declarative with high-level/low-level
- writing “faster” or “better” without saying why or in what sense
- forgetting that assembly language is processor-specific

## Key Point Checklist

_This article has covered the following key knowledge points:_

- Programming languages can be classified by abstraction level or by programming style
- The two low-level languages are machine code and assembly language
- Machine code consists of binary instructions executed directly by the CPU
- Assembly language uses mnemonics and usually has a one-to-one relationship with machine code instructions
- High-level languages are more human-readable, more portable, and easier to maintain
- Low-level languages offer more direct hardware control and can be more efficient, but are harder to write and debug
- High-level languages require translation before execution
- An assembler translates assembly language into machine code
- A compiler translates a whole high-level program before execution, while an interpreter translates and executes statement by statement
- Imperative languages describe how to perform a task through a sequence of commands
- Declarative languages describe what result is required rather than the exact control flow
- A language can belong to more than one category at once, such as high-level and imperative

## Key Terms and Concepts

- programming language classification
- low-level language
- high-level language
- machine code
- assembly language
- assembler
- compiler
- interpreter
- source code
- object code
- imperative language
- declarative language
- functional programming


Computer Systems - Programming language classification