August 2026

HTTP/3 for HttpClient:Speak HTTP/3 Without a Third-Party Stack

What Java 26 HttpClient HTTP/3 support is (JEP 517): opt in with Version.HTTP_3, fallback vs HTTP_3_URI_ONLY, and why the default stays HTTP/2.

Algorithms

Kruskal:Grow an MST by Cheapest Edge That Does Not Cycle

Sort every undirected edge cheapest-first, skip endpoints already in the same Union-Find component, accept the rest until n-1 edges — an MST that is not a shortest path from a source.

Java

Final Means Final:Stop Mutating `final` Fields With Reflection

What JEP 500 does in Java 26: warn (not fail) when deep reflection mutates final fields, how to find the callers, and how to stop needing that hole.

Algorithms

A-Star:Dijkstra Plus a Heuristic When You Can Estimate Remaining Cost

Order the heap by f = g + h, settle toward a goal when h never overestimates remaining cost, and skip stale pairs like Dijkstra — the same procedure with a heuristic that may guess low, never high.

Algorithms

Floyd-Warshall:All-Pairs When n Is Small Enough for n³

Fill a dense distance matrix by relaxing every triple (k, i, j) — all-pairs shortest paths when n³ is the bill you can pay, and a negative on the diagonal is a negative cycle.

Java

Key Derivation Functions:Derive Keys Without Rolling Your Own

What the Java 25 KDF API is (JEP 510): derive AES and HMAC keys with javax.crypto.KDF and HKDF-SHA256 instead of HMAC-then-truncate or a copied StackOverflow HKDF.

Java

Module Import Declarations:One `import module` Instead of a Wall of Stars

What Java 25 module import declarations are (JEP 511): import module M brings exported types into simple-name scope, how java.se and java.base fit, and how to resolve List clashes.

Algorithms

Bellman-Ford:Shortest Path When a Negative Edge Is Allowed

Relax every edge V-1 times, then one more pass for a negative cycle — single-source shortest path when a weight is allowed to be negative.

Java

Flexible Constructor Bodies:Validate Before `super()` Without the Hack

What flexible constructor bodies are (JEP 513 / Java 25): validate args and initialize fields in a constructor prologue before super() or this(), without the static-helper hack.

Algorithms

Dijkstra:Shortest Path When Every Edge Weight Is Non-Negative

Grow a min-heap frontier by current distance, settle each vertex once, and lazy-repush instead of decrease-key — the weighted cousin of BFS when every edge weight is non-negative.

AI/ML

How MCP Talks:Discovery, Capability Negotiation, and Transports

How MCP clients and servers discover capabilities, negotiate features, and exchange JSON-RPC over stdio or Streamable HTTP — a self-contained mental model for protocol version 2026-07-28.

AI/ML

Hardening MCP Servers:Auth, Least Privilege, and Tool Safety

Trust boundaries, host approval UX, env secrets, input validation, read-only vs mutating tools, and a practical hardening checklist for a TypeScript MCP bookmarks server.

AI/ML

Host an MCP Server for Public Use:Streamable HTTP and a Live URL

Serve the bookmarks MCP tools over Streamable HTTP with createMcpHandler, protect them with a bearer token, deploy one PaaS URL, and point Cursor at url plus headers.

AI/ML

Ship Your MCP Server:npm Package and the MCP Registry

Package a TypeScript MCP server for npm, add mcpName verification, publish with npm, and register metadata with mcp-publisher — distribution, not hosting.

Java

Compact Source Files and Instance Main:`void main()` Without the Boilerplate

What compact source files are (JEP 512 / Java 25): implicit classes, instance main methods, java.lang.IO, and automatic java.base imports — without public static void main ceremony.

AI/ML

Plug In an MCP Server in Cursor:Your First Working Connection

Wire a local MCP server in Cursor with mcp.json — project vs global config, field-by-field stdio setup, verify Connected, and run one approved tool call.

AI/ML

Build Your First MCP Server in TypeScript:Tools Over stdio

Build a local bookmarks MCP server in TypeScript — McpServer, Zod tools, stderr logging, MCP Inspector first, then wire the build into Cursor over stdio.

AI/ML

MCP Beyond Tools:Resources and Prompts in the Same Server

Add an MCP resource and prompt to a TypeScript stdio server — bootstrap from the bookmarks part-3 tag, verify in Inspector, and note Cursor host limits.

AI/ML

MCP Without the Hype:What It Is and Why Agents Need It

