Changelog

What changed, when, honestly. Dates use ISO 8601 because we are that kind of company.

July 2026

The encrypted paid edition is now CI-proven, buyer-style, across the tested products2026-07-29ci green

The paid edition of ExpectedJava, ExpectedFrontend and ExpectedC ships as an encrypted pack that only unlocks under a licence. CI now installs the real extension, activates a licence, decrypts the pack and walks every paid lesson exactly as a buyer would - open, attempt, grade - on Windows, macOS and Linux, and the build fails if any lesson misbehaves. Java and Frontend walk every paid lesson on all three systems; C runs every lesson each system's tools support and says so per lesson.
ExpectedJava: Windows now walks the complete curriculum in the editor, including the SQL, Spring and messaging tracks against real native services - previously those were proven on Windows by the grading gate alone. The same pass banned a cache lesson habit that could have cleared a learner's own Redis data when run against a shared server; lessons now clean only the keys they own.
Transparency: this buyer-style walk caught real defects the older grader-only gate could not see, and they are fixed before any store opens. The two that mattered: paid lesson text could fail to display after decryption (the sidebar read from disk instead of the decrypted pack), and in ExpectedFrontend the wipe-on-leave for decrypted paid content existed but was never wired in, so working copies outlived the lesson. Both now have per-lesson proof in CI on all three systems.

ExpectedC 0.1.1 - cross-platform debugging2026-07-16live

The git mastery pack is now in every owner's edition - the fifteen lessons built on 2026-07-10 ship in this update, the git track grows 22 to 37, and the product stands at 186 lessons. This is the first proof of the promise: buyers get every update to their edition free.
The debug track now walks green on all three operating systems. macOS launches the correct debugger - lldb on Apple Silicon, where gdb has no working port - so breakpoints, stepping, inspection and the graded checks all work on M-series Macs.
Buyer fix: on Windows the Check button could hang or report a false pass when the editor's file watcher was holding a lesson's results file. The pre-check cleanup now retries instead of aborting the run. If you saw a check stall on Windows, this is why - and it is fixed.
Honesty, not breakage: the debug lessons that can only run on Linux-only tooling - valgrind leak-hunting, the AddressSanitizer and UBSan lessons, core-dump forensics - now declare the systems they cannot run on and point you to Linux or WSL up front, instead of appearing broken on Windows or macOS.
Under the hood: CI now opens the shipped extension and walks every lesson as a learner on Linux, Windows and macOS - not just the grader gate - so a lesson that misbehaves in the real editor fails the build.

ExpectedDevOps all nine tracks built2026-07-11in development

The curriculum is complete: 146 of 146 lessons built and proven - troubleshooting (18), Docker (20), git for delivery (14), CI pipelines (24), Kubernetes (24), Helm and GitOps (14), Terraform (16), the enterprise stack (6) and the ship-it capstone (10), plus the free Lesson 0. The first hundred landed in one overnight run; the final forty-six - Helm, Terraform, enterprise and the capstone - landed later the same day. Every lesson grades against the real thing and lands only after its planted fault fails and its reference solution passes.
Built is not the same as reviewed, so every lesson also went through a two-stage review: one pass on the teaching, one on the grading - with the obvious cheats attempted live against the graders. Where a shortcut beat a grader, the grader got stronger: the bad-replica lesson now pins the healthy pods' identities, so deleting everything and letting the Deployment quietly recreate it fails, and only the surgical fix passes.
Honest notes, because the review machine exists to catch us too: one CI lesson had drifted off its brief - built as a leaked-secret exercise when the syllabus promised the stale-cache-key postmortem - and was caught and rebuilt as designed. And the Docker names-versus-identities lesson originally graded facts that could vary with the state of your local image store; it was reworked to grade store-invariant identity facts only. Transparency is the product.
What remains before this ships: the full verification pass across operating systems, then the release gate - proven, then promised, in that order.

ExpectedDevOps five tracks built2026-07-11in development

100 of the 146 planned lessons are built and proven: troubleshooting (18), Docker (20), git for delivery (14), CI pipelines (24) and Kubernetes (24). Each lesson grades against the real thing - the real Docker daemon, a real local Kubernetes cluster, real workflow runs, real git history - and lands only after its planted fault fails and its reference solution passes.
The CI track ends in Jenkins literacy: reading a real Jenkinsfile cold, fixing a broken one, and translating one to a modern workflow - because that is the pipeline the large shops actually run.
Helm and GitOps, Terraform, the enterprise stack and the ship-it capstone are still building. The full per-OS posture check comes before anything is sold, the same standard as the rest of the family.

ExpectedPython three-OS matrix, git mastery and first run2026-07-11ci green

