Programming Tutorials

Fundamentals

Variables, control flow, functions, recursion, types, memory. These ideas are the same in every language, so they are taught once here, without any one syntax. Language lessons link back when they build on one.

Beginner

Read and write small programs with confidence.

Programs and data

  1. What a program is25 minExplain source code, compiling and interpreting, and trace a small program by hand to predict what it does.
  2. Editors, terminals and running code30 minUse a terminal, a text editor and a run command to execute a program, change it and run it again.
  3. Values and types30 minClassify values by type, predict which mixed operations fail, and tell static from dynamic and strong from weak typing.
  4. Variables and assignment30 minExplain names, binding and mutation, and trace how a program's variables change as it runs.
  5. Expressions and operators35 minEvaluate expressions by hand using precedence, and predict integer division, overflow and float rounding surprises.
  6. Text, characters and encodings35 minExplain how text is stored as code points and bytes, and why the length of a string depends on what you count.

Control flow and functions

  1. Making decisions40 minWrite branching logic with if, else if and else, combine conditions with boolean operators, and use guard clauses to keep decisions readable.
  2. Repetition40 minRepeat work with while and for loops, choose between counted and conditional loops, and avoid off-by-one errors and infinite loops.
  3. Functions40 minBreak a problem into named, reusable pieces with clear inputs and outputs, and see how calls stack up while a program runs.
  4. Scope and lifetime40 minPredict which variable a name refers to, understand shadowing, and see when a variable is created and destroyed.
  5. Recursion45 minWrite and trace functions that call themselves, using a base case, a recursive case and an understanding of the call stack.
  6. When things go wrong45 minTell syntax, runtime and logic errors apart, choose between exceptions and error values, and handle bad input deliberately.

Data structures

  1. Arrays and lists45 minStore many values in order, reach any of them by position, and change, slice and loop over them safely.
  2. Maps and sets45 minLook values up by key instead of by position, test membership quickly, and choose between a list, a map and a set.
  3. Grouping data: records and objects50 minBundle related values into one named thing, attach behaviour to it, and tell apart two things that are equal from one thing with two names.
  4. Stacks, queues and linked lists55 minUse the classic last-in-first-out and first-in-first-out structures, and see how nodes that point to each other form a linked list.
  5. Trees and graphs60 minRepresent hierarchies and networks with nodes and links, search a binary search tree, and find the shortest route through a graph.
  6. Memory, values and references55 minUnderstand where data lives, what assignment really copies, why two names can change one thing, and when memory is given back.

Algorithms and complexity

  1. Algorithmic thinking50 minPlan a solution in plain steps before you write code, using decomposition, pseudocode, worked examples and a deliberate hunt for edge cases.
  2. Complexity and Big-O55 minDescribe how the work a program does grows with the size of its input, and learn the handful of growth rates that cover almost every program you will write.
  3. Searching and sorting70 minImplement linear and binary search, then insertion sort and merge sort, and learn what stability means and why you will usually call the built-in sort.
  4. Common problem-solving patterns65 minLearn five reusable ideas, two pointers, sliding window, hashing for lookup, divide and conquer and memoisation, that each turn a slow solution into a fast one.
  5. Programming paradigms60 minCompare the imperative, object-oriented, functional and declarative styles by solving one task in each, and learn what each style is good at.

Working like a programmer

  1. Debugging60 minFind bugs systematically by reproducing them, isolating them and testing hypotheses, using print statements, debuggers and stack traces.
  2. The testing mindset60 minWrite small automated tests that check your code against expected results, choose cases that expose bugs, and meet test-driven development.
  3. Version control with Git70 minTrack every change to your code with Git, work on ideas in branches, merge them back, resolve a conflict and share work through a remote.
  4. Reading documentation and other people's code55 minFind reliable answers in official documentation, read function signatures, and make sense of unfamiliar code by searching and tracing it.
  5. Clean code and security basics65 minWrite code other people can read, and avoid the beginner security mistakes that cause most real breaches, then choose your language track.