Programming Fundamentals — A-Level Computer Science Study Guide

For: A-Level Computer Science candidates sitting A-Level Computer Science.

Covers: Core programming fundamentals constructs including variables and types, control structures, procedures and functions, 1D/2D arrays, and string manipulation, aligned to the 2024-2026 A-Level Computer Science syllabus.

You should already know: Basic programming concepts; one of Python / Java / VB.

A note on the practice questions: All worked questions in the "Practice Questions" section below are original problems written by us in the A-Level Computer Science style for educational use. They are not reproductions of past Cambridge International examination papers and may differ in wording, numerical values, or context. Use them to practise the technique; cross-check with official Cambridge mark schemes for grading conventions.

1. What Is Programming Fundamentals?

Programming fundamentals are the set of universal, language-agnostic programming constructs that form the building blocks of all software applications. They are the first set of practical skills assessed in both the theory (Papers 1, 2) and practical (Papers 3,4) components of A-Level Computer Science, accounting for 15-20% of total qualification marks. Common synonyms include core programming primitives and basic programming constructs, and mastery of this topic is a prerequisite for all advanced CS content in the syllabus.

2. Variables, types, operators

Variables are named memory locations that store mutable data, with an associated data type that defines what operations can be performed on the stored value.

Core Data Types (universal across A-Level-accepted languages)

• Integer: Whole positive/negative values (e.g. 42, -17)
• Float/Real: Decimal values (e.g. 3.1415, -0.002)
• Boolean: Binary True/False values
• Character: Single alphanumeric or symbolic value (e.g. 'A', '!')
• String: Ordered sequence of characters (e.g. "A-Level Computer Science")

Statically typed languages (Java, VB) require explicit type declaration when creating a variable, while dynamically typed languages (Python) infer the type at runtime. Type conversion (e.g. converting a string to integer) is required to perform operations across mixed types.

Core Operators

• Arithmetic: $+$, $-$, $\times$, $/$, $\text{mod}$ (remainder of division), $\text{div}$ (integer division), ${}^{\wedge }$ / $\ast \ast$ (exponent)
• Comparison: $==$ (equal), $!=$ (not equal), $<$, $>$, $\le$, $\ge$
• Logical: AND, OR, NOT (used to combine comparison conditions)

Worked Example: Calculate the area of a circle with radius 5 using the formula $A=\pi r^2$:

radius = 5 # Integer type
pi = 3.14 # Float type
area = pi * radius ** 2
print(area) # Output: 78.5

Exam Tip: Examiners frequently test for type mismatch errors (e.g. adding a string and integer without conversion) in 1-mark multiple-choice questions.

3. Control structures — if/else, loops

Control structures alter the default sequential execution of code to implement decision-making and repetition, the two core logic patterns for all programs.

Selection (If/Else)

Evaluates a boolean condition to select which code block to execute. Most languages support nested if/else and multi-condition elif (else if) statements for complex decision trees.

Iteration (Loops)

• Count-controlled (for loop): Runs a fixed pre-defined number of times, ideal for traversing fixed-size data structures like arrays
• Condition-controlled (while loop): Runs repeatedly as long as a boolean condition remains true, ideal for tasks where the number of iterations is unknown in advance
• Do-while loop: Runs at least once before checking the exit condition (not natively supported in Python, but can be simulated)

Worked Example: Print all even numbers between 1 and 10 inclusive:

# For loop implementation
for i in range(1, 11):
 if i % 2 == 0:
 print(i)
# Output: 2, 4, 6, 8, 10

Exam Tip: Examiners often ask you to trace loop execution to identify output or spot infinite loops (caused by forgetting to update the loop control variable in while loops).

4. Procedures and functions — parameters and scope

Subroutines (procedures and functions) are reusable blocks of code that perform a single specific task, reducing code duplication and improving readability.

• Functions: Return a single value after execution
• Procedures (void functions): Do not return a value after execution

Parameters

Formal parameters are placeholder variables defined in the subroutine signature, while actual parameters are the concrete values passed when calling the subroutine. Two parameter passing mechanisms are assessed:

1. Pass by value: A copy of the value is passed to the subroutine; changes to the parameter inside the subroutine do not affect the original variable
2. Pass by reference: A pointer to the original memory location is passed; changes to the parameter inside the subroutine modify the original variable

Scope

Scope defines the region of code where a variable is accessible:

• Local scope: Variables declared inside a subroutine, only accessible within that subroutine, destroyed when the subroutine finishes execution
• Global scope: Variables declared outside all subroutines, accessible across the entire program (use is discouraged due to risk of unintended side effects)

Worked Example: Write a function to calculate the factorial of a non-negative integer $n$, defined as $n!={\prod }_{k=1}^{n}k$ with base case $0!=1$:

def factorial(n): # n is formal parameter, local scope
 if n == 0 or n == 1:
 return 1
 else:
 return n * factorial(n-1)

print(factorial(5)) # 5 is actual parameter, Output: 120

5. Arrays (1D and 2D)

Arrays are fixed-size, ordered data structures that store multiple values of the same data type, accessed via a numeric index. Indexes start at 0 for all A-Level-assessed languages except Visual Basic, which supports optional 1-based indexing.

1D Arrays

Single linear sequence of elements, ideal for storing lists of related data (e.g. test scores for 10 students). Valid indices for a 1D array of length $n$ are $0$ to $n-1$.

