AQA A-Level Computer Science (7517)

## Learning Outcomes

- Understand what a **data type** is and why choosing the correct type matters in programming
- Identify the main data types named in the AQA specification, including integer, real, Boolean, character, string, date/time, pointer, record, and array
- Explain the differences between commonly confused pairs such as integer and real, or character and string
- Apply data type knowledge to realistic programming scenarios and justify suitable choices
- Distinguish built-in data types from user-defined data types
- Recognise how declaration, memory use, and valid operations depend on data type
- Avoid common exam errors involving text vs numeric data, arrays vs records, and pointers vs stored values

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

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

- Understand the concept of a data type as a classification that controls stored values and valid operations
- Be familiar with primitive data types, including **integer**, **real**, **Boolean**, **character**, and **string**
- Recognise additional useful types and structures named in common course coverage, including **date/time**, **pointer**, **record**, and **array**
- Explain the difference between numeric data and text representations of numbers
- Distinguish between **character** and **string**, and between **integer** and **real**
- Understand that an **array** stores many values of the same type, accessed by index
- Understand that a **record** groups related fields, which may have different data types
- Be familiar with user-defined data types, including records and classes, and how variables are declared

## 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 a data type, and why does a programming language need data types?
2. What is the difference between `123` and `"123"` in a program?
3. How is a character different from a string?
4. Why might an array be suitable for storing test scores, but a record be better for storing one student's details?
5. What does a pointer store?

## Introduction

A program does not just store “data” in a general sense. It stores specific kinds of data, and each kind must be treated correctly. A computer needs to know whether a value is a whole number, text, a single character, a date, or a memory address, because different operations are valid for different kinds of values.

