By the end of the lessons, students should be able to: Explain why programs need to be tested. Explain what a test plan is. Explain what test data is. Identify normal test data. Identify boundary test data. Identify erroneous test data. Select suitable test data for a given problem. Predict expected results. Execute test cases against a program. Record actual results. Determine whether a test has passed or failed. Use test results to identify errors. Explain how testing contributes to program quality.

By the end of this lesson, students should be able to: • Explain why readable code is important. • Describe the benefits of writing maintainable programs. • Use comments effectively to explain code. • Create meaningful names for variables, constants, and subprograms. • Apply correct indentation in Python programs. • Explain how readable code reduces programming errors. • Refactor poorly written code into readable code.

By the end of this lesson, students should be able to: • Define syntax, runtime, and logic errors. • Distinguish between different types of programming errors. • Identify errors in Python programs. • Correct syntax, runtime, and logic errors. • Explain the causes of each error type. • Test and debug programs systematically. • Apply debugging techniques to improve program reliability.

Students should already understand: • Algorithms • Flowcharts • Pseudocode • Variables • Data types • Input, Processing and Output • Selection and Iteration • Decomposition • Abstraction

By the end of this lesson, students should be able to: • Explain what a high-level programming language is. • Describe the advantages and disadvantages of high-level languages. • Write simple programs using Python. • Use appropriate programming syntax. • Write programs that use input, processing and output. • Apply variables, constants and data types correctly. • Develop programs that solve real-world problems. • Test and debug programs.

• Define decomposition in computer science. • Explain why decomposition is an essential problem-solving technique. • Break a large problem into smaller, manageable sub-problems. • Design solutions for each sub-problem independently. • Combine individual solutions into a complete system. • Apply decomposition to real-world computing scenarios.

• Define problem analysis, decomposition, and abstraction. • Analyse a problem by identifying its requirements. • Identify the required inputs, outputs, processing, and initialisation (IOPI model). • Break a complex problem into smaller, manageable tasks. • Design a logical solution using pseudocode, flowcharts, or written algorithms. • Evaluate whether a proposed solution meets the problem requirements.

• Define abstraction. • Explain why abstraction is important in computer science. • Identify unnecessary details in real-world situations. • Create abstract models from real-life problems. • Explain how abstraction is used in software development. • Evaluate whether an abstraction is suitable for solving a particular problem.

• Explain what it means to program an abstraction of a real-world object or system. • Identify the essential characteristics (attributes) and behaviours of real-world entities. • Design and implement simple program abstractions using variables, records, classes (where appropriate), functions, and procedures. • Represent real-world data using suitable data structures. • Test and evaluate whether a program abstraction accurately models the intended real-world system.

• Define fitness for purpose in relation to algorithms. • Explain how algorithms are evaluated against specified requirements. • Use logical reasoning to determine whether an algorithm is suitable. • Design and apply test data to verify algorithm correctness. • Identify strengths, weaknesses, and limitations of algorithms. • Recommend improvements to make algorithms more efficient

• Explain how data structures influence algorithm design. • Identify different types of data structures used in problem solving. • Explain how the characteristics of data affect the choice of an algorithm. • Select suitable algorithms based on the data to be processed. • Compare different algorithms used to manipulate similar data. • Evaluate the efficiency and suitability of algorithms for different tasks.

• Define a standard algorithm. • Explain the purpose of searching and sorting algorithms. • Describe how Linear Search, Binary Search, Bubble Sort, and Merge Sort work. • Trace the execution of each algorithm using sample data. • Compare the advantages and disadvantages of different algorithms. • Identify situations where each algorithm is most appropriate. • Predict the output after each stage of an algorithm.

• Define an algorithm. • Explain why algorithms are important. • Describe where algorithms are used in everyday life. • Interpret algorithms presented as: o Written descriptions o Flowcharts o Pseudocode o Program code • Predict the output of simple algorithms. • Identify errors in simple algorithms.

• Understand how algorithms process input data to produce outputs. • Determine the correct output of algorithms using a given set of input values. • Trace algorithms step by step. • Use trace tables to record the changing values of variables. • Predict the outputs of algorithms containing sequence, selection, and iteration. • Identify logical errors when tracing an algorithm. • Verify whether an algorithm produces the expected results.

• Define the purpose of an algorithm. • Explain why algorithms are used to solve problems. • Interpret the purpose of a given algorithm. • Describe how an algorithm works by following its execution step by step. • Trace the execution of an algorithm using trace tables. • Predict the output of an algorithm from given inputs. • Identify logical errors in simple algorithms.

