Grade 10 · printable course

Computer Science Principles: Computation, Data, and Society (Part 1)

Grade 10, Units 1-4 · 306 pages · 39 lessons · PDF, print at home

A full-year, algebra-based introduction to computing for students with no prior programming experience. Students write and read Python programs, represent and analyze data, model the internet's architecture, and evaluate the social, economic, and ethical consequences of computing systems. Every tool used is free and runs in a browser with no account requiring payment. The course treats programming as one of several representational systems for solving problems, alongside data tables, flowcharts, and network diagrams, and asks students to judge computing's effects on people, not only to build artifacts. This volume holds units 1 to 4: Thinking Like a Computer: Algorithms Before Syntax; Python as a Notation: Variables, Conditionals, and Loops; Organizing Data: Lists, Strings, and Iteration Patterns; Abstraction in Code: Functions and Program Design.

Delivered by email within minutes as a PDF stamped with your name. Print any part as often as you need for the children in your household; the link never expires.

$21.99

one household licence

What is inside

Every unit and lesson in this book, in order. The same lessons are taught online at lettersanddevotion.com, so a family can move between paper and screen.

Computer Science Principles: Computation, Data, and Society

39 lessons · try a lesson online free

Unit 1: Thinking Like a Computer: Algorithms Before Syntax9 lessons
  1. 1.The definitions of algorithm, sequence, selection, iteration, decomposition, and abstraction
  2. 2.Sequential execution of a pseudocode algorithm and its effect on variable values
  3. 3.Selection and iteration control structures and their effect on variable state across multiple steps
  4. 4.Sequence, selection, and iteration as structural categories of algorithmic control flow
  5. 5.Off-by-one logic errors in loop boundary conditions
  6. 6.Decomposition of a problem into independently justifiable sub-steps
  7. 7.Abstraction as deliberate concealment of implementation detail, and its tradeoffs for the user
  8. 8.Robustness of a decomposition's boundaries under changed problem constraints
  9. 9.Correspondence between flowchart and pseudocode representations of the same algorithm
Unit 2: Python as a Notation: Variables, Conditionals, and Loops9 lessons
  1. 10.Variable assignment using = as distinct from mathematical equality
  2. 11.Sequential state change across multiple assignment statements
  3. 12.Deterministic branch selection in if/elif/else
  4. 13.Python error types: IndentationError, NameError, TypeError
  5. 14.For-loop accumulator pattern
  6. 15.While-loop termination conditions and the infinite-loop error
  7. 16.Selecting the appropriate control structure (sequence/selection/iteration) for an unfamiliar problem specification
  8. 17.An original program integrating conditionals and loops, checked against its own predicted trace
  9. 18.The distinction between syntax errors and logic errors in a program with correct underlying algorithmic intent
Unit 3: Organizing Data: Lists, Strings, and Iteration Patterns11 lessons
  1. 19.0-based list indexing
  2. 20.For-item-in-list iteration syntax
  3. 21.Index-based vs. item-based iteration over the same list
  4. 22.The relationship between list length and valid index range
  5. 23.Reading an IndexError traceback to locate the faulty index value
  6. 24.Accumulator-variable loop pattern for sum, count, or max
  7. 25.Data loss and mutation consequences of sort/filter operations on a list
  8. 26.List cleaning, iteration, and accumulation applied to an unfamiliar composite data structure
  9. 27.Irrecoverable information loss caused by filtering decisions made without foresight of future use
  10. 28.Strings as sequences of characters, compared to lists
  11. 29.The causal link between an error message's content and the code fix it implies
Unit 4: Abstraction in Code: Functions and Program Design10 lessons
  1. 30.The function signature (name, parameters, return type by inference) as a contract separate from implementation
  2. 31.Parameter passing and return value flow across a function call boundary
  3. 32.Local vs. global scope and the bugs caused by conflating them
  4. 33.Duplication in code as the signal that a function boundary belongs there
  5. 34.Function definition with parameters and a return value, as a direct replacement for duplicated code
  6. 35.Decomposition of a program into functions along its 'natural' task boundaries
  7. 36.Tradeoffs between alternative function decompositions of the same program
  8. 37.The four named function-related bug categories and their distinguishing symptoms
  9. 38.Transfer of function-decomposition reasoning to an unfamiliar problem domain
  10. 39.Full refactor of an unstructured program into a function-based design, plus a feature extension that tests whether the design supports change

More for Grade 10

Everything for Grade 10 · All printable books