Tutorials

Tutorials

Hands-on, in-browser tutorials covering languages, tools, design patterns, testing, and other software-engineering topics. Each tutorial runs in your browser — no install required — and saves your progress locally.

  • Advanced Git: Debugging, History Rewriting, and Submodules

    Go beyond the basics — master detached HEAD, git's object model, stash, cherry-pick, blame, bisect, rebase (including interactive), squash merge, and submodules. Every step is grounded in a real scenario you will meet on the job.

  • C for C++ Programmers: Origin Story

    Every systems programmer has an origin story. Yours starts here. Shed the safety net of C++, master raw memory, and emerge with powers most programmers never unlock — all through hands-on practice in an interactive Linux terminal.

  • Code Comprehension Part 1: Hypotheses & Beacons

    Part 1 of a two-part code comprehension tutorial for students who have completed the Python, React, and Node.js essentials tutorials. Practice deciding where to focus attention, reading faster with beacons, and verifying only the code that matters in a roughly one-hour session. Later quizzes interleave material from earlier steps — don't be surprised if a question in Step 6 asks about something you first met in Step 3.

  • Code Comprehension Part 2: Tests & Cross-File Flow

    Part 2 of the code comprehension tutorial. Return a few days after Part 1, then practice testing hypotheses with Node.js behavior tests and mapping interactions across React and backend files in a roughly one-hour session. Later quizzes interleave material from Part 1 and earlier Part 2 steps — don't be surprised if a Part 2 question asks about Part 1 vocabulary.

  • Code Smells & Refactoring — A Music Streaming App

    Identify smells in real Python code and apply named refactorings safely. The first refactoring you do by hand to anchor the safety dance; the rest you drive with Monaco's tool support so you can spend your time thinking instead of typing. Tests stay green throughout. Live UML class diagrams make the structural change visible. Built around a music streaming codebase you incrementally clean up over ten steps.

  • Debugging Python: From Symptom to Fix

    Learn debugging as a distinct, learnable skill — not as accidental tinkering. You'll work three real Python bugs (recursive boundary, data-representation, temporal ordering) using a hypothesis-driven process and the time-travel debugger's breakpoints, conditional breakpoints, watch expressions, and history scrubber. Ends with an interleaved triage drill and an independent transfer challenge.

  • Defensive Programming in Python

    A 75-90 minute Python tutorial for students who already know functions, classes, exceptions, and basic pytest. You will practice rejecting bad input clearly, preserving valid state, and keeping failure information visible instead of quietly hiding caller bugs.

  • Design by Contract in Python

    A 75-90 minute Python tutorial for students who have completed Defensive Programming in Python or already know Python functions, classes, exceptions, and basic pytest. You will practice contracts as responsibility allocation: caller preconditions, supplier postconditions, old-state reasoning, invariants, and legal contract strengthening.

  • Information Hiding in Python: Hide the Decision, Not Just the Field

    Refactor leaky Python modules so a plausible future change touches one file, not twenty. You will spot leaked design decisions in code that technically uses private fields, hide a storage representation behind domain operations, hide an algorithm choice behind a Protocol, swap implementations to prove the secret is really hidden, and apply Single Choice so adding a new streaming provider is one new class — not five if/else edits. **Expect to be stuck once or twice — Parnas's principle takes most engineers a couple of passes to internalize, and the gap between 'I followed it' and 'I can do it from scratch' is exactly where the learning is.**

  • Java for C++ and Python Developers

    A fast-paced, hands-on Java tutorial for senior CS students who already know C++ and Python. Master Java's type system, OOP model, and design idioms — with UML diagrams to guide your thinking.

  • Makefiles: From Pain to Power (C Edition)

    Learn how to write Makefiles, understand dependency graphs, and automate your C builds through hands-on practice in an interactive terminal.

  • Monopoly State Pattern UML

    Design Monopoly player behavior with the State pattern by drawing class, state machine, and sequence diagrams in the UML editor.

  • Node.js Essentials: JavaScript for the Backend

    A hands-on introduction to Node.js for students who already know Python and C++. Learn to run JavaScript, understand the event loop, and write modern async code — all in the browser.

  • Playwright Tutorial: End-to-End Testing for React Apps

    Translate the testing concepts from Testing Foundations into the browser. Write end-to-end tests in Playwright that test behavior, not implementation — tests that survive harmless refactors and fail for real bugs.

  • Prolog Essentials

    A hands-on introduction to logic programming with Prolog, running entirely in your browser. Learn to think declaratively — define facts, write rules, and let Prolog find the answers.

  • Python Essentials: Scripting & Automation

    A hands-on introduction to Python for students who already know C++ and shell scripting. Build a solid Python mental model by mapping every concept to what you already know — and spotting where the analogies break.

  • React Essentials: From Imperative to Declarative UI

    A hands-on introduction to React for students who already know C++ and Python and have completed the Node.js tutorial. Assumes basic familiarity with HTML tags and CSS classes (a refresher is provided in Step 1). Learn to think declaratively, build components, manage state, and compose real UIs — all live in your browser.

  • SOLID Design Principles: Stop Writing Code That Falls Apart

    Learn the SOLID principles by suffering through rigid code first, then leveling up with refactoring. Each principle hits you with a realistic scenario where one tiny change request breaks everything — and then shows you how to fix it so your code actually survives contact with reality.

  • SQL Essentials

    A hands-on introduction to SQL using SQLite, running entirely in your browser. Start by querying an existing database, then learn to filter, aggregate, create your own tables, and modify data — no installation required.

  • Shell Scripting

    Master shell scripting through hands-on exercises in an interactive Linux environment — from your first script to building real automation tools

  • TDD with pytest — Dragon Dice Battle

    Live the Red-Green-Refactor rhythm by growing a fantasy dice-scoring engine from scratch — seven tiny tests, one design pressure at a time, plus a final transfer cycle (FizzBuzz) that proves the rhythm carries to a brand-new problem. Tests drive design, refactors stay safe, and the rules of the game emerge as code.

  • Test Doubles — Stubs, Spies, and Mocks

    Learn to test code that depends on a clock, an HTTP service, a database, or a notification system — without actually hitting them. Concepts first; the Python+pytest syntax is provided so you can focus on the test-design decisions.

  • Testing Foundations with pytest

    Build the core testing skills you need BEFORE learning TDD: write meaningful assertions, choose test cases using partitions and boundaries, and test behavior instead of implementation.

  • The Observer Pattern: Stop Hard-Coding Your Dependencies

    Learn the most widely used behavioral design pattern by experiencing the pain of tightly coupled code first, then discovering how the Observer pattern makes your systems flexible and extensible. You will refactor a broken weather station into clean, decoupled architecture — guided by UML diagrams that update live as you code.

  • UML Class Diagrams in Python

    Learn to read and create UML class diagrams by writing Python code that matches target diagrams. Starting from single classes and building to full system architectures, you will discover how UML makes invisible design decisions visible.

  • UML Sequence Diagrams in Python

    Learn to read and create UML sequence diagrams by writing Python code that matches target diagrams. Starting from a few objects exchanging messages and building up to branches and loops, you will see how sequence diagrams turn invisible runtime behavior into a picture.

  • Version Control with Git

    Learn Git through hands-on practice — from your first commit to resolving merge conflicts, all inside an interactive Linux environment