Chapter 10.1: Data Types & Records

9618 AS Computer Science

📚 Learning Objectives

Understand what data types are and why they are important
Identify and use primitive data types: Integer, Real, Char, String, Boolean, Date
Understand the difference between primitive and composite data types
Define and use record data types in pseudocode
Access and modify fields within a record
Create and use arrays of records
Understand the advantages of using records for data organization

🌟 Did You Know?

Data types allow programming languages to provide different classifications for items of data, so they can be used for different purposes. For example, integers are discrete whole numbers used for counting and indexing, whereas real numbers can be used to provide accurate measurements!

📖 Prior Knowledge Required

Basic understanding of variables and identifiers
Knowledge of assignment statements
Familiarity with basic programming concepts
Understanding of what data represents in a program

1. What Are Data Types?

A data type is a classification of data into groups according to the kind of data they represent. Computers use different data types to represent different types of data in a program.

📖 Definition

Data types allow programming languages to provide different classifications for items of data, so they can be used for different purposes. The data type determines:

What values can be stored
How much memory is allocated
What operations can be performed
How the data is interpreted by the computer

1.1 Why Are Data Types Important?

It is important to choose the correct data type for a given situation to ensure accuracy and efficiency in the program.

📝 Declaring Variables with Data Types

In pseudocode and some other programming languages, data types must be declared before they can be used. Each data item is given a unique name called an identifier.

DECLARE <identifier> : <data type>

Example: DECLARE Age : INTEGER

2. Primitive Data Types

Primitive data types (also called atomic data types) refer to fundamental data types provided by a programming language. These data types are built into the language and are used to represent simple values.

Data Type	Description	Examples
INTEGER	Whole numbers (positive or negative)	10, -5, 0, 42, -100
REAL	Numbers with fractional part (positive or negative)	3.14, -2.5, 0.0, 99.99
CHAR	A single character (letter, digit, or symbol)	'a', 'B', '5', '$', '@'
STRING	A sequence of alphanumeric characters	"Hello World", "1234", "CS@9618"
BOOLEAN	Logical values - true or false only	TRUE, FALSE
DATE	Stores calendar dates	DD/MM/YY, "24/04/2025"

💡 Exam Tip

Remember: CHAR uses single quotes ('A') while STRING uses double quotes ("Hello"). A string is known as a structured type because it is a sequence of characters. A special case is the empty string: a value of data type string, but with no characters stored in it (written as "").

3. Declaring Variables in Pseudocode

Before data can be used, the data type needs to be decided. This is done by declaring the data type for each item to be used.

📝 Declaration Syntax

DECLARE <identifier> : <data type>

identifier: The unique name given to the variable
data type: The type of data the variable will store

Data Type	Pseudocode Example
INTEGER	DECLARE Age : INTEGER Age ← 10
REAL	DECLARE Temp : REAL Temp ← 3.14
CHAR	DECLARE Grade : CHAR Grade ← 'A'
STRING	DECLARE Name : STRING Name ← "Hello"
BOOLEAN	DECLARE LoggedIn : BOOLEAN LoggedIn ← TRUE
DATE	DECLARE DOB : DATE DOB ← "24/04/2025"

⚠️ Important

When assigning values:

Use ← (left arrow) or = for assignment in pseudocode
CHAR values use single quotes: 'A'
STRING values use double quotes: "Hello"
BOOLEAN values are TRUE or FALSE (no quotes)

4. Record Data Types

A record is a composite data type structure that contains a fixed number of components, which can be of different types. It allows programmers to collect together values with different data types under a single identifier.

📖 What is a Record?

A composite data structure used to store a collection of related data items
Each item can be of a different data type
Contains a fixed number of fields, each with its own name and type
Allows a programmer to group related values under one identifier
Creates a more structured and readable approach to storing data

4.1 Advantages of Record Data Types

🌟 Key Advantage

A set of data related to one thing of different types is held under a single identifier. This makes code more organized and easier to maintain!

5. Defining Records in Pseudocode

📝 Record Definition Syntax

TYPE <TypeName>
    DECLARE <identifier> : <data type>
    DECLARE <identifier> : <data type>
    DECLARE <identifier> : <data type>
    ...
ENDTYPE

5.1 Example: Employee Record

Record for employee data:

TYPE EmployeeRecord
    DECLARE EmployeeFirstName : STRING
    DECLARE EmployeeFamilyName : STRING
    DECLARE DateEmployed : DATE
    DECLARE Salary : CURRENCY
ENDTYPE

5.2 Example: Person Record

TYPE PersonType
    DECLARE Name : STRING
    DECLARE DateOfBirth : DATE
    DECLARE Height : REAL
    DECLARE NumberOfSiblings : INTEGER
    DECLARE IsFullTimeStudent : BOOLEAN
