Paper 2

Variables and constants

Use of named storage locations in code that can hold values (variable = changeable; constant = fixed)

Data types

Different kinds of data such as integer, real/float, Boolean, string

Operators

Arithmetic (+, -, *, /), relational (==, !=,

Input/output

Reading user input and displaying output to the user (e.g., input(), print())

Selection

Using if/else/elif to control the flow of a program

Iteration

Using loops (for, while) to repeat blocks of code

Subroutines

Reusable blocks of code: procedures (no return) and functions (with return)

Recursion

When a function calls itself to solve a smaller version of the problem

File handling

Reading/writing to external files using open(), read(), write(), close()

Exception handling

try/except blocks to catch and handle runtime errors

OOP: classes

Templates for objects that define properties and methods

OOP: objects

Instances of classes created using constructors

Top-down design

Breaking a problem down into smaller sub-problems

Stepwise refinement

Breaking down each sub-problem further until it's easily solvable

Modular code

Code divided into separate functions/modules for clarity and reuse

Global vs local variables

Global: used throughout the program; Local: used within subroutines

Naming conventions

Using clear, consistent names for variables and functions (e.g., camelCase, snake_case)

Comments and indentation

Writing helpful notes and using spacing to improve code readability

Abstraction

Removing unnecessary details to focus on key information

Decomposition

Breaking a complex problem into smaller parts

Algorithmic thinking

Creating step-by-step solutions to problems

Problem inputs, processes, outputs

Identifying the key components of a problem to solve it in code

Linear search

Searching through data one item at a time until a match is found

Binary search

Divides sorted data in half repeatedly to find a target item

Bubble sort

Repeatedly swaps adjacent elements if they are in the wrong order

Insertion sort

Builds a sorted list one item at a time by inserting into the correct place

Merge sort

Recursively divides list into halves, sorts and merges them

Quick sort

Picks a pivot, partitions data into pivot, then sorts recursively

Breadth-First Search

Explores nodes level by level (uses queue)

Depth-First Search

Explores as far as possible along a branch before backtracking (uses stack/recursion)

Dijkstra's algorithm

Finds the shortest path in a weighted graph from a start node to all others

A* algorithm

Similar to Dijkstra but uses heuristics to estimate cost to goal

Big-O notation

Describes time/space complexity of an algorithm (e.g., O(n), O(log n), O(n²))

Pseudocode

A structured but informal way of writing algorithms

Dry-running

Manually tracing through an algorithm with sample data

Trace tables

Tables used to track variable values as a program runs

1D arrays

List of elements accessed by a single index

2D arrays

Grid of elements accessed using two indices (rows and columns)

Records

Data structure that groups related fields under one name

Lists

Ordered collections of elements that can grow or shrink dynamically

Stacks

LIFO (Last In, First Out) structure with push, pop, and peek operations

Queues

FIFO (First In, First Out) structure with enqueue and dequeue operations

Circular queue

Queue that wraps around when it reaches the end

Priority queue

Elements are dequeued based on priority rather than order

Linked lists

Chain of nodes where each node links to the next

Binary tree

Each node has at most two children: left and right

Binary search tree

A binary tree where left < node < right

Graphs

Nodes connected by edges; can be directed/undirected, weighted/unweighted

Adjacency matrix

2D array showing connections between nodes

Adjacency list

List of nodes with their direct neighbours

Hash table

Maps keys to values using a hash function for fast access

Dictionaries

Key-value data structure (e.g., in Python)

Imperative programming

Code that follows a sequence of commands (e.g., Python)

OOP paradigm

Programming using classes and objects

Functional programming

Uses functions as first-class objects, avoids state and mutable data

Compare paradigms

Understanding the pros/cons of imperative, OOP, and functional styles

Software development lifecycle

Stages of creating software: analysis, design, implementation, testing, evaluation

Agile methodology

Iterative, flexible development approach with continuous feedback

Waterfall model

Linear, sequential development model

Black-box testing

Tests based on input/output without looking at code

White-box testing

Tests based on internal structure and logic of code

Alpha testing

Internal testing by developers before release

Beta testing

External user testing before final release

Validation

Ensuring inputs are acceptable (e.g., correct type/format)

Verification

Ensuring software matches the specification

IDE features

Tools like syntax checking, breakpoints, watches, stepping, debugging