Lessons

Mutexes, condition variables, semaphores, and reader-writer locks — the primitives that make concurrent code correct. Understand the four Coffman deadlock conditions, how lock ordering prevents them, and why contention turns a performance win into a bottleneck.

Threads are not the only model for concurrency. Learn how blocking vs non-blocking I/O works, how the event loop and reactor pattern scale to millions of connections, and how callbacks evolved into futures, promises, and async/await — plus where coroutines fit and when async loses to threads.

The parser only checks syntax — it happily accepts `x = y + z` even if none of those names exist. Semantic analysis adds meaning: it builds symbol tables, resolves names, enforces scoping rules, and runs the type checker that catches the errors a grammar cannot. Learn what happens between the raw AST and the typed AST the IR generator gets.

The parser takes a flat token stream and recovers the hierarchical structure the programmer intended. Learn context-free grammars, recursive-descent parsing, operator precedence, the difference between a parse tree and an AST, and when LL versus LR parsers matter — including the classic dangling-else ambiguity.

Before a compiler can understand your code it has to chop it into meaningful pieces. Learn how scanners work, how regular expressions become finite automata, why maximal munch is the rule, and what a real token stream looks like — the foundation every later compiler phase depends on.

The typed AST is high-level — too high for a CPU. Learn why compilers lower to an intermediate representation first, what SSA form buys you, how classic optimizations (constant folding, dead-code elimination, CSE) transform IR, and how instruction selection and register allocation finally produce machine code.

Navigate the world's most complex games market: Tencent and NetEase's dominance, the ISBN licensing system and its freeze years, the 2021 minors' play-time rules, how WeChat and Douyin mini-games work, and what it actually takes for a Western studio to earn revenue in China.

Strip away the hype. This lesson unpacks the real adoption and impact data: McKinsey's State of AI surveys, the MIT 2025 GenAI Divide, and why roughly 95% of enterprise GenAI pilots show no measurable P&L impact — plus where value has actually landed and what the pilot-to-production chasm looks like in practice.

The model is the least of your problems. This lesson examines how to structure the AI function (centralised, federated, hub-and-spoke), make defensible build-vs-buy decisions, design for actual adoption, and understand why change management — not the model — is the dominant failure mode in enterprise AI programs.

Responsible AI is a practice, not a slogan. This lesson covers the EU AI Act's four risk tiers and what each requires, model monitoring and drift detection, hallucination rates and human-in-the-loop design, guardrail KPIs, and how to run governance as a measured, auditable discipline rather than a compliance checkbox.

A descriptive overview of how the People's Republic of China is organized: the role of the Communist Party of China, the Politburo Standing Committee, the National People's Congress, the State Council, the Central Military Commission, and the People's Political Consultative Conference. Focus is on institutions and how they fit together.

You already let Copilot autocomplete your code. This lesson dives into the underused power features: chat participants, slash commands, Copilot Edits, agent mode, custom instructions, prompt files, the model picker, MCP servers, and Copilot Spaces.

A tour of the underused Claude Code power features beyond basic prompting: CLAUDE.md memory, plan mode, rewind, custom slash commands, subagents, hooks, MCP servers, statusline, and headless mode.

What measurable benchmarks say agentic software agents can actually do in 2026, what production deployments have publicly disclosed, the strongest skeptic case on the books, and how the EU AI Act reshapes the deployment math.

Where the evidence for AI in scientific discovery is strongest, where it is weakest, and how to tell them apart. Anchored on AlphaFold's peer-reviewed record, the 2024 Nobel Prize in Chemistry, and what AI-first drug-discovery companies have actually disclosed to investors.

Evidence on AI in legal practice: the Stanford RegLab hallucination benchmark of Westlaw and Lexis+ AI, the Mata v. Avianca and Park v. Kim sanctions cases, and what published ethics rules require.

Hard evidence on AI coding assistants: the Microsoft Research RCTs, METR's surprising 2025 slowdown finding, SWE-bench Verified, and why benchmark scores keep outrunning real-world value.

An evidence-led look at AI agents in customer support: the Brynjolfsson NBER RCT, Klarna's 2024 victory lap and 2025 walk-back, and what generalises beyond a single firm.

Ship a full-stack app on Next.js 15: Prisma schema, migrations vs db push, the hot-reload-safe client singleton, Server Components reading data, Server Actions mutating it, useOptimistic, Auth.js, and a Vercel + Neon deploy.

Crypto is YMYL — Google and AI engines hold these pages to a higher trust bar. How to build entity strength, structure Organization and Person schema, defend brand-name SERPs, and turn E-E-A-T into a flywheel that compounds in both classic SEO and GEO citations.

The RSC mental model: server-by-default, the 'use client' boundary, what can cross it, Server Actions with 'use server', streaming with Suspense, and a Postgres-to-Client end-to-end example.

How to actually quantify your presence in AI answer engines in 2026: query banks, sampling at scale, citation attribution, llms.txt and Common Crawl tracking, and the KPIs that survive scrutiny from leadership without overclaiming precision.

Next.js 15 App Router: page/layout/loading/error files, nested layouts, dynamic and catch-all segments, route groups, parallel routes, and the Metadata API for SEO — with the file tree as a diagram.

From hand-rolled useEffect fetches to TanStack Query v5 and SWR: race conditions, caching, mutations, optimistic updates, error boundaries, and when to push fetching to the server.