📐 Programming Fundamentals

🚀 Software Development Steps

🎯 (SE-11-01)

📌 Explore the fundamental software development steps used by programmers to systematically engineer solutions. Each stage ensures a logical progression from problem identification to a finalised product.

🤝 Online Collaboration Tools

🎯 (SE-11-03, SE-11-06)

📌 Research and Evaluate the prevalence and use of online code collaboration tools like GitHub, GitLab, and Bitbucket in modern engineering environments.

🧠 Computational Thinking and Algorithm Features

🎯 (SE-11-02)

📌 Apply computational thinking and algorithmic design by defining the key features of standard algorithms.

🔑 Key Features of Standard Algorithms

Every algorithm uses fundamental building blocks to solve problems. Understanding these features allows programmers to design robust, efficient solutions:

🔢 1. Sequence

Sequence means instructions are executed in order, one after another. Each step completes before the next begins — there is no branching or repetition.
🌏 Example: Reading a file, processing each line, then saving results.

BEGIN
    OPEN file "data.txt" FOR READING
    READ all lines FROM file INTO linesList
    FOR EACH line IN linesList
        processedLine ← UPPERCASE(line)
    END FOR
    SAVE processedLines TO "output.txt"
    CLOSE file
END

🔀 2. Selection

Selection means choosing different execution paths based on conditions using IF/ELSE or SWITCH statements. The program evaluates a condition and branches accordingly.
🌏 Example: Validating user input — if age < 18, display "Too young"; otherwise, proceed.

BEGIN
    OUTPUT "Enter your age: "
    INPUT age
    IF age ≥ 18 THEN
        OUTPUT "Welcome!"
        CALL ShowFullMenu()
    ELSE
        OUTPUT "Too young — access denied."
        EXIT program
    END IF
END

🔁 3. Iteration

Iteration means repeating a set of instructions while a condition is true, using FOR or WHILE loops. The loop body executes multiple times until the exit condition is met.
🌏 Example: Summing all numbers in a list by looping through each element.

BEGIN
    numbers ← [10, 25, 3, 47, 8]
    total ← 0
    FOR i ← 0 TO LENGTH(numbers) - 1
        total ← total + numbers[i]
    END FOR
    OUTPUT "The sum is: " + total
END

💾 4. Storing Data

Storing Data means using variables and data structures to hold values needed across multiple steps of an algorithm. Without stored state, programs cannot track progress or accumulate results.
🌏 Example: Keeping track of a running total as you iterate through numbers.

BEGIN
    runningTotal ← 0
    count ← 0
    OUTPUT "Enter numbers (-1 to finish): "
    INPUT number
    WHILE number ≠ -1
        runningTotal ← runningTotal + number
        count ← count + 1
        INPUT number
    END WHILE
    IF count > 0 THEN
        average ← runningTotal / count
        OUTPUT "Average: " + average
    ELSE
        OUTPUT "No data entered."
    END IF
END

Computational thinking is the systematic approach to problem-solving that breaks complex problems into manageable pieces and recognises patterns. By combining sequence, selection, iteration, and effective data storage, algorithms become clear, testable, and maintainable.

📈 Divide and Conquer and Backtracking Strategies

🎯 (SE-11-02)

📌 Apply divide and conquer and backtracking as algorithmic design strategies.

📈 Divide and Conquer

This strategy involves breaking a complex problem into smaller, identical sub-problems until they are simple enough to solve directly. The solutions to these sub-problems are then combined to form the final result.
🌏 Example: In a Merge Sort, a large list is repeatedly split in half until single elements remain, which are then merged back together in the correct order. This approach is highly efficient for sorting and searching large datasets.

↩️ Backtracking

Backtracking is an incremental approach to problem-solving that builds a solution one step at a time. If the algorithm reaches a state where the current path cannot possibly lead to a valid solution (violating a constraint), it "backtracks" to the previous step and tries a different option.
🌏 Example: A Sudoku Solver attempts a number in a cell; if it later finds a conflict, it returns to that cell and tries the next available number. This strategy is essential for pathfinding and optimisation problems.

# Divide and Conquer: Recursive Binary Search
def binary_search(arr, target, low, high):
    if low > high: return -1
    mid = (low + high) // 2
    if arr[mid] == target: return mid
    elif arr[mid] > target:
        return binary_search(arr, target, low, mid - 1)
    else:
        return binary_search(arr, target, mid + 1, high)

