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

(April 20–26, 2025)

Here’s another quick look at what I published this week. Most of it is still about how JavaScript works behind the scenes, how Spring Boot behaves at runtime, and what the JVM actually does when your code runs. I also spent some time putting together new stuff just for Substack.

This week was a long one. It’s the most content I’ve ever put together in a week, between keeping up my usual Medium pace and starting to grow more here on Substack. I’ve been learning a lot about how Substack works, especially how to make code blocks look better for people reading on mobile. Either this week or next, I’m planning to start posting at least three paid subscriber articles on top of everything else. Hopefully, it will turn into something I can do daily.

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

Execution Context and Call Stack in JavaScript

LeetCode #2: Add Two Numbers — Solved in Java

LeetCode #1: Two Sum — Solved in Java

Java Scope, Part 2 — Methods, Fields, and this

Java Scope, Part 1 — Local Blocks and Braces

Some Java Features That Come With Hidden Costs

How Java Actually Handles Exceptions Behind the Scenes

JavaScript Internals

• Event Delegation in JavaScript Explained
  Talks about how event delegation works, why it helps you handle events more efficiently, and shows real examples of setting it up.

• How JavaScript Handles Garbage Collection and Memory
  Looks at how JavaScript deals with memory behind the scenes, how the garbage collector knows when to free things up, and why it matters.

• The Mechanics Behind JavaScript Currying
  Goes over what currying means in JavaScript, how it changes the way you call functions, and why it can be helpful for building flexible code.

• Module Loading in JavaScript with ES Modules vs CommonJS
  Talks about the two major ways JavaScript loads modules, what makes ES Modules different from CommonJS, and how loading behavior changes depending on which one you use.

• JavaScript Hoisting in Functions and Variables
  Explains what hoisting is in JavaScript, how function and variable declarations get lifted to the top of their scopes, and why it affects how your code runs.

• JavaScript Variable Scoping and Lifetimes
  Covers how variable scoping works with var, let, and const in JavaScript, and explains how long different variables stay alive during execution.

• JavaScript Event Loop Mechanics Explained
  Breaks down how the JavaScript event loop works to handle async operations, task queues, and timers, all while running on a single thread.

Spring Boot Topics

• Creating a REST API with Spring Boot and JPA
  Walks through building a simple REST API using Spring Boot and JPA, covering the basics of setting up endpoints and working with a database.

• Building a Login System with Spring Boot and Spring Security
  Shows how to build a basic login system with Spring Boot and Spring Security, covering user authentication and setting up access control.

• Using Spring Boot with Redis for Caching and Data Storage
  Goes over how you can use Redis in a Spring Boot app, both for simple caching and for storing structured data in a lightweight, fast way.

• How to Integrate Spring Boot with RabbitMQ for Message Queuing
  Shows how to wire up a Spring Boot application with RabbitMQ, so you can handle background tasks and send messages between parts of a system.

• Why Spring Boot RestTemplate Requests Sometimes Hang or Timeout Unexpectedly
  Talks about the common reasons RestTemplate (and WebClient) calls can hang or timeout in Spring Boot applications, and what you can do about it.

• How Spring Boot Maps Environment Variables to Configuration Properties
  Shows how Spring Boot ties environment variables to its configuration system, letting you override settings without touching your code.

• What Triggers Spring Boot’s DevTools Restart Behavior and What It Actually Does
  Covers what DevTools looks for to trigger a restart in a Spring Boot app, and what happens in the background when it refreshes the application.

  Java and JVM Mechanics

• The Real Difference Between Stack and Heap in Java
  Breaks down what the stack and heap actually are in Java memory, how they work differently, and why it matters for how your program runs.

• What Really Happens When Java Passes Arguments
  Explains how Java handles arguments when you call methods, what it means to pass by value, and why object references behave the way they do.

• What Happens When You Use Reflection to Break Java’s Access Rules
  Goes into how Java’s Reflection API lets you reach into private fields and methods, and what actually happens when you bend the usual access rules.

• What Java Bytecode Instructions Actually Look Like and Do
  Takes a look at what Java bytecode really looks like after you compile your code, and explains what some common instructions are doing behind the scenes.

• Why Java Strings Are Interned and What That Means
  Explains what string interning is in Java, how it saves memory, and how it affects comparisons and performance.

• What Happens When a Java Application Starts
  Walks through everything the JVM does when you launch a Java app, starting long before it ever reaches the main() method.

• The Meaning of Class Identity in the JVM
  Explains how the JVM decides whether two classes are the same, even if they have the same name and bytecode, and what situations can make them different.

That’s everything from this past week. I’m still having a lot of fun learning more about JavaScript, so this coming week will keep the focus on Java, Spring Boot, and JavaScript. I’m planning to keep building the beginner Java series here on Substack and maybe add a few more LeetCode solutions too. Still getting into the flow of posting on both Medium and Substack, but I’m happy with the content that’s gone out so far.