Coding and AI for Kids — Syllabus | Immersive Computing Labs

Programme 1 — Foundations (visual coding → Python → web)

Twelve classes per course. Learners build games and stories first, then transition to text-based code, Python, and the web stack—with a capstone project at each level.

Level I

Animation and Games with Scratch (12 classes)

Sprites, motion, and creative storytelling using block-based programming.

Classes 1–3: Scratch environment, sprites & costumes, motion blocks, coordinates, simple animations.
Classes 4–6: Events (keyboard, clicks), looks & sound, timing, backdrops, short interactive scenes.
Classes 7–9: Loops and repetition, broadcasts, multi-sprite stories, collision basics for simple games.
Classes 10–12: Polish: scoring, game over screens, peer play-testing, iteration.

Logic with Scratch (12 classes)

Computational thinking: decisions, variables, and debugging.

Classes 1–3: Conditionals (if / else), sensing blocks, simple quizzes and branching stories.
Classes 4–6: Variables and lists, counters, storing scores and names.
Classes 7–9: Operators, comparisons, nested logic, tracing program flow.
Classes 10–12: Debugging strategies, “predict then run,” fixing edge cases.

Intro to Text-based Programming (12 classes)

Bridge from blocks to reading and writing code in a real editor.

Classes 1–3: Why text code; editors and running programs; syntax vs. ideas; pseudocode.
Classes 4–6: Sequences, input/output, simple typed exercises mirroring Scratch concepts.
Classes 7–9: Conditionals and loops in text; indentation; common errors.
Classes 10–12: Mini-projects re-implementing a Scratch idea in text; documentation habits.

Capstone I (12 classes)

End-to-end project: plan, build, test, present.

Classes 1–3: Choosing a theme, user stories, sketching screens or levels.
Classes 4–8: Implementation in Scratch and/or starter text tasks; weekly milestones.
Classes 9–11: Testing, feedback, accessibility of instructions, bug fixes.
Class 12: Demo day: short presentation and reflection.

Level II

Programming Fundamentals with Python (12 classes)

Classes 1–3: Setup, REPL, variables, types, arithmetic, strings.
Classes 4–6: Control flow: if/else, for/while, ranges.
Classes 7–9: Lists, basic functions, scope intuition, simple file or console apps.
Classes 10–12: Small integrated exercises; style and readable naming.

Logic with Python (12 classes)

Classes 1–3: Boolean logic, compound conditions, truth tables in code.
Classes 4–6: Nested structures, breaking problems into steps, flowcharts.
Classes 7–9: Classic puzzles (patterns, searches) with clear invariants.
Classes 10–12: Debugging with prints and mental traces; defensive checks.

Modular Programming with Python (12 classes)

Classes 1–3: Functions with parameters and return values; docstrings.
Classes 4–6: Multiple modules, imports, separating I/O from logic.
Classes 7–9: Dictionaries and simple data modelling; JSON-like structures.
Classes 10–12: Refactoring a script into clean modules; reuse.

Capstone II (12 classes)

Classes 1–4: Problem selection, requirements, modular design.
Classes 5–9: Build (e.g. quiz app, text adventure, data tool).
Classes 10–11: Code review style feedback, stretch goals.
Class 12: Presentation and portfolio README.

Level III

Creating Websites with HTML/CSS (12 classes)

Classes 1–3: HTML structure, semantic tags, links, images, accessibility basics.
Classes 4–6: CSS selectors, colours, typography, box model.
Classes 7–9: Layout with flexbox; simple navigation and sections.
Classes 10–12: Multi-page site; consistency and folder structure.

Responsive Websites with HTML/CSS (12 classes)

Classes 1–3: Viewport, relative units, mobile-first mindset.
Classes 4–6: Media queries, breakpoints, responsive images.
Classes 7–9: CSS grid patterns; alignment; polish.
Classes 10–12: Cross-device testing; performance and readability.

Introduction to JavaScript (12 classes)