2D Arrays

Grid of elements organized into rows and columns, ideal for storing tabular data (e.g. test scores for 10 students across 4 tests). Elements are accessed via array[row_index][column_index].

Worked Example: Store test scores for 2 students across 3 tests, then print the second student's third test score:

scores_2d = [[85, 92, 78], [70, 88, 95]]
# Second student = index 1, third test = index 2
print(scores_2d[1][2]) # Output: 95

Exam Tip: Off-by-one errors when accessing array indexes are the most common mistake on array-related questions, so always double-check index ranges before submitting your answer.

6. String manipulation

Strings are immutable ordered sequences of characters, with a standard set of built-in operations across all A-Level-accepted languages:

• Concatenation: Join two strings using the $+$ operator
• Length: Return the number of characters in the string
• Substring: Extract a contiguous segment of the string
• Character access: Return the character at a given index
• Type conversion: Convert between string and numeric types (int, float)
• Search: Find the position of a target substring within the parent string

Worked Example: Extract the subject code from the string "A-Level Computer Science", convert it to integer, add 10, and print the result:

subject_string = "A-Level Computer Science"
code_substring = subject_string[4:8] # Extract characters at positions 4-7
code_int = int(code_substring)
print(code_int + 10) # Output: 9628

Exam Tip: String manipulation is a frequent task in Paper 3 and 4 practical exams, with common tasks including counting vowels, reversing strings, and validating user input (e.g. password length checks).

7. Common Pitfalls (and how to avoid them)

• Wrong move: Using the assignment operator $=$ instead of the equality comparison operator $==$ in if/loop conditions. Why students do it: Confusion between assignment and equality syntax. Correct move: Double-check all conditions: use $==$ for equality checks, $=$ only for variable assignment.
• Wrong move: Off-by-one errors when accessing array indexes or setting loop ranges. Why students do it: Forgetting that indexes start at 0 in most A-Level languages. Correct move: For an array of length $n$, valid indices are 0 to $n-1$; trace 2-3 iterations of loops manually to confirm range correctness.
• Wrong move: Modifying local variables and expecting the corresponding global variable to update. Why students do it: Lack of understanding of variable scope rules. Correct move: Explicitly declare variables as global if you need to modify them inside a subroutine, or use function return values to pass data instead of relying on global variables.
• Wrong move: Performing arithmetic operations on string inputs without type conversion. Why students do it: Overreliance on implicit type conversion in dynamically typed languages like Python. Correct move: Always explicitly convert user input (which defaults to string type) to int/float before performing arithmetic.
• Wrong move: Writing infinite while loops by forgetting to update the loop control variable. Why students do it: Rushing when writing loop code. Correct move: After writing a while loop, confirm that the control variable is updated inside the loop body and that the exit condition will eventually be met.

8. Practice Questions (A-Level Computer Science Style)

Question 1 (3 marks, Theory)

Consider the following Python code snippet:

a = 15
b = "30"
c = a + int(b)
print(c)

a) State the data type of variables a, b, and c after execution. (2 marks) b) State the output of the final print statement. (1 mark)

Solution: a) a = integer, b = string, c = integer (1 mark for 2 correct, 2 marks for all 3 correct) b) Output = 45 (1 mark)

Question 2 (5 marks, Practical)

A sports coach needs to store the number of points scored by 12 players across 5 matches. a) State the most appropriate data structure to store this data, including its dimensions. (2 marks) b) Write code (in any A-Level-accepted language) to calculate the total points scored by the third player (index 2) across all 5 matches. (3 marks)

Solution: a) 2D array (1 mark) with 12 rows (players) and 5 columns (matches) (1 mark, total 2) b) Python example code:

points = [[...]] # 12x5 2D array of points
total = 0
for match in range(5):
 total += points[2][match]
print(total)

(1 mark for correct traversal of 5 matches, 1 mark for correct access to the third player's row, 1 mark for correct sum calculation, total 3)

Question 3 (4 marks, Code Trace)

Trace the execution of the following code and state the final output:

def compute(x, y):
 if x < y:
 return y * 3
 else:
 return x + 7

result = compute(4, 9) + compute(9, 4)
print(result)

Solution:

1. compute(4,9): 4 < 9, returns $9\times 3=27$ (1 mark)
2. compute(9,4): 9 is not <4, returns $9+7=16$ (1 mark)
3. Sum of results: $27+16=43$ (1 mark)
4. Final output: 43 (1 mark, total 4)

9. Quick Reference Cheatsheet

10. What's Next

Programming fundamentals is the foundational topic for all advanced content in the A-Level Computer Science syllabus. You will use these constructs to learn object-oriented programming (Paper 2), design and implement algorithms for data structures like stacks, queues, and linked lists (Papers 2 and 4), and complete practical programming tasks in Papers 3 and 4. A strong grasp of these core concepts will reduce the time you spend debugging code in exams and make it easier to learn more complex programming patterns later.

If you have any questions about specific concepts covered in this guide, or want to practice more A-Level Computer Science style questions tailored to your skill level, you can ask Ollie, our AI tutor, anytime on the homepage. We recommend moving next to our study guide for structured data types, which builds directly on the array and subroutine concepts you learned here.

Aligned with the Cambridge International AS & A Level Computer Science 9618 syllabus. OwlsAi is not affiliated with Cambridge Assessment International Education.