Keep ownership visible.
Choose a container →Separate an owning sequence from a borrowed view, then check the lifetime and invalidation contract.
Programming courses & practice
Work through lessons, coding exercises and projects in C++, Python, SQL, Git, Bash and Lua.
THE PRACTICE LOOP
SEE THE CONTRACT
Separate an owning sequence from a borrowed view, then check the lifetime and invalidation contract.
Move the same predicate between ON and WHERE and inspect the rows that remain.
Distinguish stored objects, reference names and working edits before deciding what can be recovered.
NEW TO PROGRAMMING?
Never written a program? Pick a language and begin here. Each of these courses opens with six short lessons that take you from printing one line to a complete interactive program: output, variables, input, decisions, loops and functions. If you have no preference, choose Python.
CHOOSE A STARTING POINT
Start with the fundamentals, or pick the tool you want to get better at. Each course shows what to learn first. Python, SQL, Git, Bash and Lua have their own learning sequences.
Start from zero with your first C++ programs, then learn values, ownership and generic code and apply them to containers, algorithms, concurrency and native systems.
Start from zero with your first Python programs, then learn objects, functions and reliable data handling and work toward numerical experiments, NumPy, PyTorch and empirical evaluation.
Query real tables and reason about NULLs, joins, grouping, windows, transactions and indexes with runnable SQLite exercises.
Work with real repository history: staging, branches, conflicts, remotes, rebase, recovery, worktrees and bisect.
Start from zero with your first scripts, then make arguments, quoting, streams, pipelines, files and processes work together in dependable shell programs.
Start from zero with your first Lua programs, then learn values, tables, functions and modules before exploring metatables, iterators, coroutines and resource cleanup.
Make the bits make sense. Learn binary, hexadecimal, one’s complement and two’s complement, with diagrams and practice.
Number foundations →BUILD ON THE FUNDAMENTALS
Go further with Go or JavaScript, or bring your Python and SQL foundations into focused courses. Every course names its prerequisites and ends with a graded project.
Understand HTTP exchanges and build deterministic URL, JSON, pagination and retry-policy tools over supplied offline responses.
Design small Python programs with real classes, explicit ownership, stable interfaces and dependable failure behavior.
Extend Python functions and iterators into reusable, deterministic data transformations.
Turn messy CSV and JSON into validated records, safe joins and an auditable sales report using Python's standard library.
Parse local HTML, resolve and classify URL references, and produce deterministic link reports in Python.
Go from a first program: a starter unit for complete beginners, then typed values and shared slices through explicit errors to a deterministic JSON log-summary capstone.
An independent Node.js language course that starts from zero, from a first program and explicit values to a tested local data CLI.
Package and review a tiny Python service through processes, images, build inputs, argv, ports, configuration, storage and lifecycle. Graded work uses honest offline fixtures.
Design durable relational schemas with native SQLite keys, dependencies, integrity, migrations and order-level reports.
Reason about request, identity, data and output boundaries with deterministic Python policy fixtures and real in-memory SQLite.
Investigate structured logs, metric support and trace fixtures; write a reproducible report that separates observations, hypotheses and limits.
Build deterministic Python models of bounded work admission, delivery ownership, retry budgets and idempotent effects, then integrate a restartable job-state simulation.
Build and evaluate a local Python search engine: stable document IDs, Unicode tokens, inverted indexes, ranked results and retrieval metrics.
Build a deterministic Python tool-calling simulation with typed arguments, explicit permissions, structured results and a bounded feedback loop.
Build a playable catch-the-ball game: pure state updates, input, elapsed time, Pygame shapes, scoring and restart.
Animate breadth-first and depth-first search on a grid, reconstruct parent paths and export a replayable trace.
Build a bounded Python CLI client against a bundled loopback API: validated pages, retries, cancellation and a deterministic report.
Build a small documented Markdown parser and publish a styled single HTML page with explicit escaping, safe links and useful diagnostics.
Define metrics at the right grain, reconcile native SQL results and publish an interactive sales-report snapshot with honest charts.
Build a standard-library Go notes API with explicit server configuration, bounded JSON, deliberate routes, repository boundaries and handler tests.
Use standard Go primitives to distinguish byte encodings, checksums, authentication, authenticated encryption and password-storage requirements.
Connect a running Go notes service to structured logs, server-owned request IDs, bounded counters and honest latency distributions.
Specify a small bug fix, bound context and tools, review proposed patches and independently verify the final code with a replayable Python/Git lab.
Map a tiny API onto compute, network, identity and storage; validate an explained local infrastructure plan before provisioning.
Add explicit contracts to JavaScript, narrow unknown data and migrate the existing JSON report CLI with real compiler diagnostics and runtime checks.
Move a small notes application from an actual SQLite fixture to an owned local PostgreSQL cluster, with versioned migrations, parameters, transactions and full-row reconciliation.
Translate records into actual Pandas operations with deliberate dtypes, missing-value policy, grouping grain and validated joins; reconcile the existing cleaning report.
PUT THE PIECES TO WORK
Choose a C++ container, investigate Git recovery or follow real rows through a SQL join.
Connect courses around backend, systems, embedded or data work, with preparation and a concrete outcome.
Trace a small program, choose an explanation and use the feedback to decide what to practice next.
Take a contract into a project. Preview an original C++/Linux artifact publisher, with starter code and tests.
Project preview →FROM PROGRAM TO PHYSICAL PROJECT
Guided lessons, downloadable code and desktop logic tests. Bring compatible parts you own, or explore the optional equipment cards when you are ready to build.
C++ / GUIDED BUILD
Make a tabletop proximity display with an ultrasonic sensor, three LEDs, bounded reads and testable C++ state transitions.
C++ / GUIDED BUILD
Use the built-in IMU and screen to count distinct motion bursts, with gravity rejection, rearming and a cooldown.
PYTHON / GUIDED BUILD
Turn a Raspberry Pi camera into a local marker journal. Validate labels, suppress repeat scans and keep a useful event log.
PYTHON / GUIDED BUILD
Read temperature and humidity, handle missing samples and drive a calm two-LED status display with MicroPython.
MORE THAN READING
Read worked examples, explore diagrams and use videos when another explanation helps. Connect the code to the idea behind it.
Answer checks, debug broken code and build in the editor. Test feedback shows what to work on next.
Use spaced coding review and flashcards to revisit the decisions: which type, which container, which command, and why.
Try flashcards →SYSTEMS PROGRAMMING TOPICS
Move from language fundamentals to the systems they run on.
CodeRigor’s courses, lessons, exercises and flashcards are currently available without charge. Optional courses, tutoring and equipment from other providers may cost money. Affiliate offers identify the provider and include a referral disclosure.
No. Python, SQL, Git, Bash and Lua have independent sequences. Inside each sequence, prerequisite links help you find the right order.
Start with the first unit of a language course, “Start here: your first programs”, which assumes no programming experience at all: Python, JavaScript, C++, Go, Bash or Lua. If you have no preference, choose Python. Six short lessons take you from printing a line of text to a complete interactive program, and the next unit of the same course continues from there. If the bits are unfamiliar, keep the binary and hex lessons alongside your study.