Bootcamps
What you get
Deep fundamentals of programming in Python: installing and running real programs, data and control flow, functions and recursion, the built-in data structures with a first look at Big-O, files and your own exceptions, testing and debugging discipline, and object-oriented programming — with a from-scratch capstone.
Where it sits
Level I · 260 hours · No prerequisites
What you get
Propositional and predicate logic, proof technique, sets, relations, and the counting and graph foundations the rest of computer science is built on.
Where it sits
Level I · 90 hours · No prerequisites
What you get
Number theory, modular arithmetic and its cryptographic applications, discrete probability, and recurrence relations — the four topics Discrete Mathematics I scopes out to this sequel.
Where it sits
Level II · 68 hours · Prerequisites: Discrete Mathematics I
What you get
Limits, continuity, derivatives, and integrals of single-variable functions, with every rule proved and then checked against a numerical script rather than taken on faith.
Where it sits
Level I · 80 hours · No prerequisites
Partly covered · being written now
What you get so far
Every structure Python's built-ins hide from you, built from scratch: dynamic arrays, linked lists, stacks and queues, trees, heaps, hash tables, and graphs, each one measured against a real Big-O argument rather than taken on faith.
Where it sits
Level I · 120 hours · Prerequisites: Programming I
DM us to ask for it — requests decide the order
Subjects
What it is
Component architecture, state, routing, accessibility, performance, and front-end build tooling.
Where it sits
School of Programming And Development · Upper level
Crunch Front — Senior Frontend Engineering
You get
Front-end at senior level: component architecture and state, routing and data loading, accessibility as a requirement, performance budgets, and build tooling — framework-agnostic on purpose, since the framework changes. It assumes HTML, CSS and JavaScript fundamentals; take C8 first.
What it is
Lexing, parsing, semantic analysis, intermediate representation, optimization, and code generation.
Where it sits
School of Programming And Development · Upper level
Not ready yet · on the build list
What it will cover
A working compiler built in stages — lexer, recursive-descent and LR parsing, an AST, type checking, an intermediate representation, a few real optimisations, and code generation.
DM us to ask for it — requests decide the order
What it is
Transformations, rasterization, shading, texturing, and the graphics pipeline.
Where it sits
School of Programming And Development · Upper level
Crunch Arcade — Game Development
You get
The pipeline used rather than derived: sprites, tilemaps, transforms, animation and scene management inside a real engine.
Still to add
The rendering mathematics — homogeneous transforms, rasterisation, shading models, and writing shaders.
What it is
Threads, locks, data races, message passing, and scaling work across cores or machines.
Where it sits
School of Programming And Development · Upper level
Crunch Go — Cloud-Native Backend in Go
You get
Concurrency as Go does it — goroutines, channels, select, context and the race detector — applied to backend services that have to stay correct under load.
Still to add
Numerical parallelism: OpenMP, MPI, GPU kernels.
Crunch Spark — Big Data & Distributed Processing
You get
Parallelism at cluster scale: MapReduce thinking, partitioning, shuffles, and tuning a distributed job so it finishes.
What it is
Lists, stacks, queues, trees, heaps, hash tables, graphs, and the complexity analysis that goes with them.
Where it sits
School of Programming And Development · Core
You get
Every core structure implemented and used — arrays, linked lists, stacks, queues, trees, heaps, hash tables and graphs — with big-O stated for each, taught as fourteen recurring problem patterns rather than a catalogue, plus amortised analysis proved three ways (aggregate, accounting, potential) and union-find's height bound proved by induction.
What it is
Greedy, divide and conquer, dynamic programming, graph algorithms, NP-completeness, and formal correctness proofs.
Where it sits
School of Programming And Development · Upper level
You get
The algorithm families and how to recognise which one a problem wants — two pointers, sliding window, binary search, backtracking, dynamic programming, graph traversal and shortest paths — each solved out loud with complexity reasoned rather than recalled, plus proof technique (induction, loop invariants, exchange arguments) proved on algorithms from the course itself.
Still to add
The complexity-theory half (NP-completeness, reductions, and what intractability means).
What it is
Logic, sets, proof technique, combinatorics, recurrences, and graph theory — the math CS is built on.
Where it sits
School of Programming And Development · Core
Not ready yet · on the build list
What it will cover
Propositional and predicate logic, proof by induction and contradiction, sets and relations, counting and combinatorics, recurrence relations, and the graph theory the algorithms courses assume.
DM us to ask for it — requests decide the order
What it is
One product carried end to end: an HTTP API over a real database with real authentication, a typed client app built against it, and both of them shipped.
Where it sits
School of Programming And Development · Upper level
You get
Ten weeks on one product — a Spring Boot API over Postgres with Flyway migrations, JWT login and per-user authorization, a typed React Native client on TanStack Query, and a capstone a stranger deploys from a cold clone onto a phone you have never touched.
Still to add
The browser half of a web-application course: HTML, CSS, the document object model, server-side templating and data-binding, and site design for the web. Network programming below HTTP: sockets, protocol implementation and distributed object computing. Agile run rather than described — no sprint planning, standup, review or retrospective is performed, and estimation stops at one unassessed story-pointing step. A team project and peer code review — no assignment asks you to review another person’s pull request. User-centred design: user research, personas and usability testing, and an accessibility bar that holds past Week 7. Formal design modelling in UML rather than ASCII and Mermaid sketches. A linter and formatter configuration — `-Xlint:all` and `tsc --noEmit` are the only style gates. The two further exercises each week: only `exercise-01` exists in all ten weeks, and several mini-project phases tell you to start from files that were never written. And published worked answers — the quizzes carry one collapsed key per file, Week 10’s is not collapsed at all, and no problem page carries a solution.
What it is
Game loops, physics, input, state, level design, and shipping a playable build.
Where it sits
School of Programming And Development · Upper level
Crunch Arcade — Game Development
You get
A game loop implemented, delta-time reasoned about, collisions, sprite animation, tilemaps, scene management, a Godot 4 project built, structured playtesting, and a small game shipped.
What it is
First programming course: variables, control flow, functions, collections, files, and a first real program.
Where it sits
School of Programming And Development · Intro
You get
Fifteen weeks of Python for absolute beginners — syntax, control flow, functions, collections, files and error handling — ending in a portfolio project rather than a final exam.
What it is
Platform UI, navigation, local storage, networking, permissions, and shipping to a store.
Where it sits
School of Programming And Development · Upper level
Crunch Droid — Android Engineering
You get
Twenty-four weeks of Android engineering — UI, navigation, persistence, networking, permissions, testing and release — aimed at senior-level competence rather than a first app.
Crunch Swift — iOS & Apple Platform Engineering
You get
The Apple platforms in Swift, with the first six weeks runnable on Linux before you need a Mac.
What it is
Processes, threads, scheduling, synchronization, virtual memory, file systems, and the kernel interface.
Where it sits
School of Programming And Development · Upper level
You get
The operating system as its operator sees it: processes and signals, the filesystem hierarchy, users, groups, permissions and ACLs, package management, services, shell scripting, and recovering a machine you broke.
Still to add
Kernel internals — writing a scheduler, a pager, or a filesystem.
Crunch Rust — Systems & Backend Engineering in Rust
You get
The concurrency and memory half done properly: ownership, borrowing, threads, channels and async, without a garbage collector between you and the machine.
What it is
Classes, inheritance, interfaces, exceptions, generics, testing, and the first serious multi-file program.
Where it sits
School of Programming And Development · Core
Crunch Sharp — C# & .NET Engineering
You get
A full object-oriented language and its type system, taught in C# and .NET over fifteen weeks: classes, interfaces, generics, exceptions, LINQ, async, and testing a multi-project solution.
Still to add
Java specifically, if your course grades Java syntax.
You get
The same design ideas in Python — protocols, descriptors, decorators, packaging and profiling — for anyone who would rather stay in one language.
Still to add
Static typing and compile-time enforcement.
What it is
Syntax and semantics, type systems, functional programming, scoping, and language design trade-offs.
Where it sits
School of Programming And Development · Upper level
Not ready yet · on the build list
What it will cover
Syntax and semantics, static and dynamic typing, type inference, scope and binding, functional programming and immutability, evaluation strategies, and why a language designer chose each.
DM us to ask for it — requests decide the order
What it is
A term-long team build with a real stakeholder, ending in a demo and a defensible artifact.
Where it sits
School of Programming And Development · Upper level
You get
Scoping and shipping a real project under a deadline: reading a brief, working on a team of strangers, a rapid full-stack toolkit, a three-minute demo pitch, and a post-mortem.
Still to add
A term-long engagement with an external stakeholder.
What it is
HTTP services, routing, persistence, authentication, and API design that survives a second client.
Where it sits
School of Programming And Development · Core
Crunch Pro — Python Web Backend
You get
Production-grade Python backends with Django and FastAPI: routing, data access, migrations, authentication, background work, testing and deployment.
Crunch Go — Cloud-Native Backend in Go
You get
The same outcomes in Go, aimed at cloud-native services and concurrency under load.
What it is
Unit, integration and system testing, coverage, test design, and automated quality gates.
Where it sits
School of Programming And Development · Upper level
You get
Testing where it bites: automated gates in a CI/CD pipeline, so a failing test stops a release rather than being noticed later.
Still to add
Test design as a subject — equivalence partitioning, boundary analysis, mutation testing, formal coverage criteria.
What it is
Git, branching, code review, build tooling, and the day-to-day mechanics of working on a shared codebase.
Where it sits
School of Programming And Development · Intro
You get
Git end to end — commits, branches, rebase and merge, pull requests, review etiquette, resolving conflicts, and recovering work you thought you lost.
What it is
Pointers, manual memory, the C toolchain, system calls, processes, and building against the OS directly.
Where it sits
School of Programming And Development · Upper level
Crunch Rust — Systems & Backend Engineering in Rust
You get
Systems programming with the same model — stack and heap, ownership, lifetimes, concurrency, and building a command-line tool, a concurrent data processor and an async networked service.
Still to add
C itself, and manual malloc/free discipline, if your course grades C.
You get
The Unix side of it: the terminal, pipes, processes, permissions, and the toolchain your programs run inside.
What it is
Algorithmic problem solving under time pressure, system-design questions, and behavioural rounds.
Where it sits
School of Programming And Development · Core
You get
Recognising the fourteen core problem patterns instead of memorising problems, talking through a solution under pressure with the FRAME method, stating complexity without hand-waving, writing code a senior engineer would pass in review, and handling behavioural and system-design rounds — fifteen weeks intensive or a year at working-professional pace.
Crunch Career — Resume, Portfolio & Interview Systems
You get
Everything around the interview: the search run as a system, resume and online presence, referrals, and negotiating the offer.
You get
Every round of the loop rehearsed as a performance you can score: the technical phone screen driven end to end on CoderPad, the forty-five-minute design round on a six-phase clock with back-of-envelope numbers, the live coding round graded against a twelve-axis sheet you apply to your own recording, and the four-to-six-hour onsite paced without burning out.
Still to add
The algorithmic curriculum the round draws on — the core data structures, the recurring problem patterns and the complexity results behind them. C13 teaches the conduct of the round and takes the problems as given; that material is C2.
What it is
Finite automata, regular and context-free languages, Turing machines, decidability, and complexity classes.
Where it sits
School of Programming And Development · Upper level
Not ready yet · on the build list
What it will cover
Finite automata and regular languages, context-free grammars and pushdown automata, Turing machines, decidability and the halting problem, and P versus NP with real reductions.
DM us to ask for it — requests decide the order
What it is
The shell, file systems, permissions, processes, services, packages, and scripting routine work away.
Where it sits
School of Programming And Development · Intro
You get
Eight weeks of living in a terminal: navigating, searching, editing and piping; reading process and system state; package management; the filesystem hierarchy; useful shell scripts; users, groups, permissions and ACLs; running a server; and recovering a machine you broke.
What it is
HTML, CSS, JavaScript, the DOM, HTTP, and building a site that works on a phone.
Where it sits
School of Programming And Development · Intro
Introduction to HTML, CSS, and JavaScript 📱💻
You get
HTML, CSS and JavaScript from nothing, plus Git and GitHub, ending in a site you built and published.