ExpectedPython went through the full three-OS gate: all 181 lessons run green on Windows, macOS and Linux in one matrix - real Postgres and Redis provisioned natively on the Windows and macOS legs, Docker-real on Linux, the same SQL and the same assertions on every OS. The product now stands at 180 marketed lessons, all CI-tested.
The fifteen git mastery lessons land here too: the git track grows 22 to 37, graded by pytest and the real git CLI reading your actual repository - plumbing, worktrees, signed work, history surgery and the inherited-repo capstone. Day-one buyers get the full track, no waiting for an update.
First run comes with it: a Start-here Lesson 0, an activation check that names any missing tool, a VS Code walkthrough and a one-click Prepare sandbox button. The Start lesson is bundled free and does not change the lesson count.
The matrix earned its keep. That first run caught four latent portability bugs that only a real second and third OS could surface: a merge that assumed a configured git identity, a trio of BSD-sed incompatibilities in the mac solves, a hash thrown off by Windows line-ending translation, and solves that assumed an interactive editor the CI runners do not have. All four fixed the same night - that is exactly what the matrix is for.
Honesty note: in review we found that the repository's VSIX staging folder had been carrying the full paid curriculum since the project was first set up. It was caught before a single VSIX was ever published - no paid content ever left the building - and the staging folder is now excluded from packaging. We would rather tell you we found it than have you wonder if we look.

ExpectedDevOps 0.0.1 - in development2026-07-11dev

The fifth product is under construction. The shared engine, grading tools, exporter and environment doctor are built and reviewed; seven risk spikes proved the grading mechanisms against the real tools - Docker layer caching, OOM kills, local workflow runs, a shared local Kubernetes cluster, YAML and Jenkinsfile structural readers.
The first lesson is proven end to end: a planted dying container, diagnosed by reading docker ps, logs and inspect, graded by the real daemon. Stub fails, solution passes, no residue - the same standard as every other product.
146 lessons planned across nine tracks, troubleshooting first. Lessons appear on the product page as they are built and proven.

ExpectedJava three-OS matrix2026-07-10ci green

Expected Learning for Java's first full matrix run: the entire 180-lesson gate CI-green on Windows, macOS and Linux in one pass - real Postgres, Redis and RabbitMQ provisioned natively on the Windows and macOS legs, Docker-real on Linux. Same SQL, same listeners, same assertions on every OS.
The run earned its keep: the Windows leg exposed a package-manager dependency conflict in our RabbitMQ provisioning (a newer Erlang blocking the pinned one). Fixed, re-run, green.

First run - the product now teaches itself2026-07-10built

ExpectedFrontend, ExpectedC and Expected Learning for Java now guide you from a cold install. On activation the extension checks your environment - the language toolchain, git, and anything a track needs - and tells you what is missing before a lesson can trip on it.
A new Lesson 0, "Start here", explains how the whole thing works: open a lesson, edit, run the check, earn the coach. It is bundled free and does not change any product's lesson count.
A VS Code walkthrough walks you through the same first steps in the editor's own onboarding panel, and a one-click "Prepare sandbox" button sets up a lesson's working files so you are never staring at an empty folder.
Honesty note: while building this we found a coach bug. A lesson whose hints were stored in an older list format could, after your first failed check, hand back the full solution instead of the first hint. It was present in every product and is now fixed in every product - the coach reveals one step at a time again, as intended.

ExpectedFrontend three-OS matrix2026-07-10ci green

Through the full three-OS gate including macOS: all 148 gradeable lessons verified stub-fails-solution-passes on Windows, macOS and Linux CI in one run - the 37-lesson git track included.
The run also caught and killed a ten-year-old class of bug (BSD sed) in three original lessons. That is what the matrix is for.

ExpectedJava git mastery2026-07-10built

The fifteen git mastery lessons are built, reviewed and CI-proven for Expected Learning for Java too - graded by JUnit and JGit reading your actual repository, with the real git CLI where the object store demands it. The git track grows 22 to 37; the product stands at 180 lessons.
Expected Learning for Java launches with them included - day-one buyers get the full track, no waiting for an update.

ExpectedC git mastery2026-07-10shipped in 0.1.1

Fifteen new git mastery lessons are built, reviewed and CI-proven for ExpectedC - plumbing and truth, repo surgery, signed work, senior rescue, and an inherited-repo capstone. The git track grows 22 to 37.
They ship free to every ExpectedC owner with the next content update, alongside per-OS lesson text - buyers get every update to their edition free, and this is the first proof of it.

ExpectedFrontend 0.2.0 - git mastery2026-07-09built

The git track goes to the metal: 15 new mastery lessons, 22 to 37, across five stages - plumbing and truth, repo surgery, automation and trust, senior rescue, and an inherited-repo capstone briefed by symptoms only.
Most courses stop at rebase. This track ends with you building a commit by hand - and rescuing the reverted merge that "shipped" nothing.
Every lesson graded from real repository state by git itself: plumbing output, refs, trees, hook exit codes, signature verification. Stub-fail and solution-pass proven per lesson, on Linux and on Windows.
Product totals: 165 lessons, 148 carrying CI solvability proofs; the free tier is unchanged.

