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

(May 11–17, 2025)

I kept the usual rhythm this week with more Java internals, Spring Boot patterns, and JavaScript mechanics, and started mixing in some Kotlin too. I’ve been reading deeper into how the JVM works, and that’s been influencing a lot of my content lately.

I also spent a good chunk of the week talking with readers. Some of the questions were about articles I wrote a few years back, and it turns out a few things have changed. To be honest, some of those older Medium posts weren’t up to the standards I try to stick to now. I ended up rewriting three Gradle articles from 2023 to fix the outdated parts and clean things up. If you want to take a look, I included them at the end of this post.

If you're new here or just want a little context on what I do, you can check out my About Me page.

Substack Exclusive

Where Synthetic Members Come From and Why the Compiler Creates Them

Class Unloading in Java and What Triggers It at Runtime

Every Bluetooth Update from 5.0 to 6.1 Explained

How JIT Compilation Uses Code Caching in Java

Java Scope, Part 4 — try-with-resources and Catch Blocks

Java Topics and JVM Mechanics

• Why Package-Level Access Changes the Way Java Classes Interact Internally
  Breaks down how package-private access shapes the way Java classes can reach each other within the same package.

• The Cost of Reflection on JVM Performance and Internal Access Checks
  Shows how the JVM handles method lookups and access checks during reflective calls, and how that work adds up.

• The Lifecycle of a StringBuilder During Large Text Concatenation
  Tracks what happens inside a StringBuilder as it grows with each append, and when it needs to resize its buffer.

• What Happens When Interfaces Extend Other Interfaces in Java
  Looks at how the JVM handles inherited method declarations across multiple interface layers.

• The Real Cost of Boxing and Unboxing Primitive Types During Java Execution
  Goes through what boxing actually triggers behind the scenes, and why it’s not as cheap as it looks.

• Why Array Covariance Can Lead to Hidden Risks in Java Programs
  Unpacks how assigning one array type to another can introduce fragile code and runtime surprises.

Spring Boot Topics

• Writing SQL Queries in Spring Boot with NamedParameterJdbcTemplate
  Shows how to plug raw SQL into your Spring Boot app using named parameters without giving up structure.

• Customizing JSON Responses in Spring Boot APIs
  Covers how to shape and format JSON responses to fit what your clients actually need.

• Using Spring Boot with Google Cloud Pub/Sub for Messaging
  Walks through wiring a Spring Boot app to publish and receive messages with Pub/Sub.

• Sending Push Notifications Using Spring Boot and Firebase
  Lays out the steps for sending push messages to mobile devices from your backend service.

• Building a Multi Module Project with Spring Boot and Maven
  Gives you a way to split growing Spring projects into cleaner, modular chunks.

• Serving Frontend Builds from Spring Boot Backends
  Shows how to serve your frontend app directly from a Spring Boot backend with minimal setup.

• Building Read-Only APIs with Spring Boot and Query Methods
  Focuses on building read-only endpoints using Spring Data's method-based queries.

JavaScript Internals

• How Object Freezing and Sealing Work in JavaScript
  Covers how Object.freeze and Object.seal lock down changes to objects and their properties.

• Mechanics Behind Async Iterators and For-Await-Of in JavaScript
  Breaks down how async iteration works and how for-await-of steps through asynchronous data.

• Inside the Mechanics of JavaScript Symbol Properties
  Shows how Symbol keys keep certain properties out of regular loops and object listings.

• What Template Literals Actually Do in JavaScript
  Walks through how JavaScript builds strings with embedded expressions using backticks.

• Behind the Scenes of Destructuring in JavaScript
  Explains how JavaScript pulls apart arrays and objects to match patterns during assignment.

• What Happens During JSON.stringify and JSON.parse in JavaScript
  Covers how JavaScript turns objects into strings and back again, and what gets lost or changed.

• Property Descriptors and Hidden Attributes in JavaScript
  Looks at how JavaScript properties store more than just values, like writability and visibility.

Kotlin Topics

• Kotlin Function Parameters and Default Values Behind the Scenes
  Shows how Kotlin handles default arguments, both when compiling and at the call site.

Gradle Rewrites

• Using Gradle to Build and Deploy Docker Containers
  This one needed a full rewrite. I cleaned up the flow, updated the plugin version, and made sure the Docker tasks work with Gradle 8. The old version had some rough patches and missed a few real-world details.

• Gradle Multi-Project Builds — Organizing and Scaling Your Projects
  The structure still held up, but a lot of the syntax and setup was outdated. I brought it up to date with Kotlin DSL, version catalogs, and modern project layouts.

• Tracking Gradle Builds with Develocity Scans
  The original still used the legacy plugin. I swapped it out for the Develocity plugin and rewrote the rest to focus on how scans actually work today. It's cleaner now and easier to follow.

I’ll be keeping some Kotlin in the mix next week along with the normal Spring Boot and Java, and I might add a few more Gradle posts too in the coming weeks. Going back through those older ones reminded me how much has changed and how far my content has come. I’m also planning to revisit some of my Rust articles. Most of those were written when I was still figuring out how to put these posts together, and they haven’t aged well. Like with the Gradle updates, I’ll be rewriting the ones that feel out of date and cleaning up the parts that didn’t land the first time.