Publication
Exploring modern software engineering,
one deep dive at a time.
Long-form technical content on AI, distributed systems, and software architecture — series, deep dives, and standalone essays.
8 series · 96 posts · updated Oct 2026
Featured Series
Season 2: Kubernetes: The Container Odyssey
This is the second season of "The Container Odyssey," a 10-part Kubernetes tutorial series written for experienced software engineers who have mastered core Kubernetes concepts and are now ready to tackle the broader ecosystem. It continues the story of Alex, who has been promoted to Platform Lead at NovaCraft and now faces the challenges of running Kubernetes at scale for 10+ engineering teams.
AI: Through an Architect's Lens
Exploring AI/ML concepts from a distributed systems architect's perspective — bridging theory with production-grade engineering.
Season 1: Kubernetes: The Container Odyssey
This is a 12-part Kubernetes tutorial series written for experienced software engineers who are new to Kubernetes. It follows the story of Alex, a senior backend engineer with a decade of experience in monoliths and VMs, who joins a fast-growing startup called NovaCraft where everything runs on Kubernetes. Each chapter solves a real problem Alex faces at NovaCraft, combining deep conceptual explanations with practical, runnable examples that you can follow on your macOS laptop. The series progresses from foundational concepts to production-ready practices, building on each previous chapter.
The Adventures of Ava the Astronaut: Learning Python One Planet at a Time.
A python series designed for absolute beginners with a storytelling narrative throughout. Each part follows Ava's space adventure while teaching a core Python concept, includes tables for clarity, code examples, and a hands-on mini-project.
Redis Deep Dive: From Cache to AI Memory
This is an extensive, multi-part Redis tutorial series written for senior software engineers. It follows the story of Maya, a Staff Engineer at GlobalMart, who leads the architectural transformation of a struggling monolith into a distributed, AI-powered platform. Each chapter combines narrative storytelling with deep conceptual explanations, internal architecture breakdowns, Mermaid diagrams, and comprehensive Java Spring Boot examples. The series progresses from foundational memory management to advanced vector search and RAG implementations.
Kotlin for Java Survivors: Life After Semicolons
A sixteen-part recovery program for Java developers moving to Kotlin: fewer NullPointerExceptions, zero semicolons, coroutines instead of thread pools, and two Spring Boot 4.1 services to prove it, one with an AI assistant that knows what it doesn't know. Just enough syntactic sugar to question why you suffered so long.
Java Evolution: From 8 to 25
A comprehensive, release-by-release tour of every major feature added to Java from version 8 through version 25. Each part covers one release — explaining the concepts behind each feature, showing practical before-and-after code examples, and placing the change in the context of the language's evolution. Whether you are upgrading a legacy codebase or simply want to stay current with modern Java, this series gives you the depth and clarity to understand not just what changed, but why.
Python for Java Developers: From Streams to Tensors
A 10-part, example-driven Python series for experienced Java, C# and other mainstream developers heading into data science, machine learning and AI. It follows Arjun, a veteran Java architect at a payments company, as he is pulled into an ML fraud-detection initiative and has to become productive in Python fast. Each part maps what you already know to the Pythonic way, explains the critical mental-model shifts in depth, and builds toward NumPy, pandas, scikit-learn, PyTorch and LLM-era tooling — with runnable code, tips, tricks and the gotchas that bite Java people specifically.
Latest
Part 0: Kotlin for Java Survivors: Life After Semicolons
A 16-part series for senior Java and Spring developers learning Kotlin 2.4. Follow Kabir, a 14-year Java veteran, from culture shock to shipping two Spring Boot 4.1 services with Kafka, Qdrant, Spring AI and LangChain4j.
Part 1: "Life After Semicolons" — Syntax, Control Flow and the Build
Kabir's first Kotlin pull request is Java with the semicolons left in. We set up a Kotlin 2.4 Gradle build, see what top-level functions compile to, and cover val/var, types without primitives, strings, default arguments, if/when/try as expressions, ranges and loops.
Part 2: "The Billion-Dollar Fix" — Null Safety and the Type System
A NullPointerException from a Java supplier SDK crashes Kabir's Kotlin code. We cover nullable types and the safe-call operators, what they compile to, smart casts and their limits, platform types and JSpecify, lateinit vs lazy, Any/Unit/Nothing, and == vs ===.
Part 3: "Classes Without Ceremony" — Constructors, Properties and Objects
Kabir starts typing getters and Lena stops him. We cover properties instead of fields, accessors and explicit backing fields, primary constructors and init order, final-by-default classes, Kotlin's different protected and internal, objects and companions instead of static, nested vs inner classes, and enums with entries.
Part 4: "Data, Sealed and Value" — Modelling the Domain
Two swapped String arguments make a Pune till ring up toor dal at zero. We rebuild the catalog model with data classes and copy(), destructuring, sealed hierarchies with exhaustive when, value classes that cost nothing until they box, and type aliases, and see what each compiles to.
Part 5: "Functions Are Values" — Lambdas, References and Inline
A return inside forEach silently skips half of a pricing audit. We look at what a Kotlin lambda really is: function types instead of functional interfaces, closures over mutable variables, references, fun interfaces, inline functions and where each kind of return goes, plus tailrec and a first look at lambdas with receivers.