What is the difference between a parameter and an argument?

A parameter is a variable listed in a subroutine's definition (e.g., def add(x, y): where x and y are parameters). An argument is the actual value passed to the subroutine when called (e.g., add(5, 3) where 5 and 3 are arguments). In OCR exams, you need to use the correct terminology and understand how arguments are passed by value or by reference.

How do I choose between a list and a dictionary in Python?

Use a list when you need an ordered collection of items accessed by index (e.g., a list of student names). Use a dictionary when you need key-value pairs for fast lookups (e.g., mapping student IDs to names). Lists are better for sequences, while dictionaries excel at associative data. In OCR, you may be asked to justify your choice based on efficiency or readability.

What is encapsulation and why is it important?

Encapsulation is the bundling of data (attributes) and methods that operate on that data within a class, restricting direct access to some components (using private or protected modifiers). It prevents accidental interference and misuse, making code more modular and maintainable. In OCR, you should be able to explain how encapsulation supports the principle of information hiding.

How do I handle errors in my code for the NEA?

Use try-except blocks to catch runtime errors like ValueError or FileNotFoundError. Validate user inputs (e.g., check if a number is within range) before processing. For the NEA, demonstrate robust error handling by anticipating common failures and providing meaningful error messages. Avoid using bare except clauses; catch specific exceptions.

What is the difference between pass by value and pass by reference?

Pass by value copies the actual value of the argument into the subroutine's parameter, so changes inside the subroutine do not affect the original variable. Pass by reference passes a reference (memory address) to the original data, so changes affect the original. In Python, immutable types (int, string) are passed by value, while mutable types (list, dict) are passed by reference. OCR exams often test this with code tracing.

When should I use recursion instead of iteration?

Recursion is ideal for problems that can be broken into smaller, similar subproblems, like tree traversal or factorial calculation. It often leads to cleaner, more elegant code. However, recursion can be less efficient due to stack overhead and may cause stack overflow for deep recursion. Iteration is generally more efficient and easier to debug. In OCR, you should be able to implement both and discuss trade-offs.

Programming techniques

OCR

A-Level

This topic covers the fundamental programming techniques required to develop software solutions, including control structures, modularity, and object-oriented programming. It emphasizes the use of recursion, variable scope, and integrated development environments (IDEs) to create efficient and maintainable code.

Objectives

Exam Tips

Pitfalls

Key Terms

Mark Points

Topic Overview

Programming techniques form the backbone of computer science, encompassing the methods and practices used to design, write, and maintain code. In OCR A-Level Computer Science, this topic covers structured programming, object-oriented programming (OOP), and functional programming paradigms, alongside essential constructs like sequence, selection, and iteration. You'll learn how to decompose problems, use subroutines effectively, and manage data through arrays, lists, and dictionaries. Mastering these techniques is crucial for developing efficient, readable, and maintainable software—a skill valued in both exams and real-world development.

This topic builds on GCSE programming fundamentals and prepares you for more advanced concepts like recursion, abstraction, and algorithm complexity. In the OCR specification, programming techniques are assessed through both written exams and the non-exam assessment (NEA), where you'll apply these skills to a substantial programming project. Understanding how to choose the right paradigm for a problem, implement robust error handling, and write modular code will directly impact your exam performance and practical ability. Beyond the classroom, these techniques are used in industry to build everything from mobile apps to AI systems.

Programming techniques are not just about syntax; they're about thinking like a computer scientist. You'll develop problem-solving strategies such as top-down design, stepwise refinement, and test-driven development. The OCR syllabus emphasises the importance of writing clear, well-documented code that is easy to debug and adapt. By the end of this topic, you should be able to compare paradigms, justify your choice of data structures, and produce programs that meet specified requirements efficiently. This knowledge is assessed through questions on code snippets, algorithm design, and scenario-based problems.

Key Concepts

Core ideas you must understand for this topic

→Structured programming: Use of sequence, selection (if/else), and iteration (for/while loops) with single entry and exit points to avoid spaghetti code.
→Subroutines (procedures and functions): Breaking code into reusable blocks; understanding scope (local vs global variables) and parameter passing (by value vs by reference).
→Object-oriented programming (OOP): Encapsulation, inheritance, polymorphism, and abstraction—designing classes with attributes and methods to model real-world entities.
→Data structures: Arrays (1D and 2D), lists, tuples, dictionaries, and records; knowing when to use each for efficient data manipulation.
→Error handling and testing: Using try-except blocks, validation, and debugging techniques to produce robust code; understanding syntax, logic, and runtime errors.

