Stay Practiced / Technical reference
Technical wiki
What is included, how it works, what the evidence means, and where the boundaries are. A source-backed reference for choosing and using the system.
20 subjects · 400 ordered units · 27,224 distinct subject practice fixtures · 6 free projects · 17 authored security labs across 2 separate tracks
01 / Reference
Curriculum inventory and counting rules
Twenty subject courses each contain twenty ordered units. A unit is an instructional sequence, not one exercise. Connected lessons can supplement a unit, and the practice library supplies additional targeted tasks. Frontend, Backend, Middleware and Architecture are independent subjects; React and Angular are alternatives, not prerequisites for each other.
The table counts distinct learner-visible fixtures from the authored inventory. Tests, assertions, skill tags and repeated attempts are not additional practice items. Non-coding activities, executable tasks, modeled simulations and Gym implementations remain separate categories. Deterministic variants are counted as fixtures, not as individually authored lectures. Security labs and project missions have separate catalogs and are excluded from these totals.
Every twentieth unit has a cumulative assignment with deliverables and an independent change. An assignment brief is not proof that its wider production system has been built. A supplied harness establishes its declared contract; architecture choices, original regressions and deployment claims can still require human review. Volume establishes available practice, not empirical teaching effectiveness or professional certification.
| Subject | Units | Lessons | Activities | Executable | Simulations | Gym | Total |
|---|---|---|---|---|---|---|---|
| JavaScript: beginner to production | 20 | 34 | 171 | 92 | 0 | 1,000 | 1,263 |
| TypeScript: contracts at scale | 20 | 34 | 188 | 78 | 0 | 1,000 | 1,266 |
| Python: beginner to production | 20 | 33 | 174 | 92 | 0 | 1,000 | 1,266 |
| SQL: data reasoning to production | 20 | 26 | 676 | 605 | 0 | 0 | 1,281 |
| Frontend engineering | 20 | 26 | 1,550 | 0 | 89 | 0 | 1,639 |
| React application engineering | 20 | 26 | 189 | 78 | 0 | 1,000 | 1,267 |
| Angular application engineering | 20 | 26 | 192 | 76 | 0 | 1,000 | 1,268 |
| PHP: requests to reliable services | 20 | 48 | 190 | 78 | 0 | 1,000 | 1,268 |
| Backend reliability engineering | 20 | 26 | 1,991 | 1 | 76 | 0 | 2,068 |
| Middleware and integration engineering | 20 | 26 | 1,798 | 1 | 77 | 0 | 1,876 |
| Software architecture under change | 20 | 26 | 1,187 | 31 | 45 | 0 | 1,263 |
| LLM and RAG engineering | 20 | 20 | 1,282 | 44 | 0 | 0 | 1,326 |
| Agentic programming | 20 | 20 | 1,282 | 40 | 0 | 0 | 1,322 |
| Node.js service engineering | 20 | 26 | 186 | 80 | 0 | 1,000 | 1,266 |
| Go: systems and services | 20 | 48 | 180 | 83 | 0 | 1,000 | 1,263 |
| Rust: ownership to reliable systems | 20 | 48 | 177 | 86 | 0 | 1,000 | 1,263 |
| C: memory, representation and systems | 20 | 48 | 182 | 81 | 0 | 1,000 | 1,263 |
| C++: value semantics to concurrent systems | 20 | 48 | 188 | 80 | 0 | 1,000 | 1,268 |
| C#: applications and asynchronous systems | 20 | 48 | 180 | 83 | 0 | 1,000 | 1,263 |
| ASP.NET Core service engineering | 20 | 26 | 188 | 77 | 0 | 1,000 | 1,265 |
02 / Reference
What happens inside a learning unit
The connected route uses five phases: understand the concept and worked trace; commit a prediction before observing execution; implement a guided contract; attempt an independent contract; return for review. Explicitly reviewed pairs identify a retained capability and a changed demand. Other catalog matches are labeled suggested independent practice and do not claim an authored transfer relationship. Prerequisites name the knowledge needed for the next decision. Small novice tasks expose one result at a time; advanced work combines constraints, failures and boundaries.
Placement is evidence-led: read a result, write a behavior, and diagnose a counterexample. Declaring experience supplies a starting preference, not demonstrated mastery. The workbench asks for a prediction, editable implementation, run/check result and explanation. A missing compiler or disconnected runner is an environment problem, not a failed skill demonstration.
Progressive hints are deliberate assistance. A worked answer helps explain the mechanism and marks the attempt as assisted. Where authored for the selected wrong answer, misconception remediation narrows the explanation before retrying the original task; the retry remains assisted evidence. Repeatedly clicking a familiar answer does not replace implementation or transfer. Course completion, theory activity completion and executable evidence are tracked as different records.
Back to contents03 / Reference
Grading, assistance, retention and uncertainty
Execution checks compare the current implementation with authored behavior, including boundaries and failure cases. Evidence binds problem/version, language, mode, assistance and tested concepts. Workspace and security receipts also bind the submitted revision and relevant source/request identities. Editing after a run makes that evidence stale for the new draft. Merely opening a lesson or following a link cannot manufacture a pass.
Starter completion supports application and recognition. Blank-page work supports recall; a dedicated bug fix supports debugging; authored joint tests support composition. An incidentally corrected failure supplies weaker debugging evidence. Knowledge predictions must be committed before the result is revealed. Trace use is an instrument; documentation, hints and solution exposure are assistance. Outside help cannot be detected reliably and should be declared.
Learning model 2 preserves older model-1 observations under their original interpretation. Scores are training estimates with limited support, not calibrated confidence intervals. One successful task is weak evidence; new attributable failures can change a mature estimate. Language-specific mastery stays separate even when canonical Gym problems connect practice across languages.
Durable retention requires independent production at least one day after the relevant exposure. Executions and assistance reset exposure timing; opening an unexecuted exercise does not become a failed retention test. The review ladder is 1, 3, 7, 14, 30, 60 and 120 days. Clean delayed recall can advance one verified rung; same-day repetitions do not push the coding review farther away. Recommendation factors expose their reasons.
Changed-situation delayed review currently covers one selected lesson in each of the twenty subjects, with two separately authored questions per lesson, reserved outside immediate practice and remediation. The other 380 primary units have an explicitly labeled familiar-question revisit: recognizing the original answer is not evidence of solving a changed problem. The course separates these two question-review counts from unaided coding transfer. Even the changed set repeats on subsequent visits; it is not a supply of continually novel assessments.
Each later question becomes eligible at least a day after independent practice and its last recorded answer or feedback. A wrong answer followed immediately by a correct answer cannot manufacture delayed evidence. A partial review resumes only the remaining eligible questions; already checked answers do not postpone other questions. This timing uses recorded activity, not a claim to detect unrecorded reading or outside help.
Retired low-value question families remain in raw backup history but no longer contribute to current completion, mastery or review projections. A complete synchronized observation log can be replayed without their contributions. Older local journals sometimes contain only combined score snapshots: these cannot be exactly separated into retired and legitimate later evidence. In that case the application keeps the last identifiable clean estimate, preserves the original snapshots and drafts, and asks for fresh practice instead of inventing a recalculated score. Stats labels this uncertainty.
Back to contents04 / Reference
Final assignments: what to run, retain and review
Each course ends with its own cumulative assignment. Expand a subject for the available implementation, required runtime, artifacts to keep, behavior to observe and reasoning to review. These requirements are part of the existing final unit, not extra activity counts or automatic completion credit.
Connected coding checks run bounded contracts. Connected workspaces inspect actual files and the declared browser or repository behavior. Build-and-review assignments require you to construct the larger feature and retain evidence; their briefs do not imply that a complete framework host or production integration is installed. A helper, a simulated schedule, a server-rendered snapshot and a mounted interaction establish different things.
Run the connected coding assignments from the final lesson, or use its Open project workspace action when available. Keep the source revision with results and disclose assistance. For an authored integration, build the stated harness and use this checklist with the assignment milestones and review rubric. Native toolchains require Plus/Pro local pairing or Pro offline; Web does not connect to local compilers.
Connected coding checks · separate final review
The reading-queue coding assignment runs five modules against supplied storage and view adapters in the browser JavaScript runner.
Runtime to use: Use that adapter harness for the assessed queue. A claim about actual focus, layout or cross-device persistence needs a separate browser or service integration.
Keep these artifacts
- Export the current five-module source and personally written cancellation regression.
- Keep the failing-before and passing-after test output with the corresponding source revision.
Observe the behavior
- Start two imports; resolve the older one last and show that its success and failure cannot replace current state.
- Cancel before publication, then cancel after publication; record the different queue and cleanup outcomes.
- Reload saved data through the adapter, including an old schema and a failed write.
Defend the result
- Trace the owner of each import and explain why aborting work and preventing publication are separate obligations.
- Attempt the changed cancellation requirement without generated implementation; disclose hints and compare the current diff with the regression.
Connected coding checks · separate final review
The reservation-library assignment compiles strict consumer fixtures and runs validation, migration, batching and publication tests.
Runtime to use: Use the supplied TypeScript compiler and local publication callback. A deployed database requires a separately tested adapter and transaction boundary.
Keep these artifacts
- Export library sources plus an accepted consumer and a deliberately rejected consumer.
- Record compile diagnostics and runtime results for the same revision, including the changed conflict/retry result.
Observe the behavior
- Show invalid wire data rejected before creating a domain value; mutate the input afterward to test ownership.
- Compare touching half-open reservations with an actual overlap and verify batch order.
- Force storage failure and schedule conflict separately; inspect the consumer branch selected for each.
Defend the result
- Explain what the compiler establishes and why runtime validation is still necessary at the wire boundary.
- Defend the public compatibility change using a fresh consumer, without a cast that bypasses the result contract.
Connected coding checks · separate final review
The telemetry-pipeline assignment runs Python in Pyodide with an in-memory ReportStore and controlled async/resource fixtures.
Runtime to use: Use browser Python for the bounded pipeline. Real files, remote enrichment or a distributed store need separate adapters and measurements; no local Python install is required for the connected checks.
Keep these artifacts
- Export parser, aggregation, enrichment and publication modules with the changed time-window regression.
- Retain a one-pass input trace, cleanup trace and report snapshot for a single source revision.
Observe the behavior
- Fail a late input row and show that no partial report replaces the last complete publication.
- Control async completions to measure the enrichment bound and confirm every owned child settles after cancellation.
- Exercise acquisition, processing and cleanup failures separately, preserving the promised primary error.
Defend the result
- Explain the owner of input consumption and publication, including why retry cannot silently reread a one-shot iterator.
- Implement boundary timestamps and unknown-device grouping from the fresh brief; explain a rejected off-by-one alternative.
Build-and-review assignment
Course queries run on browser SQLite. The complete lending database is an authored build-and-review assignment, not an installed application or automatically graded migration.
Runtime to use: Create a disposable SQLite database and name its version and transaction schedule. Claims about another engine require that engine; local toolchains belong to Plus/Pro.
Keep these artifacts
- Submit schema, seed data, queries, migration and rollback/recovery scripts.
- Save expected tables and actual query results, plus an EXPLAIN QUERY PLAN result for any plan claim.
Observe the behavior
- Distinguish title, copy and loan identity with duplicate titles and members who have no loans.
- Interrupt migration and retry it against the recorded starting schema; show retained loan history.
- Schedule competing checkouts explicitly and inspect both returned results and committed rows.
Defend the result
- Explain NULL, duplicate and tie-order behavior from actual rows rather than a query screenshot alone.
- Solve the changed overdue-period report with a new boundary fixture; do not infer production isolation or throughput from SQLite checks.
Connected workspace · separate final review
The appointment workspace runs seven React/RiskLab browser missions with DOM, focus, storage and asynchronous checks.
Runtime to use: Use the actual browser workspace and disposable response adapter. Keyboard, focus and layout observations require rendered controls, not a policy function.
Keep these artifacts
- Export the appointment feature and a learner-written regression for draft recovery and removal.
- Keep current-revision browser results plus a keyboard/focus trace and the relevant storage snapshots.
Observe the behavior
- Complete the form using the keyboard, correct a validation error and verify the intended focus target.
- Resolve an older submission after a newer edit; confirm current input survives.
- Reload an interrupted draft, then confirm submission and reload again to verify contact data is removed.
Defend the result
- Explain the distinction between a local draft and server-accepted work; inspect labels, error associations and announcements.
- Evaluate the changed retention policy and a narrow/long-content interaction without claiming universal accessibility certification.
Build-and-review assignment
The incident-triage final feature is a build-and-review assignment. Individual React exercise checks apply only to the runtime and interaction stated in their own contracts.
Runtime to use: Mount real React/RiskLab components in a browser with controlled data completions. Pure helpers, a scheduler model and server rendering do not establish effect cleanup, focus or mounted identity.
Keep these artifacts
- Submit feature components, the deterministic adapter and mounted interaction tests.
- Record source revision, renderer/runtime and event/completion order for each regression.
Observe the behavior
- Edit one incident, reorder/filter the list and inspect which stable identity retains the draft.
- Switch workspaces while details are pending; resolve the old request after the switch and inspect the visible current detail.
- Unmount/remount or replace the owner and observe subscription cleanup and exactly the intended active listeners.
Defend the result
- Trace domain identity, component identity and async publication ownership separately.
- Implement the fresh two-workspace requirement and demonstrate that equal incident IDs cannot share drafts across workspaces.
Build-and-review assignment
Current Angular course exercises run their declared TypeScript policy contracts. The complete inventory feature, rendered template and DI/router integration are not automatically established by those checks.
Runtime to use: Build and mount a real Angular host with RiskLab controls, configured providers, forms and router. A native build toolchain requires Plus/Pro; Web policy checks are not that host.
Keep these artifacts
- Submit component/template, provider configuration, routes, deterministic service adapter and real-host tests.
- Record provider instance identities, navigation events and subscription/disposal evidence for the current revision.
Observe the behavior
- Mount two warehouse features and compare intentionally shared services with independent correction drafts.
- Change warehouse or traverse Back while a request is pending; complete it late and inspect route, form and stock state.
- Dispose one feature and confirm its subscriptions stop while the other feature remains usable.
Defend the result
- Explain where provider scope owns each state value and why a modeled stream cannot prove DI lifetime.
- Defend the changed two-instance requirement from host observations, including a counterexample to accidental singleton draft state.
Build-and-review assignment
Browser PHP exercises check their declared functions in WebAssembly. The request-to-database ledger remains a separately built service assignment.
Runtime to use: Use a real PHP request host, disposable database and controllable transaction adapter for the complete ledger. A local host/toolchain requires Plus/Pro; browser function checks do not create it.
Keep these artifacts
- Submit request decoding, authorization, transition and persistence modules with database schema.
- Keep actual HTTP/status receipts, committed rows and failure-injection results for the same revision.
Observe the behavior
- Send malformed and unauthorized requests and prove that neither writes a ledger row.
- Inject failure before and after commit, then retry the same identity and compare receipts.
- Schedule fulfillment against cancellation and inspect the winning state and preserved audit record.
Defend the result
- Identify the transaction owner and explain which failures are safe to retry.
- Implement the new cancellation transition and defend idempotence using durable rows, not only a successful response.
Connected coding checks · separate final review
The request-service capstone executes JavaScript with a supplied serialized snapshot adapter, including authorization, replay, concurrency, commit failure and restart.
Runtime to use: Use the deterministic local adapter for connected grading. The broader reservation/notification design needs its own model or implementation; a live HTTP/database service is a separately reviewed extension.
Keep these artifacts
- Export request-service modules, state-machine contract and current regression results.
- Submit the reservation/cancellation schedule and before/after durable snapshots for the broader assignment.
Observe the behavior
- Run the same operation identity concurrently and after restart; compare durable state and immutable replay receipts.
- Fail the commit and verify that acceptance is not reported for an unpublished state.
- For the changed reservation model, race partial cancellation with fulfillment and inspect capacity plus audit identity.
Defend the result
- Separate the checked debit-service contract from the broader reservation and notification claims.
- Defend the cancellation design, an alternative consistency choice and what a real database or external delivery test would still need to establish.
Connected coding checks · separate final review
The durable-transport capstone runs producer/consumer modules and serialized local snapshots with duplicate, gap, quarantine and restart checks.
Runtime to use: Use the supplied deterministic adapter for graded outbox/projection/cursor behavior. Broker interoperability and external effects require a separately implemented integration.
Keep these artifacts
- Export producer, consumer, schema decoder and persistence modules with current tests.
- Save event identities, acknowledgement/cursor traces and pre/post-restart snapshots.
Observe the behavior
- Deliver a duplicate, a gap and an unknown schema version; inspect projection, cursor and quarantine together.
- Fail publication at the projection/cursor boundary and restart from the last durable snapshot.
- For the fresh change, deliver a late old-generation completion after consumer replacement and inspect the new owner.
Defend the result
- Explain why receipt deduplication is not a proof of exactly-once external effects.
- Defend tenant deadlines and replacement recovery using the changed schedule and identify any broker-specific assumptions.
Build-and-review assignment
Architecture exercises and simulations evaluate declared bounded decision/model contracts. The warehouse migration is a review assignment, not a deployed distributed system.
Runtime to use: Use an inspectable state model, with browser Python when executable, and explicit failure schedules. Deployment, throughput and fault-tolerance claims need their own measured implementation.
Keep these artifacts
- Submit invariants, ownership/dependency diagrams, migration states and decision records.
- Keep one valid schedule and a counterexample for each consistency or recovery promise.
Observe the behavior
- Transfer ownership during a reservation and show which writer can commit at each state.
- Lose a migration acknowledgement and replay it without duplicating or erasing the reservation.
- During the changed regional-outage scenario, distinguish stale reads, denied writes and retained audit identity.
Defend the result
- Compare the original and changed requirements and identify which assumptions must be withdrawn.
- Defend availability/consistency tradeoffs with model states; name measurements needed before claiming production capacity or resilience.
Connected coding checks · separate final review
Connected projects run small neural training in browser Python/NumPy and bigram, causal-attention and authorized retrieval contracts in JavaScript.
Runtime to use: Use Pyodide and the browser JavaScript runner; no PyTorch, Hugging Face or local training toolchain is required. Deployed drift monitoring or open-ended generated-answer quality needs separate evidence.
Keep these artifacts
- Export model code, tokenizer/vocabulary, split identities, hyperparameters and a restorable checkpoint.
- Keep initial/final held-out loss, numerical-gradient comparisons and authorized retrieval/citation traces for the same revision.
Observe the behavior
- Train, observe actual parameter changes and restore the checkpoint; compare predictions and held-out loss against a baseline.
- Change an authorization scope and verify forbidden or expired documents cannot supply context or citations.
- Compute drift from named probability distributions separately from a release threshold decision; a changed metric is not a deployed monitor.
Defend the result
- Explain what is learned in weights versus retrieved at query time, and why held-out loss does not establish open-ended answer quality.
- Implement the fresh expiration/vocabulary change; distinguish retraining/refitting from reindexing and defend artifact compatibility.
Connected workspace · separate final review
The Agentic workbench runs real browser files, local Git operations, learner regressions, source/HEAD-bound receipts and reload recovery; assistant proposals are supplied fixtures.
Runtime to use: Use the project workspace for the bounded repository workflow. The stage-selection helper does not run tools, persist work or perform rollback. No hosted assistant account is needed.
Keep these artifacts
- Export the repository with learner tests, commits/diff and the allowed-change contract.
- Retain failing-before/passing-after receipts tied to source digest and Git HEAD, plus the post-reload evidence record.
Observe the behavior
- Reject a confident proposal with an unauthorized edit or missing regression; run the discriminating test against actual files.
- Modify code after a passing run and confirm the old receipt cannot authorize the current change.
- Reload between stages, inspect restored files/HEAD and demonstrate the next actual step rather than merely returning a stage name.
Defend the result
- Explain the selected plan, rejected proposal and recovery boundary; a nonblank rollback string is not a successful rollback.
- Implement the fresh ordering requirement personally, disclose assistance and inspect current tests plus diff before accepting the change.
Build-and-review assignment
Node course exercises use their declared native runtime. The complete feed service is an authored implementation assignment, not a browser-emulated server.
Runtime to use: Use Node through Plus/Pro local pairing or Pro offline with a disposable HTTP/stream/worker harness. Web can read the brief but cannot connect local toolchains.
Keep these artifacts
- Submit service, stream pipeline, publication adapter and owned worker/child code with controlled fixtures.
- Record request/result, byte counts, open handles and output-artifact identity for the tested revision.
Observe the behavior
- Slow the downstream consumer and observe bounded buffering rather than just correct final content.
- Disconnect a caller during processing and verify owned streams/workers settle without publishing partial output.
- Enforce the changed decompressed-size bound and cancel preview independently of the committed output.
Defend the result
- Trace each resource owner and distinguish response completion from committed publication.
- Defend the new byte boundary and cancellation scope using a fixture that defeats a compressed-byte-only check.
Build-and-review assignment
Go exercises execute native contracts. The complete directory indexer and race/resource evidence are learner-built final deliverables.
Runtime to use: Use a Go toolchain through Plus/Pro pairing or Pro offline, disposable files and controlled goroutine schedules; run the race detector where supported.
Keep these artifacts
- Submit indexer library, command, cancellation regression and deterministic I/O fixtures.
- Record compiler/runtime version, race-test output, resource counts and last-complete-index hash.
Observe the behavior
- Cancel with workers active and confirm every owned goroutine joins and acquired reader closes once.
- Fail midway through indexing and compare the published index with the last complete version.
- Use a one-pass bounded reader and distinguish oversize, cancellation and processing errors.
Defend the result
- Explain the ownership of channels, goroutines and publication; passing one schedule does not prove all schedules safe.
- Defend error-cause preservation and byte-budget behavior using the fresh fixture and a rejected replay-based design.
Build-and-review assignment
Rust exercises compile and execute their native contracts. The framed-record library requires a learner-built caller and I/O harness.
Runtime to use: Use Rust through Plus/Pro pairing or Pro offline with positive and compile-fail caller fixtures plus controlled short reads and I/O failures.
Keep these artifacts
- Submit the public library, callers, typed errors and framed input fixtures.
- Keep compiler diagnostics for rejected borrow escape and runtime results for owned records after buffer reuse.
Observe the behavior
- Split frames across read boundaries and distinguish incomplete input from a complete invalid record.
- Retain owned values after input-buffer reuse and confirm they remain unchanged.
- Attempt the changed zero-copy callback misuse and observe compiler rejection, then test the allowed ownership path.
Defend the result
- Explain which values borrow input and which can outlive it; diagnostics alone do not explain the API tradeoff.
- Defend failure and cleanup behavior and name any unsafe or external boundary outside the checked contract.
Build-and-review assignment
C exercises use native compilation. The complete archive reader needs explicit learner-supplied allocation, I/O and instrumentation evidence.
Runtime to use: Use a C compiler through Plus/Pro pairing or Pro offline with declared address/undefined-behavior instrumentation and disposable binary fixtures.
Keep these artifacts
- Submit format contract, reader API, allocation policy and fault-injection harness.
- Record compiler flags, instrumentation output and allocation/free counts for each failure boundary.
Observe the behavior
- Exercise maximum lengths, overflow and every truncated header boundary before reading payload memory.
- Fail each allocation after partial acquisition and prove all owned blocks are released.
- Supply short chunks inside each length-field byte and confirm the changed reader never treats them as complete.
Defend the result
- Trace one rejected pointer/length alternative to its specific out-of-bounds access.
- Explain what the instrumentation observed and avoid treating clean bounded fixtures as universal memory safety.
Build-and-review assignment
C++ exercises run their native contracts. The searchable archive is a separately implemented lifetime, exception and concurrency assignment.
Runtime to use: Use a C++ compiler through Plus/Pro pairing or Pro offline with suitable lifetime/memory instrumentation and controlled exceptions/concurrent readers.
Keep these artifacts
- Submit archive owner, view/range API, replacement operation and failure-injection tests.
- Keep compiler flags, instrumentation receipts and archive identity before/after failed replacement.
Observe the behavior
- Throw during replacement and show the accepted archive remains intact with all temporary resources released.
- Keep a reader active while replacing the owner and inspect the declared view validity rule.
- Use the changed lazy range with a throwing predicate and a temporary owner to expose the lifetime boundary.
Defend the result
- Explain whether each API returns an owned value or borrowed view and what invalidates it.
- Defend exception guarantees and traversal semantics; passing fixtures do not establish universal race freedom.
Build-and-review assignment
C# course exercises execute native contracts. The complete reconciliation pipeline requires the actual asynchronous enumerator and disposal harness.
Runtime to use: Use .NET through Plus/Pro pairing or Pro offline with one-pass IAsyncEnumerable fixtures, controllable tasks and observed asynchronous disposal.
Keep these artifacts
- Submit validation, reconciliation, serialization and publication code plus changed bounded-enrichment tests.
- Record enumeration count, disposal events, task completions and accepted summary identity for one revision.
Observe the behavior
- Distinguish null and zero, and prove that a one-shot async source is enumerated only once.
- Fail processing and disposal together and inspect the promised primary failure.
- Cancel with enrichment children pending; show the bound, stable input-derived order and joined ownership.
Defend the result
- Explain how enumeration, cancellation and publication owners interact without allowing late results to escape.
- Implement the new concurrent stage personally and defend its schedule with a regression that fails when a child publishes late.
Build-and-review assignment
ASP.NET exercises establish only their declared native contracts. The equipment-checkout feature needs a learner-built real request host and persistence integration.
Runtime to use: Use ASP.NET through Plus/Pro pairing or Pro offline with an actual test host, disposable database and observable request/worker dependency scopes.
Keep these artifacts
- Submit endpoint, binding, authorization, transition and persistence code with real-host tests.
- Keep request/status traces, committed rows and scope creation/disposal logs tied to the source revision.
Observe the behavior
- Send a cross-group request and inspect both rejection and absence of durable effects.
- Race checkout requests and disconnect a caller after commit; compare retry receipts with committed state.
- Transfer equipment between groups while checkout is pending, then shut down with worker work active and observe scope cleanup.
Defend the result
- Explain authorization at the actual decision point and distinguish request-scoped from worker-owned dependencies.
- Defend the fresh ownership-transfer rule and shutdown recovery from host evidence rather than pure authorization outputs.
05 / Reference
Six free projects and the files you keep
Make your own LLM and Agentic guardrails open without login, including direct lesson links. The four original JavaScript project editors retain the hosted passkey-account requirement. Those original four also have separate permanently free DLC editions with 200 activities each: 50 exercises, 25 code-practice activities, 25 challenges and 100 Gym activities. The two AI projects do not create DLC ownership or unlock their paid subject courses.
Project work is cumulative: the editor carries your current files forward, hints mark assistance, and recovery checkpoints are explicitly selected. Download current files exports your actual saved work, including unfinished code. It does not replace your implementation with the reference solution. Drafts live on the current device; exporting is how you keep a portable copy.
The language-model project teaches an actual small next-token neural model: a training-only tokenizer, learned embeddings, tanh hidden layer, softmax, SGD, finite-difference gradient checks, held-out loss and seeded sampling. Its saved JSON includes numerical weights, tokenizer, configuration and measured provenance. It has a short context and a narrow corpus; it is not an internet-scale or chat-capable LLM. The preview requires explicit Save before adding the model artifact to the project ZIP. An extracted app can load that JSON and generate without retraining.
Agentic guardrails develops a real editable app, regression cases, a scoped repair, review notes, CLAUDE.md and conservative settings. It teaches how to reject a plausible but incorrect proposal and preserve a handoff. Claude Code is an optional separate tool, with its own installation, account and provider terms. Completing the browser project does not claim that an external assistant ran or that a repository was deployed.
| Project | Missions | Browser access | Separate DLC activities |
|---|---|---|---|
| Lunar Lander — Your First JavaScript Game | 12 | Free passkey account on hosted site | 200 |
| Weather Reporter — Your First API App | 13 | Free passkey account on hosted site | 200 |
| Git Basics — Save, Change, Recover | 12 | Free passkey account on hosted site | 200 |
| Task Board — Your First JavaScript App | 12 | Free passkey account on hosted site | 200 |
| Make your own LLM | 15 | Free; no login | None |
| Agentic guardrails | 12 | Free; no login | None |
06 / Reference
Security tracks and the limits of their evidence
Application Security has four ordered units and twelve authored labs. Its L01 and L04 samplers require no login; the full track requires Web or higher. Security Research has two units and five authored labs for Plus/Pro. Seven additional guest/VM entries are planned and unavailable. They are not included in runnable-lab counts.
A lab begins with a fictional scenario and prediction, reproduces a forbidden effect, asks for a repair, then checks forbidden and legitimate behavior. Regression requirements can demand a case that fails on the original and passes on the repair. Explanation and incident narratives remain review artifacts where no semantic grader is claimed.
Runtime profiles name the fidelity: an isolated JavaScript handler uses structured inputs and fresh fictional state; isolated DOM work exercises actual browser behavior; SQLite and Wasm profiles run those engines; recorded analysis classifies supplied synthetic events. A browser marker is not evidence of a real account compromise. A Wasm bounds trap is not native code execution. The runner is an isolated origin and receives no account credentials or connector authority.
Guided MCP security links explicitly record assistance on the named lab draft. That classification persists and travels with later commands and receipts; it does not complete the lab. Public direct links without the assistance flag stay ordinary arrivals. Content entitlement is checked separately from runtime readiness, and a missing runner leaves saved learner work readable and exportable.
| Track | Units | Authored labs | Full track | Free samplers | Planned / unavailable |
|---|---|---|---|---|---|
| Application Security | 4 | 12 | Web, Plus, Pro | L01, L04 | 0 |
| Security Research | 2 | 5 | Plus, Pro | None | 7 |
07 / Reference
Where code executes and what each runtime establishes
Browser engines execute on your device. Python uses a bundled Pyodide worker; SQL uses SQLite through that Python runtime. Architecture boundary exercises reuse the Python engine. PHP uses a real PHP WebAssembly build and loads on demand. Script runtimes transform the declared source and execute the authored harness; AI numerical assignments can request the bundled NumPy runtime. Runtime assets are served from the application, not fetched from a third-party CDN during ordinary practice.
A simulation models a stated system. Passing a browser queue, transaction or service contract does not claim that a real broker, cloud deployment or production database was operated. React and Angular tasks test their declared component contract; a framework label alone does not establish a full deployed application. Check each task’s runtime and acceptance criteria.
Node.js, Go, Rust, C, C++, C# and ASP.NET Core coding use a paired local runtime or the Pro workstation with compatible tools. The connector asks for explicit pairing and scoped authorization. Runtime diagnostics distinguish entitlement, an installed toolchain and a ready execution provider. Requesting local execution never silently falls back to a browser engine. Native packages, compiler versions and machine limits can affect availability.
| Subject | Runtime / scope | Course access |
|---|---|---|
| JavaScript: beginner to production | Browser JavaScript; isolated authored harnesses | Free, Web, Plus, Pro |
| TypeScript: contracts at scale | Browser JavaScript after TypeScript transformation | Web, Plus, Pro |
| Python: beginner to production | Bundled CPython/Pyodide in a browser worker | Web, Plus, Pro |
| SQL: data reasoning to production | SQLite through the bundled Python runtime and SQL harness | Web, Plus, Pro |
| Frontend engineering | Interactive browser engineering simulations and workspace work | Web, Plus, Pro |
| React application engineering | Browser React exercises with the declared component/test harness | Web, Plus, Pro |
| Angular application engineering | TypeScript policy contracts in the browser; a real Angular host is a separate final-assignment requirement | Web, Plus, Pro |
| PHP: requests to reliable services | PHP compiled to WebAssembly; starts on first use | Web, Plus, Pro |
| Backend reliability engineering | Browser simulations and executable multi-file JavaScript service contracts | Web, Plus, Pro |
| Middleware and integration engineering | Browser simulations and executable multi-file JavaScript integration contracts | Web, Plus, Pro |
| Software architecture under change | Reading, simulations and executable Python boundary exercises | Web, Plus, Pro |
| LLM and RAG engineering | Browser JavaScript contracts; Python/NumPy for declared numerical assignments | Web, Plus, Pro |
| Agentic programming | Browser JavaScript contracts/workspaces; Python/NumPy where declared | Web, Plus, Pro |
| Node.js service engineering | Paired local Node.js runtime and declared packages | Plus, Pro |
| Go: systems and services | Paired local Go toolchain | Plus, Pro |
| Rust: ownership to reliable systems | Paired local Rust toolchain | Plus, Pro |
| C: memory, representation and systems | Paired local C compiler/toolchain | Plus, Pro |
| C++: value semantics to concurrent systems | Paired local C++ compiler/toolchain | Plus, Pro |
| C#: applications and asynchronous systems | Paired local .NET SDK | Plus, Pro |
| ASP.NET Core service engineering | Paired local .NET/ASP.NET Core toolchain | Plus, Pro |
08 / Reference
Plan boundaries, offline operation and per-device setup
Free includes the JavaScript practice boundary and the separately identified public samplers and projects. Web enables paid browser curricula, reading/reasoning subjects, browser simulations and cloud progress. Web does not authorize the local native connector. Plus adds that connector and native coding; Pro adds the offline workstation. An entitlement is permission, not proof that a compiler or runner is installed and healthy.
Paid plans include reading across the subject catalog; native execution still follows the Plus/Pro boundary. Application Security’s full track starts at Web, while Security Research starts at Plus. The free AI projects are specific public exceptions; they do not unlock all LLM/RAG or Agentic coursework. Current prices, taxes, purchase availability and billing conditions belong to Pricing and Terms, not to this technical snapshot.
Pro offline activation is per device. The signed lease binds device identity, account generation, audience, expiry and a content hash; workstation leases are bounded to at most 30 days and require renewal. Download and activation require connectivity. A browser cache is not the Pro offline workstation, and moving an installer does not move a valid activation or a native toolchain. Install, pair/activate and check runtime diagnostics on each computer you intend to use.
Exporting your own files is separate from subscription access to protected curriculum. Project ZIPs and explicit learner-work exports keep the allowed files; they do not copy paid reference solutions or remove entitlement checks. Owned expansion packs remain associated with the account after downgrade, while the current plan still determines which subjects and runtimes can be used. A pack purchase alone does not enable cloud sync.
| Plan | Browser subject IDs | Reading | Cloud progress | Local connector | Offline workstation |
|---|---|---|---|---|---|
| Free | 1 | JavaScript + public exceptions | Not included | Not included | Not included |
| Web | 12 | All subjects | Included | Not included | Not included |
| Plus | 12 | All subjects | Included | Included | Not included |
| Pro | 12 | All subjects | Included | Included | Included |
09 / Reference
MCP teaching, four public paths and authority boundaries
The public Streamable HTTP endpoint is /mcp/public. It needs no Stay Practiced login or API key. Four guided paths cover Make your own LLM, Agentic guardrails, and security samplers L01/L04. find_guided_paths returns an ordered outline and exact next tool call; project mission/hint tools and security lesson/hint tools provide one requested step at a time. The MCP learning page supplies copyable starting prompts and browser handoffs.
Public tools also expose authored Free JavaScript teaching, released daily challenges and project starter workspaces. They return public instruction, editable starters and bounded visible guidance. They do not read private progress, reveal paid answers, run your code on a server, write to your computer, purchase products or award completion. A client with its own file tools can create the offered local workspace only under that client’s authorization.
Authenticated coaching at /mcp is separate. It uses passkey-approved OAuth and scopes. Free/Web accounts receive Free JavaScript coaching; other member subject coaching requires Plus/Pro. Progress-summary access has separate consent. An external assistant account is not included in a Stay Practiced plan, and the assistant provider’s data policy applies to anything you share in chat.
The app contains no embedded generative assistant in ordinary practice. The small model project trains your own teaching model locally. A guided assistant visit is learning assistance, not independent evidence. To demonstrate independent retention, return to a fresh appropriately delayed task without that help.
Back to contents10 / Reference
Storage, privacy and account recovery
Source code, drafts, raw answers, predictions and compiler diagnostics remain on the learner’s device in the ordinary trainer flow. Browser storage uses IndexedDB with bounded fallbacks; the desktop progress store uses SQLite. Anonymous project drafts stay local. Clearing site data, changing browser profiles or losing a device can remove that work, so use exports for the files you need to keep.
Web/Plus/Pro cloud continuity sends bounded learning evidence: exercise and skill IDs, versions, timestamps, assistance flags and numeric completion metrics. It reconstructs progress, not the source files or raw answers. Signed-in stores are scoped to account identity and generation; anonymous work is not silently merged into an account. Free and anonymous practice do not gain cloud sync from a project or pack download.
Accounts use passkeys, with no name, email or password requested at registration. The authenticator keeps its private credential; the service stores public credential metadata and account/session records. Recovery codes are private, shown once and verified using stored verification data. Account recovery requires replacement credentials before ordinary protected access resumes.
The trainer does not add behavioral advertising or analytics. Hosting and payment providers still receive the network/payment information needed for their services; that differs from a promise of no network metadata anywhere. An external assistant sees what you send to it. Privacy describes retention, deletion and provider boundaries, and Terms defines the service conditions.
Back to contents11 / Reference
Portable artifacts, backups and evidence exports
A project download preserves current filenames and content within the export policy. The model artifact bridge accepts a bounded JSON object under model/, ties it to the current preview revision and asks you to save it explicitly. Cancel or stale-source rejection does not replace your files. A confirmed save persists exact content before the preview receives a success receipt; download then includes that saved artifact.
Security learner-work exports keep your permitted repair, reproduction, regression, finding and prediction files. Authored baselines, private fixtures and worked repairs are not exported as learner-owned answers. A downgrade can remove execution permission while preserving the ability to read and export existing permitted work.
Progress backup and study export serve different purposes. A study export is an explicit local download with a new study-specific identifier and a fixed numeric/identity whitelist; it excludes source, raw prediction text, account/device IDs and diagnostics. Imported marked holdouts do not raise mastery or train recommendations. Neither a local exported file nor a browser test is a tamper-proof examination certificate.
Back to contents12 / Reference
Implementation architecture and trust boundaries
The interface is React with RiskLab primitives and source-controlled style rules. Content authoring, generated public metadata, protected content delivery, runtime execution, evidence admission and progress projection are separate layers. The browser chooses a permitted ready runtime using capabilities such as execute, test, trace, format, lint and diagnose; availability is not inferred from a course title.
Project previews run in a restricted iframe with bounded source instrumentation, timers and message validation. Saved artifact requests must match the live preview and current revision. Security labs use a separate isolated runner origin, validated messages and operation-specific receipts. Local native execution crosses the explicitly paired connector boundary. These isolation layers limit what a teaching task can do; none turns arbitrary externally edited code into trusted production software.
The hosted service uses Cloudflare for delivery and account infrastructure, passkey authentication, signed content/entitlement metadata and provider-managed payments. Private content delivery and member MCP authorization are enforced independently of public catalog visibility. Public metadata names scope and counts without shipping paid exercise bodies, hidden checks or answer keys.
Back to contents13 / Reference
Accessibility and practical operation
The interface uses semantic headings, labels, keyboard actions, visible focus, status messages and a skip-to-content link. The wiki has section anchors and keyboard-focusable scrolling tables. Workbench controls support a simpler editor and adjustable panes so reading, editing and results can be used without relying on a single dense layout. Theme and motion preferences are available through the shared interface.
A browser and keyboard are the basic tools, but task prerequisites still matter. The language-model project expects JavaScript functions, arrays, loops and basic algebra; Agentic guardrails expects basic JavaScript objects, arrays and functions. Runtime diagnostics, readable error messages and local recovery are part of the workflow. These features describe implemented support, not a blanket accessibility certification or a claim that every device has been audited.
Back to contents14 / Reference
Credits, source provenance and verification
Stay Practiced is authored by Ryan P. Walsh. Bundled components retain their own licenses, including React, Monaco/Codicon, Dagre, Pyodide/Python packages, NumPy, esbuild, PHP WebAssembly, Electron and SQLite. Exact dependency versions and license notices are recorded in the lockfile and distributed third-party notices. Interface text uses system fonts.
The Lake Chelan background photograph was supplied by the site owner and identified by the owner as National Park Service imagery. An individual photographer and original NPS URL were not supplied. That attribution is not a software or curriculum license and implies no NPS endorsement.
This page is generated from a compact public snapshot of the curriculum inventory plus named product, runtime, evidence and privacy sources. Its JSON lists SHA-256 hashes of those exact local source files and a combined snapshot digest. The hash makes changes inspectable; it is not a third-party audit, a certification or proof of deployed runtime health. Rebuilding the wiki updates counts without bundling the full lesson inventory into this page.
Back to contents