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

(April 27–May 3, 2025)

Here’s a look at what I’ve been posting this week. Lately, most of my time has gone into Java, Spring Boot, and JavaScript. Those three have been keeping me busy, and I’m starting to settle into a good posting rhythm across both Medium and Substack.

This week had a better flow to it. I mixed in some deeper mechanics, a few Spring Boot how tos, and circled back to some JavaScript internals. I also started a behind-the-scenes section here on Substack and tried adding voiceovers to a couple of my LeetCode breakdowns. Still figuring out how I want to use those, but it’s been fun to experiment with.

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

Java Scope, Part 3 — Loops, Lambdas, and Streams

When @ComponentScan Skipped My Package

That One Lazy Bean I Didn’t Know About in Spring Boot

LeetCode #3: Longest Substring Without Repeating Characters — Solved in Java

LeetCode #4: Median of Two Sorted Arrays — Solved in Java

LeetCode #5: Longest Palindromic Substring — Solved in Java

Java Topics and JVM Mechanics

• Behind the Behavior of Static Fields in Multithreaded Java Applications
  Takes a closer look at how static fields behave when more than one thread is involved, and why the results aren’t always what you’d guess.

• Why Thread Priorities in Java Do Not Guarantee Execution Order
  Setting a higher priority doesn’t mean a thread will run first. This goes over what the priority flag actually does and why it often gets ignored.

• What Happens When Threads Compete for Resources in Java Applications
  Goes into what really happens when threads fight over the same lock, how waiting works, and what that means for your program’s flow.

• Where Java Threads Wait, Block and Sleep at the JVM Level
  Covers the different ways threads can pause in Java and what the JVM is doing when a thread is stuck, sleeping, or waiting on something else.

• Where the JVM Spends Time During Class Loading and Initialization
  Looks at what the JVM is busy doing before your code runs, including finding the class, linking it, and checking that it's safe to use.

• Why Class Identity in Java Depends on More Than Just the Name
  Two classes can have the same name and still not be the same to the JVM. This explains why that happens and what makes them different.

• Where Java Stores Constant Values and Why It Matters
  Talks about how final constants are handled during compilation and where they end up in memory once your code is running.

Spring Boot Topics

• Building a Basic CRUD App with Thymeleaf and Spring Boot
  Builds out a simple CRUD app with Thymeleaf, showing how to wire up HTML forms, map them to controllers, and handle data in the backend.

• Consuming External REST APIs with Spring Boot WebClient
  Covers how to use WebClient to make HTTP calls to outside services, and explains why it’s often preferred over RestTemplate in newer apps.

• Handling Validation in Spring Boot with Bean Validation (Hibernate Validator)
  Shows how to add validation rules with annotations like @NotNull and @Size, and how Spring checks those before the request goes any further.

• Connecting Spring Boot Applications to MongoDB
  Walks through the steps to connect a Spring Boot project to MongoDB, including setting up models, repositories, and some example queries.

• Sending Emails from a Spring Boot Application
  Gives a rundown of how to send emails in Spring Boot, from adding the right dependencies to writing the mail-sending logic.

• Paginating API Results with Spring Boot and Spring Data
  Explains how to break large result sets into pages using Spring Data, and how to return extra info like page numbers and totals in the response.

• Using Spring Boot with PostgreSQL for Data Persistence
  Covers the setup for using PostgreSQL with Spring Boot, including how to handle the connection and map data to and from the database.

JavaScript Internals

• Memory Leaks in JavaScript and What Causes Them
  This one gets into how JavaScript ends up holding onto memory it doesn’t need, what usually triggers it, and some real examples that are easy to miss.

• Functional Programming Tricks That Work Well in JavaScript
  Covers a few practical ways to write cleaner, shorter code using functions in JavaScript, mainly stuff that ends up saving time.

• What Actually Happens When You Use “new” in JavaScript
  Walks through what the new keyword sets up behind the scenes, including how it wires up the prototype and builds the object you get back.

• Property Access and Enumeration in JavaScript Objects
  Goes into how JavaScript decides what shows up when you loop through an object, and what stays hidden unless you ask for it directly.

• Scope Chains and Lookup Rules in JavaScript
  Talks about how variable lookups work, starting from the current scope and moving outward when something isn’t found right away.

• The Mechanics Behind JavaScript’s typeof and instanceof
  Breaks down what these two checks really return, why they sometimes don’t agree, and what’s going in the background when they run.

• How setTimeout and setInterval Work in JavaScript
  Covers how JavaScript queues up delayed functions, how long those waits actually last, and what affects their timing.

I’ve gotten some great feedback lately, especially on the JavaScript articles, so I’ll be sticking with more of those alongside my usual Java and Spring Boot topics. Beyond that, I’m still building things out on Substack and seeing what else makes sense to add as this all grows. Definitely keeping busy!