Java on

What's New in Java 25 (JDK 25)

Fri, 24 Oct 2025 00:00:00 +0000

Java 25 (JDK 25) is here — and it’s an LTS release. That means most vendors will support it for years, and many teams will plan upgrades from JDK 17 or 21 directly to 25. In this post, I’ll walk through the highlights that matter in real projects: language changes, concurrency improvements (Project Loom), runtime and GC work, observability via JFR, security/crypto, and AOT ergonomics.

This post is based on the official OpenJDK pages and JEPs for JDK 25.

Remove Duplicates from a Sorted Array — The Two-Pointer Technique

Sat, 09 Aug 2025 00:00:00 +0000

Removing duplicates from a sorted array is one of those problems that sounds trivial until you add the constraint: do it in-place, without allocating another array. That constraint is what makes it interesting and what makes the two-pointer pattern the right tool.

The problem: given a sorted integer array nums, remove duplicates in-place so each unique element appears exactly once. Return k — the count of unique elements. The values at nums[0] through nums[k-1] must be the unique elements in order; anything beyond index k-1 doesn’t matter.

Solving LeetCode's Valid Parentheses Problem with a Stack in Java

Wed, 06 Aug 2025 00:00:00 +0000

Some LeetCode problems feel like busy work. The Valid Parentheses problem is not one of them. It’s a clean, well-defined problem that teaches a genuinely useful pattern — the stack — and produces code that’s actually elegant when you get it right.

The problem: given a string containing only (, ), {, }, [, and ], determine if the input is valid. A string is valid if every opening bracket is closed by the correct bracket type, in the correct order.

@Component vs @Bean in Spring: When to Use Each

Thu, 31 Jul 2025 00:00:00 +0000

Spring’s dependency injection is powerful, but it gives you more than one way to register a bean with the container. Two of the most common approaches are @Component and @Bean. They accomplish similar goals but work differently and belong in different situations.

Understanding which to use — and why — leads to cleaner, more intentional Spring code.

What Is a Spring Bean?

Before comparing the two annotations, it’s worth being precise: a bean is simply an object managed by Spring’s IoC (Inversion of Control) container. Spring handles instantiation, configuration, and lifecycle management. You declare what you want; Spring figures out how to wire it together.

Spring Annotations: @Scheduling, @Async, @Component, @Service, @Configuration, @Bean

Tue, 15 Jul 2025 00:00:00 +0000

Spring’s annotation model can feel overwhelming at first. There are annotations for everything: creating beans, scheduling tasks, running things asynchronously, declaring configuration. Understanding what each one does — and more importantly, when each one is appropriate — is the difference between fighting the framework and working with it.

This guide covers six of the most important annotations in day-to-day Spring development.

@Component

The base annotation for any class you want Spring to manage. When Spring’s component scanner finds a class marked with @Component, it instantiates it and adds it to the application context.

Spring Boot Layered Architecture: Controller, Service, and Repository

Sun, 15 Jun 2025 00:00:00 +0000

One of the first questions you face when building a Spring Boot application is how to organize your code. You could put everything in one class. You could organize by feature. You could follow some informal convention that made sense to you at the time. But Spring Boot has a well-established pattern that most serious projects follow: three-layer architecture, separating the code into Controller, Service, and Repository layers.

This isn’t arbitrary organization. Each layer has a specific responsibility and talks only to its adjacent layers. The result is code that’s easier to test, easier to change, and much easier for a new developer to navigate.

C# vs Java: A Practical Comparison for 2025

Fri, 28 Mar 2025 00:00:00 +0000

Java and C# are often described as rivals — born from similar philosophical roots, shaped by massive corporate investments, and used in largely overlapping problem spaces. Both are statically typed, object-oriented, garbage-collected, and designed for building serious software at scale. Both run on virtual machines. Both have enormous ecosystems.

And yet, they’ve evolved in meaningfully different directions. Knowing which to reach for — and why — is the mark of a developer who has thought carefully about the tools, not just learned whichever one came first.

Why I Still Prefer Java Over Python

Fri, 28 Mar 2025 00:00:00 +0000

Java doesn’t have a great reputation for being lovable. It’s verbose. It requires a lot of ceremony. Oracle’s licensing history has left scars. And if you’ve ever tried to explain generics or checked exceptions to someone who learned Python first, you know the look you get.

And yet, I keep coming back to Java. Not out of stubbornness or habit — but because, when I’m building something that has to actually last, Java’s constraints start looking more like features.