![Programming data types including integer, real, Boolean, character, string, date/time, pointer, record, and array.](https://static.pastpaperhero.com/images/aqa-a-level-computer-science-7517-programming-fundamentals-data-types_00.png)

_Primitive and structured data types are organised by stored value format, from numeric and text values to arrays and records._

This matters in Paper 1 because AQA often tests whether you can choose an appropriate type, explain a distinction clearly, or spot why a particular choice would cause errors or inefficiency. Strong answers do more than name a type. They explain why that type fits the data and what would go wrong with the wrong choice.

> **Key Term: data type**
> A classification of data that determines what kind of value can be stored and what operations can be performed on it.

### Why data types matter in real programs

Choosing the correct data type affects three main things: **correctness**, **memory use**, and **processing**.

First, correctness. If a value represents age in years, then an integer is sensible because ages are usually counted in whole numbers. If a value represents temperature, a real is often needed because temperatures can include decimal parts. If you choose badly, the program may reject valid data or process it wrongly.

Second, memory use. Different data types usually require different amounts of memory. A whole number stored as an integer will usually use less memory than storing the same value as a real. In small programs this may seem minor, but in large systems with millions of values, type choice affects efficiency.

Third, processing. The data type controls what operations make sense. Adding two integers gives a numeric result. Joining two strings gives concatenated text. These are not interchangeable.

For example:

- `123 + 456` gives `579`
- `"123" + "456"` gives `"123456"`

The values look similar to a human, but the computer treats them differently because their data types are different.

> **Key Term: declaration**
> The process of creating a variable and, in many languages, stating its data type.

In strongly typed languages, declaration usually makes the type explicit. In weakly typed or dynamically typed languages, the type may be inferred from the assigned value. For the exam, do not get stuck on one language's syntax. Focus on the principle that variables need a suitable data type.

> **Test Tip:** If a question says “justify your choice of data type”, do not stop after writing the type name. Add a reason linked to the value stored and the operations needed.

### Primitive and simple data types

The core primitive types you must know are integer, real, Boolean, character, and string. These are the building blocks from which larger structures are made.

> **Key Term: integer**
> A whole number with no fractional part.

Integers are used for values such as:

- number of students in a class
- goals scored
- age in years
- menu option selected

Why integer and not real? Because these values are counted as whole units. A class cannot contain 28.6 students. If a variable should never contain a decimal part, integer is usually the better choice.

> **Key Term: real**
> A numeric value that may contain a fractional part.

Reals are used for values such as:

- price: `12.99`
- speed: `45.6`
- temperature: `18.5`
- average mark: `67.25`

The key distinction is not “large” versus “small” number. It is “whole number only” versus “may contain a fraction”. Students often miss this and choose real for any number. That is too vague.

A second point is that real values can raise accuracy issues in some programming languages because decimal values may be stored approximately. For AQA, you do not need a deep hardware explanation here, but you should know that real values are used when decimal parts are needed, not just because they “look more advanced”.

> **Key Term: Boolean**
> A data type that can hold only two values: TRUE or FALSE.

Boolean values are central to decision making. They are used in:

- `LoggedIn = TRUE`
- `Found = FALSE`
- `ValidPassword = TRUE`

A Boolean is not the same as the strings `"TRUE"` or `"FALSE"`. A Boolean is a logical value used directly in conditions such as `IF LoggedIn THEN`.

> **Key Term: character**
> A single symbol, such as a letter, digit, or punctuation mark.

Examples include:

- `'A'`
- `'7'`
- `'?'`

A character stores exactly one symbol. That symbol might be a letter, number, or special sign. The character `'7'` is still text, not a numeric integer.

> **Key Term: string**
> A sequence of characters.

Examples include:

- `"Hello"`
- `"AQA"`
- `"7"`
- `"EC4Y 0DZ"`

A string can contain one character, many characters, spaces, or digits treated as text. That means `"25"` is a string, while `25` is a number. This distinction matters when sorting, comparing, or calculating.

For example, if you store exam marks as strings, then adding `"40"` and `"2"` may produce `"402"` rather than `42`. That is clearly wrong for arithmetic.

> **Test Tip:** In exam questions, watch the quotation marks. Values in quotation marks are usually strings. A digit in single quotes is usually a character. A value with no quotes may be numeric or Boolean depending on context.

### Structured and specialised data types

Some data types store more than one simple value in an organised form. These are essential because real programs rarely work with isolated values only.

> **Key Term: date/time**
> A data type used to store dates, times, or both in a format the program can process correctly.

At first glance, storing a date as a string may seem easy, such as `"12/03/2025"`. But this causes problems. A string is just text. The computer cannot reliably validate, compare, or calculate with it unless extra processing is added.

A date/time type is better when the program needs to:

- check whether a date is valid
- compare one date with another
- calculate time differences
- sort events in time order

For instance, an appointment system should store the appointment time as date/time, not as plain text, because the program may need to find the next available slot.

> **Key Term: array**
> A collection of elements of the same data type, stored under one identifier and accessed by index.

If you need to store many values of the same kind, an array is often suitable. For example:

- test scores for one class
- temperatures recorded each hour
- names of players in a team

An array is useful because the values are ordered and can be processed with loops. If `Scores[0]`, `Scores[1]`, and `Scores[2]` all store integers, the program can total them, search them, or sort them efficiently.

The crucial rule is that array elements are of the **same data type**. AQA exam questions often rely on this. If you need one structure to hold a student's name, age, and attendance percentage together, an array is not the best fit because those fields may have different meanings and types.

Also remember the exam convention: arrays are normally indexed from **0** unless the question says otherwise.

Worked example:

Suppose a program stores five marks:

`Marks = [72, 65, 81, 90, 77]`

If indexing starts at 0:

- `Marks[0] = 72`
- `Marks[1] = 65`
- `Marks[4] = 77`

Students often lose marks by assuming the first element is 1.

> **Key Term: record**
> A collection of named fields used to store related data about one entity; the fields may have different data types.

A record is different from an array because it groups different attributes together. For one student, a record might contain:

- `Name` as string
- `Age` as integer
- `AverageMark` as real
- `Enrolled` as Boolean

This is a good fit because all four values describe the same entity: one student. The fields are named, so the data is easier to understand and less error-prone than using position numbers.

Compare these carefully:

- **Array**: many values of the same type
- **Record**: one item with several named attributes, often of different types

That distinction appears often in exam questions because the two structures solve different storage problems.

> **Key Term: user-defined data type**
> A data type created by the programmer, often by combining existing types into a single new structure.

Records are a common example of user-defined data types. Instead of repeatedly handling separate variables such as `Username`, `Password`, and `LastLogin`, the programmer can define one record type that groups them together. This makes code clearer and reduces mistakes.

### Pointers, references, and choosing the right type

> **Key Term: pointer**
> A data item that stores the memory address or location of another item, rather than the item itself.

This is one of the most misunderstood types. A pointer does **not** normally store the actual data value. It stores where that data can be found in memory.

If a pointer contains address `1001`, it means “go to memory location 1001”. The data at that address might be an integer, string, or something more complex.

Why is this useful? Because pointers are important in linked structures such as linked lists, trees, and graphs. Instead of storing everything in one fixed block of memory, the program can connect items by storing addresses.

A common mistake is to say that a pointer stores “the next value”. More accurately, it stores the address of the next item.

Consider a simple linked idea:

- Node A stores data `15`
- Node A also stores a pointer to Node B
- The pointer does not equal Node B's data
- The pointer equals Node B's address

That distinction matters because it explains how dynamic structures can be built.

> **Key Term: built-in data type**
> A data type provided directly by a programming language.

Built-in types usually include the primitive types such as integer and Boolean. Some languages also provide array, string, or date/time types directly. The exact list varies by language, so in the exam you should explain the concept rather than argue from one language only.

Now apply data type selection to typical scenarios:

1. **Age of a customer**
   - Best type: integer
   - Why: whole number only

2. **Price of a train ticket**
   - Best type: real
   - Why: may include decimal places

3. **Middle initial**
   - Best type: character
   - Why: one symbol only

4. **Postcode**
   - Best type: string
   - Why: contains letters, digits, and spaces; not used in arithmetic

5. **Whether a seat is booked**
   - Best type: Boolean
   - Why: only true or false states

6. **Thirty daily temperatures**
   - Best type: array of real
   - Why: many values of the same type, indexed for processing

7. **One employee's details**
   - Best type: record
   - Why: multiple named fields with different meanings and types

8. **Link to the next node in a linked list**
   - Best type: pointer
   - Why: stores an address, not ordinary user data

These examples show that “most suitable” depends on both the form of the data and how the program will use it.

> **Test Tip:** When choosing between string and numeric types, ask yourself: will the program calculate with this value? If yes, use a numeric type. If no, and the value may contain non-numeric symbols such as spaces or letters, string is often better.

### Common confusions and how to avoid them

Several errors appear again and again.

First, confusing text with numbers:

- `25` is numeric
- `"25"` is text
- `'2'` is a single character

These look similar, but they behave differently.

Second, confusing array with record:

- an array of 30 marks stores many similar items
- a record for one student stores one entity with several fields

Third, confusing a pointer with the value it points to:

- pointer = address
- pointed-to item = stored data at that address

Fourth, using string for dates when date/time would allow validation and comparison more easily.

Fifth, forgetting that arrays are indexed and usually start at 0 in AQA-style pseudocode unless stated otherwise.

If you explain these clearly in an exam, you show genuine understanding rather than memorised definitions.

## Key Point Checklist

_This article has covered the following key knowledge points:_

- A data type classifies data and determines what values and operations are valid
- Choosing the correct data type affects correctness, memory use, and processing
- Integer stores whole numbers with no fractional part
- Real stores numeric values that may include decimal parts
- Boolean stores only TRUE or FALSE
- Character stores a single symbol, while string stores a sequence of characters
- `"123"` is a string, while `123` is a numeric value
- Date/time is often better than string when dates or times must be validated, compared, or calculated
- An array stores multiple values of the same data type and accesses them by index
- A record stores related named fields, and the fields may have different data types
- A pointer stores a memory address or location, not the data value itself
- User-defined data types allow programmers to group built-in types into more meaningful structures

## Key Terms and Concepts

- data type
- declaration
- integer
- real
- Boolean
- character
- string
- date/time
- array
- record
- user-defined data type
- pointer
- built-in data type


Programming Fundamentals - Data types