What the Model Context Protocol is, the host/client/server vocabulary, tools vs resources vs prompts, and when agents need MCP — or when Skills and rules are enough.

Algorithms

Strongly Connected Components:Collapse a Directed Graph to a DAG

DFS to record finish order, transpose the digraph, DFS again in reverse finish order — each second-pass tree is a strongly connected component, and the condensation is a DAG.

Java

Compact Object Headers:Cut Header Size Without Changing a Line of Code

What JEP 519 compact object headers are: shrink 64-bit HotSpot headers from 12–16 bytes to 8 without changing application source, how to enable the flag on 24/25, and why Java 27 turns it on by default.

Spring Boot

Spring Boot Observability:Health, Metrics, and Correlation IDs

Build an observable Spring Boot service with Actuator health probes, Prometheus metrics, W3C trace context, request IDs, and production-safe endpoint security.

Java

Class-File API:Parse and Transform Bytecode Without ASM

What the Java 24 Class-File API is (JEP 484): parse, generate, and transform .class files with java.lang.classfile so tools track the class-file format without a third-party ASM lag.

Spring Boot

Testing Slices + Testcontainers:Fast Tests Without Booting the Whole App

Choose focused Spring Boot test slices and verify a Spring Data JPA repository against a real PostgreSQL database with Testcontainers.

Java

Markdown Javadoc:Write Docs in `///` Instead of HTML Soup

What Java 23 Markdown documentation comments are (JEP 467): adjacent /// lines, CommonMark plus GFM tables, and how @param and {@link} still work beside /** */.

Spring Boot

Spring Security Basics at the Service

Turn a Spring Boot API into an OAuth2 resource server, validate JWTs locally, and authorize business actions with method security instead of trusting the edge alone.

Java

Foreign Function and Memory API:Call Native Code Without the JNI Stack

What Java 22 FFM is (JEP 454): Arena, MemorySegment, and Linker downcalls so you can call native code and manage off-heap memory without JNI.

Spring Boot

REST API with Boot 3 + Records as DTOs

Design a Spring Boot 3 REST boundary with Java records, Bean Validation, Jackson, and explicit mapping to service-owned models.

Java

Unnamed Variables and Patterns:Ignore What You Do Not Need With `_`

Learn where Java 22 lets you use underscore for intentionally unused locals, catch parameters, lambda parameters, type patterns, and nested record patterns.

Spring Boot

Spring Data JPA Footguns:Entities vs Records, N+1, Transactions

Build a safe Spring Data JPA boundary with proxy-friendly entities, record DTOs, explicit fetch plans, and service-owned transactions.

Java

Stream Gatherers:Custom Intermediate Ops Without Breaking the Pipeline

What Java Stream Gatherers are (JEP 485 / Java 24), why map/filter/flatMap hit a wall, built-ins like windowFixed and fold, and how to write a short custom gatherer.

Java

Java Streams Advanced:Collectors, Short-Circuiting, and Pitfalls That Bite in Production

Go beyond map/filter/collect: groupingBy, teeing, takeWhile/dropWhile, short-circuit order, primitive streams, parallel pitfalls, and Stream best practices for production Java.

Java

Java Streams:Filter, Map, and Collect Without the Nested Loop Soup

A beginner-to-intermediate guide to Java Streams: source → filter/map/flatMap → collect, lazy pipelines, and when a plain for loop is clearer.

Spring Boot

Spring Boot Virtual Threads:Flip One Flag, Then Fix What Breaks

Enable spring.threads.virtual.enabled on Boot 3.2+, understand what Tomcat and the application task executor actually switch, and size Hikari, RestClient, and observability so the flag does not become a thundering herd.

Algorithms

Topological Sort:Order a DAG Before You Run the Work

Emit each vertex only after its predecessors — Kahn with indegree and a queue, or DFS reverse finish times — and treat leftover vertices as a cycle.

Java

Scoped Values:Share Immutable Context Without ThreadLocal Pain

What Java scoped values are (JEP 506 / Java 25), how they differ from ThreadLocal, why they fit virtual threads, and how to bind request context with where/run and where/call.

Java

Structured Concurrency:Treat Related Tasks as One Unit of Work

Learn the JDK 27 StructuredTaskScope factory API, Joiner policies, fan-in, sibling cancellation, and how structured concurrency fits virtual threads and scoped values.

Java

Sealed Classes + Pattern Switch:Exhaustive Code Without `instanceof` Soup

