What would you like to learn?

Before you start No programming experience needed. Begin with values, basic strings, and arrays; the later chapters build toward asynchronous work and data validation.

1. Your first JavaScript programBeginner
2. Values and decisionsBeginner
3. Strings you can read and changeBeginner
4. Arrays and the first itemBeginner
5. Functions and loop boundariesBeginner
6. Objects with named propertiesBeginner
7. Destructuring, defaults, and rest parametersIntermediate
8. Transform collections without surprisesIntermediate
9. Object identity and deliberate nested updatesIntermediate
10. Closures and keyed stateIntermediate
11. Methods, receivers, and class invariantsIntermediate
12. Modules and explicit dependenciesIntermediate
13. Promises and failure pathsAdvanced
14. Concurrent promises and result orderingAdvanced
15. Text, Unicode, and explicit normalizationIntermediate
16. Recursive decomposition and search invariantsAdvanced
17. Validate data at boundariesAdvanced

Before you start No programming experience needed. Start with your first program, then strings, lists, decisions, and small functions before the deeper topics.

1. Your first Python programBeginner
2. Working with stringsBeginner
3. Lists and changing one itemBeginner
4. Decisions and repeating workBeginner
5. Functions that return an answerBeginner
6. Values, text, and arithmeticBeginner
7. Functions and dependable defaultsBeginner
8. Lists, sets, and dictionariesIntermediate
9. Comprehensions and nested aliasingIntermediate
10. Lexical scope and closuresIntermediate
11. Iterators and lazy pipelinesIntermediate
12. Instance state and behavioral contractsIntermediate
13. Exceptions and resource boundariesAdvanced
14. JSON parsing and domain validationAdvanced
15. Records, ordering, and invariantsAdvanced
16. Modules and tests that challenge a contractIntermediate
17. Recursive algorithms and terminating rangesAdvanced

Before you start This is a focused C++ course for learners who can already read typed functions and arrays. Later lessons assume comfort reasoning about references, ownership, and lifetime.

1. Values, expressions, and typesBeginner
2. Functions, references, and lifetimeIntermediate
3. Owned strings and borrowed string viewsAdvanced
4. Vectors, bounds, and invalidationIntermediate
5. Value classes and constructor invariantsIntermediate
6. Maps, lookup, and accidental insertionIntermediate
7. Algorithms and comparison contractsIntermediate
8. Templates and meaningful type requirementsAdvanced
9. Recursion and half-open range reasoningAdvanced
10. Resource ownership with RAIIAdvanced
11. Move operations and valid remaining stateAdvanced
12. Exception safety and committing changesAdvanced
13. Optional results and interface contractsAdvanced

Before you start No previous Java required. Intro to Java explains how a small program runs; objects, types, methods, and collections are introduced as you progress.

1. Intro to JavaBeginner
2. Using objectsBeginner
3. Data typesBeginner
4. ClassesIntermediate
5. DecisionsBeginner
6. IterationIntermediate
7. Arrays and ArrayListsIntermediate
8. Sorting and searchingIntermediate
9. Designing classesIntermediate
10. Interfaces and polymorphismAdvanced
11. InheritanceAdvanced
12. Exception handlingAdvanced
13. RecursionAdvanced

Before you start No previous C# required. Start with a small program, then values and arrays before methods, classes, and asynchronous work.

1. Run and read a C# programBeginner
2. Values, types, and stringsBeginner
3. Create and read an arrayBeginner
4. Decisions, loops, and methodsBeginner
5. Arrays, value copies, and shared referencesIntermediate
6. Pattern matching and exhaustive decisionsIntermediate
7. Classes, properties, and invariantsIntermediate
8. Collections and LINQ pipelinesIntermediate
9. Dictionary contracts and equality rulesIntermediate
10. Delegates and captured stateIntermediate
11. Iterator methods and deferred executionAdvanced
12. Interfaces and virtual behaviorAdvanced
13. Nullable values and explicit failuresIntermediate
14. Deterministic cleanup with usingAdvanced
15. Tasks, asynchronous completion, and failureAdvanced

Before you start Assumes binary and hexadecimal notation, registers, signed arithmetic, and memory addresses. These x86-64 lessons are for learners with prior low-level programming experience.

1. Registers and operand widthsMaster
2. Sign extension and zero extensionMaster
3. Addresses and sized memory operandsMaster
4. Record layout, stride, and byte orderMaster
5. Arithmetic, masks, and shiftsMaster
6. Extracting and replacing packed bit fieldsMaster
7. Carry, signed overflow, and wide additionMaster
8. Comparisons and signed branchesMaster
9. Bounded loops over arraysMaster
10. Bounded byte scans and sentinel searchesMaster
11. Division and implicit register pairsMaster
12. Leaf functions and calling contractsMaster
13. Nested calls and System V stack disciplineMaster