# Backtracking: Maze Pathfinding (tries 4 directions)
visited = set()
def find_path(x, y, maze):
    if is_exit(x, y): return True
    if is_wall(x, y) or (x, y) in visited: return False

    visited.add((x, y)) # Mark as visited
    # Try all 4 directions: right, down, left, up
    for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
        if find_path(x + dx, y + dy, maze):
            return True

    return False # Backtrack to previous cell

📝 Developing Algorithms Using Pseudocode and Flowcharts

🎯 (SE-11-02)

📌 Develop structured algorithms using pseudocode and flowcharts, including the use of subprograms.

📝 Pseudocode

Pseudocode is an informal, human-readable notation for writing algorithms — a bridge between natural language and programming code. It uses common programming keywords (IF, WHILE, FOR) mixed with English-like descriptions, making logic crystal clear without being tied to a specific programming language's syntax. This allows designers and developers to communicate algorithm logic to non-programmers, and to verify correctness before investing time in actual coding.
🌏 Example:

FUNCTION searchList(list, target)
    FOR index FROM 0 TO length(list) - 1
        IF list[index] EQUALS target THEN
            RETURN index
        END IF
    END FOR
    RETURN -1  // Not found
END FUNCTION

📊 Flowcharts

Flowcharts use visual symbols to represent algorithm steps and decision points. Rectangles represent processes, diamonds represent decisions, and arrows show flow direction. This visual representation makes complex logic easy to follow, helps identify loops and branches, and allows stakeholders to validate correctness before implementation.
🌏 Example: A flowchart for validating user age would show a diamond (decision point) — "Is age ≥ 18?" — with two paths: YES leads to "Show full menu" and NO leads to "Show restricted menu."

🧩 Subprograms

A subprogram (function or procedure) is a reusable block of code that performs a specific task. Pseudocode and flowcharts must clearly show how subprograms are called, what parameters they accept, and what they return. This modular approach reduces code duplication, improves readability, and makes testing easier.
🌏 Example: A main program calls FUNCTION validatePassword(pwd) which returns TRUE or FALSE, allowing the validation logic to be reused across multiple entry points.

// ❌ Cluttered (Poor Practice)
BEGIN
    // Gathering input
    OUTPUT "Enter your score out of 100"
    INPUT score
    WHILE score < 0 OR score > 100
        OUTPUT "Invalid. Please enter a valid score: "
        INPUT score
    END WHILE

    // Processing logic
    IF score >= 85 THEN
        grade = "High Distinction"
    ELSE IF score >= 75 THEN
        grade = "Distinction"
    ... (and so on) ...
    END IF
    
    // Output
    OUTPUT "Your grade is ", grade
END

In contrast, an uncluttered mainline is completely modularized, significantly reducing complexity:

// ✅ NESA-Standard Uncluttered Mainline
BEGIN Mainline
    score ← CALL GetValidScore()
    grade ← CALL CalculateGrade(score)
    CALL DisplayResult(grade)
END Mainline

// Subroutines are defined separately below:
FUNCTION GetValidScore()
...

📊 Modelling Tools for Design

🎯 (SE-11-02)

📌 Use modelling tools including structure charts, abstraction and refinement diagrams to support top-down and bottom-up design.

🏗️ Structure Charts

Structure charts are a top-down tool used to show the hierarchy of subroutines in a system. They focus on modularity, showing which module calls another and what data (parameters) or control signals (flags) are passed between them.
🌏 Example: A structure chart for an ATM would show the 'Main' module calling 'Verify PIN' and passing back a 'Valid/Invalid' flag. This allows engineers to see high-level dependencies without getting bogged down in code logic.

🔍 Abstraction and Refinement

Abstraction involves hiding implementation details to focus on high-level goals (the 'What'). Stepwise Refinement is the process of breaking those high-level goals into smaller, more specific details (the 'How').
🌏 Example: An abstract instruction like 'Initialise System' is refined into 'Set counter to 0', 'Clear display', and 'Open file stream'. Together, they allow for manageable development of complex systems.

🔍 Analysing Algorithm Logic and Structure

🎯 (SE-11-02)

📌 Analyse the logic and structure of written algorithms, including determining inputs and outputs, purpose, desk checking, peer checking, and identifying connections to subroutines or functions.

📥 Determining Inputs, Outputs, and Purpose

Before writing code, clearly identify what data the algorithm needs (inputs), what it produces (outputs), and why it exists (purpose). This clarity prevents bugs and ensures the solution addresses the right problem.
🌏 Example: A sorting algorithm has INPUT: unsorted list; OUTPUT: sorted list; PURPOSE: arrange items in ascending order for efficient searching.

