B1.1.1 Construct problem specification (AO3)
B1.1.1_1 Includes: problem statement, constraints, objectives, input/output specs, evaluation criteria
Problem Statement
- Clearly defines the problem to be solved
- Provides context and scope
- Example: "Develop a system to manage student course registrations, tracking enrollments and grades."
Constraints
- Specifies limitations or requirements
- Hardware, software, time, or data restrictions
- Example: System must run on existing school servers, support 1,000 users, and comply with data privacy laws.
Objectives
- Outlines goals of the solution
- Focuses on what the system should achieve
- Example: Enable students to register for courses, allow administrators to update grades, and generate enrollment reports.
Input/Output Specifications
- Details data the system will accept and produce
- Clear definition of inputs and outputs
- Example: Inputs: Student ID, course selection; Outputs: Confirmation of enrollment, grade reports.
Evaluation Criteria
- Defines metrics to assess solution's success
- Performance, accuracy, or user satisfaction
- Example: System must process registrations in under 2 seconds, achieve 99% accuracy in grade reporting, and receive positive user feedback.
Construction Process
- Write a clear, concise problem statement to guide development
- List constraints (e.g., budget, platform compatibility) to set boundaries
- Define measurable objectives to ensure the solution meets user needs
- Specify inputs (e.g., user data) and outputs (e.g., reports) to clarify functionality
- Establish evaluation criteria (e.g., response time, error rate) to measure success
- Example: For a library management system, the specification might include: Problem: Automate book loans; Constraints: Use existing database; Objectives: Track loans and returns; Inputs: Book ID, user ID; Outputs: Loan status; Evaluation: 100% accurate loan tracking, user-friendly interface.
Worked Example — School Library Management System
The following is a complete problem specification demonstrating each required component.
1. Problem Statement
The school library currently manages book loans using paper records. Staff struggle to locate overdue books, members cannot check availability without visiting in person, and generating reports for the head teacher takes several hours each term. A digital system is required to replace the manual process.
2. Objectives
- Allow library staff to record loans, returns, and new member registrations in under 30 seconds per transaction
- Enable members to check book availability via a simple search interface
- Automatically flag overdue loans and send email reminders to members
- Generate a termly usage report with loan counts, popular titles, and overdue statistics
3. Inputs
- Member ID (scanned barcode or typed), member name, year group
- Book ISBN (scanned barcode), book title, author, genre, number of copies
- Loan date (auto-generated), due date (calculated: loan date + 14 days)
- Return date (entered by staff on book return)
4. Outputs
- On-screen confirmation of loan or return with member and book details
- List of books currently on loan to a given member
- Overdue loan alerts displayed to staff at login and sent by email to members
- Termly report: total loans, books by loan frequency, overdue rates by year group
5. Constraints
- Must run on existing school hardware (Windows PCs, no specialist equipment beyond barcode scanners)
- Must be usable by non-technical library staff with minimal training
- Budget: software development and deployment within £2 000
- Must comply with GDPR — no member personal data shared with third parties
- Must be operational before the start of the next academic year
6. Success Criteria
- Staff can complete a loan transaction in under 30 seconds (measured by timing 20 test transactions)
- All overdue loans are flagged automatically with no manual checking required
- Termly report generated in under 2 minutes with no manual data entry
- System handles simultaneous use by at least 3 staff terminals without data conflicts
- 100% of paper records successfully migrated to the digital system before go-live
B1.1.2 Describe computational thinking concepts (AO2)
B1.1.2_1 Abstraction, algorithmic design, decomposition, pattern recognition
Abstraction
- Description: Simplifying complex problems by focusing on essential details and ignoring irrelevant ones
- Purpose: Reduces complexity, making problems easier to solve by filtering out unnecessary information
- Example: Modeling a car in a traffic simulation by considering only speed and position, ignoring details like color or brand
Algorithmic Design
- Description: Creating step-by-step procedures (algorithms) to solve a problem efficiently
- Purpose: Provides a clear, repeatable process to achieve a solution
- Example: Designing an algorithm to sort student names alphabetically using a method like bubble sort
Decomposition
- Description: Breaking a complex problem into smaller, manageable subproblems
- Purpose: Simplifies problem-solving by addressing each part independently
- Example: Developing a school management system by separating tasks like student registration, grade tracking, and reporting
Pattern Recognition
- Description: Identifying similarities or trends in data to inform solutions or optimize processes
- Purpose: Leverages common patterns to simplify problem-solving or predict outcomes
- Example: Recognizing that student grades follow a pattern of improvement after tutoring, informing a predictive model
B1.1.3 Explain computational thinking for problem-solving (AO2)
B1.1.3_1 Techniques toolkit, not always programming
Techniques Toolkit
- Computational thinking (CT) involves a set of problem-solving techniques: abstraction, decomposition, pattern recognition, and algorithmic design
- Abstraction: Focuses on relevant details, ignoring unnecessary complexities
- Example: Simplifying a payroll system by focusing on employee hours and pay rates, ignoring office decor
- Decomposition: Breaks complex problems into smaller, manageable parts
- Example: Dividing a website development project into designing the UI, coding the backend, and managing the database
- Pattern Recognition: Identifies trends or similarities to apply known solutions
- Example: Noticing repeated errors in user inputs to design better validation rules
- Algorithmic Design: Creates step-by-step procedures to solve problems
- Example: Developing a sequence of steps to calculate student GPAs from course grades
Not Always Programming
- CT applies beyond coding, used in planning, analysis, and decision-making across disciplines
- Example: A business analyst uses decomposition to break down a sales forecasting problem without writing code
- CT principles guide structured thinking in non-technical contexts, like organizing a project timeline or optimizing a workflow
B1.1.3_2 Examples: software development, data analysis, machine learning, database design, network security
Software Development
- Application: CT breaks down software requirements into modules (decomposition), designs algorithms for functionality, and abstracts user needs
- Example: Developing a mobile app by decomposing it into user interface, data storage, and API integration, using algorithms for efficient processing
Data Analysis
- Application: Uses pattern recognition to identify trends and abstraction to focus on key metrics, simplifying complex datasets
- Example: Analyzing sales data to find patterns in customer purchases, focusing only on relevant metrics like revenue and product type
Machine Learning
- Application: Applies decomposition to preprocess data, select models, and tune parameters; pattern recognition identifies data features
- Example: Designing a spam filter by breaking down tasks into data cleaning, feature selection, and model training, recognizing patterns in spam keywords
Database Design
- Application: Uses abstraction to model entities and relationships, decomposition to structure tables, and algorithms for querying
- Example: Designing a school database by abstracting entities (students, courses), decomposing into tables, and creating algorithms for grade queries
Network Security
- Application: Decomposition breaks down security protocols, pattern recognition detects attack patterns, and algorithms define response strategies
- Example: Identifying a DDoS attack by recognizing traffic patterns, decomposing the response into detection, filtering, and mitigation steps
B1.1.4 Trace flowcharts for algorithms (AO3)
B1.1.4_1 Use standard symbols: Connector, Decision, Flowline, Input/Output, Process, Start/End
Connector
- Circle or small shape linking parts of a flowchart
- Often used to connect separate pages or sections
- Example: A circle labeled "A" connects to another part of the flowchart to continue the process
Decision
- Diamond shape representing a conditional branch
- e.g., yes/no or true/false decisions
- Example: A diamond with "Is age > 18?" branches to different paths based on the answer
Flowline
- Arrows showing the direction of process flow
- Connecting symbols
- Example: An arrow from a process to a decision indicates the sequence of steps
Input/Output
- Parallelogram indicating data input or output
- e.g., user input, display results
- Example: A parallelogram labeled "Enter student grade" for input or "Display result" for output
Process
- Rectangle representing a computation or action
- Example: A rectangle with "Calculate average grade" for a computation step
Start/End
- Oval or rounded rectangle marking the beginning or end of the algorithm
- Example: An oval labeled "Start" or "End" to denote the algorithm's entry or exit point
Purpose
- Standard symbols ensure clarity and consistency in representing algorithms
- Making flowcharts universally understandable
B1.1.4_2 Depict processes, decisions, control flows
Processes
- Represented by rectangles, showing actions like calculations or data manipulation
- Example: A process box for "Add 1 to counter" in a loop counting iterations
Decisions
- Shown as diamonds, indicating branching points where the algorithm chooses a path based on a condition
- Example: A decision box with "Is balance < 0?" directs to overdraft handling or normal processing
Control Flows
- Flowlines (arrows) guide the sequence of execution
- Connecting processes, decisions, and other symbols
- Example: An arrow from a decision "Is input valid?" to a process "Save data" for valid inputs, or to "Display error" for invalid ones
Example Flowchart
- A flowchart for calculating a student's average grade might include:
- Start → Input grades (Input/Output) → Calculate average (Process) → Is average ≥ 60? (Decision) → Yes: Display "Pass" (Output) / No: Display "Fail" (Output) → End
B1.1.4_3 Track variable changes, determine outputs
Tracking Variable Changes
- Trace the flowchart step-by-step
- Updating variable values as processes are executed
- Example: In a flowchart summing numbers, initialize sum = 0, then for each input number, update sum = sum + number in a process box
Determining Outputs
- Follow the flowchart's control flow through decisions and processes
- To compute the final output
- Example: For a flowchart checking if a number is even, input number = 4, decision "Is number % 2 = 0?" leads to output "Even."
Tracing Process
- Start at the "Start" symbol, follow flowlines, evaluate decisions, update variables in process steps, and note outputs at Input/Output symbols
- Example: Tracing a flowchart for a login system:
- Input: username, password (Input/Output)
- Decision: "Is username valid?" → If no, output "Invalid username" and end
- Process: Check password → Decision: "Is password correct?" → If yes, output "Login successful"; if no, output "Login failed."
Use Case
- Tracing a flowchart for a grade calculator with inputs (grades), processes (sum, divide by count), decisions (pass/fail threshold), and outputs (pass/fail result) ensures correct algorithm logic and output prediction
Trace Practice
- Loop example: Start with total = 0 and count = 1. Repeat while count ≤ 3: total = total + count, count = count + 1. Trace: total values are 1, 3, 6; final output is 6.
- Decision example: Input mark = 72. Decision "mark ≥ 60?" follows the Yes branch, so the output is "Pass".
- Output prediction: Record each variable change in a trace table before deciding the final output.