AQA A-Level Computer Science (7517)

## Learning Outcomes

- Explain the difference between a variable and a constant using precise AQA terminology
- Distinguish clearly between declaration, assignment and initialisation
- Identify suitable data types for variables and constants in simple programming contexts
- Interpret and write AQA-style pseudocode using identifiers and assignment correctly
- Explain why named constants improve readability, maintenance and error reduction
- Compare local and global variables and explain how scope affects access to data
- Spot common exam errors involving constants, variables and assignment statements

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

For the AQA A-Level Computer Science (7517), you are expected to understand constants and variables in programming languages, with a focus on the following syllabus points:

![Variables, constants, declaration, assignment and initialisation in pseudocode, including identifiers, data types and changing or fixed stored values.](https://static.pastpaperhero.com/images/aqa-a-level-computer-science-7517-programming-fundamentals-constants-and-variables_00.png)

_Programming storage concepts are distinguished by separating mutable variables from fixed constants and by defining declaration, initialisation and assignment._

- Know that a **variable** stores a value that can change during program execution
- Know that a **constant** stores a value that does not change during program execution
- Explain the advantages of using **named constants** instead of repeated literal values
- Identify what a **declaration statement** does and how it may include a data type
- Understand that an **assignment statement** stores a value or expression result in a variable
- Distinguish **assignment** from **initialisation**
- Recognise that declaration syntax differs between programming languages, while pseudocode remains language-independent
- Understand the linked idea of **scope**, including the difference between local and global variables

## 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 a variable and a constant?
2. How is declaration different from assignment?
3. Why are named constants better than using raw values such as `20` or `3.14159` repeatedly?
4. What does `score ← score + 1` mean in pseudocode?
5. What is the difference between a local variable and a global variable?

## Introduction

Programs work by storing data in memory, processing it, and then producing output. To do that reliably, a programmer needs a clear way to name values and control whether those values can change. That is where **constants** and **variables** come in.

This subtopic looks simple, but exam questions often test the exact meaning of terms such as declaration, assignment, initialisation, identifier and scope. Students often know what these words mean informally, but lose marks because they use vague phrasing. For AQA, the safest approach is to define each term precisely and then apply it to short code or pseudocode examples.

> **Key Term: variable**
> A named storage location in memory whose value can change during program execution.

### Variables, constants and identifiers

A program stores values so that it can use them later. Those values are attached to names called **identifiers**. An identifier is simply the name the programmer gives to a variable or constant, such as `age`, `totalCost` or `VAT_RATE`.

A **variable** can hold different values at different points in a program. For example, in a quiz program, a variable called `score` may start at `0`, then become `1`, `2` and `3` as the user answers questions correctly. The key point is not just that it stores data, but that the stored value may change.

A **constant** is used when a value should stay the same for the whole run of the program. A circle area program might use `PI`, or a business program might use `VAT_RATE`. In both cases, the value has a fixed meaning within that program run and should not be changed by accident.

> **Key Term: constant**
> A named value or storage item whose value does not change during program execution.
>
> **Key Term: identifier**
> The name used to refer to a variable or constant in a program.

Why does this distinction matter? Because it affects both program correctness and code quality.

If a value should change but you treat it as fixed, your program becomes too rigid. If a value should stay fixed but you store it in a normal variable, another part of the code may change it accidentally. That can cause hard-to-find bugs.

Consider this example in AQA-style pseudocode:

```txt
DECLARE radius : REAL
CONSTANT PI = 3.14159
radius ← 5
area ← PI * radius * radius
```

Here:

- `radius` is a variable because the user might enter a different radius each time
- `PI` is a constant because its value should remain fixed
- `area` is also a variable because it stores a calculated result

A common student mistake is to describe a constant as "a value that never changes ever". That is too loose. The exam-safe wording is that it does not change **during program execution**.

Meaningful naming also matters. `VAT_RATE` is much clearer than `x`, and `numberOfMiles` is better than `n`. Good identifiers help with reading, debugging and updating code later.

> **Test Tip:** In definition questions, use the phrases "named storage location", "value can change" and "does not change during program execution". These are much safer than informal phrases such as "box of data" or "something the computer remembers".

### Declaration, assignment and initialisation

These three ideas are closely linked, so students often mix them up. Examiners expect you to separate them clearly.

A **declaration** introduces an identifier into the program. In many languages, it also states the data type. For example:

```txt
DECLARE age : INTEGER
DECLARE name : STRING
```

This tells the program that `age` and `name` exist, and what sort of values they are expected to hold.

> **Key Term: declaration**
> The process of introducing a variable or constant to a program, usually with its identifier and often its data type.

An **assignment** gives a variable a value. In pseudocode, this is usually shown with the assignment arrow `←`.

```txt
age ← 16
name ← "Sam"
```

This means "store 16 in `age`" and "store `Sam` in `name`". It does not mean mathematical equality. In programming, the right-hand side is evaluated first, then the result is stored in the variable on the left-hand side.

> **Key Term: assignment**
> Storing a value or the result of an expression in a variable.

That is why this statement works:

```txt
score ← score + 1
```

In maths, `score = score + 1` looks impossible. In programming, it means:

1. take the current value of `score`
2. add 1
3. store the new result back in `score`

If `score` was `7`, it becomes `8`.

An **initialisation** is the first assignment given to a variable. So in this example:

```txt
DECLARE total : INTEGER
total ← 0
```

the declaration is `DECLARE total : INTEGER`, and the initialisation is `total ← 0`.

Later, if the code says:

```txt
total ← total + price
```

that is an assignment, but not an initialisation, because `total` already had its first value.

> **Key Term: initialisation**
> The first value assigned to a variable, often at or just after declaration.

In some programming languages, declaration and assignment happen separately. In others, they can happen together. For example, strongly typed languages often require explicit declaration, while Python usually creates variables when a value is first assigned. That means syntax differs between languages, but the underlying concepts do not change.

For AQA, this is a key distinction: you must know the concept even if the exact syntax depends on the language.

Here is a simple side-by-side comparison:

- **Declaration**: creates or introduces the identifier
- **Assignment**: gives it a value
- **Initialisation**: the first assignment only

Students also need to connect this to **data types**. A variable is not just a name: it stores a value of a particular type, such as integer, real, Boolean or string. Choosing the correct type matters because it controls what values are valid and what operations are allowed.

Example:

```txt
DECLARE age : INTEGER
DECLARE temperature : REAL
DECLARE isLoggedIn : BOOLEAN
DECLARE surname : STRING
```

Why not store `age` as a string? Because if you want to compare it numerically, such as `IF age >= 18`, an integer is more suitable. Why not store `isLoggedIn` as a string like `"yes"` or `"no"`? Because Boolean values `TRUE` and `FALSE` make logical tests clearer and safer.

> **Key Term: data type**
> A classification of data that determines the kind of values that can be stored and the operations that can be performed on them.

String conversion is another place where variables and data types matter. For example:

```txt
numString ← "123"
numValue ← int(numString)
```

The variable `numString` stores a string, while `numValue` stores an integer. If a student ignores the data type difference, they may misunderstand what the program is doing.

> **Test Tip:** If a question asks you to explain `score ← score + 1`, do not say "score equals score plus one". Say "the current value of score is increased by 1 and the new value is stored back in score".

### Why named constants are useful

AQA specifically expects you to explain the advantages of using named constants. This often appears as a short explain question.

Suppose a program adds VAT at 20%. A weak version of the code might be:

```txt
priceWithVAT ← price + (price * 0.20)
```

This works, but `0.20` is a raw literal value. If the VAT rate changes, the programmer must search through the whole program and replace every `0.20`. That creates two risks:

- one occurrence may be missed
- one occurrence may be changed incorrectly

A better version is:

```txt
CONSTANT VAT_RATE = 0.20
priceWithVAT ← price + (price * VAT_RATE)
```

Now the meaning is clear and the value only needs to be changed in one place.

The advantages of named constants are usually grouped into three areas.

First, **readability**. `PASS_MARK` is clearer than `40`. The name tells the reader what the value represents.

Second, **maintainability**. If the value changes later, the programmer edits one declaration instead of many lines.

Third, **error reduction**. Repeated raw values, often called **magic numbers**, are easy to mistype or forget to update.

> **Key Term: named constant**
> A constant given a meaningful identifier instead of using the literal value directly throughout the code.

Consider a second example:

```txt
CONSTANT MAX_LIVES = 3
lives ← MAX_LIVES
```

This is better than writing `lives ← 3` if the number has a special meaning in the program. The code becomes more self-explanatory.

However, not every literal should automatically become a constant. If a value is used once and has no wider meaning, creating a constant may add clutter. The exam point is not that constants must be used everywhere, but that they are useful for fixed values with repeated or important meaning.

In languages such as Python, there is no built-in enforcement for true constants in the same way as in some other languages. Programmers often use naming conventions such as uppercase identifiers to signal that a value should not be changed. For exam purposes, focus on the concept: the value is intended to remain fixed.

### Scope: local and global variables

Although the core subtopic is constants and variables, exam questions often link this to **scope**. Scope means where in the program an identifier can be accessed.

> **Key Term: scope**
> The region of a program in which an identifier can be accessed.

A **local variable** is declared inside a subroutine or block and can only be used there. Once that subroutine finishes, the local variable is usually destroyed.

A **global variable** is declared outside subroutines and can be accessed from multiple parts of the program.

> **Key Term: local variable**
> A variable declared within a subroutine or block that can only be accessed there.
>
> **Key Term: global variable**
> A variable declared in a wider program scope that can be accessed by multiple parts of the program.

Here is an example:

```txt
DECLARE totalSales : REAL

PROCEDURE AddSale()
    DECLARE saleValue : REAL
    saleValue ← USERINPUT
    totalSales ← totalSales + saleValue
ENDPROCEDURE
```

`totalSales` is global because it is available to the procedure. `saleValue` is local because it only exists inside `AddSale`.

Why does this matter?

Local variables are usually safer because:

- they reduce accidental interference from elsewhere
- they are easier to debug
- they support modular programming
- they use memory only while needed

Global variables can be useful for shared program-wide values, especially named constants, but overusing them makes programs harder to track. If many subroutines can change the same global variable, bugs become harder to find because the source of the change is less obvious.

Students often write vague statements such as "global variables are used in more places". Better wording is "a global variable can be accessed from multiple subroutines or across the program, while a local variable can only be accessed within the block or subroutine where it is declared".

Another common problem is declaring a variable inside a loop or `IF` block, then trying to use it outside that block. If the variable is out of scope, the program cannot access it there.

Here is a typical mistake:

```txt
IF mark > 40 THEN
    DECLARE result : STRING
    result ← "Pass"
ENDIF
OUTPUT result
```

If `result` was declared only inside the `IF` block, trying to output it afterwards may cause a scope error. A safer version would declare `result` before the `IF`.

```txt
DECLARE result : STRING
IF mark > 40 THEN
    result ← "Pass"
ELSE
    result ← "Fail"
ENDIF
OUTPUT result
```

This example shows why scope is not just a definition to memorise. It affects how a working program must be designed.

> **Test Tip:** In comparison questions, use precise access wording: "local variables can only be accessed within their subroutine or block; global variables can be accessed more widely across the program." Avoid vague phrases such as "local is smaller" or "global is bigger".

## Key Point Checklist

_This article has covered the following key knowledge points:_

- A variable is a named storage location whose value can change during program execution
- A constant is a named value whose value does not change during program execution
- An identifier is the name used for a variable or constant
- A declaration introduces an identifier and may include its data type
- An assignment stores a value or expression result in a variable
- Initialisation is the first assignment given to a variable
- In AQA-style pseudocode, `←` represents assignment, not mathematical equality
- `score ← score + 1` means increase the current value by 1 and store the result back in `score`
- Data types such as integer, real, Boolean and string determine valid values and operations
- Named constants improve readability, maintenance and error reduction
- A local variable can only be accessed within its block or subroutine
- A global variable can be accessed more widely, but too many global variables can make debugging harder

## Key Terms and Concepts

- variable
- constant
- identifier
- declaration
- assignment
- initialisation
- data type
- named constant
- scope
- local variable
- global variable


Programming Fundamentals - Constants and variables