Summary

• Description:

  The MS Word document comprises Grade 10 CBC Computer Studies Term 3 2026 Scheme of Work created for senior school computer studies educators implementing the curriculum under the Kenya Institute of Curriculum Development (KICD) 2025 Competency-Based Curriculum framework. This technical guide outlines a structured, hands-on programming curriculum, serving as an indispensable resource for lesson preparation, laboratory practical arrangement, syntax error debugging, and software project assessment throughout the third term.

  The entire term's instruction is focused on Strand 3.0, "Software Development," progressing systematically across six specialized sub-strands: Sub-Strand 3.1 ("Computer Programming Concepts"), Sub-Strand 3.2 ("Program Development Overview"), Sub-Strand 3.3 ("Identifiers and Operators"), Sub-Strand 3.4 ("Control Structures"), Sub-Strand 3.5 ("Data Structures"), and Sub-Strand 3.6 ("Functions"). Learners build foundational knowledge by exploring programming terminology, language levels (low-level vs. high-level), language evolution across generations, programming paradigms (procedural, OOP, functional, logic, event-driven), and machine/assembly instruction execution. The scheme then covers the 7 stages of the program development cycle, algorithm design using pseudocode and standard flowcharts, reserved words, variable/constant declarations across data types, I/O operations, operator precedence rules, control structures (sequence, selection: if/if-else/nested if, iteration: for/while loops, break/continue), structured data collections (lists, 1D/2D arrays, dictionaries, sets, tuples), modular programming with built-in and user-defined functions, parameter passing, return values, and variable scope (local vs. global).

  Key Scheme Details

  • Education Level: Grade 10 (Senior School)
  • Subject: Computer Studies
  • Term: Term 3
  • Year: 2026
  • Curriculum: KICD Competency-Based Curriculum (CBC) 2025 Framework
  • Number of Weeks Covered: 9 Calendar Weeks
  • Number of Teaching Weeks: 8 Weeks
  • Number of Lessons per Week: 4 Lessons
  • Total Number of Lessons: 32 Lessons
  • Half-Term/Mid-Term Break: Week 7 (7 October 2026 – 11 October 2026)
  • Examination/Assessment Period: Week 9 (Theory & Practical Lab Exams)
  • Strand Covered: Software Development
  • Sub-Strands Covered: Computer Programming Concepts, Program Development Overview, Identifiers and Operators, Control Structures, Data Structures, Functions, Integrated Reviews and Assessments
  • Assessment Methods: Oral questions, written exercises, flowchart symbol evaluations, practical coding tasks, pseudocode reviews, code inspection, operator calculation tests, debugging rubrics, program execution checks, lab exam ratings, portfolio assessments
  • Learning Resources: Grade 10 Computer Studies Curriculum Design, high-level IDE environments (Python IDLE, Code::Blocks), computers, tablets, sample assembly sheets, flowchart stencils, traffic light logic sheets, video tutorials, code worksheets, USB backup drives, past exam papers, marking schemes

  Weekly Coverage

  • Week 1: Computer Programming Concepts — Programming terminology (source code, compiler, interpreter, IDE), low-level vs. high-level languages, evolution across 1st to 5th generations, programming paradigms (procedural, OOP, functional, logic, event-driven), and simulating low-level machine/assembly code execution.
  • Week 2: Program Development Overview — Seven stages of the program development cycle, algorithm characteristics, writing pseudocode using standard keywords, identifying standard flowchart symbols, and designing traffic light safety algorithms.
  • Week 3: Identifiers and Operators (Declaration & Syntax) — Reserved words, high-level language environments, declaring variables and constants with data types (integer, float, string, boolean), writing input/output statements, and categories of operators (arithmetic, relational, logical) with precedence rules.
  • Week 4: Operators Execution & Control Structures (Selection) — Executing programs with operators, debugging operator logic, conceptual execution paths of control structures, boolean branching expressions, and writing programs using decision statements (if, if-else, nested if) for pedestrian road crossing signals.
  • Week 5: Iteration Structures & Data Structures — Writing iteration loops (for, while) with break/continue statements, introduction to data structures (lists, arrays, dictionaries, sets, tuples), declaring 1D and 2D arrays/lists, accessing elements via row/column indices, and mutability/indexing comparisons.
  • Week 6: Data Manipulation Projects & Modular Functions — Executing record storage programs using data structures, introduction to modular programming, built-in vs. user-defined functions, general function syntax, parameter passing, return values, and variable scope (local vs. global).
  • Week 7: Mid-Term Break — Scheduled mid-term break from 7 October 2026 to 11 October 2026.
  • Week 8: Library Modules, Custom Functions & Modular Projects — Importing standard library modules (e.g., math), writing custom user-defined functions with parameters and return values, building a multi-function modular project, and comprehensive Strand 3.0 review.
  • Week 9: End-of-Term Examinations & Lab Archiving — Sitting for the Written Theory Exam, sitting for the Practical Programming Lab Exam, reviewing exam marking schemes, backing up code projects, securing lab hardware, and updating student learning portfolios.

  Strands and Sub-Strands Covered

  • Strand 3.0: Software Development
    • Sub-Strand 3.1: Computer Programming Concepts
      • Core terminology: syntax, semantics, source code, object code, compilers, interpreters, assemblers, IDEs
      • Language levels: machine code (binary/hex), assembly (mnemonics), high-level languages
      • Generational timeline (1GL machine to 5GL natural language AI systems)
      • Paradigms: structured, procedural, object-oriented, functional, logic, event-driven
    • Sub-Strand 3.2: Program Development Overview
      • Seven development stages: problem definition, analysis, design, coding, testing, implementation, maintenance
      • Algorithm criteria: finite, definite, input, output, effective
      • Algorithmic tools: standard pseudocode keywords (INPUT, PROCESS, OUTPUT, IF, WHILE) and flowchart symbols
    • Sub-Strand 3.3: Identifiers and Operators
      • Language reserved words, syntax rules, and environment setup (e.g., Python IDLE)
      • Data types: primitive (integer, float, char, boolean) and composite (strings)
      • Variable/constant declarations, memory allocation, and interactive I/O handling
      • Operators: arithmetic, assignment, increment/decrement, relational, logical, and operator precedence (PEMDAS)
    • Sub-Strand 3.4: Control Structures
      • Linear sequence execution vs. branching vs. looping execution paths
      • Conditional selection: simple `if`, binary `if-else`, and multi-way `nested if / elif` constructs
      • Iterative loops: count-controlled (`for`) and condition-controlled (`while`) loops
      • Loop control modification: `break` and `continue` execution overrides
    • Sub-Strand 3.5: Data Structures
      • Structured memory organization: homogeneous vs. heterogeneous collections
      • Single (1D) and multi-dimensional (2D) arrays/lists indexing, traversal, and mutation
      • Key-value mappings (dictionaries), unique sets, and immutable tuples
    • Sub-Strand 3.6: Functions
      • Modular design principles, code reusability, and debugging isolation
      • Built-in library functions vs. user-defined functions
      • Function headers, signatures, formal/actual parameter passing, and return value handling
      • Scope rules: local function scope vs. global script scope, lifetime, and namespace collision prevention

  The scheme covers the following key topics and learning areas:

  • Language Translation, Algorithmics, and Logic Design
    • Source code compilation vs. line-by-line interpretation execution dynamics
    • Pseudocode formulation and standard flowchart modeling for real-life automated systems
    • Boolean algebra, truth tables, and compound conditional logic construction
  • Syntax Rules, Control Flow, and Array Manipulations
    • Static vs. dynamic variable typing and memory allocation rules
    • Nested control loops, boundary condition checking, and infinite loop prevention
    • Matrix traversal using nested loops across 2D list row/column indices
  • Modular Software Architecture and Data Security
    • Abstraction through custom user-defined function definitions and modular file imports
    • Variable encapsulation, global state mutation risks, and parameter passing mechanisms
    • Data storage record handling, file backups, and computer laboratory hardware security

  Learning Outcomes and Competencies

  This scheme develops computational thinking, algorithmic logic, software engineering competence, and practical problem-solving capabilities. Learners cultivate logical reasoning through flowchart design, mathematical precision through operator evaluation, and syntax accuracy through program compilation. Practical lab coding builds debugging skills, creative software design, and digital literacy. Furthermore, learners develop teamwork through modular software projects, structured documentation habits, self-reliance, and awareness of technological growth required for computer science and software development careers.

  Learning Experiences and Practical Activities

  Learners engage in active practical computer lab exercises, such as brainstorming programming terms, preparing generational timeline charts, and writing low-level assembly mnemonics (MOV, ADD, SUB). Algorithmic practicals involve drawing flowcharts using stencils, writing pseudocode for traffic light road safety systems, and setting up high-level IDE environments (Python IDLE). Coding activities include declaring variables with specific data types, writing interactive speed check I/O programs, evaluating complex operator expressions, executing conditional pedestrian crossing branching code, running `for`/`while` loops, manipulating 2D student mark matrices, importing math libraries, writing custom functions with return values, debugging syntax errors, and archiving code files to USB storage drives.

  Assessment Methods

  • Formative and Lab Assessment: Oral questions, classroom brainstorming checks, syntax error debugging checks, code inspection during lab sessions, and flowchart stencil drawing checks.
  • Practical Programming Assessment: Practical coding task evaluations, pseudocode writing checks, 2D array traversal checks, user-defined function execution checks, debugging rubrics, and project portfolio scoring.
  • Summative Assessment: Operator precedence calculation tests, written sub-strand quizzes, a formal End-of-Term Written Theory Examination, a hands-on Practical Computer Lab Exam, and script reviews.

  Learning Resources

  • Software and IDE Environments: High-level programming environments (Python IDLE, Scratch, C++/Code::Blocks), code execution scripting tools, debugging utilities, and video tutorial sets.
  • Laboratory Hardware: Desktop computers, laptops, tablets, USB flash storage drives, presentation projectors, and computer lab networking infrastructure.
  • Textual and Visual Media: Grade 10 Computer Studies Curriculum Design (KICD 2025), sample assembly code sheets, flowchart stencils, operator precedence charts, traffic light logic sheets, code worksheets, past examination papers, and official marking schemes.
• Category:

  Schemes of Work
• Level:

  Grade 10
• Subject:

  COMPUTER STUDIES
• Posted By:

  Caleb_Peter

Enter your details below to initiate a payment using MPESA.