Before you start Bring basic JavaScript variables, functions, arrays, and object literals. Classes are taught later; you do not need to finish the whole JavaScript course first.

1. Read compiler feedback and run a checked programIntermediate
2. Types as working contractsBeginner
3. Object shapes and readonly viewsBeginner
4. Tuples, rest parameters, and array boundariesIntermediate
5. Narrowing and explicit statesIntermediate
6. Literal inference and checked configurationIntermediate
7. Preserve relationships with genericsIntermediate
8. Function compatibility and callback promisesAdvanced
9. Classes, structural contracts, and private stateIntermediate
10. Module boundaries and type-only dependenciesIntermediate
11. Typed asynchronous results and explicit failureAdvanced
12. Derive API types from one modelAdvanced
13. Conditional types and union distributionAdvanced
14. Unknown input and trustworthy resultsAdvanced

Before you start Bring basic programming experience with functions, loops, and arrays. This focused course develops explicit memory and pointer reasoning; it is not a first-programming course.

1. Values and explicit computationBeginner
2. Functions and bounded loopsBeginner
3. Integer limits and checked arithmeticAdvanced
4. Arrays, lengths, and terminated textIntermediate
5. Text parsing and complete-consumption checksAdvanced
6. Unsigned masks and packed flagsIntermediate
7. Addresses, borrowing, and lifetimeAdvanced
8. Structs and explicit success resultsIntermediate
9. Headers, linkage, and separate compilationIntermediate
10. Function pointers and comparator contractsAdvanced
11. Streams, end-of-file, and error handlingIntermediate
12. Allocation and ownership contractsAdvanced
13. Resizing allocations without losing ownershipAdvanced

Before you start Basic variables, functions, and loops are useful preparation. The course introduces Go syntax before moving into slices, maps, interfaces, and concurrency.

1. Values, functions, and loopsBeginner
2. Bytes, runes, and text boundariesIntermediate
3. Slices and shared backing arraysIntermediate
4. Maps and presence checksIntermediate
5. Pointers and controlled mutationIntermediate
6. Structs, methods, and small interfacesIntermediate
7. Sorting, searching, and stable tiesIntermediate
8. Errors and deferred cleanupAdvanced
9. Generic functions and useful constraintsAdvanced
10. Readers, records, and partial progressAdvanced
11. Tests, invariants, and boundary casesAdvanced
12. Goroutines and channel coordinationAdvanced
13. Cancellation and bounded concurrent workAdvanced

Before you start Bring experience with functions, collections, and typed values. Start at bindings if Rust is new to you; ownership and borrowing are developed in the following chapters.

1. Bindings and expressionsBeginner
2. Ownership and moved valuesIntermediate
3. Borrowing and slicesIntermediate
4. UTF-8 strings and safe boundariesIntermediate
5. Structs and invariant-preserving methodsIntermediate
6. Enums and exhaustive decisionsIntermediate
7. Recoverable errors with ResultAdvanced
8. Iterator pipelines and collectionAdvanced
9. Hash maps and entry-based aggregationIntermediate
10. Traits and replaceable behaviorAdvanced
11. Generic borrowing and lifetime relationshipsAdvanced
12. Tests for boundaries and mutation contractsAdvanced
13. Owned messages and thread completionAdvanced

Before you start Basic variables, functions, and collections are helpful. The early chapters introduce Kotlin expressions and control flow before null safety, classes, and advanced APIs.

1. Values and functionsBeginner
2. Conditions, ranges, and iterationBeginner
3. Text transformations and search boundariesIntermediate
4. Null safety and validationIntermediate
5. Arrays and two-dimensional traversalIntermediate
6. Collections and transformationsIntermediate
7. Maps, sets, and occurrence policiesIntermediate
8. Higher-order functions and captured stateAdvanced
9. Classes and data valuesIntermediate
10. Interfaces and sealed alternativesAdvanced
11. Generic APIs and varianceAdvanced
12. Lazy sequences and bounded evaluationAdvanced
13. Validation, failures, and contract testsAdvanced

Before you start Basic variables, decisions, and collections are helpful. Start with Swift bindings and control flow before string indexing, optionals, and value semantics.

1. Constants, variables, and expressionsBeginner
2. Decisions and iterationBeginner
3. Strings and collection indicesIntermediate
4. Functions and optional resultsIntermediate
5. Closures and captured stateAdvanced
6. Arrays, dictionaries, and value copiesIntermediate
7. Transforming and grouping collectionsIntermediate
8. Structures and classesIntermediate
9. Associated values and exhaustive stateIntermediate
10. Initialization and bounded stateIntermediate
11. Protocols and throwing operationsAdvanced
12. Generic algorithms and constraintsAdvanced
13. Reference ownership and closure cyclesAdvanced