📋 Desk Checking and Peer Checking

Desk checking (or "dry running") involves manually tracing through an algorithm step-by-step with sample data, recording the value of each variable at each step to verify correctness before implementation. Peer checking is having another person review the algorithm logic to catch errors or inefficiencies that the original author might miss.
🌏 Example: Desk checking a loop from 1 to 10 — write down i=1, i=2, ... to verify the loop executes exactly 10 times, not 9 or 11.

🔗 Identifying Connections to Subroutines and Functions

Analyse how an algorithm calls other functions and what data is passed between them. Document the purpose of each function call and the parameters it receives, ensuring data flows correctly through the program.
🌏 Example: An algorithm that calculates employee pay might call FUNCTION calculateTax(salary) and FUNCTION applyBonus(basePay, bonusPercent), understanding what each returns and how it affects the final result.

🎯 Programming Paradigms

🎯 (SE-11-02)

📌 Experiment with object-oriented programming, imperative, logic and functional programming paradigms.

📦 Object-Oriented Programming (OOP)

Data and functions are bundled together in "objects" that model real-world entities. Emphasises reusability, modularity, and maintainability. Classes define blueprints; instances are created from them.
🌏 Example: A Car class has properties (colour, speed) and methods (accelerate(), brake()); multiple car objects can be created from this template.

💻 Imperative Programming

Programs are sequences of explicit commands (statements) that change program state step-by-step. Python, Java, and C are imperative languages. Focus on "how" to solve the problem (procedures and control flow).
🌏 Example: "Set count to 0; LOOP: add next number to count; increment loop counter; IF loop counter < 10, GO TO LOOP."

🧠 Logic Programming

Programs state facts and rules; the interpreter derives new facts through logical inference. Less common than imperative, but heavily used in artificial intelligence, constraint logic, and database query planning (Outcome SE-11-02). Focus on "what" is true, not "how" to compute it.

% NESA requires students to "define and edit facts" and "create, edit and remove rules"

% 1. DEFINE FACTS (The fundamental truths of the knowledge base)
parent(john, mary).
parent(john, peter).
parent(mary, bob).
parent(peter, sarah).

% 2. CREATE RULES (Logic derived from facts using variables)
% "X is a grandparent of Z IF X is a parent of Y AND Y is a parent of Z"
grandparent(X, Z) :- 
    parent(X, Y), 
    parent(Y, Z).

% "A and B are siblings IF they share a parent P AND are not the same person"
sibling(A, B) :- 
    parent(P, A), 
    parent(P, B),
    A \= B. 

% 3. LOGIC ENGINE INFERENCE (Querying the system)
% This is how a logic paradigm dynamically solves problems without imperative loops:

% Query: grandparent(john, bob).
% Engine derivation steps:
% - Search: parent(john, Y) -> Matches Y = mary
% - Search: parent(mary, bob) -> Fact exists!
% Output: TRUE

% Query: sibling(mary, peter).
% Engine derivation steps:
% - Search: parent(P, mary) -> Matches P = john
% - Search: parent(john, peter) -> Fact exists!
% - Search: mary \= peter -> TRUE
% Output: TRUE

λ Functional Programming

Programs are built from pure functions (same input always produces same output, no side effects) and immutable data. Emphasises recursion and function composition.
🌏 Example (Lisp/Scheme): Computing factorial recursively as (factorial 5) = 5 × (factorial 4) × ... × 1, without modifying state.

Modern development often uses hybrid approaches — Python supports both OOP and functional styles; JavaScript supports imperative and functional paradigms. Experimenting with different paradigms strengthens problem-solving skills and helps you choose the best tool for each context.

🔢 Number Systems and Two's Complement

🎯 (SE-11-03)

📌 Investigate the use of number systems for computing purposes, including binary, decimal and hexadecimal. Represent integers using two's complement.