ENDTYPE

💡 Exam Tip

Records in programming are a type of data structure used to group related data in your code. These are not the same as records in a database, which refer to a complete set of fields on a single entity in a table (row)!

6. Using Records - Declaring & Assigning

6.1 Declaring a Record Variable

After defining the record type, you can declare a variable of that type:

DECLARE Person : PersonType

6.2 Assigning Values to Fields

Use the dot notation to access individual fields:

Person.Name ← "Fred"
Person.NumberOfSiblings ← 3
Person.IsFullTimeStudent ← TRUE
Person.Height ← 1.75
Person.DateOfBirth ← "15/03/2005"

6.3 Reading from Records

To output a field of a record:

OUTPUT Person.Name

📝 Accessing Fields

The format is: RecordName.FieldName

The record name identifies which record variable to use
The field name identifies which field within the record
The dot (.) separates the record name from the field name

7. Arrays of Records

We can use arrays of records to store multiple records of the same type. This is useful when we have several entities' data to work with and do not want to use a separate 1D array for each field.

7.1 Declaring an Array of Records

Using the Person record type, we can declare an array for 100 person records:

DECLARE Person : ARRAY[1:100] OF PersonType

7.2 Accessing Individual Records

We can access an individual's data using the array index combined with dot notation:

Person[1].Name ← "Fred"
Person[1].NumberOfSiblings ← 3
Person[1].IsFullTimeStudent ← TRUE

OUTPUT Person[1].Name

⚠️ Important: Array Index + Field Access

The format is: RecordArray[Index].FieldName

First, specify the array name
Then, in square brackets, specify the index
Finally, after a dot, specify the field name

8. Key Features of Records

Feature	Explanation
Can store different data types	Unlike arrays, records are not limited to a single type
Fields are named	Each item in the record has a meaningful identifier
Structured storage	Easier to manage complex data about real-world entities
Single identifier	All related data is grouped under one name
Fixed structure	The number and type of fields are defined once

8.1 Records vs Arrays

Aspect	Array	Record
Data Types	Same type only	Different types allowed
Access Method	Index number	Field name
Size	Can be dynamic	Fixed number of fields
Use Case	Lists of same-type items	Related data of different types

🧠 Memory Trick

RECORD = Related Elements Collected Organized under Record Definition

Think of a record like a form you fill out - each field has a name and can hold different types of information!

9. More Record Examples

9.1 Car Record Example

TYPE Car
    DECLARE Make : STRING
    DECLARE Model : STRING
    DECLARE Colour : STRING
    DECLARE Price : REAL
    DECLARE DateOfRegistration : DATE
ENDTYPE

DECLARE MyCar : Car

MyCar.Make ← "Toyota"
MyCar.Model ← "Yaris"
MyCar.Colour ← "Red"
MyCar.Price ← 14995.99
MyCar.DateOfRegistration ← "12/03/2022"

OUTPUT "Make: ", MyCar.Make
OUTPUT "Model: ", MyCar.Model
OUTPUT "Colour: ", MyCar.Colour
OUTPUT "Price: £", MyCar.Price

9.2 Book Record Example

TYPE TBookRecord
    DECLARE Title : STRING
    DECLARE Author : STRING
    DECLARE ISBN : STRING
    DECLARE Price : REAL
    DECLARE InStock : BOOLEAN
ENDTYPE

DECLARE Book1 : TBookRecord

Book1.Author ← "EMK"
Book1.Title ← "CS Made Easy"
Book1.Price ← 24.99
Book1.InStock ← TRUE

💡 Exam Tip

When asked to define a record type, always include:

The TYPE ... ENDTYPE structure
Appropriate field names (meaningful identifiers)
Correct data types for each field

10. Exam-Style Questions (Part 1)

1. State the most appropriate data type for each of the following: (a) A person's age, (b) The price of an item, (c) Whether a user is logged in, (d) A customer's name. [4 marks]

Answer:

(a) INTEGER - Age is a whole number
(b) REAL - Prices can have decimal places (e.g., 19.99)
(c) BOOLEAN - Only two states: logged in or not (TRUE/FALSE)
(d) STRING - Names are sequences of characters

Additional points for deeper understanding:

CURRENCY could also be used for price in some languages
DATE would be used if storing date of birth instead of age

2. Explain the difference between a CHAR data type and a STRING data type. Give an example of each. [4 marks]

Answer:

CHAR stores a single character only, enclosed in single quotes
STRING stores a sequence of zero or more characters, enclosed in double quotes
CHAR example: 'A', '5', '@'
STRING example: "Hello", "CS9618", "" (empty string)

