An Engineer's musings
Languages, tooling, and how things work under the hood — with the occasional tangent. Kotlin and the JVM show up often, but each post is really just a careful look at an idea worth understanding.
- 12
- tracks
- 48
- series
- 659
- posts
Pick a path
-
JVM & Backend
112 postsKotlin, Ktor, Guice, and Misk — for engineers building backends on the JVM.
- Kotlin for Java Engineers
- Kotlin Workbooks
- Building APIs with Ktor
- Guice for JVM Engineers · I
- Guice for JVM Engineers · II
- Building Production Services with Misk
-
AI & ML
73 postsA math-light path into running and fine-tuning real AI models — and wiring them to your own tools and data — for engineers, not researchers.
- Practical PyTorch: Running Models — Foundations
- Practical PyTorch: Running Models — Vision
- Practical PyTorch: Running Models — Language
- Practical PyTorch: Running Models — LLMs
- Practical PyTorch: Running Models — Audio
- Practical PyTorch: Training Models
- Building MCP Servers
- LangGraph from Scratch
-
Data & Analytics Engineering
111 postsBuilding reliable data transformations as real software — starting with dbt, verified on DuckDB.
- Airflow from Scratch
- Airflow in Practice
- Orchestrating dbt with Airflow
- Snowflake from the Ground Up
- The Modern Data Stack: Snowflake + dbt + Airflow
- Dimensional Modeling from the Ground Up
- Prefect for Airflow Engineers
-
Integration & iPaaS
34 postsConnecting systems, APIs, and data with an integration platform — starting with MuleSoft, from first flow to production.
- MuleSoft from Scratch
- MuleSoft in Practice
- DataWeave: The Language
- DataWeave in the Wild
-
Python for Kids
62 postsA five-phase summer of coding for middle-schoolers — from turtle drawings to a taste of AI.
- Python for Kids · Phase I
- Python for Kids · Phase II
- Python for Kids · Phase III
- Python for Kids · Phase IV
- Python for Kids · Phase V
-
Platform Engineering
41 postsThe layer under your services — Kubernetes from an empty cluster, then a service mesh with Istio, with every claim run against a real lab.
- Kubernetes from Scratch
- Istio from Scratch
- Istio in Practice
-
Claude Certifications
59 postsStudy guides for the Anthropic Claude certification exams — the underlying skills, mapped to each exam blueprint and built against the current SDK and tooling.
- CCAR-Foundations: Claude Certified Architect
- CCD-Foundations: Claude Certified Developer
- CCA-Professional: Claude Certified Architect
-
Go
56 postsLearning Go from the ground up — the language, its concurrency model, building real software, and production-grade Go — compile-verified against a pinned toolchain.
- Go from the Ground Up
- Concurrency in Go
- Building Real Things in Go
- Go in Production
-
SQL
51 postsSQL as a language, from your first SELECT to reading a query plan — the language, the analytical toolkit, how the database runs your query, and SQL in production, all run-verified against PostgreSQL 18.
- SQL from the Ground Up
- Querying Like You Mean It
- How Databases Run Your Query
- SQL in the Real World
-
DuckDB
18 postsAn analytics database with no server, where a Parquet file is a table and the engine lives inside your process — the counterpart to the server-and-row-store model the SQL track teaches.
- DuckDB from the Ground Up
-
Apache Iceberg
40 postsThe open table format underneath the modern lakehouse — an explicit, versioned list of files with an atomic way to swap it, which is what a directory of Parquet never had.
- Apache Iceberg from the Ground Up
- Apache Iceberg in the Wild
-
macOS
2 postsNotes and fixes from keeping an Intel Mac healthy.
- macOS
Browse the series
-
JVM & BackendKotlin for Java Engineers
A ground-up tour of Kotlin for developers coming from Java.
27 posts -
JVM & BackendKotlin Workbooks
Short coding exercises to practice the concepts from each Kotlin lesson.
27 posts -
JVM & BackendBuilding APIs with Ktor
Build real-world backends and APIs in Kotlin with Ktor — from your first route to production.
17 posts -
JVM & BackendGuice for JVM Engineers · I
Dependency injection with Guice from the ground up — fundamentals, in Kotlin and Java.
8 posts -
JVM & BackendGuice for JVM Engineers · II
Advanced Guice: multibindings, generics, assisted injection, AOP, private modules, custom scopes, the servlet extension, and testing.
8 posts -
JVM & BackendBuilding Production Services with Misk
A source-verified, production-first guide to Cash App's open-source Kotlin microservice container.
25 posts -
AI & MLPractical PyTorch: Running Models — Foundations
Tensors, shapes, the GPU, and building your first model from a single layer up — the math-free groundwork, in Colab.
7 posts -
AI & MLPractical PyTorch: Running Models — Vision
Convolution and LeNet, ResNet up close, and running a pretrained image classifier end to end — then wrapping it in an app.
5 posts -
AI & MLPractical PyTorch: Running Models — Language
Words to vectors, attention and the transformer, DistilBERT, Hugging Face pipelines, embeddings, and a semantic search engine.
9 posts -
AI & MLPractical PyTorch: Running Models — LLMs
Find and run heavyweight models from the Hub, debug runs, and drive a decoder — GPT-2, sampling, chat models, and a chatbot.
6 posts -
AI & MLPractical PyTorch: Running Models — Audio
Generate speech and music with pretrained models — text-to-speech, neural audio codecs, and MusicGen — in Colab, still without the math.
8 posts -
AI & MLPractical PyTorch: Training Models
Understanding & fine-tuning — how models learn, and adapting a pretrained model to your own data, still without the heavy math.
9 posts -
AI & MLBuilding MCP Servers
The Model Context Protocol from first principles to a production server — tools, resources, prompts, transports, and auth, in Python and TypeScript.
12 posts -
AI & MLLangGraph from Scratch
Build agentic systems from first principles — LangChain 1.x primitives, the StateGraph, tools and RAG, persistence and human-in-the-loop, up to a multi-agent bookshop support system. Run-verified on langchain 1.3 / langgraph 1.2.
17 posts -
Data & Analytics EngineeringAirflow from Scratch
Orchestration for newcomers — why it exists, running Airflow locally, and building your first DAGs with the TaskFlow API on Airflow 3.
13 posts -
Data & Analytics EngineeringAirflow in Practice
Custom operators, sensors, dynamic mapping, assets, executors, and shipping to production — Airflow 3 beyond the basics.
18 posts -
Data & Analytics EngineeringOrchestrating dbt with Airflow
Turn a dbt project into a real Airflow task graph with Cosmos — a task per model, selectors, state-aware runs, tests, and CI.
11 posts -
Data & Analytics EngineeringSnowflake from the Ground Up
A cloud data warehouse from first principles — Snowsight, virtual warehouses, loading, roles, time travel, semi-structured data, clustering and performance, cost governance, data sharing, and programmability.
20 posts -
Data & Analytics EngineeringThe Modern Data Stack: Snowflake + dbt + Airflow
The capstone — point dbt at Snowflake with key-pair auth, orchestrate it with Airflow and Cosmos, and build a TPCH pipeline end to end.
12 posts -
Data & Analytics EngineeringDimensional Modeling from the Ground Up
What to actually build in the warehouse — the star schema, fact and dimension tables, and slowly changing dimensions, each modeled in dbt on Snowflake.
17 posts -
Data & Analytics EngineeringPrefect for Airflow Engineers
The Pythonic orchestrator, seen from Airflow — flows and tasks, dynamic execution, deployments, work pools, blocks, and Prefect 3's transactions.
20 posts -
Integration & iPaaSMuleSoft from Scratch
Integration for newcomers — what MuleSoft is, your first Mule app, DataWeave, connectors, and a deploy to the cloud.
9 posts -
Integration & iPaaSMuleSoft in Practice
API-led connectivity, advanced DataWeave, batch, policies, security, and CI/CD — MuleSoft beyond the basics.
9 posts -
Integration & iPaaSDataWeave: The Language
DataWeave 2.0 as a functional language — the data model, types, functions, and the map/filter/reduce core that transforms behave.
8 posts -
Integration & iPaaSDataWeave in the Wild
Real formats and real problems — XML, CSV and flat files, dates, the standard library, modules, testing, and streaming at scale.
8 posts -
Python for KidsPython for Kids · Phase I
Summer coding for middle-schoolers — draw with Python and the turtle, right in the browser.
13 posts -
Python for KidsPython for Kids · Phase II
Words, logic, and data: programs that talk back.
13 posts -
Python for KidsPython for Kids · Phase III
Code Your Own Games — build real arcade games in the browser with pygame, no install.
12 posts -
Python for KidsPython for Kids · Phase IV
Data Detective — load and chart real data in Google Colab with pandas and matplotlib.
12 posts -
Python for KidsPython for Kids · Phase V
A Taste of AI — use, teach, and train machine-learning models in Colab.
12 posts -
Platform EngineeringKubernetes from Scratch
Containers, orchestrated — pods, deployments, services, and the reconcile loop, built up from an empty kind cluster to a running bookshop.
15 posts -
Platform EngineeringIstio from Scratch
A service mesh without sidecars — ambient mode, ztunnel, waypoints, and mTLS you did not have to ask for, on Istio 1.30.
12 posts -
Platform EngineeringIstio in Practice
The mesh in the real world — the sidecars you inherit, migrating without an outage, tracing, egress, multicluster, cost, upgrades, and debugging it at 3am.
14 posts -
Claude CertificationsCCAR-Foundations: Claude Certified Architect
An independent, unofficial study guide to the Claude Certified Architect – Foundations exam (CCAR-F): the agentic loop, tools and MCP, Claude Code, prompt engineering, and context management — mapped to the exam blueprint and run against a stated package matrix.
16 posts -
Claude CertificationsCCD-Foundations: Claude Certified Developer
Prep for the Claude Certified Developer – Foundations exam (CCDV-F): integrating Claude through the API, building agents and MCP servers, model selection and cost, prompt and context engineering, and security — run-verified against anthropic 0.120, the Agent SDK, Strands, and PydanticAI.
21 posts -
Claude CertificationsCCA-Professional: Claude Certified Architect
Prep for the Claude Certified Architect – Professional exam (CCAR-P): designing, integrating, evaluating, and governing production Claude systems — solution architecture, RAG, evaluation frameworks, cost and latency optimization, governance and compliance, and the stakeholder lifecycle — run-verified where it is code (RAG and eval on a real pipeline), grounded design guidance where it is architecture.
22 posts -
GoGo from the Ground Up
Learn Go the way it is meant to be written — the toolchain, types and zero values, slices and maps, structs and methods, interfaces, errors as values, and generics — every snippet compiled and run against Go 1.26.
15 posts -
GoConcurrency in Go
Goroutines, channels, and the select statement, then the sync toolkit, context, pipelines and worker pools, goroutine leaks, errgroup, and the memory model — the part of Go everyone comes for, run under the race detector against Go 1.26.
14 posts -
GoBuilding Real Things in Go
From the standard library to a running service — HTTP servers and the 1.22 router, JSON, requests and middleware, the http.Client, files and io, time, CLIs, database/sql, and testing in depth (table-driven, httptest, benchmarks, fuzzing) — every program built and run against Go 1.26.
14 posts -
GoGo in Production
What it takes to run Go for real — project layout, structured logging with slog, configuration, graceful shutdown, pprof profiling, observability, build and release, go generate, dependency and vulnerability management, containers, the runtime and GC knobs, and reliability patterns — verified against Go 1.26 where it is code.
13 posts -
SQLSQL from the Ground Up
The relational model and your first SELECT through joins, aggregation, subqueries, set operations, writing data, and constraints — every query run against PostgreSQL 18, NULL and three-valued logic given a chapter of its own.
14 posts -
SQLQuerying Like You Mean It
The analytical half of SQL — CTEs and recursion, the full window-function arc, GROUPING SETS, pivoting, dates, strings and regex, JSON/JSONB, arrays and LATERAL — run against PostgreSQL 18 over the bookshop.
13 posts -
SQLHow Databases Run Your Query
Reading EXPLAIN ANALYZE, indexes (B-tree, partial, covering, GIN/GiST), join algorithms and the planner, MVCC and isolation with real anomaly demos, locking and deadlocks, VACUUM, and partitioning — measured against PostgreSQL 18.
13 posts -
SQLSQL in the Real World
Normalization and keys, views and generated columns, triggers and functions, migrations, and SQL from application code — parameterized queries, injection, pooling, and transactions across a request — against PostgreSQL 18.
11 posts -
DuckDBDuckDB from the Ground Up
The analytics database that runs inside your process — files as tables, a vectorized engine, nested types, and the embedding story a server-based warehouse cannot tell. Run-verified against DuckDB 1.5.5.
18 posts -
Apache IcebergApache Iceberg from the Ground Up
The table format that made a folder of Parquet behave like a table — snapshots, schema and partition evolution, row-level deletes, and the maintenance nobody warns you about. Run-verified against Iceberg 1.11.0.
21 posts -
Apache IcebergApache Iceberg in the Wild
Iceberg once it is shared infrastructure — object storage, production catalogs, conflicting writers, multi-engine correctness, compaction as policy, streaming tables, incidents, recovery and the bill. Every chapter opens with something broken.
19 posts -
macOSmacOS
Notes and fixes from keeping an Intel Mac healthy.
2 posts
Latest posts
-
Appendix A: Version Four Is a Number, Not a Format Appendix A. Iceberg 1.11.0's jar declares format version 4 supported, and Spark will create a v4 table today, but the v4 specification is unreleased and the table's metadata carries exactly v3's fields. What the Summit 2026 roadmap set out, what has been voted into the spec, what is still contested, which engines read the table Spark wrote, and why no production table should carry the number yet. -
The Bill Is a Table Too The cost model of the bookshop's lakehouse, populated from the lab's own request and byte counts: what a commit costs, what a streaming writer costs a day, what compaction buys back, what the metadata file costs the catalog per load, and what the unreferenced files cost until they are cleaned. Then the operating model that owns each line, and the production review that puts the whole book on one page. -
Fifty Thousand Orders, and Everything That Happens to Them One table, one session: build it, evolve its schema and its layout, mutate it, wreck it with forty commits, then measure the repair — and get the same answer from three engines that never spoke to each other. -
What the Service Takes Off Your Hands, and What It Takes Away Managed Iceberg, held against the seventeen chapters before it: which maintenance jobs each of five services runs for you, which of the book's decisions each one takes away, where the catalog is the lock-in and the format is not, and an operating-model matrix for deciding when to accept the trade. Documentation-verified, dated, and labelled as such throughout. -
A Bitmap and a Serial Number The two v3 additions that change a table's architecture rather than its type system: deletion vectors, which replace a Parquet file with 44 bytes of bitmap, and row lineage, which gives every row a stable identity and turns change data capture into a WHERE clause.