Computer science, revisited
The CS you half-remember,
taught properly this time.
You shipped the feature. You still could not say what the scheduler did, or why the JIT made it fast. 478 short video lessons across 52 tracks — Linux, the JVM, Spring, Gradle and machine learning — built to repair exactly that.
- Tracks
- 52
- Lessons
- 478
- Runtime
- 17h 49m
Members-only library. Every lesson is behind sign-in. Titles and outlines are public so you know what you are getting; the video itself is served only to an active member, checked on the server for each request.
Foundations
AI & Machine Learning
The landscape and the workflow, supervised and unsupervised learning, honest evaluation, deep learning, and how LLMs actually work.
24 minHow the Internet Works
The protocols themselves, vendor-neutral: layering and encapsulation, Ethernet and ARP, IP and routing, TCP and QUIC, DNS, HTTP and TLS — what is actually on the wire, and why it is shaped that way.
29 minHow We Got Here
A technical history where every arrow is a complaint: something hurt, somebody built a fix, and the fix created the next problem. Characters act out what it cost; the artefacts — an EJB deployment descriptor, a SOAP envelope, the same call as REST — are shown exactly as they were.
57 minHow Computers Work
No jargon and no code: switches and binary, logic gates that add, the fetch-decode-execute loop, memory versus storage, what a compiler does, and why computers grew more cores instead of getting faster.
18 minOperating Systems, in Plain Language
What the machine is doing while you wait: processes and turn-taking, virtual memory, where files really live, drivers and interrupts, threads and the bugs they cause, accounts, containers, and the boot sequence.
18 minLanguages & Runtimes
Java
The language and its platform end to end: objects, memory, collections, generics, concurrency, streams and the modern Java you should be writing.
23 minJava Deep Dive: Inside the JVM
Class loading, bytecode, the JIT, the heap, every garbage collector, the memory model and how to observe all of it in a live process.
31 minJava Concurrency, Animated
Threads, the memory model and what the hardware is allowed to do behind your back: races, happens-before, locks, atomics and virtual threads — drawn rather than described.
21 minHibernate and JPA
The ORM machinery itself, underneath the repositories. The persistence context that makes an UPDATE appear without a save() call, the proxy that makes lazy loading possible and LazyInitializationException inevitable, the N+1 and the cartesian product its fix creates, a second level cache that is correct only while Hibernate is the only writer, lost updates, and the identity strategy that silently disables batching.
14 minTypeScript for Java Engineers
A type checker that runs before the code and then deletes every type it checked. Structural typing where a shape matches without an implements clause, erasure that removes the entire type system rather than one parameter so a cast verifies nothing, unions and narrowing as a sealed hierarchy without the classes, and why a validator at every boundary is the only place a type stops being a claim.
8 minNode, for the JVM Engineer
One thread runs your JavaScript, and everything Node is good at and everything that goes catastrophically wrong follows from it. The event loop and why microtasks starve it, a two-second hash that is an outage rather than a slow endpoint, concurrency with no data races but real interleaving across every await, workers as isolates that share nothing, backpressure, why Node has no jar hell, and V8 reading the host memory instead of the cgroup.
17 minReact, Beginner to Reconciler
A component is a function returning a description of the UI, and every confusion traces back to that. Why mutating an array changes nothing, why your logged state is stale, Fiber turning recursive rendering into an abandonable work queue and why that forces purity, hooks stored as an ordered array which is the actual reason for the rules, the memo that silently does nothing, and what really makes an app slow.
14 minNestJS: Spring, for Node
The resemblance to Spring is deliberate, and so is where it stops. Injection by type that works only because a compiler flag emits metadata TypeScript would otherwise erase, interfaces that cannot be injected because they have no runtime presence, the request pipeline order that is most of the debugging, singletons shared by every concurrent request on one thread, and request scope that spreads up the whole injection chain.
10 minModern Java
The language as it is now: lambdas and what they really are, streams and collectors, Optional used properly, records, sealed types and pattern matching, the small wins — and an honest map of what changed between 8 and 21.
18 minCollections and Generics
Choosing a structure by the operation you do most, what happens inside a HashMap, ordering contracts, the fail-fast exception everybody meets — then generics, erasure, and why a list of cats is not a list of animals.
11 minTesting in Java
JUnit 5, AssertJ, Mockito and Testcontainers — written around the judgement rather than the syntax: what makes a suite trusted, what not to mock, and why coverage finds gaps but never proves quality.
7 minBackend & Architecture
Spring Boot
From an empty directory to a tested, production-shaped service: beans, REST APIs, Data JPA and what to do before you ship.
15 minSpring Framework Internals
The container itself — IoC, dependency injection, the bean lifecycle, context refresh, AOP proxies — and the design philosophy behind it.
27 minSpring Boot Internals
How the magic works: the startup sequence, auto-configuration internals, starters, the Environment, embedded servers, Actuator, AOT and native images.
27 minServices, APIs and DDD
Bounded contexts and aggregates, REST that survives changing, the failures that only appear once a call crosses a network, and the patterns invented to live with them — sagas, outbox, circuit breakers, contract tests and the strangler migration.
31 minKafka
An append-only log that is not a queue — reading removes nothing, retention is a clock rather than a backlog, and ordering exists only inside a partition. Keys and the ordering they choose, producing without losing or duplicating, consumer groups and the rebalance storm that is really slow processing, where exactly-once stops, the outbox for the write Kafka cannot include, and when a table with SKIP LOCKED was the right answer all along.
18 minJMS and Message Brokers
The broker that tracks state per message, which is what buys acknowledgement, redelivery, priority and selectors — everything Kafka deliberately does not do. Queues against topics, the acknowledgement mode that is a trap because it sounds precise, redelivery and the DLQ as broker settings rather than code, and the question that decides between a log and a queue: are these events, or are these work?
5 minDistributed Transactions and Sagas
What @Transactional means when there are two resources, why two-phase commit is correct and still lost, and what replaced it. The in-doubt window where a prepared resource holds locks because deciding alone risks disagreeing with the other — and sagas, where a compensation is a new business fact rather than an erasure, so the irreversible step goes last.
8 minSpring Security
One servlet filter delegating to an ordered chain, and every rule you write configures a link in it. The ordering mistake that silently kills your own admin rule, hasRole against hasAuthority and the prefix that matches nothing, @PreAuthorize bypassed by a call from inside the same bean, the JWT that cannot be revoked, CSRF and CORS which sound similar and solve opposite problems, and testing it so the test would actually fail.
16 minBuilding Microservices with Spring Boot
The hands-on companion to the DDD track: the project skeleton, a controller that fails properly, Flyway migrations, the gateway, circuit breakers and bulkheads, an aggregator that fans out in parallel, choreography and sagas, idempotency, Testcontainers, and an image that is not a liability.
25 minSpring Data, Batch and Async
In build order: repositories and the three ways to query, the N+1 problem and how to see it coming, Spring Data REST and when it is a trap, why Batch exists and how a job is written, @Async, CompletableFuture and the pool you did not mean to use, virtual threads, and the distributed problems behind @Scheduled and @Cacheable.
19 minObject-Oriented Design
Encapsulation, abstraction, inheritance and its limits, polymorphism, composition, all five SOLID principles, coupling and cohesion, value objects, and the equals/hashCode contract — each one paired with the code it changes.
20 minDesign Patterns
All twenty-three Gang of Four patterns, grouped and introduced by the problem each solves — then pinned to where they already live in the JDK and Spring, plus the anti-patterns that come from overusing them.
24 minData & Databases
PostgreSQL for Developers
What is specifically Postgres, for people who already know SQL: MVCC and the row versions it leaves behind, the types that quietly corrupt data, jsonb, index types beyond B-tree, reading a plan properly, ON CONFLICT, SKIP LOCKED, and migrations that do not take the site down.
19 minPostgreSQL for Administrators
Keeping it alive: the process-per-connection model, the six settings that matter, WAL and what COMMIT really promises, vacuum and transaction ID wraparound, point-in-time recovery, replication and the slot that fills your disk, pooling, and what to actually put an alert on.
17 minSQL for Interviews and Work
The real vocabulary — ACID, normalisation, joins, isolation levels, indexes, window functions — each one explained in plain English and followed by the question an interviewer asks next.
21 minOracle PL/SQL
Where procedural code belongs inside a database: blocks and %TYPE, cursors, exceptions done properly, packages, triggers, and the bulk operations that turn a four-hour job into a short one.
17 minInfrastructure & Operations
Linux from the Ground Up
The whole mental model of a Linux box, from what the kernel actually is to writing shell scripts that survive contact with production.
29 minLinux Internals
What happens under the syscall boundary: processes, virtual memory, the VFS, interrupts and IPC — the subsystems your code runs on top of.
25 minLinux Networking
Follow a packet from the wire to your socket, then learn to debug it: addressing, routing, DNS, nftables, tunnels and TCP behaviour.
24 minLinux Storage
Partitions, LVM, RAID, filesystem choice, network storage and the recovery playbook for when a disk starts lying to you.
24 minLinux Performance
A method instead of guesswork: CPU, memory, disk and network analysis with perf, flame graphs, tracing and eBPF.
23 minLinux Security
Defence in layers — permissions beyond rwx, capabilities, PAM, sudo, SELinux and AppArmor, service sandboxing and hardening.
26 minLinux Scheduling
How the kernel decides what runs next: CFS, EEVDF, real-time classes, SMP and NUMA, cgroups, and the I/O schedulers.
22 minLinux Package Management
What is really inside a package, how dependency resolution and repository trust work, and how to build and ship your own.
23 minGradle
Gradle as a model rather than a pile of scripts: tasks, incremental builds, dependency resolution, multi-project builds and performance.
18 minLinux Internals, Animated
The drawn counterpart to the recorded internals track: addresses being translated, syscalls crossing the privilege boundary, pages reclaimed under pressure — the parts that are a process rather than a fact.
22 minDocker
A container is a process with a different view of the system, and an image is a stack of diffs — almost every surprise comes from forgetting one of those. Layers and the build cache, a Dockerfile for the JVM including the heap setting nobody sets, networking and why the default bridge has no DNS, what survives a restart, and why a tag is not a deployment record.
17 minKubernetes
One idea repeated everywhere: a control loop comparing what you declared with what exists. Pods and why the unit is not a container, rollouts gated by readiness, Services and the empty endpoint list, probes and the liveness check that turns a database blip into an outage, requests and limits and why CPU throttles silently while memory kills, StatefulSets, autoscaling that does not, RBAC defaults that are convenient rather than safe, and reading a pod that will not start.
26 minTerraform
The same declarative idea as Kubernetes with one critical difference: it reconciles once, when you ask, and the world keeps moving between runs. Reading a plan for the two characters that mean your database is about to be replaced, the state file and why it is a secrets file, modules that stay honest, drift from the fix somebody made at 3am, and a pipeline where the plan is the review artefact.
12 minAWS, Properly
The level where the decisions get made. How IAM actually evaluates a request and why an explicit Deny ends every argument, what makes a subnet public, the health check default that keeps a deadlocked application in the load balancer, storage class minimums that make a lifecycle rule increase your bill, Multi-AZ against a read replica, four messaging services that are not alternatives, and the charges that follow your code rather than your provisioning.
18 minDevOps
Not a tool tour — the practice, and what each part was reacting to. Continuous integration as a merging discipline rather than a server, build-once promotion, what a canary has to watch to be worth anything, GitOps as the drift problem with the schedule fixed, three observability signals and which question each answers, error budgets as permission to take risk, blameless review as the only way to get accurate facts, and the pipeline as production.
18 minRHCSA (EX200), End to End
A practical exam: a live RHEL system, a list of outcomes, and a score based on the state of the machine after it is rebooted. Every objective area, taught as the mechanism and then as the exam — what LVM's indirection actually buys, why enable and start are separate, what SELinux is asking that permissions are not, and what rd.break is really doing. Each lesson has a lab, graded by inspecting the system exactly as the exam does.
34 minAWS, Short Course
Not a service catalogue — the handful of ideas that actually get asked about: regions and zones, IAM, the compute and storage choices, VPC networking, queues, and where the bill comes from.
18 minSecurity & Cryptography
Number Theory for Cryptography
The mathematics public-key cryptography is built from: modular arithmetic, the Euclidean algorithm, primes, Fermat and Euler, the Chinese remainder theorem, discrete logs and elliptic curves.
16 minCryptography, Animated
Key exchange, symmetric ciphers and modes, hashes and MACs, authenticated encryption, RSA and elliptic curves, signatures, certificates and the TLS handshake — drawn rather than described.
24 minInformation Security
Defending real systems: threat modelling, authentication and authorisation, the classic web vulnerability classes, secrets and key management, supply chain, and detection and response.
20 min