Fundamentals of programming — AQA A-Level Computer Science

Fundamentals of programming is the bedrock of computer science, covering how to design, write, and test code to solve problems. In AQA A-Level Computer Science, this topic introduces the core constructs of programming: sequence, selection, and iteration, along with data types, variables, and operators. You'll learn to break down problems into smaller steps using algorithms and then implement them in a high-level language like Python, Java, or C#. Mastering these basics is essential because every advanced topic—from data structures to object-oriented programming—builds on this foundation.

Why does this matter? Programming is how we turn ideas into working software. In the AQA specification, you're expected to write programs that are not only correct but also efficient and readable. This topic teaches you to think like a programmer: to use meaningful variable names, comment your code, and structure it logically. It also introduces key concepts like subroutines (functions and procedures) and parameter passing, which are crucial for managing complexity. Beyond exams, these skills are directly applicable to real-world software development, making this topic one of the most practical in the course.

Fundamentals of programming fits into the wider subject by providing the toolkit for all subsequent programming tasks. Whether you're implementing a binary search, simulating a network, or creating a GUI, you'll rely on the constructs learned here. The AQA exam often includes a programming question worth 8–12 marks, where you must write or complete code. A strong grasp of fundamentals ensures you can tackle these questions confidently, avoiding common pitfalls like off-by-one errors or infinite loops. This topic also links to computational thinking, as you'll learn to decompose problems and use abstraction to focus on key details.

• →Variables and data types: Understand how to declare variables and use appropriate data types (integer, real, Boolean, character, string) to store and manipulate data.
• →Sequence, selection, and iteration: Master the three basic constructs—sequential execution, IF/ELSE statements for selection, and loops (FOR, WHILE, REPEAT) for iteration.
• →Subroutines: Know how to define and call functions (return a value) and procedures (perform an action), and understand the difference between passing parameters by value and by reference.
• →Operators: Be able to use arithmetic (+, -, *, /, MOD, DIV), relational (==, !=, <, >, <=, >=), and logical operators (AND, OR, NOT) in expressions.
• →Input/output: Use commands like PRINT and INPUT to interact with the user, and understand how to format output.

• Award credit for correctly declaring and initialising variables with explicit data types (e.g., int, float, string) and meaningful identifiers.
• Credit for appropriate use of constants (e.g., const or final) where values logically should not change, improving code robustness.
• Look for correct syntax and semantic use of operators, including proper handling of integer vs. floating-point division and string concatenation.
• Assess proper use of input statements, including any required type conversion (e.g., casting input to integer), and clear user prompts.
• Evaluate output statements for correct formatting, such as concatenation of labels and values, and appropriate use of newline characters.
• Check that assignment statements correctly update variable values, with no confusion between the assignment operator and equality comparison.
• Credit for demonstrating awareness of operator precedence by using parentheses where necessary to make expression intent explicit.

• 💡Always initialise variables at the point of declaration to avoid ambiguity and gain marks for good practice.
• 💡Explicitly comment on the use of constants to demonstrate understanding of immutability and code reliability.
• 💡When evaluating expressions in exam questions, break them down step-by-step using precedence rules, and show intermediate values to secure method marks.
• 💡In code-writing tasks, use descriptive variable names and include clear output formatting to make your program logic easy to follow.
• 💡Check whether the specification requires input validation or type conversion; including these can earn additional marks even if not explicitly stated.
• 💡Practise tracing through code with multiple operators and mixed data types to build confidence in predicting output.
• 💡Tip 1: Always trace through your code with a simple test case before writing it. Examiners love to see that you've considered edge cases (e.g., empty input, negative numbers). Use a trace table to track variable values.
• 💡Tip 2: Use meaningful variable names (e.g., 'totalMarks' not 'tm') and add brief comments to explain complex logic. This shows you understand good programming practice and makes your code easier to mark.
• 💡Tip 3: In exam questions, read the specification carefully. If it asks for a function that returns a value, make sure you use RETURN, not just PRINT. If it asks for a procedure, don't return anything.

• Confusing the assignment operator (=) with the equality operator (==), leading to logical errors in code and in written exam questions.
• Forgetting to initialise variables before use, which can cause undefined behaviour or compiler errors.
• Misunderstanding operator precedence (e.g., assuming addition happens before multiplication) resulting in incorrect expression evaluation.
• Failing to convert input data types (e.g., reading a string without parsing it to an integer when numeric operations are intended).
• Using variables instead of constants for fixed values (like tax rates or mathematical constants) which reduces code clarity and maintainability.
• Omitting user prompts in input statements, making the program unclear to the end-user.
• Misconception: 'Assignment (=) means equality.' Correction: In most languages, = is assignment (e.g., x = 5 sets x to 5), while == is used for equality comparison. Mixing them up causes logic errors.
• Misconception: 'A WHILE loop always runs at least once.' Correction: A WHILE loop checks the condition before each iteration, so it may never run if the condition is initially false. A REPEAT loop (or DO WHILE) runs at least once because it checks after.
• Misconception: 'Variables declared inside a subroutine are accessible everywhere.' Correction: Variables have scope—those declared inside a subroutine are local and cannot be accessed outside. Global variables are declared outside all subroutines.