Before you start Start with the values chapter. Basic programming experience is helpful for the later blocks, methods, and collection transformations; review the linked foundations whenever needed.

1. Values and expressionsBeginner
2. String mutation and precise matchingIntermediate
3. Methods, arguments, and blocksBeginner
4. Keyword arguments and explicit optionsIntermediate
5. Array copies and nested stateIntermediate
6. Enumerable transformationsIntermediate
7. Hash defaults and mutationIntermediate
8. Sorting and deterministic tie rulesIntermediate
9. Objects with small behavior contractsAdvanced
10. Inheritance, super, and substitutionAdvanced
11. Recursive decomposition and terminationAdvanced
12. Lazy sequences and controlled failureAdvanced
13. Contract-focused tests and boundariesAdvanced

Before you start Start with values and comparisons. These lessons use small PHP scripts; prior web-server knowledge is not required. Review variables and functions if those ideas are unfamiliar.

1. Values and explicit comparisonBeginner
2. String offsets and exact parsingIntermediate
3. Functions and typed boundariesBeginner
4. Arrays as ordered mapsIntermediate
5. Copies, object handles, and referencesIntermediate
6. Sorting keys, records, and tiesIntermediate
7. Closures and capture policiesAdvanced
8. Classes and invariant-preserving operationsIntermediate
9. Interfaces and replaceable collaboratorsAdvanced
10. Parsing and exception contractsIntermediate
11. Prepared statements and database boundariesAdvanced
12. Generators and bounded memoryAdvanced
13. Boundary tests and exact outcomesAdvanced

Before you start No SQL experience needed. Begin by reading a table and selecting columns. Later chapters introduce joins, grouping, windows, and recursive queries using SQLite.

1. Read a table and choose columnsBeginner
2. Select rows with a clear orderBeginner
3. Missing values and three-valued logicBeginner
4. Keys, constraints, and valid rowsIntermediate
5. Join tables without losing the questionIntermediate
6. Existence tests and correlated questionsIntermediate
7. Aggregate at the right grainIntermediate
8. Set operations and duplicate meaningIntermediate
9. CTEs and windowed analysisAdvanced
10. Dates, ranges, and deterministic periodsIntermediate
11. Recursive CTEs and terminationAdvanced
12. Updates, upserts, and affected rowsAdvanced
13. Transactions, constraints, and query plansAdvanced
14. Indexes and evidence-based query tuningAdvanced

Before you start Assumes you can open a terminal and run a simple command with arguments. The course then explains quoting, exit status, variables, and shell control flow.

1. Words, quotes, and argumentsBeginner
2. Parameter expansion and missing-value policyIntermediate
3. Exit status and conditional workBeginner
4. Integer arithmetic and command statusIntermediate
5. Arrays, functions, and exact argument listsIntermediate
6. Patterns and filename-safe iterationIntermediate
7. Read records without corrupting themIntermediate
8. Redirections and separate output channelsIntermediate
9. Pipelines, subshells, and failure propagationAdvanced
10. Options and positional argument contractsIntermediate
11. Background jobs and explicit completionAdvanced
12. Build predictable command-line toolsAdvanced
13. Testing exact arguments and failure behaviorAdvanced

Before you start Basic arithmetic and an interest in tabular data are useful. Start with vectors before missing values, data frames, and grouped calculations.

1. Vectors and elementwise arithmeticBeginner
2. Coercion and recycling contractsBeginner
3. Indexing and missing valuesBeginner
4. Categories and level semanticsIntermediate
5. Data frames and column structureIntermediate
6. Matrix shape and margin operationsIntermediate
7. Functions and controlled iterationIntermediate
8. Lists and predictable transformationsAdvanced
9. Keyed alignment and join cardinalityIntermediate
10. Grouped summaries and validationAdvanced
11. Lexical scope and forced configurationAdvanced
12. Conditions and reliable cleanupAdvanced
13. Reproducible sampling and simulationAdvanced

Before you start Basic variables and functions are helpful. The early chapters introduce Dart types and control flow before records, collections, classes, and asynchronous results.

1. Types, bindings, and null safetyBeginner
2. Functions and control flowBeginner
3. Records and structural patternsIntermediate
4. Lists, maps, and transformationsIntermediate
5. Generic contracts and runtime element checksIntermediate
6. Lazy iterables and generator demandIntermediate
7. Classes and validated stateIntermediate
8. Value equality and stable hash keysAdvanced
9. Interfaces and substitutionAdvanced
10. Sealed results and exhaustive branchingAdvanced
11. Futures and failure boundariesAdvanced
12. Streams, ordering, and cancellationAdvanced
13. Isolates and message-owned workAdvanced