Classes 1–3: JS in the browser, DOM, events, changing text and styles.
Classes 4–6: Functions, arrays, simple form validation.
Classes 7–9: Fetch intro or local data; JSON; async intuition (callbacks or promises at age-appropriate depth).
Classes 10–12: Small interactive widgets; connecting HTML/CSS/JS.

Capstone III (12 classes)

Classes 1–4: Topic brief (portfolio, club site, interactive explainer).
Classes 5–9: Responsive UI + client-side behaviour; iteration.
Classes 10–11: UX pass, accessibility, deployment options (static host).
Class 12: Live demo and retrospective.

Programme 2 — Data Science

Ten classes per course. Moves from “what is data science?” to statistics, inference, and a first look at machine learning—with capstones at each level.

Level I

What is Data Science? (10 classes)

Data types, questions data can answer, ethics & privacy at a high level.
Workflow: question → data → analysis → insight → decision.
Tools overview (notebooks, spreadsheets vs. code); reproducibility ideas.
Case sketches: school, sports, environment—without heavy math first.

Advance Python for Data Science (10 classes)

NumPy-style thinking: arrays, vectorised operations (as appropriate to cohort).
Tabular data with pandas: read, filter, group, merge.
Cleaning: missing values, types, simple imputation strategies.
Short pipelines from raw CSV to tidy tables.

Data Visualization (10 classes)

Chart grammar: when to use bar, line, scatter, histogram.
Honest axes, labels, and avoiding misleading visuals.
Building dashboards or multi-panel figures for one dataset.
Critique: read a chart and list strengths and weaknesses.

Functions and Tables (10 classes)

Functions as transformations on tables (apply, map concepts).
Aggregations, pivot-like summaries, derived columns.
Connecting visual choice to table operations.
Mini-analyses end-to-end on curated datasets.

Capstone — I (10 classes)

Pick a question, source or use provided data, clean and visualize.
Written narrative: methods, figures, limitations.
Peer review and revision; final notebook or report.

Level II

Math for Data Science: Statistics and Probability (10 classes)

Descriptive stats: mean, median, spread; when each misleads.
Probability basics: events, independence, Bayes intuition.
Random variables and expectation at introductory level.
Linking math to code simulations for intuition.

Causality and Experiments (10 classes)

Correlation vs. causation; confounders introduced clearly.
RCTs and natural experiments—what randomisation buys you.
Designing a simple A/B test conceptually.
Ethical use of experiments with human subjects (age-appropriate).

Randomness – Part 2 (10 classes)

Deeper on distributions beyond the basics; variance and tails.
Simulation-heavy lessons to build gut feel.
Seeds and reproducibility in code.
Connecting simulations to real-world variability.

Sampling and Empirical Distributions (10 classes)

Populations vs. samples; sampling bias.
Empirical distributions and the law of large numbers (informal).
Bootstrap intuition (may stay conceptual or light implementation).
Exercises with synthetic and real small datasets.

Capstone — II (10 classes)

Project with statistical question + experimental or observational framing.
Clear statement of assumptions and limits.
Presentation with charts and verbal defence of conclusions.

Level III

Testing Hypotheses (10 classes)

Null and alternative hypotheses; p-values introduced carefully.
Type I/II errors; why “significant” ≠ “important.”
Simple tests in context (e.g. proportions, means) with software help.
Multiple comparisons mentioned as a caution.

Comparing Two Samples (10 classes)

Two-sample problems; paired vs. independent designs.
Visual exploration before formal testing.
Effect sizes and confidence intervals (conceptual + basic computation).
Reporting results responsibly.

Estimation and Prediction (10 classes)

Estimators, uncertainty, prediction intervals vs. confidence intervals.
Simple linear intuition: fitting a line, residuals.
Train/validation mindset without yet full ML stack.
Case: predict a numeric outcome from one or two features.

Introduction to Machine Learning (10 classes)

Supervised vs. unsupervised preview; loss functions at high level.
Simple models: k-NN, decision stump or linear classifier—interpretability first.
Metrics: accuracy, precision/recall trade-offs introduced.
Overfitting explained with train/test split.

Capstone — III (10 classes)

