Describe the solution — OCR A-Level Computer Science
Describe the solution explained
Describe the solution covers 4 specification points, including (a) Explain and justify the structure of the… and (b) Describe the parts of the solution using….
Read the full explanation
Open a point below for its explanation and revision guidance.
(a) Explain and justify the structure of the solution.
This asks you to explain and justify the structure of your solution. Identify the main components, such as modules or stages of processing, and state what each is responsible for. Explain the structure by showing how data and control pass between them, for example a menu module calling a validation routine before a storage module saves a record. Justify each structural choice by linking it to a requirement from your analysis, such as keeping input handling separate so interface changes do not affect stored data. Use the exact names from your design so the reader can follow the flow.
(b) Describe the parts of the solution using algorithms justifying how these algorithms form a complete solution to the problem.
This asks you to describe the parts of the solution using algorithms and to justify how those algorithms form a complete solution to the problem. For each part, give the algorithm in a clear form such as structured English, pseudocode or a flowchart, showing its inputs, processing and outputs. Justify completeness by mapping each algorithm to a requirement from your analysis, then checking that every requirement and every data flow between parts is covered. Show how one algorithm's output becomes another's input, so no step is left without a method. Describe what each algorithm does rather than only naming it.
(c) Describe usability features to be included in the solution.
Usability describes how easily and effectively a user can complete tasks with the solution. To describe usability features, give an account of each one you will build into your own solution: what it is, how it appears to the user and why it helps them. Typical features include clear labels, consistent layouts, validation that reports errors beside the affected field, and a confirmation step before data is deleted. For example, a booking form that shows a red border and the words date must be in the future beside an invalid date lets the user correct it without restarting. Link every feature to a user need from your analysis, and avoid generic lists that could apply to any program.
(d) Identify key variables / data structures / classes justifying choices and any necessary validation.
To identify means naming the key variables, data structures and classes in your design. Justifying choices means explaining why each one suits the problem, for example a fixed-length array of 30 integers for the marks of 30 students, a dictionary keyed by username for fast lookup, or a Student class that groups a name, ID and mark. Link each justification to a requirement from your analysis. Any necessary validation should be named for the data each structure holds, such as a range check of 0 to 100 on a mark, a length check on a username, or a presence check on a required field, with a reason for each check. Include validation only where the data needs it.
Your focus
- Identify the components of a solution and state the responsibility of each.
- Explain the data and control flow between components using the names from a design.
- Justify a structural choice by linking it to a requirement from the analysis.
Show all 12 objectives
- Describe each part of a solution using an algorithm representation.
- Map algorithms to the requirements they satisfy.
- Justify that a set of algorithms forms a complete solution to the problem.
- Describe at least three usability features for a named solution.
- Explain how each feature appears to a named user and why it helps them.
- Link each feature to a requirement identified in the analysis.
- Identify at least three key variables, data structures or classes in a design.
- Justify each choice by a property relevant to the problem.
- Specify a validation check and its reason for a named data item.
Describe the solution exam tips
Marking Points
- Identifies the main components of the solution and states the responsibility of each.
- Explains how data and control flow between components, using the names from the design.
- Justifies each structural choice by referring to a requirement or constraint from the analysis.
- Shows why the chosen structure suits the problem, such as separation of concerns that limits the effect of changes.
- Uses consistent terminology so the structure can be followed without reading the code.
- Describes each part of the solution and the algorithm it uses, in a clear form such as pseudocode, a flowchart or structured English.
- Shows the inputs, processing and outputs of each algorithm so its function can be followed.
- Maps each algorithm to a requirement from the analysis to show which requirement it fulfils.
- Checks that the algorithms together cover every requirement and every data handoff between parts.
- Justifies completeness by identifying any gap and explaining how the set of algorithms closes it.
- Names usability features that are specific to the solution rather than generic.
- Explains how each feature appears to the user and what it does for them.
- Links each feature to a user need identified in the analysis.
- Gives a concrete example of feature behaviour, such as validation placed beside the field it affects.
- Names key variables, data structures or classes that the solution will use.
- Justifies each choice by referring to the data it holds and the requirement it meets.
- States the validation needed for specific data, with the reason for each check.
- Recognises when validation is not needed rather than adding it to every input.
Examiner Tips
- 💡Name the components first, then write one sentence for each stating its responsibility.
- 💡For each justification, complete the chain: the structural choice, the requirement it meets, and why it meets that requirement.
- 💡Keep the vocabulary consistent with your design documentation so the explanation matches the evidence you present.
- 💡Build a table of requirements against algorithms to check coverage before you write the answer.
- 💡Use one consistent representation throughout, such as pseudocode, and define any variable names you introduce.
- 💡Trace one typical case from input to output through your algorithms, then state any limitation you find honestly.
- 💡Plan a short list of three to five features before writing, each tied to a user need.
- 💡Give each feature its own paragraph covering what it is, how it appears and why it helps.
- 💡Check that every feature you describe appears in your design so that the account matches the solution.
- 💡Build a table with columns for the structure, what it holds, why it suits the problem and any validation, then write up from it.
- 💡Use the same names as your design so that the reader can match each item to your code.
- 💡Justify each choice with a named property, such as speed of lookup, fixed size or grouping of related attributes.
Common Mistakes
- Lists components without explaining how they interact; add the links and data flow between them.
- Asserts that a structure is good without referring to any requirement; tie each choice to a stated need from the analysis.
- Describes the code line by line instead of the architecture; move to components, responsibilities and their relationships.
- Names algorithms without describing what they do; add the inputs, processing and outputs for each one.
- Claims completeness without checking the requirements; map every requirement to at least one algorithm.
- Omits how the output of one algorithm feeds into the next; state the data handoff between parts.
- Lists features without explaining their benefit to the user; add how each one helps them.
- Describes general design theory rather than features the solution will contain; restrict the answer to planned features.
- Gives features that suit any program rather than the stated problem; tie each one to a specific user need.
- Lists generic terms such as array or class without naming what each holds in this solution; name the specific item and its purpose.
- Justifies choices with vague statements such as it is good; state the property that suits the problem, such as fast lookup or fixed size.
- Adds validation to every input without reason; justify each check against the data it protects.