 ## Syllabus

###### Grades 1-2: Preparatory Computational Thinking

This course is designed to prepare very young children for learning the core ideas of computer
science. It is thought that children at this age have very limited mental faculties for performing
one of the central aspects of computational thinking: abstraction. Lessons and activities in this
course will therefore mostly concern concrete pattern finding and following and completing
instructions. This course may be done without a computer, but the experience of the students
can be enriched if computers are available. This lesson outline is (heavily) based on
and https://code.org/educate/curriculum/elementary-school .
• Lesson 1: Pattern Recognition
• Lesson 2: Sequencing, Debugging
o Using the Computer, Learning to Click, Drag, and Drop
• Lesson 3: Loops
• Lesson 4: Binary Representation of Numbers
• Lesson 5: Representation of Text and Images

###### Grades 3-4: Introduction to Computer Science and Computational Thinking 1

This course introduces young children to the core ideas of computer science. Many key ideas of
computer science are made accessible and engaging for this age group by presenting them as
games. This course may be done without a computer, but the experience of the students can be
enriched if computers are available. This lesson outline is (heavily) based on
https://classic.csunplugged.org/ and https://code.org/educate/curriculum/elementary-school .
• Lesson 1: Review of Sequencing and Loops, Conditions
• Lesson 2: Trees
• Lesson 3: Information Theory
• Lesson 4: Searching
• Lesson 5: Sorting
• Lesson 6: Programming Languages

###### Grades 5-6: Introduction to Computer Science and Computational Thinking 2

This is a natural continuation of the previous course. If the schedule allows, in theory, a 3rd
grader who has completed the previous course can immediately start this course. There is no
need to wait until the 5th grade, as long as the student is mature enough for slightly more
abstract reasoning. A little bit of familiarity with algebra will be assumed for some parts of the
course, in particular, the use of variables and functions, but students will likely be able to learn
the concept even without having encountered it in math classes before as they will be presented
using a visual programming language. Some parts of this course strictly require a computer
while some parts don’t. This lesson outline is (lightly) based on https://classic.csunplugged.org/
and https://code.org/educate/curriculum/elementary-school .
• Lesson 1: Functions
• Lesson 2: Variables
• Lesson 3: Introduction to Networks (Graph Theory)
• Lesson 4: Finite State Automata
• Lesson 5: Boolean Algebra, Constraint Satisfaction Problems

###### Grades 7-8: Programming in Python

Now that the student has “conceptually” learned most core computer science concepts and
have done a little bit of programming in a visual programming language, they should be ready to
do some “real” programming. Algebra is a pre-requisite for this course: students should already
be familiar with the notions of variables, equations, inequalities, and functions.
• Lesson 1: Introduction to Python, Input and Output, Primitives, Variables, Model of
• Evaluation, Conditionals
• Lesson 2: Lists, Strings, Iteration, Loop Invariants
• Lesson 3: Functions, Principle of Abstraction and Modularity, Top-down Design
• Lesson 4: Testing and Debugging
• Lesson 5: Lambda Expressions and Higher-Order Functions
• Lesson 6: Recursion

###### Grades 9-10: Introduction to Algorithm Design 1

Having learned and mastered the basics of programming, students can now begin their journey
into what is popularly called “competitive programming.” At this stage, they begin learning
fundamental problem solving and algorithm design principles which are at the heart of computer
science. Additionally, they also learn how to prove correctness and efficiency, and learn
practical implementation with a programming language.
• Lesson 1: Complete Search
• Lesson 2: Asymptotic Analysis
• Lesson 3: Modular Arithmetic
• Lesson 4: Counting
• Lesson 5: Divide-and-Conquer, Part 1: Binary Search
• Lesson 6: Divide-and-Conquer, Part 2: Sorting and More Examples
• Lesson 7: Introduction to Networks (Graph Theory)
• Lesson 8: Network Exploration (Graph Traversal)
• Lesson 9: Recursive Backtracking
• Lesson 10: Dynamic Programming

###### Grades 11-12: Introduction to Algorithm Design 2

This is a natural continuation of the previous course. If the schedule allows, in theory, a 9th
grader who has completed the previous course can immediately start this course. There is no
need to wait until the 11th grade, as long as the student is mature enough for analysis and
proofs. This lesson outline is (lightly) based on a programming camp that we have already
successfully held in the Philippines.
• Lesson 1: Introduction to C++, Review of Binary Representation, Bitwise Operations,
• Bitmasking
• Lesson 2: Linear Data Structures
• Lesson 3: Tree Data Structures
• Lesson 4: Greedy Algorithms
• Lesson 5: Shortest Paths
• Lesson 6: Amortized Analysis, Two-pointers Method, Disjoint Set Union-Find