• Understand the process of developing an algorithm to solve a problem. • Identify the three fundamental programming constructs: o Sequence o Selection o Iteration • Design algorithms using appropriate representations: o Written descriptions o Flowcharts o Pseudocode o Draft program code • Apply logical thinking to solve real-world problems. • Evaluate and improve simple algorithms.

• Explain the different types of errors that occur in algorithms. • Identify logical errors in algorithms. • Use trace tables to detect and correct algorithm errors. • Test algorithms using different sets of input data. • Correct errors in sequence, selection, and iteration constructs. • Evaluate whether an algorithm produces the intended output.

• Explain what a high-level programming language is. • Differentiate between algorithms and program code. • Convert algorithms (written descriptions, pseudocode, and flowcharts) into Python programs. • Apply the three programming constructs (sequence, selection, and iteration) in code. • Use variables, input, processing, and output statements in Python. • Test and debug simple programs. • Compare algorithms with their coded implementations.

Learning Objective 1.1.1 Understand what an algorithm is, what algorithms are used for, and be able to interpret algorithms (flowcharts, pseudocode, written descriptions, and program code). Learning Objectives By the end of this lesson, learners should be able to: • Define an algorithm. • Explain why algorithms are important. • Describe where algorithms are used in everyday life. • Interpret algorithms presented as: o Written descriptions o Flowcharts o Pseudocode o Program code • Predict the output of simple algorithms. • Identify errors in simple algorithms.

1.1 Algorithms 1.1.1 Understand what an algorithm is, what algorithms are used for and be able to interpret algorithms (flowcharts, pseudocode, written descriptions, program code). 1.1.2 Understand how to create an algorithm to solve a particular problem, making use of programming constructs (sequence, selection, iteration) and using appropriate conventions (flowchart, pseudocode, written description, draft program code). 1.1.3 Understand the purpose of a given algorithm and how an algorithm works. 1.1.4 Understand how to determine the correct output of an algorithm for a given set of data. 1.1.5 Understand how to identify and correct errors in algorithms, including using trace tables. 1.1.6 Understand how to code an algorithm in a high-level language. 1.1.7 Understand how the choice of algorithm is influenced by the data structures and data values that need to be manipulated. 1.1.8 Understand how standard algorithms work (bubble sort, merge sort, linear search, binary search). 1.1.9 Be able to evaluate the fitness for purpose of algorithms in meeting specified requirements efficiently, using logical reasoning and test data. 1.2 Decomposition and abstraction 1.2.1 Be able to analyse a problem, investigate requirements (inputs, outputs, processing, initialisation) and design solutions. 1.2.2 Be able to decompose a problem into smaller sub-problems. 1.2.3 Understand how abstraction can be used effectively to model aspects of the real world. 1.2.4 Be able to program abstractions of real-world examples.

3.1 Binary 3.1.1 Understand that computers use binary to represent data (numbers, text, sound, graphics) and program instructions. 3.1.2 Understand how computers represent and manipulate numbers (unsigned integers, signed integers (sign and magnitude, two’s complement)). 3.1.3 Be able to convert between binary and denary whole numbers (0–255). 3.1.4 Understand how to perform binary arithmetic (add, shifts (logical and arithmetic)) and understand the concept of overflow. 3.1.5 Understand why hexadecimal notation is used and be able to convert between hexadecimal and binary. 3.2 Data representation 3.2.1 Understand how computers encode characters using ASCII and Unicode. 3.2.2 Understand how bitmap images are represented in binary (pixels, resolution, colour depth). 3.2.3 Understand how sound, an analogue signal, is represented in binary. 3.2.4 Understand the limitations of binary representation of data (sampling frequency, resolution) when constructed by the number of available bits. 3.3 Data storage and compression 3.3.1 Understand how to use and convert between binary and denary multiples (as defined by the International Electrotechnical Commission (IEC)): • bit • nibble • byte • kibibyte (KiB) 210 • mebibyte (MiB) 220 3.3.3 Understand how a lossless, run-length encoding (RLE) algorithm works. 3.3.4 Understand that file storage is measured in bytes and be able to calculate file sizes. 3.4 Encryption • gibibyte (GiB) 230 • tebibyte (TiB) 240 • kilobyte (kB), 103 • megabyte (MB) 106 • gigabyte (GB) 109 • terabyte (TB) 1012. 3.3.2 Understand the need for data compression and methods of compressing data (lossless, lossy), and that JPEG and MP3 are examples of lossy algorithms. 3.4.1 Understand the need for data encryption. 3.4.2 Understand how encryption algorithms work (Pigpen cipher, Caesar cipher, Vigenére cipher, Rail Fence cipher).