What do OCR sections 2.1 and 2.2 cover?

Section 2.1 covers the elements of computational thinking: thinking abstractly (abstraction and models), thinking ahead (inputs, outputs, preconditions, caching, reusable components), thinking procedurally, thinking logically (decision points and conditions) and thinking concurrently, together with the computational methods of problem recognition, divide and conquer, backtracking, heuristics, performance modelling and visualisation. Section 2.2 covers programming techniques (sequence, selection, iteration, recursion, subroutines, parameters, scope) and object-oriented programming.

What is the difference between abstraction and decomposition?

Abstraction removes or hides detail that is not relevant to the problem, so only the important features remain, making it simpler to reason about. Decomposition breaks a large problem into smaller sub-problems that are each easier to understand, solve, test and maintain. Abstraction simplifies each part; decomposition divides the whole. They are used together when designing a solution or model.

When is a heuristic used instead of an exact method?

A heuristic, a practical rule of thumb that finds a good-enough solution quickly without guaranteeing the optimum, is used when finding the exact best solution is computationally infeasible in reasonable time. The travelling salesman problem and route finding across a large map are examples: the number of possibilities is too large to check exhaustively, so a near-optimal answer found fast is preferable to an exact answer that cannot be computed in time.

What must every recursive subroutine have?

A recursive subroutine must have a base case, a stopping condition that is solved directly without further recursion, and a recursive case that calls itself with input moving towards the base case. Without a reachable base case the recursion never stops and overflows the call stack. Each call adds a stack frame, so deep recursion uses more memory than the equivalent loop.

How should I revise sections 2.1 and 2.2?

Learn each computational thinking skill and method as a one-line definition with an example, because OCR asks you to explain and apply them. For programming, be fluent writing subroutines (including recursive ones) in OCR pseudocode, explaining by value versus by reference and local versus global scope, and writing a class definition with private attributes, a constructor, getters and an overridden method for polymorphism.

EnglandComputer Science

OCR A-Level Computer Science Programming and computational thinking: abstraction, constructs and OOP made exam-ready

A deep-dive OCR H446 guide to Component 02 sections 2.1 and 2.2, computational thinking and programming. Covers thinking abstractly and decomposition, thinking ahead, logically and concurrently, the computational methods, the programming constructs with subroutines, scope, parameters and recursion, and object-oriented programming techniques.

Generated by Claude Opus 4.815 min readH446 2.1 / 2.2Updated 2026-06-02

Reviewed by: AI editorial process; not yet individually human-reviewed

Jump to a section

What this section actually demands
Computational thinking
Programming techniques
How this section is examined
Check your knowledge

What this section actually demands

Sections 2.1 and 2.2 are the heart of Component 02. Section 2.1 is conceptual: you explain the thinking skills and computational methods and apply them to a scenario. Section 2.2 is practical: you read and write subroutines, recursion and class definitions. OCR rewards precise definitions with examples for the thinking content, and correct, well-structured code for the programming content.

This guide walks through the topics in order and sets out the exam patterns OCR repeats. Each topic has a matching dot-point page with practice; this overview ties them together.

Computational thinking

Thinking abstractly and decomposition covers abstraction (representational and procedural) and models, and breaking a problem into sub-problems. Thinking ahead and procedural decomposition covers inputs, outputs, preconditions, caching and reusable components, and ordering the steps of a solution. Thinking logically and computational methods covers decision points and conditions, plus problem recognition, divide and conquer, backtracking, heuristics, performance modelling and visualisation. Thinking concurrently and parallel processing covers identifying independent parts and the difference between concurrency and true parallelism.

Programming techniques

Programming constructs and subroutines covers sequence, selection and iteration, recursion (base and recursive cases, the call stack), subroutines (procedures and functions), parameters by value and by reference, local and global scope, and IDE features. Object-oriented programming techniques covers defining classes with private attributes and methods, constructors and instantiation, getters and setters, inheritance and method overriding for polymorphism, and the benefits of OOP.

How this section is examined

A typical OCR profile for sections 2.1 and 2.2:

Define and apply thinking skills. Explain abstraction, decomposition, backtracking, heuristics; apply them to a described problem.
Concurrency reasoning. Concurrent versus parallel; which parts of a task can run at once.
Write subroutines. Iterative and recursive versions; explain parameters and scope.
Object-oriented code. Write a class definition; design a hierarchy with inheritance and polymorphism (levels of response).

Check your knowledge

A mix of recall and applied questions covering the section. Attempt them under timed conditions, then check against the solutions.

State what abstraction removes from a problem. (1 mark)
State what a heuristic finds and what it does not guarantee. (2 marks)
State the difference between concurrent processing on one core and true parallel processing. (2 marks)
State what every recursive subroutine must have. (1 mark)
State the difference between passing a parameter by value and by reference. (2 marks)
State why class attributes are made private. (1 mark)

Sources & how we know this

OCR AS and A Level Computer Science (H046, H446) specification — OCR (2015)