Before you start Start with values and truth, then scope and functions. Lua-specific rules such as one-based sequence indexes are introduced in the lessons.

1. Values, types, and truthBeginner
2. Lexical scope and accidental globalsBeginner
3. Functions, locals, and return valuesBeginner
4. Multiple results and exact argument packsIntermediate
5. Tables and sequencesIntermediate
6. Iteration and string processingIntermediate
7. Captures and literal-safe substitutionsIntermediate
8. Bytes, code points, and text boundariesIntermediate
9. Closures and module boundariesAdvanced
10. Custom iterators and termination contractsAdvanced
11. Metatables and protected callsAdvanced
12. Intercepting writes and raw operationsAdvanced
13. Coroutine suspension and result channelsAdvanced

Before you start Assumes experience with variables, loops, arrays, and key-value data. This focused Perl course introduces sigils and context before regular expressions and deeper text processing.

1. Scalars and explicit comparisonIntermediate
2. Arrays, hashes, and contextIntermediate
3. Iteration and function boundariesIntermediate
4. Context-sensitive interfacesIntermediate
5. References and nested structuresAdvanced
6. Lexical closures and private stateIntermediate
7. Anchored parsing and capturesAdvanced
8. Global matching and parser progressAdvanced
9. Filtering, mapping, and numeric orderAdvanced
10. Lexical filehandles and explicit text decodingIntermediate
11. Packages and explicit public interfacesAdvanced
12. Blessed references and method receiversAdvanced
13. Exception capture and honest success signalsAdvanced

Before you start Assumes basic function and list experience. The course introduces Haskell expressions and type signatures, then develops pattern matching and immutable transformations.

1. Expressions, types, and applicationIntermediate
2. Higher-order functions and compositionIntermediate
3. Patterns and guardsIntermediate
4. Algebraic data types and recursive modelsIntermediate
5. Structural recursion and base casesIntermediate
6. List transformations and lazinessAdvanced
7. Fold direction, demand, and strictnessAdvanced
8. Maybe and total interfacesAdvanced
9. Either and explanatory failuresIntermediate
10. Traverse collections of checked resultsAdvanced
11. Type classes, newtypes, and lawsAdvanced
12. Persistent maps and explicit lookup failureAdvanced
13. Pure computation and IO sequencingAdvanced

Before you start Basic function and collection experience is helpful. Start with immutable values and pattern matching before processes and concurrent programs.

1. Immutable values and pattern matchingIntermediate
2. Lists, maps, and data shapeIntermediate
3. Binary text and Unicode boundariesIntermediate
4. Function clauses and guardsIntermediate
5. Composing tagged results with withIntermediate
6. Structs and explicit domain shapeIntermediate
7. Enum pipelines and reductionsAdvanced
8. Lazy enumeration and bounded demandAdvanced
9. Recursive list processingAdvanced
10. Processes and explicit messagesAdvanced
11. Task results, links, and time budgetsAdvanced
12. Serialized state with GenServerAdvanced
13. Supervision and recovery boundariesAdvanced

Before you start Basic arithmetic and programming experience are useful. The early chapters introduce Julia values and loops before arrays, broadcasting, and numerical work.

1. Values, types, and functionsBeginner
2. Conditions, loops, and local calculationsBeginner
3. Arrays, indexing, and broadcastingIntermediate
4. Views, copies, and array ownershipIntermediate
5. Dictionaries, tuples, and named valuesIntermediate
6. Generators and deliberate materializationIntermediate
7. Composite types and multiple dispatchAdvanced
8. Parametric storage and flexible interfacesAdvanced
9. Dispatch intersections and method ambiguityAdvanced
10. Missing data and recoverable failuresAdvanced
11. Numeric representation and error budgetsAdvanced
12. Type stability and measured optimizationAdvanced
13. Tasks, channels, and producer lifecyclesAdvanced

Before you start Assumes you can open a terminal and run a command. The course develops PowerShell values and object pipelines before functions, errors, and automation patterns.

1. Values, interpolation, and expressionsBeginner
2. Hashtables, keys, and deterministic orderIntermediate
3. Work with object pipelinesBeginner
4. Collections, comparisons, and nullIntermediate
5. Regex captures with explicit success checksIntermediate
6. Functions and clean output contractsIntermediate
7. Splatting and mutually exclusive parametersAdvanced
8. Literal paths and provider boundariesIntermediate
9. JSON and CSV as data contractsIntermediate
10. Scope, shared objects, and module boundariesAdvanced
11. Handle failures at the right boundaryAdvanced
12. Build reusable pipeline commandsAdvanced
13. Background jobs and isolated resultsAdvanced