Cross-platform2026-07-08proven on C

One universal extension per language, built to grade identically on Windows VS Code, WSL, Linux and macOS - no separate downloads, no "which version".
Every grader now runs without a shell: the engine spawns each language's own tools directly, so native Windows needs no Unix layer.
Memory errors - use-after-free, overflow, double-free - graded natively on every OS by AddressSanitizer. Leak-hunting by each platform's own tool: valgrind on Linux, Apple's leaks on macOS.
Lesson text adapts to the machine: Windows paths and commands on Windows, WSL on WSL, macOS on macOS - no mismatched commands to translate in your head. The work only real Linux tooling does - POSIX systems programming, and the deepest memory analysis (leak-hunting on Windows, uninitialized-read detection) - runs in WSL, the real valgrind and syscalls those lessons teach.
Held to a three-OS test matrix: a lesson that grades differently on any OS fails the build. The native-Windows claim ships for a language only once its matrix is green.
ExpectedC is the first through the gate: all 171 lessons verified green on Windows, macOS and Linux. Java, Python and Frontend follow the same template.

ExpectedC 0.1.02026-07-08live

Lesson text renders native per OS from one source: Windows, WSL, macOS and Linux readers each see their own paths, commands and tools. WSL-gated lessons guide you there with a soft-lock banner up front instead of failing mysteriously.
ExpectedC takes the launch lead: the first Expected Learning product to ship live - the cross-platform matrix made it the natural flagship.
The full curriculum exists: 171 lessons across nine tracks, every one CI-proven solvable before shipping.
Cross-platform, proven not promised: one build verified green on Windows, macOS and Linux CI - build once, prove three times, ship one. Sold for Windows, WSL and Linux today; macOS ships the moment it is verified on real Apple hardware.
Real tools grade real work: gdb over the Debug Adapter Protocol, AddressSanitizer natively on every OS, valgrind on Linux, Apple's leaks on macOS, real make and CMake, core-dump forensics.
Honest about the metal: the systems track and valgrind-class deep analysis run in WSL on Windows - the same real Linux the lessons teach, and the extension says so up front.
Graded by expected_test.h - a single-header C harness that emits the same JUnit the rest of the family reads.
Free tier: 24 lessons bundled with the extension. Full edition: one-time purchase, all 171 plus updates. Answers shipped encoded - the same standard as Java and Python.

ExpectedFrontend 0.1.02026-07-07in development

150 lessons across eight tracks, debugging first: the JS debugger built into VS Code, node:test, real TypeScript via tsc, and a faithful zero-install React runtime.
No extension dependencies and no package installs - the whole toolchain ships with Node and VS Code.

ExpectedPython 0.1.02026-07-06built

The full curriculum exists: 165 lessons across eight tracks, every one CI-proven solvable before shipping.
Real tools grade real work: a live debugger, real Postgres and Redis, real git, pytest and FastAPI - no simulators.
A dedicated pytest testing track, a FastAPI API track, and a Celery, asyncio and Redis advanced-backend track.
Tracks ordered by learning magnitude: debugging first (the flagship), infrastructure last - you operate code only after you can build and test it.
Free tier: 20 lessons bundled with the extension. Full edition: one-time purchase, all 165 plus updates.
Same license-key activation as Expected Learning for Java - built once in the shared engine, inherited by every product.

ExpectedJava 0.1.02026-07-05launching soon

The platform exists: 165 lessons across eight tracks, every one CI-proven solvable before shipping.
Concurrency (virtual threads included), file IO, java.net.http and Maven literacy included from day one - no waiting for a version two.
A dedicated testing track: JUnit, AssertJ, fixtures, parameterized tests and Mockito - first test to a TDD capstone, ten lessons.
Live debugger grading: goals tick from your actual debug session over the Debug Adapter Protocol.
SQL graded by real Postgres with row-level diffs; Git graded by reading your actual history.
Free tier: 22 lessons bundled with the extension. Full edition: one-time purchase, all 165 plus updates.
Answers, explanations and hints ship encoded - earned through the coach, never browsed.
License-key activation for the full edition: 2 machines, monthly re-check, offline-tolerant. Refunds deactivate the key.
Progress export and import, environment doctor script, devcontainer for one-command setup.

Planned after launchorder set by your feedback

Drill mode: passed katas return cold weeks later - spaced repetition on real tools.
ExpectedFrontend is built, CI-tested on three OSes, and queued behind Java and Python.

Buyers get every update to their edition free - that is a pledge, not a promo.