End-to-end ML mini-project: data → model → evaluation.
Written discussion of errors and fairness considerations.
Final demo and reflection on what would improve the model.

Programme 3 — Machine Learning & AI (deep learning & GenAI)

Ten classes per course. Builds from practical data access and classical ML through neural networks and transformers to generative AI and LLM application development.

Level I

Revisiting CSV Files and APIs (10 classes)

Robust CSV ingestion, encoding, and schema inspection.
REST APIs: GET requests, pagination, keys and rate limits responsibly.
Combining API data with local tables.
Error handling and logging patterns for data pipelines.

Math Refresher – Probability and Statistics (10 classes)

Vectors, matrices, dot products—geometric intuition for later nets.
Gradients introduced as “direction of steepest ascent” (conceptual).
Distributions used in ML (Gaussian, Bernoulli) tied to loss choices.
Short exercises bridging pen-and-paper and NumPy.

Supervised and Unsupervised Learning (10 classes)

Regression vs. classification; clustering vs. dimensionality reduction.
Feature engineering and scaling; categorical encodings.
Model families: trees, ensembles, SVMs at survey level.
Unsupervised: k-means, PCA intuition.

ML Model Evaluation, Optimization, and Validation (10 classes)

Cross-validation; stratification; leakage detection.
Optimisers: SGD, momentum—what they do, not full proofs.
Regularisation: L1/L2, dropout preview.
Hyperparameter search strategies (grid/random) at practical depth.

Capstone — I (10 classes)

Full classical ML project: API or CSV → features → models → rigorous evaluation.
Written comparison of models and error analysis.

Level II

Advanced Models and Optimization (10 classes)

Gradient descent variants; learning-rate schedules.
Advanced ensembles; stacking/blending overview.
When deep learning wins vs. tabular classics.
Practical debugging of training curves.

Neuron, Neural Network and DNN (10 classes)

Perceptron, activations, loss for classification/regression.
Backprop intuition; computation graphs at high level.
Building a small net in a framework; batching, GPU optional.
Vanishing/exploding gradients—symptoms and mitigations.

ANN, CNN, RNN (10 classes)

Feedforward ANNs for tabular and simple vector inputs.
CNNs: convolutions, pooling, a simple image classifier.
RNNs/GRU/LSTM intuition for sequences; limitations.
Transfer learning on a small vision task.

Transformer architecture (10 classes)

Attention mechanism; self-attention vs. cross-attention.
Positional encoding; encoder–decoder vs. decoder-only.
Scaling, context length, and compute trade-offs (qualitative).
Hands-on with a small transformer demo or library module.

Capstone — II (10 classes)

Deep learning project: vision or sequence task with documented experiments.
Ablation: one change at a time; learning from failures.

Level III

Introduction to Generative AI and LLMs (10 classes)

From language modelling to instruction tuning and RLHF (overview).
Capabilities and limits: hallucinations, bias, safety.
Use cases: summarisation, Q&A, drafting, coding assistance.
Responsible use policies and data handling.

LLM Architecture and training (10 classes)

Tokenisation, embeddings, autoregressive generation.
Pre-training vs. fine-tuning vs. adapters (LoRA-style concepts).
Evaluation: benchmarks, human eval, task-specific metrics.
Compute and data scale—why “bigger” isn’t always better for your problem.

Application Development with LLMs (10 classes)

Calling model APIs: prompts, parameters (temperature, max tokens).
RAG pattern: retrieval, chunking, vector stores—concept and build.
Agents and tools: when to chain calls; guardrails.
Shipping a small app: UI, secrets, logging, cost awareness.

Prompt Engineering using ChatGPT (10 classes)

Clear instructions, roles, and output formats (JSON, tables).
Few-shot examples; chain-of-thought when appropriate.
Iterative refinement; red-teaming your own prompts.
Building a prompt library for a real workflow.

Capstone — III (10 classes)

GenAI product or research artefact: e.g. RAG assistant, teaching bot, or evaluation study.
Documentation: prompt design, failure modes, and ethics checklist.
Final presentation with live demo.