CODEDOJO / COURSES
Your next skill starts here.
Choose a language, find your level, and learn one step at a time.
47 courses to exploreLet’s figure it out.
Ask me about this course or where to start.
47 courses
React Patterns, Good Practices & Internals
Learn to reason about React: render vs commit, reconciliation, identity and Fiber, keys, state snapshots, stale closures, effects, refs, performance, async React and internals. 167 lessons built on prediction, experiments, production bugs and senior interview answers — all runnable in the IDE.
Azure: Zero to Hero
70 lessons covering Azure from cloud concepts to real-world production patterns. Portal, VMs, App Service, AKS, Cosmos DB, Key Vault — plus Entra ID/MSAL, Service Bus, Azure Artifacts, Helm, reliability/operations, and Infrastructure as Code deep dives.
Terraform: Zero to Production
44 lessons of Infrastructure as Code: HCL, providers, resources, variables, remote state, modules, multi-environment, and real-world patterns — with concrete, sanitized examples.
Next.js Course
Zero to hero in Next.js: App Router, Server & Client Components, data fetching & caching, Server Actions, middleware, metadata, and deployment. Monaco editor with live preview.
Vue.js Course
Zero to hero in Vue 3: reactivity, Composition API, components & slots, Vue Router, Pinia, and more. Monaco editor with live preview — real Vue running in the browser.
Svelte Course
Zero to hero in Svelte 5: runes ($state, $derived, $effect), components, transitions, stores, and more. Monaco editor with live preview — the real Svelte compiler running in the browser.
Angular Course
Zero to hero in Angular v22: standalone components, signals, control flow (@if/@for), dependency injection, services, routing, reactive forms, and more. Monaco editor with static code verification.
Reactor Flux — Complete Guide
Interactive reference for all Flux operators: creation, transformation, filtering, combining, backpressure, scheduling, and more with runnable Kotlin examples.
Kotlin & Coroutines Course
The most complete and up-to-date Kotlin course — 68 bilingual lessons split into Beginner, Intermediate and Advanced, each with a Visualize-tab animation and runnable challenges that execute in-browser on JetBrains' free compiler. Everything from the basics through coroutines, Flow, sequences, DSLs, generics, sealed classes and algorithms.
Kotlin Coroutines & Reactive
The big reactive-stack course, in two parts: suspend + WebFlux, coroutine↔Reactor bridging, Flow↔Reactor, structured concurrency, dispatchers, timeouts & retries — then coroutines in depth: cooperative cancellation, channels & select, Flow back-pressure, hot flows, shared state, CoroutineContext and custom operators. 16 lessons with runnable examples.
Kotlin Persistence
Talk to SQL and Mongo from Kotlin: JDBC, jOOQ, R2DBC, Spring Data + coroutines, reactive transactions, and MongoDB change streams as a Flow — 8 lessons with annotated examples.
Jackson with Kotlin
Production JSON in Kotlin with Jackson: the Kotlin module, annotations + @field:/@get: use-site targets, polymorphism over sealed classes, custom (de)serializers, trees/streaming, and WebFlux.
Kotlin Testing
Test Kotlin/Spring services: JUnit 5, MockK (incl. coEvery for suspend), kotlinx-coroutines-test (runTest), Reactor StepVerifier, Testcontainers, and the fakes-vs-mocks strategy.
Kotlin — Design Patterns Masterclass
A chapter-by-chapter authored course: OOP and the five SOLID principles, the full Gang-of-Four catalogue retold in idiomatic Kotlin, and a Ride-Sharing capstone. 36 lessons · 43 challenges · animated walkthroughs.
Kotlin — Refactoring Masterclass
Refactor real code step by step: code smells, extract function, replace conditionals with polymorphism, immutability and idiomatic Kotlin patterns — with tests validating every improvement.
C# Course — Zero to Hero
Master C# on .NET 8, live runnable: types & control flow → loops & arrays → methods → classes, inheritance & collections → exceptions → generics → delegates & events → regex → async/await → structs, enums & records. Every chapter ends with a real capstone, and every lesson ships SVG visualizations and stdin/stdout-graded practice.
Java Masterclass — Zero to fluent
Learn Java from scratch by writing real Java in a full Monaco editor: how the JVM runs your code, types, operators, control flow, loops, and the object model. 37 lessons with visualizations and practices graded instantly in the browser (no server, zero cost).
Data Structures & Algorithms
55 lessons and 220 graded exercises: Big-O, sorting (heap sort included), binary search (and binary search on the answer), linked lists, stacks and queues, hash tables, BSTs and AVL rotations, heaps, tries, graphs with BFS, DFS, topological sort, union-find, Dijkstra, Bellman–Ford, Floyd–Warshall, strongly connected components and minimum spanning trees, dynamic programming (including on strings, and Kadane), greedy and Huffman coding, sliding windows, monotonic stacks, intervals, palindromes by centre expansion, Rabin–Karp, Floyd cycle detection, Fenwick and segment trees, Fisher–Yates shuffling, number theory and designing an LRU cache — in real Java that compiles and runs in the Arena IDE, with a Visualize tab that animates every algorithm step by step.
Data Structures & Algorithms · Kotlin
The same essential algorithms — sorting, binary search, lists, stacks, queues, hashing, BSTs and heaps — in idiomatic Kotlin that compiles and runs in the Arena IDE, with step-by-step animations in the Visualize tab.
Design Principles & SOLID
SOLID (SRP, OCP, LSP, ISP, DIP) plus DRY, KISS, YAGNI and composition over inheritance — each principle with a bad-vs-good example, a runnable Kotlin demo, a graded exercise, and an animated class diagram in Visualize.
Gradle for Kotlin
The JVM build system with the Kotlin DSL: build.gradle.kts, the Kotlin plugin, the kotlin{} extension, dependencies, repositories, tasks, version catalogs and multi-module builds — with annotated examples and a quiz per lesson.
Kotlin Deep Dive — Masterclass
A from-the-ground-up Kotlin masterclass: essentials → OOP → coroutines → flows → an advanced type system. Live runnable Kotlin, inline visualizations, pitfall/deeper/tip/FAQ callouts, and stdin/stdout-graded practice.
Reactive Kotlin — Reactor, Coroutines & WebFlux
The reactive Kotlin stack the way it actually ships in production, modelled on a real vehicle-inventory import service: Kotlin idioms → Project Reactor (Mono/Flux) → coroutines & interop → Spring WebFlux. Everything compiles and runs on the server-side Kotlin compiler with faithful teaching primitives — the semantics are real, the code runs.
Kotlin Java InterOp
Call Java from Kotlin. Platform types, nullability, SAM conversions, getters/setters, and mapped types.
Kotlin + Spring Boot
Build real backends with Spring Boot and Kotlin: IoC/DI, REST, JPA, security, JWT, microservices and deployment. 20 chapters, 126 lessons on an embedded mini-Spring runtime.
Go Course — Zero to Hero
11 chapters of modern Go (1.23+), runnable inline: values & variables, control flow, structs & methods, interfaces, idiomatic errors, and the concurrency model with goroutines and channels. Every lesson ships prose, runnable examples, and instantly graded practice.
Learn Python — Zero to Hero
A full walk through modern Python — variables, types, conditionals, loops, strings, lists, dicts, functions, comprehensions and classes — all practiced in the Arena with your own in-browser IDE, live console.log, and stdin/stdout tests running server-side on CPython 3.10.
React 19 Course
What's new in React 19: the use() hook, useActionState, useOptimistic, Actions and forms, ref as a prop, metadata hoisting, and Server Components. Monaco editor with the Arena IDE and verify.
Salesforce Course
10 lessons on Salesforce & Apex fundamentals: SOQL, DML & the order of execution, governor limits & bulkification, triggers, the Trigger Handler pattern, test classes, security (CRUD/FLS, with sharing, WITH SECURITY_ENFORCED), collections, SOSL, and asynchronous Apex.
Android Kotlin Playbook
Zero-to-Hero Android development with Jetpack Compose, Kotlin Coroutines, and Clean Architecture. Interactive lessons with code editors.
Java 17: Interview Prep
40 deep lessons covering Java 17 from primitives and OOP to streams, concurrency, JVM internals, and modern features (records, sealed, pattern matching, virtual threads).
React Course
Learn React from scratch. Components, props, hooks. Monaco editor with TypeScript/React autocomplete and live preview.
TypeScript Course
Learn TypeScript. Types, interfaces, unions. Monaco editor with autocomplete, run in-browser, and verify.
CSS Course
Learn CSS Flexbox. Monaco editor with live HTML+CSS preview and verify—learn by doing.
Apollo GraphQL
Master Apollo Client 4. Queries, mutations, cache, Suspense hooks, testing, and performance. Monaco editor with TypeScript.
MobX: Interview Prep
24 lessons on MobX's reactivity model: observable, computed, action, autorun, React integration, store patterns, testing, and comparison with Redux/Zustand.
Machine Learning Bootcamp
9 tracks. Zero to hero — Python, statistics, classical ML, NLP, and deep learning, all running in your browser with direct links to the math course.
Kotlin Path — guided roadmap
A beginner-to-advanced route through all 5 Kotlin courses, with a recommended order and your unified progress.
Mathematics for Machine Learning
Interactive visualizations covering linear algebra, calculus, probability, and ML applications
Spring Reactive Programming
Master reactive programming with Spring: Reactive Manifesto, Project Reactor, Mono & Flux, backpressure, Spring WebFlux, and reactive patterns with Kotlin.
Math for Algorithms
165 lessons across 26 parts — the largest course on the site. Mathematics through code: indexes, modulo, ranges, search, recursion, graphs and complexity, all the way to NP-completeness. By hand first, then in JS/TS, then the same task again in compiled Kotlin (162 graded drills).
Kotlin — The Interview Round
16 runnable challenges on the questions everyone thinks they know: == vs === and the Int cache, copy() dropping body properties, extensions that cannot override, smart casts that are refused, inline and non-local return. Predict, run, explain.
Kotlin Spring Boot — The Interview Round
7 challenges on what Spring does to your objects: self-invocation disabling @Transactional, constructor vs field injection, a stateful singleton leaking between requests, the Filter/Interceptor/Advice order, N+1, rollback rules and the lost update.
Kotlin Coroutines
Coroutines as their own subject — no Spring or Reactor in the way. 118 lessons across 22 parts: from what suspend actually compiles to (CPS, continuations, why no thread blocks) through structure, cancellation, context, shared state, channels, Flow and testing; then scheduler internals, JVM concurrency foundations, resilience, throughput, scope architecture, production operations (correlation ids, metrics, graceful shutdown, Kubernetes) and design decisions backed by measured numbers. It ends in six labs: an aggregator, a bounded scraper, a work queue, an event bus, a streaming pipeline and a capstone. Every practice runs against the real kotlinx.coroutines library, and runTest's virtual clock makes the timing exact.
Kotlin + Spring Boot 4
DI, coroutines, and controller/service/repo layering in Spring Boot 4, plus what no other course covers: OkHttp + Failsafe clients (retries/circuit breakers) for flaky external APIs, polyglot persistence (Postgres + Liquibase, Redis cache-aside, Mongo), fire-and-forget coroutine writes, a config-driven rules engine, and Testcontainers + MockK + Datadog metrics — 26 lessons built around a real vehicle-valuation service.
Rust Course — Zero to Hero
Ownership, borrowing, structs and enums, error handling with Option/Result, collections, traits and generics, lifetimes, closures and iterators, fearless concurrency, and testing — 16 lessons with annotated examples and a CLI capstone.
React Anti-Patterns · Code Review
58 lessons in finding and fixing React design mistakes.