Computational Thinking, Coding and Intelligent Systems
Free to read online. For a copy of this book, or to quote, highlight or reproduce any part of it, please request permission through the contact page beforehand.
Editorial and publication note
This is a proposed educational series. IEEE-style technical writing and citations do not imply IEEE endorsement, publication, accreditation, certification, or affiliation. Any standard, designation, author credential, publication detail, or institutional relationship must be verified before publication. These Word files are expanded educational drafts and chapter-development manuscripts for editorial review; they are not represented as final peer-reviewed or publication-ready books.
The proposed series title is descriptive only. Do not use IEEE logos or imply IEEE affiliation without authorisation. Any references to standards should be checked in the official IEEE Standards Association catalogue and used only within their stated scope.
About this book
Introduces decomposition, abstraction, Python programming, data structures, algorithmic efficiency, visualisation, statistics, and elementary AI.
Who should use this book
This volume is designed for ages 13–16. Instructors should adapt pacing, depth, tools, and examples to learner needs and local curriculum requirements.
Learning outcomes
- Explain the main concepts and vocabulary introduced throughout the volume.
- Apply a structured method to a relevant practical problem.
- Interpret evidence, identify limitations, and communicate results clearly.
- Consider privacy, fairness, safety, security, and human oversight where relevant.
How to use this book
Read the chapter explanation, complete the activity, answer the review questions, and keep a learning journal recording assumptions, decisions, mistakes, and improvements. For technical work, save code, data dictionaries, test results, and software-version details.
Table of contents
- Chapter 1: The Foundations of Computational Thinking
- Chapter 2: Decomposition, Abstraction, and Pattern Recognition
- Chapter 3: Variables, Data Types, and Expressions
- Chapter 4: Conditions, Loops, and Functions
- Chapter 5: Lists, Dictionaries, and Data Structures
- Chapter 6: Algorithms, Pseudocode, and Flowcharts
- Chapter 7: Searching, Sorting, and Computational Efficiency
- Chapter 8: Introduction to Python
- Chapter 9: Data Collection and Visualisation
- Chapter 10: Probability and Introductory Statistics
- Chapter 11: Rule-Based AI and Simple Machine Learning
- Chapter 12: Testing, Debugging, and Documentation
- Chapter 13: Cybersecurity and Responsible Coding
- Chapter 14: Integrated Programming Project
Chapter 1: The Foundations of Computational Thinking
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in the foundations of computational thinking.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Computational thinking frames problems so that solutions can be expressed as repeatable processes. It combines decomposition, pattern recognition, abstraction, and algorithm design. Not every problem needs a computer, but these methods make complex tasks easier to reason about.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Decompose a school-event planning task into inputs, subtasks, constraints, and outputs.
Chapter review
- What is the main idea in 'The Foundations of Computational Thinking'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 2: Decomposition, Abstraction, and Pattern Recognition
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in decomposition, abstraction, and pattern recognition.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Decomposition breaks a problem into smaller parts; abstraction retains relevant detail and omits distractions; pattern recognition finds reusable structure. The challenge is deciding which details matter to the problem.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Represent a transport-planning problem with a simple model and state what has been omitted.
Chapter review
- What is the main idea in 'Decomposition, Abstraction, and Pattern Recognition'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 3: Variables, Data Types, and Expressions
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in variables, data types, and expressions.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Variables name values, while data types describe what values represent and which operations are meaningful. Numeric, text, Boolean, and collection types should not be confused. Validate input and choose descriptive variable names.
Worked example and application
Worked example: use a small, fictional dataset with a documented meaning for each column. Check completeness and units, calculate a simple summary, visualise the result, and write one conclusion that is directly supported by the observations. State what the dataset cannot establish.
Practical activity
Write pseudocode to calculate a total and average while checking that the number of values is not zero.
Chapter review
- What is the main idea in 'Variables, Data Types, and Expressions'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 4: Conditions, Loops, and Functions
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in conditions, loops, and functions.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Conditions select paths; loops repeat work; functions package reusable behaviour. Incorrect loop boundaries and unhandled conditions are common sources of bugs. Functions should have clear inputs, outputs, and responsibilities.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Create pseudocode that counts values meeting a condition and test empty and non-empty inputs.
Chapter review
- What is the main idea in 'Conditions, Loops, and Functions'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 5: Lists, Dictionaries, and Data Structures
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in lists, dictionaries, and data structures.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Data structures organise information for access and processing. Lists preserve sequences; dictionaries map keys to values. The structure should match the operations needed, and data should be checked before processing.
Worked example and application
Worked example: use a small, fictional dataset with a documented meaning for each column. Check completeness and units, calculate a simple summary, visualise the result, and write one conclusion that is directly supported by the observations. State what the dataset cannot establish.
Practical activity
Represent fictional product inventory using a list and a dictionary; compare their use cases.
Chapter review
- What is the main idea in 'Lists, Dictionaries, and Data Structures'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 6: Algorithms, Pseudocode, and Flowcharts
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in algorithms, pseudocode, and flowcharts.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Pseudocode describes logic without committing to a programming language. Flowcharts make control flow visible. Both are useful for discussing a solution before implementation and for communicating with collaborators.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Design a flowchart and pseudocode for a simple grade-band calculator with boundary tests.
Chapter review
- What is the main idea in 'Algorithms, Pseudocode, and Flowcharts'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 7: Searching, Sorting, and Computational Efficiency
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in searching, sorting, and computational efficiency.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Searching locates items; sorting arranges them. Linear search examines items one by one, while binary search requires ordered data. Complexity notation gives a high-level view of how resource needs grow with input size.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Compare a manual linear search with binary search on a sorted list and record the number of comparisons.
Chapter review
- What is the main idea in 'Searching, Sorting, and Computational Efficiency'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 8: Introduction to Python
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in introduction to python.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Python provides readable syntax for variables, conditions, loops, functions, collections, and libraries. Program behaviour should be tested with normal, boundary, and invalid inputs. Use a safe, school-approved environment and avoid sharing secrets in code.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Write a small program that reads fictional measurements, calculates summaries, and handles missing values explicitly.
Chapter review
- What is the main idea in 'Introduction to Python'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 9: Data Collection and Visualisation
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in data collection and visualisation.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Data preparation includes understanding columns, units, missingness, duplicates, and provenance. Visualisation should answer a question and label scales clearly. A chart can mislead if axes, grouping, or sample size are hidden.
Worked example and application
Worked example: use a small, fictional dataset with a documented meaning for each column. Check completeness and units, calculate a simple summary, visualise the result, and write one conclusion that is directly supported by the observations. State what the dataset cannot establish.
Practical activity
Create a chart from a public or fictional dataset and write a caption explaining its message and limitations.
Chapter review
- What is the main idea in 'Data Collection and Visualisation'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 10: Probability and Introductory Statistics
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in probability and introductory statistics.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Probability quantifies uncertainty under stated assumptions. Descriptive statistics summarise observed data; inferential methods estimate beyond the sample and require caution. Correlation alone does not prove causation.
Worked example and application
Worked example: use a small, fictional dataset with a documented meaning for each column. Check completeness and units, calculate a simple summary, visualise the result, and write one conclusion that is directly supported by the observations. State what the dataset cannot establish.
Practical activity
Simulate repeated coin flips or use a public dataset to compare observed frequencies with expectations.
Chapter review
- What is the main idea in 'Probability and Introductory Statistics'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 11: Rule-Based AI and Simple Machine Learning
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in rule-based ai and simple machine learning.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Rule-based systems follow explicit conditions. Machine-learning systems fit patterns from examples. Compare their transparency, data requirements, failure modes, and evaluation needs rather than assuming one is always superior.
Worked example and application
Worked example: imagine a small team considering this concept for a clearly scoped, low-risk task. First define the intended outcome and inputs; then choose a simple baseline, document assumptions, test representative examples, inspect errors, and explain when the method should not be used. Compare the result with a human-reviewed alternative before proposing deployment.
Practical activity
Build a rule-based classifier, evaluate it on held-out examples, and discuss what a learned model might add.
Chapter review
- What is the main idea in 'Rule-Based AI and Simple Machine Learning'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 12: Testing, Debugging, and Documentation
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in testing, debugging, and documentation.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Testing checks expected behaviour; debugging identifies causes of failures; documentation explains purpose and assumptions. Test cases should cover ordinary inputs, boundaries, and invalid inputs. Reproducible code needs clear setup instructions.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Create a test table for a function and fix a deliberately introduced logic error.
Chapter review
- What is the main idea in 'Testing, Debugging, and Documentation'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 13: Cybersecurity and Responsible Coding
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in cybersecurity and responsible coding.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
Secure coding includes input validation, least privilege, dependency awareness, privacy protection, and safe handling of credentials. Ethical practice also considers accessibility, consent, and foreseeable misuse.
Worked example and application
Worked example: list the system's users, affected people, assets, likely failure modes, and potential consequences. Select preventive and detective controls, assign an accountable owner, and record the residual risk that remains after controls.
Practical activity
Review a fictional program design and list privacy and security controls before implementation.
Chapter review
- What is the main idea in 'Cybersecurity and Responsible Coding'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Chapter 14: Integrated Programming Project
Learning outcomes
By the end of this chapter, the learner should be able to:
- Explain the central concepts introduced in integrated programming project.
- Apply the ideas to a clearly defined example or practical task.
- Identify at least one limitation, assumption, or responsible-use consideration.
Core explanation
A useful application has a defined user, a clear task, a documented dataset, tested code, and an understandable output. The project should include known limitations and an improvement plan.
Worked example and application
Worked example: define a real-world task, list the inputs and constraints, sketch the steps or system components, and test the proposed solution with at least one ordinary case and one edge case. Record the outcome and what you would improve.
Practical activity
Build a Python application that reads a dataset, analyses it, and presents results in a clear report.
Chapter review
- What is the main idea in 'Integrated Programming Project'?
- Which assumptions or data requirements matter most in this topic?
- What could cause the approach to fail or produce a misleading result?
- How would you explain the result or limitation to a non-specialist?
Key takeaways
- Start with a clear question, objective, or system requirement.
- Document inputs, assumptions, methods, and limitations.
- Test the approach with relevant examples and review the consequences of errors.
Capstone project
Create a Python application that reads a dataset, analyses it, and presents results in a clear report. Include source code, a data dictionary, test cases, a visualisation, limitations, and setup instructions.
Suggested project deliverables
- A short problem statement and intended audience.
- A description of data, inputs, assumptions, tools, and method.
- Evidence of testing, analysis, or evaluation appropriate to the project.
- A clear explanation of results, limitations, and foreseeable risks.
- A final report or presentation and a reflection on possible improvements.
Assessment guidance
Evaluate code correctness, decomposition, data validation, test coverage, interpretation of results, security awareness, and clarity of documentation.
Glossary
Abstraction: Keeping the details relevant to a problem while omitting unnecessary complexity.
Data structure: A way to organise data for access and modification.
Complexity: A description of how computational resource needs grow with input size.
Function: A named, reusable unit of code.
Held-out data: Data not used during model fitting and reserved for evaluation.
Responsible practice checklist
- Use data and materials only when their source and permitted use are understood.
- Avoid exposing personal, confidential, or credential information.
- Document assumptions, missing information, and important limitations.
- Test ordinary cases, boundary cases, and foreseeable failure conditions.
- Use human review where errors could materially affect people, safety, rights, or resources.
- Do not claim that a system is fair, safe, secure, compliant, or reliable without appropriate evidence.
References and further reading
The source material supplied for this project does not provide a complete, volume-specific bibliography. Before publication, add verified primary sources, textbooks, official documentation, and standards applicable to this volume. Confirm exact titles, editions, publication dates, URLs, licences, and access dates. Do not cite a standard as evidence of conformity unless the required assessment has actually been performed.
For IEEE-style technical manuscripts, use numbered citations in order of first appearance when required by the target venue, and verify the venue's official author instructions.