What I Posted This Week — JavaScript, Spring Boot, and Java

(May 4–10, 2025)

Here’s what I’ve been posting this week. Most of it landed right where I’ve been spending the bulk of my time still in JavaScript internals, Spring Boot mechanics, and the kinds of Java behaviors that only show up when you’re deep into a project.

I’ve kept the mix going and found myself enjoying the how-to style posts in Spring Boot more than I expected. They’ve been a good change of pace. I also feel like I’ve finally gotten the hang of Substack’s layout and tools. It feels natural now, and I’m able to shape posts the way I do on Medium.

If you’re new to my work or just want to learn a little more about me, you can check out my About Me page.

Substack Exclusive

The Internal Steps of a ClassCast During Java Execution Test

Where Java Anonymous Classes Live in Memory and How They Behave

What Class Version Numbers Tell the JVM During Class Loading

Java Topics and JVM Mechanics

• What Happens When Java Performs Method Overriding Across Multiple Inheritance Layers
  Each override adds another step the JVM has to deal with. This one breaks down how those layers stack and what that means for execution.

• The Meaning of Volatile Variables in the Java Memory Model
  This post clears up what volatile actually does for visibility and why it's not a fix-all for threading issues.

• Where Object Headers Are Stored and What They Contain in Java Memory
  Every object in Java carries a header. This goes through what’s stored there and how the JVM uses it.

• Why Object Mutability Affects Performance and Thread Safety in Java Applications
  Shows what happens when you work with shared mutable state, and why it’s usually better to avoid it.

• The Lifecycle of a Java Class from Source Code to Loaded Class Object
  Walks through what happens between writing a .java file and running the class.

• Where Recursive Calls Live in Java’s Memory Layout
  Explains how the call stack fills up when recursion happens, and how the JVM keeps track of each frame.

• What Object References Actually Represent in Java Memory
  You're working with references, not the objects themselves. This one goes through what that means in memory terms.

Spring Boot Topics

• Using Application Events to Decouple Components in Spring Boot
  Instead of calling other services directly, you can send out events. This shows how to wire that up.

• Running Background Jobs in Spring Boot Without External Tools
  Covers how to schedule or run tasks without adding more libraries or relying on a queue.

• Using Lombok With Spring Boot to Reduce Boilerplate Code
  Walks through how Lombok cuts down on getters, constructors, and other filler code in Spring apps.

• Adding Request Logging to Spring Boot APIs
  Shows how to add logging that tracks each request without needing a bunch of config.

• Uploading and Serving Static Files in Spring Boot
  Goes through how to upload files and make them accessible later with a simple setup.

• Building a Notification System with Spring Boot and WebSockets
  This one builds out a live update system using WebSockets, useful for things like alerts or live dashboards.

• Integrating Spring Boot with Kafka for Messaging
  Explains how to set up Kafka in a Spring Boot app and start sending messages between services.

JavaScript Internals

• Event Loop Behavior During Heavy Computation in JavaScript
  Too much computation in one go can block the browser. This post shows why and what to watch for.

• The Mechanics of JavaScript Array Methods
  Covers how methods like map, filter, and forEach actually run and what they’re doing behind the scenes.

• How Proxies Intercept Behavior in JavaScript Objects
  Walks through how proxies let you catch reads, writes, and function calls on objects.

• The Difference Between == and === in JavaScript
  This one clears up how the two equality checks behave and why they don’t always give the same result.

• The Mechanics of Event Bubbling and Capturing in JavaScript
  Covers how events travel through the DOM and how to catch them at different points.

• Deep vs Shallow Copy Behavior in JavaScript
  Shows what gets copied and what doesn’t when you clone an object or array.

• How Values Get Passed in JavaScript Functions
  Explains how JavaScript handles function arguments and what gets copied and what stays linked.

I’ve still got more Spring Boot and JavaScript posts coming next, but I’m also planning to start switching back and forth between Java and Kotlin. I think it’ll help to see both side by side. I’m also lining up a few more Substack exclusives, probably more Java and some extra Kotlin content so stay tuned!