• Binary (Base 2): Used by hardware for electrical on/off states.
• Decimal (Base 10): The standard human system for counting.
• Hexadecimal (Base 16): Efficiently represents bytes (e.g., #FFFFFF for white in CSS).

➕ Two's Complement

Two's Complement is the standard method for representing signed (negative) integers in binary. To represent a negative number, the bits of the positive equivalent are inverted (0 to 1 and vice-versa) and 1 is added to the result. This system is preferred as it allows for simple addition/subtraction circuits and eliminates the 'double zero' (+0 and -0) problem used in older systems.

1. Start with the positive number: 5 = 00000101
2. Invert all bits (One's Complement): 11111010 (each 0 becomes 1, each 1 becomes 0)
3. Add 1 to the result: 11111010 + 1 = 11111011
4. Result: -5 in 8-bit Two's Complement = 11111011

# Representing integers in different bases
number = 255
print(bin(number)) # 0b11111111 (Binary)
print(hex(number)) # 0xff       (Hexadecimal)

# Binary to Decimal for hardware addresses
print(int("1010", 2)) # 10

📋 Data Types and Data Dictionaries

🎯 (SE-11-03, SE-11-04)

📌 Investigate standard data types including char/string, Boolean, real, single precision floating point, integer, and date/time. Create data dictionaries as a tool to describe data and data types, structure data, and record relationships.

Data Dictionary: A metadata tool describing every variable's name, data type, size, description, and validation rules.
🌏 Example: Documenting that 'User_ID' must be an integer between 1 and 9999. (SE-11-04)

📚 Data Structures

🎯 (SE-11-03, SE-11-04)

📌 Use data structures of arrays, records, trees and sequential files to organize and store data efficiently.

# Single dimension
scores = [45, 67, 89]
# Multidimensional
board = [[0 for _ in range(8)] for _ in range(8)]

# In Python, using a class or dictionary
student = {
    "name": "Alice",
    "id": 12345,
    "gpa": 3.95
}

history = []; history.append("Action"); history.pop()

users = {"alice": {"age": 17, "year": 11}}

💻 Applying Computational Thinking and Programming Skills

🎯 (SE-11-05, SE-11-06)

📌 Apply skills in computational thinking and programming to develop a software solution, including converting an algorithm into code, using control structures, using data structures, using standard modules, and creating relevant subprograms with parameter passing.

💻 Converting Algorithm to Code

Translating pseudocode or flowcharts into actual programming language syntax. Each algorithm step becomes a statement; pseudocode's IF becomes the language's if keyword; loops translate directly.

🔀 Using Control Structures

Implementing sequence (statements in order), selection (if/else, switch), and iteration (for, while loops) to direct program flow based on conditions and data.

📚 Using Data Structures

Selecting and implementing appropriate data structures (arrays, records, trees, hash tables) to organise data so algorithms can access it efficiently.

📦 Using Standard Modules

Leveraging built-in libraries and functions (e.g., Python's math module, datetime module, string methods) instead of reinventing functionality. Standard modules are tested, optimised, and consistent across projects.

🔧 Creating Subprograms with Parameter Passing

Writing functions and procedures that accept parameters (inputs), perform a specific task, and return results. Parameters can be passed by value (copy) or by reference (address), allowing functions to modify caller's data when needed.
🌏 Example: FUNCTION calculateBonus(salary, percent) takes two parameters, calculates the bonus, and returns the result.

💾 Implementing Data Structures for Storage

Creating concrete implementations of abstract data structures in code. This includes single and multidimensional arrays, linked lists, trees with nodes, stacks using lists, and hash tables using dictionaries.

🔧 Functions & Procedures — Deep Dive

🎯 (SE-11-05, SE-11-06)

📌 Apply parameter passing, scope rules, and recursion to design modular, reusable subprograms. Understand the distinction between functions (return values) and procedures (perform actions).

⚖️ Functions vs Procedures

📥 Parameter Passing

Pass by value: A copy of the variable is sent. The original variable in the caller is unchanged, even if the function modifies the parameter.

def double(n):
    n = n * 2     # modifies the local copy only
    return n

score = 50
result = double(score)
print(score)    # still 50 — original unchanged
print(result)   # 100

Pass by reference (mutable objects): Python passes a reference to the object. Mutable types (lists, dicts) can be modified inside the function — the caller sees the change.

def add_score(scores, new_score):
    scores.append(new_score)   # modifies the original list

results = [80, 75, 90]
add_score(results, 95)
print(results)   # [80, 75, 90, 95] — list WAS modified

↩️ Return Values

# Single return value
def circle_area(radius):
    import math
    return math.pi * radius ** 2

# Multiple return values (Python returns a tuple)
def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([5, 3, 9, 1, 7])
print(low, high)   # 1  9

# Function returning None (procedure style)
def greet(name):
    print(f"Hello, {name}!")
    # no return statement → returns None implicitly

🌐 Variable Scope

Scope determines which parts of your program can access a variable. Python uses the LEGB rule to look up names:

LEGB Lookup Order
─────────────────────────────────────────────
L  Local      — variables defined inside the current function
E  Enclosing  — variables in any enclosing (outer) function
G  Global     — variables defined at module level
B  Built-in   — Python's built-in names (print, len, range…)
─────────────────────────────────────────────
Python searches L → E → G → B until the name is found.

x = 10           # Global scope

def show():
    x = 99       # Local scope — shadows the global x
    print(x)     # 99

show()
print(x)         # 10 — global unchanged

# Using global keyword (avoid when possible)
counter = 0
def increment():
    global counter
    counter += 1

increment()
print(counter)   # 1

🔄 Recursive Functions

A recursive function is one that calls itself. Every recursive function must have:

• Base case: The condition that stops the recursion (no more recursive calls).
• Recursive case: Where the function calls itself with a simpler input, moving toward the base case.

# Iterative approach
def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Recursive approach
def factorial_recursive(n):
    if n == 0 or n == 1:   # Base case
        return 1
    return n * factorial_recursive(n - 1)   # Recursive case

print(factorial_iterative(5))   # 120
print(factorial_recursive(5))   # 120

# Call stack for factorial_recursive(4):
# factorial(4) → 4 × factorial(3)
#   factorial(3) → 3 × factorial(2)
#     factorial(2) → 2 × factorial(1)
#       factorial(1) → returns 1   ← base case reached
#     factorial(2) → returns 2
#   factorial(3) → returns 6
# factorial(4) → returns 24

def fibonacci(n):
    if n <= 1:           # Base cases: fib(0)=0, fib(1)=1
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(8):
    print(fibonacci(i), end=" ")
# Output: 0 1 1 2 3 5 8 13

🏷️ Variable Declaration & Naming Conventions

🎯 (SE-11-05)

📌 Apply naming conventions and best practices for variable declaration to produce readable, maintainable code.

🏷️ Python Naming Conventions

📝 Descriptive Naming — Good vs Bad

⚙️ Project Management Models

🎯 (SE-11-05)

📌 Compare the execution of the Waterfall and Agile project management models as applied to software development.

🧪 Testing, Debugging and Error Handling

🎯 (SE-11-06, SE-11-07)

📌 Test and Evaluate solutions, considering functionality, performance, readability, and documentation quality. Use debugging tools. Determine suitable test data sets and identify typical coding errors.

📋 Evaluation Criteria

Software solutions are evaluated on multiple dimensions:

• Functionality: Does the program produce correct outputs for all inputs?
• Performance: Does it run efficiently (time complexity, memory usage)?
• Readability: Is the code clear, well-structured, and easy to understand?
• Documentation Quality: Are functions documented? Are complex sections explained?

🎯 Test Data Selection

Selecting the right data is critical for ensuring secure and robust code execution (SE-11-07).

🛠️ Debugging Tools

🔴 Breakpoints

A breakpoint is an instruction set within an IDE (such as Visual Studio Code or PyCharm) that pauses program execution at a specific line, allowing the engineer to inspect the current state of all variables and memory at that exact moment. For example, when debugging a loop that is supposed to accumulate a total but is producing an incorrect result, placing a breakpoint at the beginning of each iteration allows the engineer to examine the running total before and after each calculation — pinpointing precisely where the logic diverges from the expected behaviour without having to add print statements throughout the code.

👁️ Watches

A watch is a debugging feature that continuously monitors the value of a specific variable as the program executes, updating in real time with each statement. This is particularly useful when a variable is modified across multiple functions or modules. For example, setting a watch on a total_price variable allows an engineer to observe exactly at which line — and within which function — an incorrect GST calculation is being applied, rather than manually tracing through the entire codebase to find the source of the discrepancy.

⏭️ Single Line Stepping

Single line stepping (also known as "step-through" debugging) executes the program one statement at a time, pausing after each line. This allows engineers to trace the exact path of execution through complex control structures — such as nested conditionals or recursive functions — verifying that each branch evaluates as intended. For example, stepping through an IF/ELIF/ELSE chain confirms which condition is evaluating to True for a particular input, revealing logical errors in the control flow that would be completely invisible during normal, uninterrupted execution.

def process_input(value):
    try:
        n = int(value)
        if 1 <= n <= 100: return "Valid" # Boundary check
        else: return "Out of Range"
    except ValueError:
        return "Abnormal Data" # Handling faulty data

# Example testing
print(process_input(100))   # Boundary: Valid
print(process_input("ABC")) # Abnormal: Handled

⚠️ Typical Errors in Code Development

Understanding common error types helps programmers identify and fix problems systematically: