Programming Fundamentals (Year 11)

Software development steps (the order) Process

The fixed sequence of the development cycle: requirements definition, determining specifications, design, development, integration, testing and debugging, installation, maintenance.

Example: Order to memorise: Requirements, Specifications, Design, Development, Integration, Testing and debugging, Installation, Maintenance.

Requirements definition Process

Finding out what the client needs: gathering and documenting the problem, users, functional and non-functional requirements and constraints (client scenario, environment, objectives).

Example: Outline pattern: 'Meet the client and document what the software must do, such as login and data storage.'

Determining specifications Process

Turning requirements into a detailed description of what the software will do: inputs, processes, outputs, data, performance, technical needs and compliance. Tools include IPO charts, data dictionaries and Gantt charts.

Example: Requirements say WHAT the client wants; specifications say exactly HOW WELL and in WHAT FORM the software will deliver it.

Design Process

Planning the solution before coding using modelling tools: algorithms (pseudocode, flowcharts), structure charts, DFDs, class diagrams, storyboards, decision trees and data dictionaries.

Example: Link each design tool to its purpose: DFD = data movement; structure chart = module hierarchy; class diagram = classes and relationships.

Development Process

Writing the code that implements the design in the chosen language, following the algorithms and good coding practice (comments, naming, modular subroutines).

Example: Development turns the design into working code.

Integration Process

Combining separately built modules or subsystems into one working system and checking they communicate correctly through their interfaces.

Example: Integration comes AFTER development and BEFORE system testing.

Testing and debugging Process

Testing runs the software with chosen data to find errors; debugging finds the cause of each error and fixes it.

Example: Testing finds that something is wrong; debugging finds out why and fixes it.

Installation Process

Putting the finished system into use in the client's environment (direct, phased, parallel or pilot method) including setup and training.

Example: Installation comes after testing and before maintenance.

Maintenance Process

Changes made after release to keep software working and useful: corrective (fix errors), adaptive (new environment) and perfective (improve or add features).

Example: 'A patch to fix a crash is corrective maintenance.'

Online code collaboration tools Process

Web platforms where developers store, share, review and co-edit code with version control and issue tracking, for example GitHub, GitLab or Bitbucket.

Example: 'GitHub lets team members branch, merge and review each other's changes without overwriting work.'

Computational thinking Term

A problem-solving approach: decompose a problem, spot patterns, abstract away detail and design an algorithm.

Example: Use it to justify breaking a large task into subroutines.

Check this one: The syllabus asks you to apply computational thinking and algorithmic design but does not list its four parts; the breakdown given here is the standard definition.

Algorithm Term

A finite, ordered set of clear steps that solves a problem or completes a task, with defined inputs and outputs.

Example: An algorithm can be shown as pseudocode or a flowchart.

Sequence Term

A control structure where statements run one after another in the order written.

Example: Every program uses sequence; selection and iteration change the order.

Selection Term

A control structure that chooses which path to run depending on a condition: binary selection (IF ... ELSE), multi-way selection (CASEWHERE) or nested IF.

Example: 'Use IF/ELSE selection to output Pass when mark >= 50.'

Iteration (repetition) Term

A control structure that repeats statements while or until a condition: pre-test loop (WHILE ... ENDWHILE), post-test loop (REPEAT ... UNTIL) or counted loop (FOR ... NEXT).

Example: 'FOR each item in the array: total = total + item.'

Divide and conquer Term

Breaking a large problem into smaller sub-problems, solving each one and combining the results (for example binary search or splitting a program into subroutines).

Example: Use it to explain why a program is split into subroutines.

Backtracking Term

Trying one choice and, if it reaches a dead end, undoing it and trying the next, as in maze solving or Sudoku.

Example: 'A maze solver backtracks to the last junction when it hits a wall.'

Top-down design Term

Starting with the whole problem (the mainline) and refining it step by step into smaller subroutines.

Example: A structure chart shows top-down design.

Bottom-up design Term

Building and testing small low-level modules first, then combining them into larger parts of the system.

Example: Contrast: top-down starts with the mainline; bottom-up starts with the lowest-level modules.

Abstraction Term

Hiding unnecessary detail so you focus on what matters, such as calling a subroutine without knowing how it works.

Example: Also an OOP principle (see Object-oriented card).

Refinement Term

Adding successively more detail: a subroutine is expanded into its own algorithm or structure chart, named the same as the subroutine.

Example: 'Show the refinement of the Validate subroutine in a separate chart.'

Pseudocode Term

Structured, language-independent English-like code: keywords in capitals (IF, ELSE, WHILE, ENDWHILE, FOR, NEXT, SET, GET, DISPLAY), paired structures and consistent indentation.

Example: Always write a mainline plus subroutines, use indentation and close every structure (ENDIF, ENDWHILE).

Flowchart Term

A diagram of an algorithm drawn with standard symbols (terminator, process, input/output, decision) joined by arrows, read top to bottom and left to right. Decision arrows must be labelled (Yes/No).

Example: Check there is one Start, one End, labelled decision branches and arrowheads on every line.

Subroutine (module, subprogram, procedure) Term

A named block of statements that performs one specific task and can be called many times; the terms subroutine, module, subprogram and procedure are used interchangeably in the course.

Example: 'One logical task per subroutine makes code reusable and easier to maintain.'

Function v procedure Term

A function returns a value to the caller (RETURN); a procedure carries out a task and does not return a value.

Example: 'def calc_total(a, b): return a + b' is a function.

Parameter and argument Term

A parameter is a variable in the subroutine's definition that receives data; an argument is the actual value passed when the subroutine is called.

Example: 'def greet(name)' has parameter name; 'greet("Sam")' passes argument "Sam".

Mainline Term

The main algorithm that controls the program by calling subroutines in order. Good mainlines are clear and uncluttered.

Example: Put calls to your subroutines in the mainline, and call functions after they are defined (2025 Q19 marker note).

Desk checking Term

Manually stepping through an algorithm with sample data and recording variable values (a trace table) to check it works before coding.

Example: A trace table has a column for each variable and a row for each step.

Peer checking Term

Another person reviews the algorithm or code to find errors you may have missed.

Example: Contrast: desk checking is by the author; peer checking is by someone else.

Inputs, outputs and purpose of an algorithm Term

When analysing an algorithm, identify the data it takes in (inputs), the results it produces (outputs), what it is designed to do (purpose) and how it connects to other subroutines.

Example: 'Inputs: array of marks. Output: the average. Purpose: calculate the class mean.'

Check this one: Not found word-for-word in the supplied syllabus, specifications, marking guidelines or notes; the definition is standard computing knowledge, so check it against your class notes.

IPO chart (Input, Process, Output) Term

A table listing the inputs, the processes applied and the outputs of a system or subroutine; used when determining specifications.

Example: 'IPO: Input username and password, Process compare with stored hash, Output access granted or denied.'

Check this one: Not named in the 2022 syllabus text; taught in the school notes and used in past SDD papers.

Linear search Term

A search that checks each item in order until the target is found or the list ends. Works on unsorted data; slow for large lists.

Example: 'FOR i = 0 TO length-1: IF list[i] == target THEN found.'

Check this one: Not named in the syllabus; it appears in past questions and the school notes.

Binary search Term

A search on a SORTED list that checks the middle item and discards half the list each time (a divide and conquer method).

Example: 'Binary search needs sorted data; each step halves the search space.'

Check this one: Not named in the syllabus; it appears in past SDD questions.

Recursion Term

A subroutine that calls itself on a smaller version of the problem until it reaches a base case that stops it.

Example: 'Factorial: n * factorial(n-1) with base case n = 0.'

Check this one: Not named in the 2022 syllabus text; included because of the functional paradigm and past SDD coding questions.

Imperative paradigm Term

A programming style that gives the computer an ordered list of commands that change program state (for example Python procedural code).

Example: Paradigm cards: object-oriented, imperative, logic, functional.

Logic paradigm Term

A programming style that states facts and rules and lets the system answer queries by logical inference (for example Prolog).

Example: 'Facts and rules, not step-by-step commands.'

Functional paradigm Term

A programming style that builds programs from functions, avoids changing state, and treats functions as values that can be passed around.

Example: 'Computation is the evaluation of functions.'

Binary (base 2) Term

A number system using only the digits 0 and 1. Computers store all data in binary; each digit is one bit and 8 bits make a byte.

Example: 1011 in binary = 8 + 2 + 1 = 11 in decimal.

Decimal (base 10) Term

The everyday number system using digits 0 to 9.

Example: Use place values (1, 10, 100) when converting.

Hexadecimal (base 16) Term

A base-16 system using 0 to 9 and A to F (A = 10 ... F = 15). One hex digit stands for exactly 4 bits, so it is a compact way to write binary.

Example: 2F in hex = 0010 1111 in binary = 47 in decimal.

Two's complement Term

A way of storing signed (positive and negative) integers in binary: write the positive number, invert every bit, then add 1 to get the negative. The left-most bit is the sign bit (1 = negative).

Example: 8-bit: +5 = 00000101; invert = 11111010; add 1 = 11111011 = -5.

Character representation (ASCII, Unicode) Term

