Computer Science: Problem Specification and Computational Thinking

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.

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