What You Need to Demonstrate

Key skills and knowledge for this topic

Correct use of programming constructs: sequence, iteration, and branching.
Understanding and implementation of recursion compared to iterative approaches.
Correct application of global and local variable scope.
Effective use of modularity through functions and procedures, including parameter passing by value and by reference.
Demonstration of object-oriented programming techniques.
Effective use of an IDE for program development and debugging.

Marking Points

Key points examiners look for in your answers

Correct use of programming constructs: sequence, iteration, and branching.
Understanding and implementation of recursion compared to iterative approaches.
Correct application of global and local variable scope.
Effective use of modularity through functions and procedures, including parameter passing by value and by reference.
Demonstration of object-oriented programming techniques.
Effective use of an IDE for program development and debugging.

Examiner Tips

Expert advice for maximising your marks

💡Be prepared to trace code snippets involving recursion and identify the base case.
💡Practice identifying whether a variable should be global or local in a given context.
💡Ensure you can distinguish between passing by value and passing by reference in pseudocode.
💡Familiarize yourself with the provided pseudocode syntax to avoid syntax errors in the exam.
💡When asked to write code, focus on logical correctness and clarity rather than memorizing specific language syntax.
💡Always trace through your code with a simple test case before writing the final answer. Examiners award marks for correct logic, not just syntax. Use a trace table to show variable changes.
💡When asked to compare paradigms (e.g., procedural vs OOP), use specific examples from the scenario. Don't just list features—explain how they solve the problem differently.
💡In the NEA, document your programming techniques clearly. Use comments, meaningful variable names, and modular design. Examiners look for evidence of structured programming and appropriate use of data structures.

Common Mistakes

Pitfalls to avoid in your exam answers

Confusing parameter passing by value with passing by reference.
Incorrectly managing variable scope, leading to unintended side effects.
Failing to provide a base case in recursive functions, leading to stack overflow.
Inappropriate use of global variables when local variables would be more suitable.
Poor annotation of code, making maintenance difficult.
Misconception: 'A function and a procedure are the same thing.' Correction: A function returns a value, while a procedure does not. In Python, all subroutines are functions, but they can return None. In OCR, you must distinguish between them in pseudocode.
Misconception: 'Global variables are always bad.' Correction: While overuse of globals can lead to code that is hard to debug, they are sometimes necessary (e.g., constants). The key is to minimise their use and prefer local variables with parameter passing.
Misconception: 'Inheritance always improves code.' Correction: Inheritance can create tight coupling and complex hierarchies. Composition (using objects within other objects) is often a better design choice. OCR expects you to evaluate trade-offs.

Frequently Asked Questions

Common questions students ask about this topic

Before You Start

Prior knowledge that will help with this topic

•Basic programming constructs: variables, data types, input/output, and simple conditionals (from GCSE or AS Level).
•Understanding of algorithms: how to design a simple algorithm using flowcharts or pseudocode.
•Familiarity with a programming language (Python is recommended for OCR) and ability to write and run simple programs.

Likely Command Words

How questions on this topic are typically asked

Describe

Explain

Identify

Write

Compare

Trace

Ready to test yourself?

Practice questions tailored to this topic

Programming techniques

Topic Overview

Key Concepts

What You Need to Demonstrate

Marking Points

Examiner Tips

Common Mistakes

Frequently Asked Questions

Before You Start

Likely Command Words

Ready to test yourself?

Related Topics in OCR A-Level Computer Science

Algorithms

Analysis of the problem

Applications Generation

Boolean Algebra

Topic Synopsis

Key Concepts & Core Principles

Exam Tips & Revision Strategies

Common Misconceptions & Mistakes to Avoid

Examiner Marking Points

Programming techniques

Topic Overview

Key Concepts

What You Need to Demonstrate

Marking Points

Examiner Tips

Common Mistakes

Frequently Asked Questions

What is the difference between a parameter and an argument?

How do I choose between a list and a dictionary in Python?

What is encapsulation and why is it important?

How do I handle errors in my code for the NEA?

What is the difference between pass by value and pass by reference?

When should I use recursion instead of iteration?

Before You Start

Likely Command Words

Ready to test yourself?

Related Topics in OCR A-Level Computer Science

Algorithms

Analysis of the problem

Applications Generation

Boolean Algebra