Characters are stored as numeric codes. ASCII uses 7 or 8 bits for basic English characters; Unicode uses more bits so it can represent characters from all languages and symbols.

Example: Say Unicode supports many languages; ASCII is limited.

Data types Term

The kind of value a variable holds: character, string, Boolean, integer, real (single-precision floating point) and date/time. The type decides how much memory it uses and what operations are allowed.

Example: 'Age = integer; price = real; isMember = Boolean; name = string.'

Integer Term

A whole number, positive or negative, with no fractional part.

Example: Use int for counts and array indexes.

Real (floating point) Term

A number with a fractional part. Single-precision floating point stores a real in 32 bits (4 bytes).

Example: 'price = 19.95' is a real.

Boolean Term

A data type with only two values, True or False, used in conditions.

Example: 'isLoggedIn = True' controls a selection.

Character and string Term

A character is a single symbol; a string is a sequence of characters (text) such as a name.

Example: 'name = "Sam"' is a string; 'S' is a character.

Date and time Term

A data type for calendar dates and clock times, stored as a single value (32 bits in the course data dictionary examples).

Example: Use date/time for an order date in a data dictionary.

Array Term

A data structure holding a fixed number of items of the same type, accessed by index; can be single or multi-dimensional (rows and columns).

Example: 'marks[0]' is the first item.

Multi-dimensional array Term

An array of arrays, used for grids or tables and accessed by row and column index, such as grid[row][col].

Example: 'grid[2][3]' is row 2, column 3.

Record Term

A data structure that groups related fields of different types into one item, such as a student with name, age and mark.

Example: 'One record per row of a table.'

List Term

An ordered, changeable collection of items (Python list) that can grow and shrink and can hold mixed types.

Example: 'scores = [3, 5]; scores.append(8)'

Tree Term

A hierarchical data structure of nodes: one root, each node having child nodes and leaves at the bottom (for example folder structures or decision trees).

Example: 'A file system is a tree.'

Stack Term

A last-in, first-out (LIFO) structure where items are added (push) and removed (pop) at the top.

Example: 'Undo uses a stack.'

Hash table Term

A structure that stores key and value pairs, using a hash function on the key to find the storage location, so lookups are very fast (a Python dictionary).

Example: 'Fast lookup: ages["Sam"].'

Sequential file Term

A file of data stored and read one item or line after another, such as a text or CSV file.

Example: 'Open, read line by line, close.'

Quality criteria for evaluating code Term

The syllabus tests solutions against four qualities: functionality, performance, readability of code and quality of documentation.

Example: Mention all four when asked how you would evaluate or test code.

Syntax error Term

A mistake that breaks the language rules (missing colon, bracket or misspelt keyword), so the program will not run.

Example: 'print("hi" with no closing bracket.'

Logic error Term

The program runs but gives the wrong result because the algorithm is wrong, for example using > instead of >=. 2025 markers said students confused these with syntax errors.

Example: 'Average = total / 2 instead of total / count.'

Runtime error Term

An error that appears while the program is running and stops it, such as dividing by zero or an index outside the array.

Example: 'Dividing by zero crashes at runtime.'

Debugging tools Process

Software features that help find and fix errors: breakpoints, single line stepping, watch windows, checking interfaces between functions and debugging output statements.

Example: 2025 Q15b: name two tools and say how each shows where a logic error occurs.

Breakpoint Term

A marker on a line of code where execution pauses so you can inspect variable values.

Example: 'A breakpoint halts the program so the programmer can check variables.'

Single line stepping Term

Running a program one line at a time in the debugger to watch how it flows and how values change.

Example: Use with breakpoints to locate a logic error.

Watch window (variable watch) Term

A debugger feature that shows the live value of chosen variables as the program runs.

Example: 'Watch total change each loop to see where the sum goes wrong.'

Debugging output statements Term

Print statements added to show that a section was reached or the value of a variable.

Example: 'print("total =", total)'

Boundary values Term

Test data at and either side of a limit of the valid range. For a valid range of 1 to 10: 0, 1, 10, 11.

Example: Valid range 18 to 65 means test 17, 18, 65, 66.

Path coverage Term

Choosing test data so every path through the code (each branch and loop) runs at least once.

Example: 'Include one value that makes the IF true and one that makes it false.'

Faulty and abnormal data Term

Data that is the wrong type, empty, too large or small or has odd characters, used to check the program rejects it or handles it without crashing.

Example: 'Enter "abc" where a number is expected.'

Code optimisation Term

Improving the speed or memory use of working code (better algorithm, fewer repeated calculations, built-in functions).

Example: See language-dependent and language-independent optimisation.