Additional points for deeper understanding:

A STRING is considered a structured type because it is a sequence of characters
CHAR takes less memory than a STRING containing one character
The empty string "" is a valid STRING with zero characters

3. Define a record type called StudentRecord that stores: student name, student ID, exam score, and whether the student has passed. [5 marks]

Answer:

TYPE StudentRecord
    DECLARE StudentName : STRING
    DECLARE StudentID : STRING
    DECLARE ExamScore : REAL
    DECLARE HasPassed : BOOLEAN
ENDTYPE

Additional points for deeper understanding:

StudentID could be STRING (e.g., "S12345") rather than INTEGER if it contains letters
ExamScore could be INTEGER if only whole marks are used
Alternative field names: Name, ID, Score, Passed - as long as they're meaningful

4. Write pseudocode to declare a variable called MyClass of type StudentRecord (using the record type from Q3), then assign values to all fields and output the student name. [4 marks]

Answer:

DECLARE MyClass : StudentRecord

MyClass.StudentName ← "John Smith"
MyClass.StudentID ← "S12345"
MyClass.ExamScore ← 78.5
MyClass.HasPassed ← TRUE

OUTPUT MyClass.StudentName

Additional points for deeper understanding:

The DECLARE statement creates a variable of the record type
Dot notation (.) is used to access individual fields
The ← symbol (or =) is used for assignment

5. State two advantages of using a record data type instead of separate variables. [2 marks]

Answer:

All related data is stored under one identifier, making code more organized
Easier to manage complex data about real-world entities

Additional points for deeper understanding:

Fields have meaningful names, improving code readability
Can pass all related data as a single parameter to procedures/functions
Can create arrays of records to store multiple related items
Reduces the risk of mixing up data from different entities

10. Exam-Style Questions (Part 2)

6. A school stores information about books in a library. Write pseudocode to define a record type called BookType with fields for: title, author, ISBN, number of pages, and whether it is available. [5 marks]

Answer:

TYPE BookType
    DECLARE Title : STRING
    DECLARE Author : STRING
    DECLARE ISBN : STRING
    DECLARE NumberOfPages : INTEGER
    DECLARE IsAvailable : BOOLEAN
ENDTYPE

Additional points for deeper understanding:

ISBN is STRING because it may contain hyphens (e.g., "978-0-123456-78-9")
NumberOfPages is INTEGER because pages are whole numbers
IsAvailable is BOOLEAN - either available (TRUE) or not (FALSE)

7. Using the BookType from Question 6, write pseudocode to: (a) Declare an array that can store 500 books, (b) Assign values to the first book in the array. [5 marks]

Answer:

DECLARE Library : ARRAY[1:500] OF BookType

Library[1].Title ← "Computer Science"
Library[1].Author ← "S. Smith"
Library[1].ISBN ← "978-0-123456-78-9"
Library[1].NumberOfPages ← 350
Library[1].IsAvailable ← TRUE

Additional points for deeper understanding:

The array index goes in square brackets [ ]
Use dot notation after the index to access fields
Array could also be declared as ARRAY[0:499] depending on language

8. Compare arrays and records. Give one similarity and two differences. [4 marks]

Answer:

Similarity:

Both are data structures that store multiple pieces of data under a single identifier

Differences:

Arrays store data of the same type; records can store different types
Array elements are accessed by index number; record fields are accessed by field name
Arrays can have dynamic size; records have a fixed number of fields

9. Explain why the correct choice of data type is important when writing a program. [4 marks]

Answer:

Ensures accuracy - correct data type prevents invalid operations (e.g., arithmetic on strings)
Ensures efficiency - appropriate types use memory efficiently
Determines what values can be stored (e.g., BOOLEAN can only be TRUE or FALSE)
Determines what operations can be performed (e.g., arithmetic on numbers, concatenation on strings)

Additional points for deeper understanding:

Prevents runtime errors from type mismatches
Makes code more readable and maintainable
Helps compiler/interpreter optimize memory usage

10. Write pseudocode that uses a loop to output the names of all students in an array of 30 StudentRecord variables. Assume the array is called Students. [4 marks]

Answer:

FOR Index ← 1 TO 30
    OUTPUT Students[Index].StudentName
NEXT Index

Additional points for deeper understanding:

Alternative: FOR Index ← 0 TO 29 (depends on array declaration)
The loop variable (Index) is used as the array index
Dot notation accesses the StudentName field of each record
WHILE loop could also be used with a counter variable

11. Glossary

