What I Wrote This Week — JavaScript, Spring Boot, and the JVM
(April 13–19, 2025)
Here’s a quick look at what I published on Medium this week. Most of it focused on how JavaScript works behind the scenes, how Spring Boot behaves at runtime, and what the JVM actually does when your code runs.
If you like figuring out what your tools are really doing, or noticing the small things that catch people off guard, there’s probably something in here you’ll enjoy. Each one is free for anyone to read.
JavaScript Internals
What JavaScript Closures Are and What They Do
Closures can feel invisible when you first use them. This article shows how they work and what makes them tick.
What the this Keyword Really Does in Different JavaScript Contexts
Depending on where and how it’s used, this can mean different things. This goes over what those differences are.
Object Creation in JavaScript and What Happens Behind the Scenes
From constructor functions to prototypes, this walks through how objects get built and wired together.
JavaScript Prototype Chain Lookup Explained
Ever wonder how JavaScript knows where to find a property? This explains what happens when it searches up the chain.
Spring Boot Topics
How Spring Boot Registers Filters, Interceptors and Servlets Without web.xml
In modern applications, you don’t need a web.xml file anymore. Here’s how Spring Boot handles it with annotations and config classes.
Why Some @Configuration Beans Get Created Twice Without Warning
Unexpected double-instantiation? This explains why it happens and how to avoid it.
How Spring Boot Handles YAML Parsing and Binding to Complex Objects
From nested configs to lists and enums, this shows how Spring maps YAML into usable objects.
How Spring Boot Applies @ConditionalOnClass and Other Conditional Logic
Explains how Spring decides when to activate certain beans based on what’s on the classpath.
Managing Lifecycle Hooks with SmartLifecycle in Spring Boot
Covers how to hook into the application lifecycle with more control than @PostConstruct gives you.
Working with ConversionService for Type-Safe Configuration Binding
How to wire up Spring Boot config binding when you're working with more complex types or want validation.
Implementing Method-Level Retry in Spring Boot
This shows how to retry failed methods using Spring annotations without adding extra logic to your service code.
Java and JVM Mechanics
Why Object Equality in Java Isn’t Always What You Expect
Covers the difference between reference equality and logical equality, and how equals() fits in.
Where Java Stores Static vs. Instance Data in Memory
Looks at how the JVM separates static fields from instance fields, and what that means for memory usage.
The Purpose and Mechanics of Escape Analysis in the JVM
Why the JVM sometimes skips heap allocation entirely. This article breaks down what escape analysis is doing.
Behind the Scenes of How Java Resolves Method Overloading
Overloaded methods seem simple, but the compiler follows a specific set of steps to figure out which one gets called.
Why Java Generics Don’t Work the Same as C++ Templates
Java’s generics feel more limited for a reason. This article is all about what type erasure do and how they change the game.
Why Java Uses Type Inference in Modern Language Features
Newer Java versions let you skip writing out some types. This article shows how the compiler figures it out.
Why the JVM Needs a Constant Pool and What It Stores
Breaks down what the constant pool holds and why the JVM relies on it during class loading and execution.
Racket Internals
How Racket Syntax Objects Retain Source Information
Explains how Racket tracks where your code came from, which helps with error reporting and tooling.
How Structures Work in Racket and What Happens During Instantiation
Covers what happens when you define a structure and create one, including memory layout and function generation.
The Mechanics Behind How Racket’s Module System Manages Dependencies and Scope Isolation
Covers how Racket keeps modules separate, handles dependencies, and avoids scope leaks between files.
That’s everything from last week. I’ll be stepping away from Racket for a bit and focusing more on JavaScript going forward, along with the usual Spring Boot and Java topics. A few performance-focused pieces are also in the works.
If you’ve been enjoying these and want to keep up, subscribing here helps support my writing and lets me keep posting new content each week.