4.14.3.3–4.14.3.4, 4.14.5.3 - Technical solutions, proficiency and coding style (Python)
Use independent Python examples to distinguish completeness from demonstrated technical skill, improve code structure and present a readable technical listing. The short exercises are formative skill practice; they do not produce or certify your assessed project.
Completeness and demonstrated skill
A technical solution must address its requirements and demonstrate that its chosen techniques have been implemented proficiently. Completeness concerns how much of the required solution works. Proficiency concerns the technical skill actually demonstrated by the implementation. They are connected, but a long list of planned features is evidence of neither.
The official NEA technical-solution section has 42 marks: 15 for completeness and 27 for techniques used with demonstrated proficiency. The tables below explain that reference framework. They are not the marking rubric for a six-mark exercise in this course.
| Completeness level | Official range | What the delivered system achieves |
|---|---|---|
| 3 | 11–15 | Almost all requirements within A-level demand |
| 2 | 6–10 | Many requirements; the upper part of the band includes some of the most important requirements |
| 1 | 1–5 | Some aspects of the problem or investigation |
Requirements beyond A-level demand are disregarded for this judgement. A missing core booking operation matters more than an unimplemented decorative extra. Link each requirement to a visible implemented feature and test result instead of counting completed screens.
| Techniques and proficiency level | Official range | Appropriate demonstrated demand |
|---|---|---|
| 3 | 19–27 | Technical skill equivalent to Group A, applied sufficiently to show proficiency |
| 2 | 10–18 | Technical skill equivalent to Group B, applied sufficiently to show proficiency |
| 1 | 1–9 | Technical skill equivalent to Group C, applied sufficiently to show proficiency |
First identify the level of demand attempted, then check what the program actually achieves. If the intended higher-demand approach does not demonstrate proficiency, consider the lower level supported by the implemented work. Within a matched band, the extent of achievement, coding style and effectiveness determine the mark; including a named structure does not automatically earn the band.
For Group A demand, performance ranges from an adequately implemented, less effective solution with some excellent style characteristics, through a well-programmed effective solution with most excellent characteristics, to excellent programming and a highly effective solution with all or almost all excellent characteristics. Group B similarly ranges from just adequate implementation with good style and at most one excellent characteristic, through effective well-programmed work with some excellent characteristics, to stronger programming and effectiveness with most excellent characteristics. Group C ranges from severely limited implementation with basic style and little effectiveness, through effective simple work with some good characteristics, to strong simple implementation with almost all relevant good characteristics. These are descriptions of overall evidence, not separate checkbox awards.
Consider two independent prototypes. One reliably fulfils every requirement using a simple list and linear search. Another declares a tree class but never inserts or searches its nodes correctly. The first supplies real completeness and skill evidence; the second does not demonstrate tree proficiency merely by naming the class. Conversely, a technically strong core may still omit an important requirement, so its completeness evidence must be considered separately.
Technical Groups A, B and C as indicative examples
The official technical groups illustrate levels of demand through both models and algorithms. A model represents the relevant data or system; an algorithm operates on that representation. Choose techniques because they solve the problem, then demonstrate how they work. Adding unnecessary complexity can reduce effectiveness.
| Group | Indicative models and structures | Indicative operations and algorithms |
|---|---|---|
| A | Complex databases with several linked tables; hash tables, lists, stacks, queues, graphs, trees or equivalent structures; direct-access files; complex scientific, mathematical, robotics, control or business models; complex user-defined OOP with relationships such as inheritance, composition, polymorphism and interfaces; complex client–server models | Parameterised cross-table SQL, aggregate SQL and user/CASE-generated data-definition scripts; traversal and structure maintenance, hashing and stack/queue operations; advanced matrix work, recursion, complex optimisation/scheduling/pattern matching or equivalent algorithms, mergesort or a similarly efficient sort; dynamic objects in complex OOP; complex server-side request/response processing and parameterised web-service calls with JSON/XML parsing |
| B | Simple databases, for example two or three linked tables; multidimensional arrays, dictionaries and records; text or sequential-access files; simple scientific, mathematical, robotics, control or business models; simple OOP and client–server models | Single-table or non-parameterised SQL; bubble sort and binary search; file reading/writing; simple user-defined mathematical/statistical algorithms; object generation in simple OOP; simple server-side request/response processing and web-service calls with JSON/XML parsing |
| C | One-dimensional arrays, appropriate simple types and a single-table database | Linear search, simple calculations such as an average and non-SQL table access |
The table is indicative. Equivalent algorithms and data models are encouraged. A Python list used only as a short fixed collection does not automatically establish Group A proficiency: examine the demand of the model and operations, their appropriateness and how sufficiently they are used. Nor does one API call turn a simple script into a complex client–server solution.
For example, a club tool that reads a text file, stores member records in a dictionary and calculates simple totals resembles Group B examples. A dependency planner whose graph model supports correctly implemented traversal and scheduling can demonstrate a different level of demand. The label depends on actual implemented work and effectiveness, not a count of libraries imported. If a substantial hardware project does not fit the examples readily, the official procedure is for the centre to consult the AQA NEA Adviser or explain the marking rationale when submitting for moderation; this course cannot certify that judgement.
A practical technique justification connects a requirement to a choice and its consequence: “Lookup by membership ID is needed repeatedly, so a dictionary keyed by that unique ID avoids manually searching every record. Missing IDs are handled explicitly.” It should also recognise constraints and alternatives, such as the memory cost and the adequacy of a simpler linear search for a very small collection.
Cohesion, coupling and defensive code
Cohesion means the operations within a module serve one clear purpose. Coupling concerns its dependency on other parts of the program. A cohesive function that receives data through parameters and returns a result has a clear interface; a function that secretly changes a global list or depends on a hard-coded file path is harder to reuse and test.
Separate reading, interpreting and presenting data. load_scores(filename) deals with the file; mean_score(scores) computes a result; the caller chooses what to display. The file path is parameterised, so tests can use a different file without editing the function. Related functions can later be grouped in a module. Good interfaces make assumptions and outcomes explicit.
Continue this lesson.
You’re previewing NovaLearn without an account. Create a free account to read the rest.
Create free account