Term	Definition
Data Type	A classification of data into groups according to the kind of data they represent
Primitive Data Type	Fundamental data types built into a programming language (e.g., INTEGER, REAL, CHAR, STRING, BOOLEAN, DATE)
Atomic Data Type	Another name for primitive data types - basic, indivisible data types
INTEGER	A data type for whole numbers, positive or negative (e.g., 42, -7, 0)
REAL	A data type for numbers with a fractional part (e.g., 3.14, -2.5)
CHAR	A data type for a single character, enclosed in single quotes (e.g., 'A', '5')
STRING	A structured data type for a sequence of characters, enclosed in double quotes (e.g., "Hello")
BOOLEAN	A data type that can only have two values: TRUE or FALSE
DATE	A data type for storing calendar dates (e.g., DD/MM/YYYY)
Identifier	A unique name given to a variable, constant, or other programming element
Record	A composite data structure containing a fixed number of fields of different data types
Field	A single item within a record, with its own name and data type
Composite Data Type	A data type composed of multiple primitive data types (e.g., records)
Dot Notation	The use of a dot (.) to access fields within a record (e.g., Person.Name)
Array of Records	An array where each element is a record of a defined type

12. Exam Success Tips (Part 1)

💡 Data Type Selection - Key Reminders

INTEGER = Whole numbers only (counting, indexing, quantities)
REAL = Numbers with decimals (measurements, prices, percentages)
CHAR = Single character in single quotes ('A')
STRING = Text/sequence in double quotes ("Hello")
BOOLEAN = Only TRUE or FALSE (yes/no situations)
DATE = Calendar dates (birthdays, deadlines)

💡 Quote Rules - Don't Get Confused!

CHAR uses single quotes: 'A', '7', '@'
STRING uses double quotes: "Hello", "123"
BOOLEAN uses no quotes: TRUE, FALSE
Empty string is "" (double quotes with nothing inside)

💡 Record Definition Checklist

When asked to define a record, make sure you include:

TYPE ... ENDTYPE structure (must have both!)
Meaningful field names (not just "field1", "field2")
Correct data types for each field
DECLARE keyword for each field

💡 Accessing Record Fields

Use dot notation: RecordName.FieldName
For arrays of records: ArrayName[Index].FieldName
Assignment uses ← (arrow) or =
Output uses OUTPUT followed by the field reference

🧠 Memory Trick: Record Definition Template

TYPE TypeName
    DECLARE Field1 : DataType1
    DECLARE Field2 : DataType2
    ...
ENDTYPE

Remember: TYPE starts it, ENDTYPE ends it, DECLARE for each field!

12. Exam Success Tips (Part 2)

⚠️ Common Mistakes to Avoid

Don't confuse CHAR (single character) with STRING (sequence)
Don't use wrong quotes: CHAR needs ' ', STRING needs " "
Don't forget ENDTYPE at the end of record definitions
Don't forget to DECLARE a variable of the record type before using it
Don't mix up record fields with array indexes: Person.Name vs Array[1]
Don't put quotes around BOOLEAN values (TRUE, FALSE not "TRUE", "FALSE")
Don't forget that STRING is a structured type, not primitive

❌ Wrong vs ✓ Right

❌ Wrong	✓ Right
Name ← "Ali"	DECLARE Name : STRING Name ← "Ali"
Grade ← A	Grade ← 'A'
Active ← "TRUE"	Active ← TRUE
Person[Name] ← "Ali"	Person.Name ← "Ali"

💡 Answer Strategy Tips

Read the mark allocation carefully - it tells you how many points to make
For "define" questions: Write the complete TYPE...ENDTYPE structure
For "explain" questions: Give reasons WHY something is used
For "compare" questions: Mention BOTH items for each point
Always use correct pseudocode syntax in your answers

13. Key Takeaways

📌 Primitive Data Types

INTEGER: Whole numbers (42, -7, 0)
REAL: Decimal numbers (3.14, -2.5)
CHAR: Single character in single quotes ('A')
STRING: Text in double quotes ("Hello") - structured type
BOOLEAN: TRUE or FALSE only
DATE: Calendar dates

📌 Record Data Types

Records group related data of different types under one identifier
Define with TYPE...ENDTYPE structure
Access fields using dot notation (RecordName.FieldName)
Can create arrays of records for multiple entities

📌 Declaration Syntax

// Variable declaration
DECLARE Identifier : DataType

// Record definition
TYPE TypeName
    DECLARE Field : DataType
ENDTYPE

// Array of records
DECLARE ArrayName : ARRAY[1:n] OF TypeName

🌟 Quick Reference

Topic	Key Point
Data Types	Determine what values can be stored and what operations are allowed
CHAR vs STRING	CHAR = single character ('A'), STRING = sequence ("Hello")
Record Access	RecordName.FieldName for single record, ArrayName[Index].FieldName for arrays
Record Advantage	Groups related data of different types under one identifier