Thinking Logically & Concurrently: Decisions and Doing Things at Once (OCR A-Level CS 2.1.4–2.1.5)

Free Thinking Logically Concurrently revision resources (OCR A-Level Computer Science, 2.1.4)

We’ve made exam-style practice for this exact topic, free to download: Thinking Logically Concurrently question sheet, mark scheme and cheat sheet. Grab them, have a go, then read the full guide below.

Two more computational-thinking skills round off section 2.1. Thinking logically (2.1.4) is about the decisions a solution makes — where they happen, what conditions control them, and how they change the flow. Thinking concurrently (2.1.5) is about spotting which parts of a problem can run at the same time, and weighing whether that's worth it. Both appear in Paper 2 — the concurrency part is a regular 9-mark "discuss" essay.

Let's take them in turn.

Thinking logically: decisions and conditions

A program rarely runs straight through — it makes decisions that send it down different paths. Thinking logically means:

• Identifying the decision points — the places where the solution must choose between alternatives (2.1.4a). On a flowchart these are the diamonds; in code they're IF/CASE statements.

• Determining the logical conditions — the test at each decision that decides which way to go (2.1.4b). For example age >= 18, password == stored, or attempts > 3.

• Determining how decisions affect the flow — which statements run, and which are skipped, depending on whether the condition is True or False (2.1.4c).

A simple example: a login routine. The decision point is "is the password correct?"; the condition is entered == stored; and the flow branches — if True, grant access; if False, increment the attempt count and ask again. Trace the True and False paths and you've answered the typical exam question.

Thinking concurrently: doing things at the same time

Concurrent processing means carrying out more than one task at the same time (or interleaving them) rather than strictly one after another. To think concurrently you first identify the parts of a problem that can be done at the same time (2.1.5a) — i.e. the parts that don't depend on each other's results.

For example, when generating a report, you could fetch data from several sources at once because none waits on another; but you can't calculate the total before the data has arrived — that part must stay sequential.

Benefits and trade-offs (2.1.5b) — the heart of the 9-mark essay:

• Benefits: tasks can finish sooner (especially on multi-core processors); the system stays responsive (one slow task doesn't freeze everything); good use of resources for big problems like weather forecasting or image processing.

• Trade-offs: it's harder to design and debug; tasks that share data can interfere with each other (race conditions), so you need careful coordination; some problems can't be parallelised because each step needs the previous result; and there's overhead in splitting and recombining the work, so the speed-up is less than proportional to the number of cores.

The honest conclusion: concurrency helps when the work divides cleanly into independent parts and there are cores to run them — otherwise the extra complexity may not pay off.

Worked example: a weather-forecasting model

A forecast divides the map into a grid and computes each cell. Many cells can be computed concurrently because, for one time-step, they don't depend on each other — so on a multi-core machine the forecast finishes far sooner. But each new time-step depends on the previous one, so the steps must run in order. That mix — concurrent within a step, sequential between steps — is exactly the kind of analysis 2.1.5 rewards.

Common exam mistakes

• Confusing decision point with condition. The point is where a choice is made; the condition is the test (x > 10) that decides it.

• Forgetting the False path. "How does the decision affect flow?" needs both outcomes — what runs if True and if False.

• Saying concurrency always doubles speed. Overhead and dependencies mean the speed-up is less than proportional.

• Parallelising dependent steps. Only independent parts can run at once; sequential dependencies must be respected.

• One-sided concurrency essays. "Discuss/outline benefits and trade-offs" — give both, then conclude.

Quick recap

• Thinking logically: find the decision points, the logical conditions that control them, and how each decision changes the flow (what runs vs is skipped).

• Decision points = IF/CASE (diamonds on a flowchart); conditions = the test, e.g. age >= 18.

• Thinking concurrently: identify parts that can run at the same time — the independent ones.

• Benefits: finishes sooner, more responsive, great for big divisible problems.

• Trade-offs: harder to design/debug, data clashes, dependencies, overhead → less than proportional speed-up.

Frequently asked questions

What is a decision point in a program? A decision point is a place in a solution where the program must choose between alternatives, such as an IF or CASE statement (a diamond on a flowchart). Identifying decision points is the first part of thinking logically, because they determine where the flow of the program can branch.

What is a logical condition? A logical condition is the test at a decision point that decides which path the program takes, such as age >= 18 or password == stored. The condition evaluates to True or False, and that result determines which statements run next.

How do decisions affect the flow through a program? A decision causes the program to branch: depending on whether the condition is True or False, different statements run and others are skipped. To describe the flow you trace both the True path and the False path from the decision point.

What is concurrent processing? Concurrent processing means carrying out more than one task at the same time, or interleaving tasks, rather than running them strictly one after another. It is used to complete work sooner and keep a system responsive, and is especially effective on multi-core processors.

What are the benefits and trade-offs of concurrent processing? The benefits are that tasks can finish sooner, the system stays responsive, and large divisible problems like weather forecasting are handled efficiently. The trade-offs are that it is harder to design and debug, tasks sharing data can interfere, some steps cannot be parallelised because they depend on previous results, and overhead means the speed-up is less than proportional to the number of cores.

Which parts of a problem can be done concurrently? Only the parts that are independent — that do not depend on each other's results — can be carried out at the same time. Parts where one step needs the output of a previous step must stay sequential, so analysing the dependencies tells you what can be parallelised.