Brendan Lynskey · Portfolio home · Interactive sites
Software engineering, web development, and computer science repositories — presentations, playgrounds, and reference projects.
| Project | Description |
|---|---|
| Introduction to CI/CD (md) | Interactive presentation on continuous integration and deployment — pipelines, quality gates, protecting main, CI across repos, deploying safely (migrations, smoke checks, health endpoints), observability, DORA metrics, and a Key terms glossary of every CI/CD term used on this GitHub |
| Introduction to Jenkins (md) | Interactive presentation introducing Jenkins — controller and agents, plugins, declarative and scripted pipelines, credentials, test reports, shared libraries, security, and Jenkins vs GitHub Actions vs GitLab CI, with real screenshots and pipelines from a local Jenkins |
| Introduction to GitHub Actions (md) | Interactive presentation on using GitHub Actions — workflows, triggers, matrices, caching, artifacts, reusable workflows and custom actions, least-privilege tokens, environments, OIDC, script injection, debugging, protecting main with rulesets and required checks, and Lighthouse CI, with every demo workflow run for real |
| Introduction to Databases (md) | Slide deck covering relational theory, SQL, transactions, indexing, NoSQL models, and choosing the right database engine |
| Deploying Web Applications (md) | Interactive presentation on deploying web apps — static hosting, PaaS, cloud providers, DNS, HTTPS, and deployment strategies for free and paid access |
| Deploying with Docker (md) | Interactive presentation on Docker and containers — Dockerfiles, Compose, registries, Kubernetes basics, and cloud container hosting |
| Deploying Node.js Microservices (md) | Interactive presentation on deploying Node.js microservices — service design, containerisation, inter-service communication, Kubernetes, AWS, and production observability |
| Introduction to Node.js (md) | Interactive presentation on Node.js — V8 engine, event loop, async I/O, streams, Express middleware, npm, security, and scaling to production |
| Introduction to VSCode Extensions (md) | Interactive presentation on VSCode extensions — Extension API, Language Server Protocol, Webviews, testing, packaging, publishing, and CI/CD |
| Writing VS Code Extensions — Tutorial Series (repo) | Step-by-step five-part tutorial on building VS Code extensions — (1) getting started & scaffolding with yo code, (2) commands & contribution points, (3) the Extension API in depth, (4) webviews & language features (Tree Views, Webviews, IntelliSense, diagnostics, LSP), (5) testing, packaging & publishing to the Marketplace and Open VSX. Hub landing page + five interactive decks |
| Monetising & Distributing Software (md) | Interactive presentation on turning code into a product — SaaS, licensing, Stripe integration, app stores, and scaling from free to paid |
| tmux with Claude Code (md) | Interactive presentation on tmux — terminal multiplexing, session management, pane workflows, and optimal use with Claude Code |
| Introduction to GitHub (md) | Interactive presentation on GitHub — repositories, pull requests, Actions, GitHub CLI, security features, Copilot, GitLab comparison, and alternative platforms |
| Introduction to Simulation (md) | Interactive presentation on simulation across engineering — field solvers, SPICE, event-driven and cycle-based RTL, architecture and system models, Monte Carlo, virtual platforms, stiffness and step control, co-simulation, digital twins and verification and validation — with an interactive four-solver demo, measured simulator speeds, and links into every simulation series here |
| Simulation Engineering Toolkit (repo) | Fourteen interactive decks on the engineering around a performance simulator — Rust for simulation engineers and a bit-exact PyO3 port, C++/SystemC TLM-2.0 models, DRAM/HBM memory modelling, a cocotb/Verilator verification bridge, testing frameworks, Jenkins (real runs of five simulator repos), Jira and engineering metrics (JQL checked against Atlassian’s docs), specifications, requirements and test plans (EARS, a generated traceability matrix), PyTorch and ONNX front ends, performance analysis (py-spy flame graphs, cachegrind, regression gates from measured noise), and measurement tools and methods (a catalogue of every profiler, counter, energy and trace tool, coverage tool and architecture estimator the series uses, with measured overheads and a CACTI SRAM sweep), and power, performance and area (an area, yield and cost model for an FHE accelerator, a live Pareto-front explorer, and the trade-offs the series make, named), and an accelerator model in SimPy, end to end (a torch.export or ONNX graph through memory, DMA, buffer and compute-array models, with stall attribution, timelines, a cycle-stepped twin, a bit-identical C++/pybind11 fast path and an NTT workload). Every number from a recorded run; a glossary links each concept to its slide |
| Rust_DES_Kernel | A discrete-event simulation kernel in Rust and a bit-exact port of a SimPy LLM-serving simulator, exposed to Python with PyO3/maturin — differential, golden, property-based (proptest, Hypothesis) and mutation tests (95% score), 97.5% line coverage, 71–74× faster than SimPy; GitHub Actions and a Jenkins pipeline with JUnit, coverage and a performance gate |
| Torch_Sim_Frontend | PyTorch and ONNX front ends for an accelerator cost model — a dispatch trace on the meta device or under fake tensors, torch.export, a torch.compile backend and a weightless ONNX graph walk, all agreeing exactly on Llama-3-8B; traces Llama-3-70B with no weights; roofline and offload cost models, operator coverage by operators, FLOPs and time; a SimPy accelerator model run end to end from the graph (memory, interconnect, DMA, on-chip buffer with back-pressure, compute array and vector unit; utilisation, stall and hot-spot reports, timeline plots), a bit-identical C++20/pybind11 fast path, a cycle-stepped twin, an NTT workload and ONNX Runtime execution-provider partitioning; an EARS specification with a generated traceability matrix; GitHub Actions and Jenkins |
| MCP Gateway Playground | Docker MCP Gateway demo — custom MCP servers for tools, resources, and prompts behind a gateway, with a web-based client UI |
| MCP Supergateway Playground | MCP playground using supergateway — three MCP servers with SSE bridge, web UI, and CLI control for Claude Code mobile |
| transformer-explainer (live · slides · PDF) | Full-stack reference project — Next.js 14 App Router, TypeScript strict, Drizzle + Neon Postgres, Auth.js v5 GitHub OAuth, MDX content, D3 visualisations, Vitest + Playwright + axe-core. Built as a teaching artefact: the content is an interactive Transformer-decoder explainer; the codebase is a clean walked-through example of every layer (Server Components, Route Handlers, the graceful-fallback pattern, monotonic SQL upserts, token-bucket rate limiting, end-to-end OAuth, the test pyramid, CI/CD, Vercel deploy). 8-page backend-engineering PDF tour and a Reveal.js presentation included |
The series primer. Sixty years of who are you? and what may you do? on one map — history, threat landscape, standards lineage, and a reading roadmap to the eleven decks below. No code, no RFCs in the body. Read this first if the field is new (or if you’ve read pieces over the years and want them indexed).
| Project | Description |
|---|---|
| Identity & Authorisation — A Primer (md) | The gateway deck — why these problems exist, the four eras (mainframe → web → mobile/cloud → agent & wallet), the AuthN and AuthZ conceptual maps, north-south vs east-west, the standards landscape (IETF / OIDF / OASIS / W3C / FIDO / NIST / CNCF), the threat-class → defence table, build-vs-buy, the GDPR / PSD2 / eIDAS 2.0 / DORA / EU AI Act backdrop, and a reading roadmap to all eleven decks below |
A seven-deck treatment of identity and access — who is the user, and how do they prove that to other systems? Authentication primitives plus the federation stacks (OAuth, OIDC, SAML/SCIM) that propagate identity. The companion Authorisation section below covers the what may they do half. (Start with the Primer above if the field is new.)
| Project | Description |
|---|---|
| Authentication Methods (md) | Establishing who the user is — Argon2id password hashing, NIST 800-63B policy, rate-limiting & credential stuffing, the three factor classes and AAL ladder, TOTP/HOTP, the SMS/email/push trade-offs, WebAuthn / FIDO2 / Passkeys (vocabulary + cryptographic origin binding), platform vs roaming and synced vs device-bound, discoverable credentials + conditional UI, attestation / AAGUID / FIDO MDS, account recovery, risk-based auth + CAEP/SSF, anti-bot detection, build vs buy |
| OAuth — A Gentle Primer (Part 0) (md) | No-RFC, no-code primer on OAuth — the valet-key mental model, AuthN vs AuthZ, the password-sharing problem, “Sign in with Google” walked through, the five universal steps, tokens, scopes, glossary and the MCP angle. Read first if delegated auth is new |
| Introduction to OAuth (Part 1) (md) | Interactive presentation on OAuth — purpose, history, OAuth 1.0a → 2.0 → 2.1, all grant types, PKCE, OpenID Connect, JWTs, DPoP/mTLS, BCP 240 attacks & defences, library and flow selection |
| OAuth for MCP Servers (Part 2) (md) | Companion deck on OAuth for the Model Context Protocol — the 2025 MCP authorisation profile, Resource Indicators, DPoP, the Docker MCP Gateway as an OAuth broker, and a full tour of commercial (Auth0, Entra, Stytch, WorkOS, Clerk, Cognito) and open-source (Keycloak, ZITADEL, Authentik, Ory Hydra, Authelia, Logto) providers |
| Introduction to OpenID Connect (repo) | OIDC foundations — OIDC = OAuth + ID token, JWT validation, discovery, JWKS rotation, UserInfo, response types, RP-initiated / back-channel logout, CIBA, SIOPv2 & Verifiable Credentials, OpenID Federation 1.0 (Sep 2024), FAPI 2.0, real-world OP quirks (Google / Entra / Apple / Okta / Keycloak / ZITADEL / Cognito), workload OIDC for CI/CD |
| Advanced OpenID Connect (md) | The deep-end OIDC companion — validation edge cases (aud / azp, pairwise subjects, alg confusion), PAR / JAR / JARM, FAPI 2.0 Security Profile + Message Signing, mTLS / private_key_jwt / DPoP, three logout specs, Token Exchange (RFC 8693), OpenID Federation 1.0 trust chains, eIDAS 2.0 + EUDI Wallet, the SIOPv2 + OpenID4VCI + OpenID4VP wallet stack, ISO mDL (18013-5/-7), workload OIDC deep dive, MFA UX, observability, migration playbooks, and reference architectures by domain |
| SAML 2.0 & SCIM (md) | The parallel enterprise stack — SAML history, roles, metadata exchange, SP/IdP-initiated SSO, bindings, assertion structure & validation, NameID formats, SAML attacks (XSW, XXE, replay) and defences, Single Logout (and why CAEP replaces it), SAML vs OIDC decision matrix, WS-Federation / Kerberos / LDAP-bind legacy, SCIM 2.0 protocol & resource model, JIT vs SCIM provisioning, group sync, IdP quirks (Entra / Okta / Workspace / Ping / OneLogin / ADFS), IdP brokers, B2B enterprise-readiness checklist |
A three-deck treatment of what may the user (or workload) do, and how do we enforce it? — the decision-and-enforcement complement to Identity & Access. Conceptual foundations, then east-west service-to-service authz, then north-south edge-and-gateway authz. (See the Primer at the top for how this section sits in the wider field.)
| Project | Description |
|---|---|
| Authorization Models (md) | The decision layer — PEP/PDP/PAP/PIP architecture, the DAC → MAC → RBAC → ABAC → ReBAC arc, role-explosion in RBAC, XACML lineage and modern Cedar for ABAC, Google Zanzibar and the relationship-tuple model with OpenFGA / SpiceDB. Policy-as-Code engines compared (OPA / Rego, Cedar, OpenFGA, SpiceDB, Casbin). Deployment topologies, performance & caching, audit & explainability, the AuthN-to-AuthZ mapping, decision matrix, migration patterns, reference architectures by domain, production gotchas |
| Workload Identity & Service-Mesh AuthZ (md) | East-west authorisation — the workload-identity problem; SPIFFE & SPIRE in depth (SVIDs, attestation, federation/trust bundles); service-mesh AuthZ across Istio AuthorizationPolicy / Linkerd / Cilium L4-L7 + Tetragon; mTLS at scale (issuance, rotation, root rotation); cloud-native workload identity (IRSA / GCP WI / Azure WI / WIF); K8s ServiceAccountTokenVolumeProjection; service-mesh + JWT for end-user identity at L7; workload identity for AI agents & MCP servers; choosing a stack; migration; production gotchas |
| Edge & Gateway AuthZ (md) | North-south authorisation — token validation at the edge (JWT vs introspection); Envoy ext_authz; AWS API Gateway authorizers; Cloudflare Access & Workers; Kong / Apigee / Tyk / Krakend; rate-limit-as-policy; mTLS termination + identity propagation; JWT downscoping & Token Exchange at the edge; WAF vs AuthZ boundary; GraphQL gateway patterns; webhook authorisation; the MCP Gateway as the AI-era edge authz pattern; multi-tenant edge; observability; anti-patterns; choosing a stack |
*aaS)A six-deck consolidated treatment of cloud service models — IaaS / PaaS / SaaS / CaaS / FaaS / AIaaS — with deep coverage of architecture, deployment, security and the LLM-as-a-Service landscape. Companion to the Deployment, Docker and Monetising decks above; new content is the architectural and operational depth (multi-tenancy, IAM, compliance, managed AI) those decks deliberately don’t cover.
| Project | Description |
|---|---|
Cloud *aaS Hub |
Series index — links to all six decks plus related existing material |
Cloud *aaS 01 — Service Models (repo) |
The *aaS taxonomy — IaaS / PaaS / SaaS / CaaS / FaaS / AIaaS, the shared-responsibility model, 1999 → 2026 history, pricing models, vendor matrix, when to use what |
Cloud *aaS 02 — IaaS Foundations (repo) |
Compute (VMs, spot, bare metal), networking (VPC, subnets, peering, Transit Gateway, PrivateLink), storage (block / object / file), regions & AZs, identity primitives, when IaaS still wins |
Cloud *aaS 03 — PaaS / FaaS / CaaS (repo) |
Heroku / Render / Fly / Vercel / App Engine · Lambda / Cloud Functions / Workers · Cloud Run / ECS Fargate / Container Apps · managed Kubernetes (EKS / GKE / AKS) · cold starts, latency, pricing, decision matrix |
Cloud *aaS 04 — SaaS Architecture (repo) |
Multi-tenancy patterns (silo / pool / bridge / hybrid), tenant isolation (RLS), B2B identity (SAML / OIDC / SCIM), Auth-as-a-Service providers, metering & billing data model, per-tenant observability, residency, cell-based architecture |
Cloud *aaS 05 — Cloud Security (repo) |
Shared-responsibility deep dive · IAM across AWS / GCP / Azure (STS, federation, OIDC) · secrets (KMS / HSM / Vault) · network security (PrivateLink, mTLS, zero trust) · encryption (at rest / in transit / in use, confidential compute) · compliance (SOC 2 / ISO / HIPAA / GDPR / PCI / FedRAMP / EU AI Act / DORA) · supply chain (SBOM, SLSA, Sigstore) · real incidents |
Cloud *aaS 06 — LLM-as-a-Service (repo) |
OpenAI / Anthropic / Google / Bedrock / Vertex / Azure OpenAI / Together / Groq / Fireworks / Replicate · pricing & latency · prompt caching · embeddings & RAG-as-a-Service · agents-as-a-Service · fine-tuning APIs · evals / observability / guardrails · MCP server hosting · LLM-specific security · cost engineering |
| Project | Description |
|---|---|
| Introduction to WebSockets (md) | Interactive presentation on WebSockets — RFC 6455, browser API, Node.js ws, Socket.IO, scaling, security, and real-time communication patterns |
| Introduction to Server-Sent Events (md) | Interactive presentation on Server-Sent Events — EventSource API, text/event-stream protocol, auto-reconnect, AI/LLM streaming, scaling, and security |
| Introduction to Web Workers (md) | Interactive presentation on Web Workers — dedicated workers, shared workers, Service Workers, Cache API, offline-first architecture, and PWAs |
| Introduction to React (md) | Interactive presentation on React — JSX, virtual DOM, components, hooks, state management, routing, performance, and the ecosystem |
| Introduction to Angular (md) | Interactive presentation on Angular — CLI, components, signals, dependency injection, RxJS, routing, forms, and production builds |
| Introduction to Next.js (md) | Interactive presentation on Next.js — App Router, React Server Components, server actions, rendering strategies, middleware, and deployment |
| Introduction to Reveal.js (md) | Interactive presentation on Reveal.js — slide structure, Markdown support, themes, plugins, code highlighting, speaker notes, and deployment |
| Introduction to Server-Side Templating (md) | Interactive presentation on server-side templating — rendering pipelines, EJS, Pug, Handlebars, Nunjucks, template inheritance, security, and Express integration |
| Introduction to EJS (md) | Interactive presentation on EJS — tag syntax, control flow, layouts, partials, includes, XSS prevention, performance, caching, and production project structure |
| Introduction to Pug (md) | Interactive presentation on Pug — indentation-based syntax, mixins, template inheritance, filters, interpolation, Express integration, security, and performance |
| Introduction to Handlebars (md) | Interactive presentation on Handlebars — expressions, helpers, partials, precompilation, layouts, path expressions, security, and Express integration |
| Introduction to Express.js (md) | Interactive presentation on Express.js — routing, middleware, error handling, static files, security, template engines, project structure, and Express 5 |
| Express in Practice (md) | Companion deck of production patterns for Express — Express 5 changes, async error pipeline, project structure at scale, validation at the boundary, AuthN / AuthZ patterns, streaming & uploads, rate limiting & caching, transaction-per-request, BullMQ jobs, supertest + contract tests, observability (pino + OpenTelemetry), helmet/CSP/CORS/CSRF, performance & clustering, graceful shutdown, reverse proxy, OpenAPI contract-first, Express vs Fastify/Koa/Hono/NestJS, Express 4 → 5 migration playbook |
| Introduction to FastAPI (md) | Interactive presentation on FastAPI — the modern Python web framework where type hints become the API. Pydantic v2 validation, Starlette / ASGI, Depends() injection with sub-deps & yield-cleanup, async vs sync rules, OAuth2 / JWT / API-key security utilities, background tasks & SSE / WebSocket streaming, SQLAlchemy 2.0 async, Pydantic Settings for config, TestClient + dependency_overrides, OpenAPI 3.1 generation & client codegen, lifespan events, Docker / K8s deployment, structlog + Prometheus + OpenTelemetry, security hardening, and FastAPI vs Flask / Django REST / Litestar / Starlette |
| Introduction to Passport.js (md) | Interactive presentation on Passport.js — strategies, sessions, local auth, OAuth 2.0, Google/GitHub login, JWT, route protection, and security best practices |
| Introduction to Express Middleware (md) | Interactive presentation on Express middleware — request pipeline, authentication, authorisation, validation, error handling, composition patterns, and testing |
| Introduction to REST API Design (md) | Interactive presentation on REST API design — HTTP methods, resource naming, status codes, pagination, versioning, authentication, caching, HATEOAS, and Express implementation |
| Introduction to Web Authentication (md) | Interactive presentation on web authentication — sessions, cookies, JWT, OAuth 2.0, password hashing, MFA, CSRF, CORS, RBAC, and token security |
| Introduction to CSS Layout (md) | Interactive presentation on CSS layout — box model, Flexbox, CSS Grid, responsive design, container queries, custom properties, logical properties, and production layout patterns |
| Introduction to Testing Web Applications (md) | Interactive presentation on web application testing — Jest, Supertest, React Testing Library, Playwright, Cypress, TDD, coverage, CI/CD integration, and testing patterns |
| Introduction to TypeScript (md) | Interactive presentation on TypeScript — type system, generics, interfaces, advanced types, Node.js and Express integration, React typing, compiler configuration, and migration strategies |
| Introduction to Node.js & Databases (md) | Interactive presentation on Node.js database integration — raw SQL drivers, Knex, Prisma, Sequelize, Mongoose, migrations, transactions, connection pooling, performance, and testing |
| Introduction to Knex (md) | Companion deck on Knex — the chainable SQL query builder for Node.js. Installation & drivers, knexfile.js, the tarn connection pool, SELECT/JOIN/aggregate chains, sub-queries & CTEs, knex.raw bindings, the schema builder, migrations & seeds, transactions & savepoints, streams & batchInsert, TypeScript Knex.Tables declaration merging, in-memory SQLite + Testcontainers testing, performance & N+1 traps, and Knex vs Prisma / Drizzle / Kysely / TypeORM |
| Introduction to GraphQL (md) | Interactive presentation on GraphQL — schema definition, queries, mutations, subscriptions, resolvers, Apollo Server and Client, DataLoader, authentication, pagination, and performance |
| Project | Description |
|---|---|
| Sorting Algorithms (md) | Interactive presentation on sorting algorithms — bubble, merge, quick, heap, radix, counting, stability, complexity analysis, and real-world implementations |
| Graph Algorithms (md) | Interactive presentation on graph algorithms — BFS, DFS, topological sort, connected components, cycle detection, and graph coloring |
| Dynamic Programming (md) | Interactive presentation on dynamic programming — optimal substructure, memoization, tabulation, knapsack, edit distance, and state transitions |
| Greedy Algorithms (md) | Interactive presentation on greedy algorithms — greedy choice property, activity selection, Huffman coding, fractional knapsack, and exchange arguments |
| Divide and Conquer (md) | Interactive presentation on divide and conquer — Master theorem, merge sort, quick sort, Strassen’s algorithm, closest pair, and FFT |
| Backtracking Algorithms (md) | Interactive presentation on backtracking — state space trees, N-Queens, Sudoku, constraint satisfaction, pruning, and branch and bound |
| String Matching Algorithms (md) | Interactive presentation on string matching — KMP, Rabin-Karp, Boyer-Moore, suffix arrays, Aho-Corasick, and pattern matching |
| Shortest Path Algorithms (md) | Interactive presentation on shortest path algorithms — Dijkstra, Bellman-Ford, Floyd-Warshall, A* search, negative cycles, and routing |
| Minimum Spanning Trees (md) | Interactive presentation on minimum spanning trees — Kruskal’s, Prim’s, Borůvka’s, cut property, Union-Find, and network design |
| Network Flow Algorithms (md) | Interactive presentation on network flow — max-flow min-cut, Ford-Fulkerson, Edmonds-Karp, Dinic’s, bipartite matching, and cost flow |
| Computational Complexity (md) | Interactive presentation on computational complexity — Big-O, P vs NP, NP-completeness, reductions, approximation, and amortised analysis |
| Hashing Algorithms (md) | Interactive presentation on hashing algorithms — hash functions, collision resolution, open addressing, consistent hashing, cryptographic hashes, and perfect hashing |
| Project | Description |
|---|---|
| Arrays and Linked Lists (md) | Interactive presentation on arrays and linked lists — contiguous memory, dynamic arrays, singly linked, doubly linked, skip lists, and cache performance |
| Stacks and Queues (md) | Interactive presentation on stacks and queues — LIFO, FIFO, priority queues, monotonic structures, deque, and expression evaluation |
| Binary Trees (md) | Interactive presentation on binary trees — traversals, tree properties, LCA, Morris traversal, expression trees, and serialisation |
| Binary Search Trees (md) | Interactive presentation on binary search trees — BST invariant, search and insertion, balancing, treaps, splay trees, and order statistics |
| Heaps and Priority Queues (md) | Interactive presentation on heaps — binary heaps, heap sort, Fibonacci heaps, build-heap, decrease-key, and priority queue ADT |
| Hash Tables (md) | Interactive presentation on hash tables — hash functions, collision resolution, open addressing, cuckoo hashing, load factor, and concurrent maps |
| Graph Data Structures (md) | Interactive presentation on graph data structures — adjacency matrix, adjacency list, CSR format, DAGs, property graphs, and graph libraries |
| Tries (md) | Interactive presentation on tries — prefix trees, radix trees, suffix trees, autocomplete, Patricia tries, and IP routing |
| Balanced Trees (md) | Interactive presentation on balanced trees — AVL trees, Red-Black trees, rotations, 2-3 trees, balance factor, and persistent trees |
| B-Trees (md) | Interactive presentation on B-trees — B-tree operations, B+ trees, disk I/O, database indexes, node splitting, and LSM comparison |
| Disjoint Sets (Union-Find) (md) | Interactive presentation on disjoint sets — union by rank, path compression, inverse Ackermann, Kruskal’s MST, and connected components |
| Bloom Filters & Probabilistic DS (md) | Interactive presentation on probabilistic data structures — Bloom filters, HyperLogLog, Count-Min Sketch, cuckoo filters, and cardinality estimation |
| Project | Description |
|---|---|
| Coding Challenge Coach (prompt) | LLM-examined, LeetCode-style coding practice for rebuilding hand-coding skill — 822 problems in Python, C, JavaScript, TypeScript, Verilog, SystemVerilog and VHDL across DSA, Modern Python (asyncio, concurrency, typing), Data & SQL, DSP, numerical, AI/ML, LangChain/LangGraph, web/FastAPI, embedded C and digital design. Per-language levels start at easy-only Warm-up; /challenge, /hint, /grade, /solution slash commands; reference-verified tests with Accepted / Wrong Answer / TLE verdicts; hidden tests + 100-point rubric at grading; real OpenAI / Gemini / OpenRouter calls to low-cost models plus a deterministic fake-LLM server; Binary Chop worked in all seven languages; Claude never writes your code (examiner-mode CLAUDE.md + hook) |
A ten-deck consolidated series on compiler construction — how source text becomes running code. From the history of the field and the classic pipeline, through the front end (lexing, parsing, semantic analysis & type systems), the middle end (intermediate representations, SSA, optimisation), the back end (code generation), and runtimes (JITs, GC, WebAssembly), ending by building a small compiler end to end. Each deck is a self-contained Reveal.js presentation with hand-authored inline-SVG diagrams and copy-and-run code, plus a Markdown companion.
| Project | Description |
|---|---|
| Compilers — Series Hub (repo) | Series index & landing page — links to all ten decks, the pipeline-at-a-glance diagram, and the learning arc (front end → middle end → back end → runtime → capstone) |
| 01 — A History of Compilers (md) | First assemblers (Booth, Wheeler), Hopper’s A-0 & the word “compiler”, FORTRAN’s optimiser, ALGOL & BNF, the Chomsky hierarchy, LR/LALR parsing, lex & yacc, the Dragon Book, GCC, SSA, the JIT lineage (Self → HotSpot), LLVM, and the modern infrastructure era (Wasm, MLIR) |
| 02 — The Compiler Pipeline (md) | Compiler vs interpreter vs JIT, analysis vs synthesis, the phases end to end, a worked trace of one statement through every stage, front/middle/back ends and the N×M “narrow waist”, the full toolchain, bootstrapping & T-diagrams, cross-compilation |
| 03 — Lexical Analysis (md) | Regular expressions & regular languages, NFA vs DFA, Thompson’s construction, the subset construction & DFA minimisation, maximal munch & lookahead, hand-written vs generated scanners (lex/flex/re2c), literals & Unicode, the Python INDENT/DEDENT and C lexer-hack cases |
| 04 — Syntax Analysis (Parsing) (md) | Context-free grammars, derivations, parse trees vs ASTs, ambiguity & precedence; top-down (recursive descent, FIRST/FOLLOW, LL(1), Pratt parsing); bottom-up (shift-reduce, LR(0) items, SLR/LALR(1)); conflicts; generators (yacc/bison, ANTLR, tree-sitter, PEG); error recovery |
| 05 — Semantic Analysis & Type Systems (md) | Symbol tables & scope, name resolution & shadowing, attribute grammars & syntax-directed translation, type-system axes, typing judgements (Γ ⊢ e : τ), Hindley–Milner inference & unification, subtyping & variance, generics & type classes, diagnostics |
| 06 — Intermediate Representations (md) | Why an IR, the HIR/MIR/LIR spectrum, three-address code, stack vs register bytecode (JVM/CPython/Wasm vs Lua/Dalvik), control-flow graphs, dominators, SSA & φ-functions (construction & destruction), LLVM IR in depth, CPS, sea-of-nodes, MLIR |
| 07 — Optimization (md) | The “as-if” rule, scope levels up to LTO & PGO, the data-flow framework (lattices, transfer functions, fixed points), the four classic analyses, classic transforms (CSE, DCE, inlining, strength reduction), loop optimisations & vectorisation, SSA-based passes (SCCP, GVN), alias analysis, phase ordering |
| 08 — Code Generation (md) | The three interacting subproblems; instruction selection (tree tiling, BURS, SelectionDAG/GlobalISel); register allocation (interference graphs, graph colouring, Chaitin–Briggs, linear scan, coalescing); instruction scheduling; the System V AMD64 ABI, stack frames & prologue/epilogue; a worked x86-64 / AArch64 example |
| 09 — Runtimes, JITs & Modern Backends (md) | Interpreters & dispatch (threaded code, computed goto), JITs (baseline vs optimising, tracing, tiered execution in V8/HotSpot), inline caches, deoptimisation & OSR, garbage collection (generational, concurrent), exception handling, dynamic linking (PLT/GOT), and modern backends: LLVM, Cranelift, GraalVM, MLIR, WebAssembly |
| 10 — Building a Mini-Compiler (md) | Capstone — one tiny language (“MiniLang”) threaded through the whole pipeline in real, runnable code: grammar → hand-written lexer → recursive-descent + Pratt parser → type checker → three-address IR → constant folding & DCE → stack-VM bytecode → an interpreter that runs it — plus testing, error messages, and where to go next |
| Project | Description |
|---|---|
| Docker Networking (md) | Interactive presentation on Docker networking — bridge, host, overlay, macvlan, DNS resolution, port mapping, network isolation, and production patterns |
| Docker Volumes & Storage (md) | Interactive presentation on Docker storage — named volumes, bind mounts, tmpfs, volume drivers, backup strategies, storage drivers, and database persistence |
| Docker Compose in Depth (md) | Interactive presentation on Docker Compose — services, networks, volumes, profiles, watch mode, multi-environment configs, scaling, and YAML anchors |
| Docker Security (md) | Interactive presentation on Docker security — image scanning, non-root users, secrets, capabilities, seccomp, AppArmor, rootless Docker, and CIS benchmarks |
| Docker Multi-Stage Builds (md) | Interactive presentation on multi-stage builds — FROM AS syntax, distroless images, BuildKit cache mounts, layer optimisation, and language-specific patterns |
| Docker for CI/CD (md) | Interactive presentation on Docker in CI/CD — GitHub Actions, GitLab CI, Jenkins, image tagging, layer caching, security scanning, and deployment strategies |
| Docker Swarm & Orchestration (md) | Interactive presentation on Docker Swarm — cluster setup, services, overlay networking, rolling updates, stacks, secrets, scaling, and Swarm vs Kubernetes |
| Docker Troubleshooting (md) | Interactive presentation on Docker troubleshooting — exit codes, logs, exec debugging, inspect, networking issues, volume permissions, and debugging tools |
| Docker for LLMs, Agents & MCP (md) | Interactive presentation on Docker for AI — Ollama, vLLM, GPU passthrough, LangChain/CrewAI agents, MCP servers, MCP gateways, and production inference patterns |
| Project | Description |
|---|---|
| Introduction to uv (md) | Interactive presentation on uv — Astral’s Rust-based all-in-one Python package & project manager. Installation, uv pip drop-in, projects & uv.lock, uv sync & uv run, Python version management, PEP 723 inline scripts, uvx tools, workspaces, build & publish, performance internals, migration from pip-tools and Poetry, CI patterns |
| uv in Practice (md) | Companion deck of production recipes for uv — Dockerfile patterns, multi-stage distroless images, BuildKit cache mounts, GitHub Actions / GitLab CI / Jenkins / Buildkite, pre-commit hooks, monorepo workspaces, private indexes, reproducibility & SBOM, PEP 723 scripts at scale, PyTorch + CUDA wheel selection, conda/mamba interop, Poetry → uv migration playbook, troubleshooting |
| Introduction to Poetry (md) | Interactive presentation on Poetry — the opinionated Python dependency manager & build backend. Installation, poetry new / init, pyproject.toml in the Poetry 2.0 / PEP 621 era, poetry add / remove, hash-pinned poetry.lock, install & sync, poetry env & in-project venvs, dependency groups vs extras, private indexes & source priorities, build & publish via poetry-core, plugins (export, bundle, poethepoet), Mixology resolver internals, comparison with pip / pipenv / pdm / Hatch / uv, migration from requirements.txt, Poetry 1.x → 2.0 migration, CI & Docker patterns |