What sealed classes are (JEP 409 / Java 17), how pattern switch and record patterns finish the story on Java 21, and how to replace cascading instanceof with compiler-checked exhaustiveness.

Java

Locks After Loom:When `synchronized` Still Wins

After virtual threads, when intrinsic locks still win — pinning vs JEP 491, wait/notify, monitors, and ReentrantLock — so you do not treat synchronized as obsolete.

Java

Virtual Threads:Millions of Tasks Without a Thread Pool Circus

What Java virtual threads are (JEP 444 / Java 21), how they differ from platform threads, when they win for I/O-bound work, and the pinning and ThreadLocal gotchas—plus what Java 25 changed.

Kubernetes

kubectl:See What Is Deployed and How It Is Configured

Hands-on kubectl recipes for deploy verification — find pods by label, read placement and resources, confirm image tags or digests, and read recent cluster events.

Kubernetes

Kubernetes with kind:A Cluster for Learning, Testing, and POCs

Spin up a disposable local Kubernetes cluster with kind — install prerequisites, create a multi-node cluster, verify with kubectl, deploy a sample app, and tear it down cleanly.

Java

Java Records:Immutable Data Without the Boilerplate

What Java records are, when they shipped (JEP 395 / Java 16), the problem they solve, and practical use cases with code—from DTOs to sealed-pattern matching.

SOLID

SOLID in Practice:Apply the Five Without the Ceremony

Walk one order/payment notification service through all five SOLID principles end to end — the seams that matter, the ones that do not, and when to stop applying the checklist.

SOLID

Dependency Inversion:Depend on Abstractions, Not on `new`

Apply Dependency Inversion in Java: move Stripe and SMTP construction out of OrderProcessor, inject abstractions, and see how Spring DI is one wiring option — not the principle itself.

AI/ML

AI Agent Skills:What They Are and How to Use Them

Hands-on Cursor Agent Skills for beginners — what a skill is, where it lives, how to write a SKILL.md, and how the agent picks it up.

Git

Stay Off Main:Git Branches Without the Fear

Hands-on Git branching — create a feature branch, push it with upstream tracking, merge back into main, and clean up local and remote branches.

Git

When Push Fails:Merge Conflicts, Revert, and Rollback

Hands-on Git for the stuck push — fetch remote changes, resolve merge conflicts, then revert or roll back commits safely.

Spring Boot

Spring Cloud Gateway:Put a Front Door on Your Microservices

When to put an API gateway in front of your services, the trade-offs that matter, and a working Spring Cloud Gateway Server Web MVC example on the Servlet stack.

Git

Git Without the Panic:Init, Commit, Push

Hands-on Git for beginners — init a repo, stage and commit safely, read diffs, and push your first project to a remote.

SOLID

Interface Segregation:Stop Forcing Clients to Depend on What They Ignore

Apply Interface Segregation in Java: break a fat PaymentOperations interface into client-shaped seams so charge, refund, and report clients stop stubbing unused methods.

Algorithms

Cycle Detection:Directed, Undirected, and the Color/Parent Trick

Detect a directed cycle with 3-color DFS (gray means on the recursion stack) and an undirected cycle by skipping the parent — a visited flag alone is the diamond trap.

SOLID

Liskov Substitution:Subtypes That Don't Surprise Callers

Spot Liskov Substitution violations in Java inheritance — UnsupportedOperationException, tightened preconditions, null surprises — and replace dishonest subtypes with honest types.

Algorithms

DFS:Finish Times, Recursion vs an Explicit Stack, and What a Cycle Looks Like

Walk a graph with DFS, stamp finish times, run the same walk on an ArrayDeque, and recognize a back edge as the shape of a cycle.

SOLID

Open-Closed:Add Behavior Without Rewriting the Core

Apply the Open-Closed Principle in Java: replace growing if/switch payment forests with extension seams so new providers are added, not edited into the core.

SOLID

Single Responsibility:One Reason to Change, Not One Method

What the Single Responsibility Principle actually means — one audience, one reason to change — with a Java OrderProcessor god class split into cohesive pieces.

Linux

Linux Troubleshooting Toolkit:Diagnose Crashes and High Load

Hands-on triage with htop, journalctl, dmesg, and lsof — diagnose high load and crashes by chaining the right tool at each step.

SOLID

SOLID Roadmap:Five Principles Without the Textbook

What SOLID means in practice, a glossary of the five principles, when they become cargo-cult, and a map of this series — with a shared order/payment domain for later posts.