What I Wrote This Week — Java, Spring Boot, and Racket

(April 06–12, 2025)

Here’s a quick recap of what I’ve published over the past week on Medium. If you’re working with Java, Spring Boot, or just curious how Racket handles things behind the scenes, these might be worth checking out. Some are new, a few build on older topics, but all of them focus on the kind of stuff that can get skipped in tutorials. Racket’s not the most common language, but I’ve actually had a lot of fun digging into how it works and breaking it down in writing.

Java Topics

• What Happens During Java Object Construction and Initialization
  Step-by-step look at how Java actually builds an object — what memory gets touched, when constructors run, and what order things happen in.

• How Java Handles Dependency Injection with Reflection and Proxies
  Walks through how DI works under the hood, and how Spring gets involved when it needs to wrap beans or wire things up at runtime.

• What Happens When the Java Compiler Handles Lambdas and Functional Interfaces
  Short look at how lambdas turn into bytecode, and why functional interfaces are the glue that holds it together.

• The Proxy Pattern in Java and What Makes It Flexible at Runtime
  Covers how method calls can be intercepted and shaped on the fly using proxy objects.

• How Java Enum Types Work and Why They Are Type Safe
  Enums might feel simple, but this shows what they’re doing behind the curtain and why they behave differently from constants.

• The Mechanics of Java’s Thread Scheduling and Context Switching
  If you’ve ever wondered how Java juggles threads, this one breaks down how the JVM handles scheduling at runtime.

• How Java Virtual Threads Work Differently from Traditional Threads

  Virtual threads let Java handle tons of concurrent tasks without the overhead of traditional OS threads. Here we break down how they work and why they’re a better fit for I/O-heavy workloads.

Spring Boot Stuff

• Extending ObjectMapper for Consistent JSON Behavior Across Services
  If you’ve run into mismatched JSON or weird formatting across microservices, this shows how to keep things consistent using one shared config.

• Using @EventListener with Conditional Event Consumption
  How to control when and how event listeners fire using Spring’s expression language.

• Registering Functional Endpoints with Spring Boot and RouterFunction
  If you’ve only used @RestController, here’s another way to wire up HTTP routes using a functional style.

• Enabling Dynamic Property Injection at Runtime
  Walks through how to swap out configuration values on the fly without restarting your app.

• Building Composite Configuration Sources
  Shows how Spring decides which config value to use when multiple sources (YAML, env vars, etc.) are in play.

• Controlling Bean Initialization Order in Spring Boot Applications
  A quick one about how to make sure your beans load in the right order, especially when one depends on another.

• Inside the Initialization of @RestController Beans
  Ever wonder what actually happens when Spring Boot picks up a @RestController? This walks through how controllers get scanned, registered, and wired before your app starts handling requests.

Racket Internals

• Working with Ports and I/O in Racket and How Data Is Streamed
  Covers how Racket handles input and output, and how streams let you work with data bit by bit.

• How Hash Tables Are Implemented in Racket and Why They Are Fast
  A look at how hash tables are built in and why they perform the way they do.

• How Racket Implements Pattern Matching with match and What Happens Internally
  Goes into how pattern matching works and what Racket does to figure out which branch to take.

• The Mechanics Behind Racket’s Evaluation Model
  Takes a look at how Racket steps through code and decides what to run first.

• How Racket Parses Code by Comparing the Reader and Parser
  Racket splits parsing into two parts, this breaks down what happens in each step.

• How Racket Handles Tail Recursion to Prevent Stack Overflow
  If you’ve used recursive functions in Racket, this shows how it avoids blowing up the stack.

• Drawing with Racket’s 2htdp/image and How Images are Built from Functions
  Racket makes it pretty easy to create images using code. This one looks at how the 2htdp/image library works, how you build visuals with functions, and what’s happening behind the scenes when it puts everything together.

That’s it for last week’s posts. I’ve got more Java and Spring Boot articles coming this week as usual, but I’ll be taking a break from Racket for now and switching gears to focus on some JavaScript topics. Should be a fun change of pace.