Estimate project
← All posts

Java: Thirty Years, Three Lessons

Java is 30! In a tribute to the language behind so much of modern tech, four senior engineers pass on key lessons to the next generation of developers. Find out what keeps it unstoppable.

26 min read
Javauncoverjavapattern matchingProgramming Languages

Three decades ago, the little Duke showed up on the tech scene, and Java made its daring promise to “write once, run anywhere.” Today, in 2025, Java remains the backbone of enterprise software, powering everything from insurtech platforms to the crypto wallets that are quickly becoming a standard part of modern banking apps.

Most of my working time goes into turning engineering excellence into business value. Still, every great story begins with the people who actually live it. I asked four of our senior engineers what lessons they would hand down to the next generation of Java developers.

Here are three decades and three(ish) lessons, told by people who write production code every single day. Happy birthday, Java! 🎂

Syntax is only the surface

Picking up my first language felt like learning magic. I’d type a few lines of code, and something would appear on the screen. It was amazing.

In the beginning, everything seemed simple and clear. I learned the syntax and tried out the popular features. I got to know collections, loops, and exceptions, and even stumbled upon multithreading. My thinking was: “Once I’m good enough at the language, there’s nothing I won’t be able to build.”

But as my ideas got bigger, I ran into the “reality check” wall.

It turned out that knowing the language doesn’t suffice to build real software. Suddenly, I had to learn about Spring Boot, databases, Rest API, and “deployment”, whatever that meant back then.

As a software developer, I came to see that this was only the tip of the iceberg.

Building a good product takes more than just writing code. Our aim is no longer simply to make something. We want the product to last. We have to verify that business requirements are satisfied and make sure our changes don’t break everything. We want the app to be secure, observable, and maintainable.

That led me to an important realization: writing Java means working with a whole ecosystem. I had to get to know tools, frameworks, and libraries.

A lot of this I picked up from developers I met at local meetups and at various conferences. The funny thing is that many of them weren’t Java developers, and yet we could still exchange experience and knowledge. That’s because these are problems all of us deal with, no matter which language we use.

So if you’re on this path as well, keep in mind: the language is only the way in. The true craft is in everything around it.

Java isn’t slow anymore

For years, Java has had a reputation for being slow. I heard that a lot, even back when programming was only a hobby for me.

And on the surface, it did seem reasonable. Java runs on a virtual machine, uses a garbage collector, and adds layers of abstraction. It all felt heavy.

As far back as 2011, Robert Hundt published a paper, “Loop Recognition in C++/Java/Go/Scala“, in which he analyzed and compared these 4 languages. Next to C++, Java was slow. Naturally, right? C++ runs closer to the metal. How could anyone compete with that?

Yet every new version makes Java faster, and every version brings something new to the table.

Take the Just In Time compiler (JIT), for example – a real lifesaver for Java applications. It detects hotspots (code paths that run frequently) and compiles them into native machine code.

Got dead code that will never run? JIT gets rid of it. If a method is called frequently, JIT will inline it – copying the method’s body into the calling method. If an object variable lives only within the scope of a single method, JIT can place it on the stack.

In that case, the object isn’t allocated on the heap at all, so the garbage collector never has to manage it.

And there’s much more….

Java 19 brought virtual threads, a convenient way to deal with blocking calls such as reading from a database.

Thanks to these changes, Java got much better. For instance, in 2024 Mr. Gunnar Morling launched a challenge called “The One Billion Row Challenge“.

The task was quite simple: write a Java program that reads temperature measurements from a * .txt file, computes the max, mean, and min temperature for each weather station, and prints the stations in alphabetical order.

Sounds easy, except that the file contained 1,000,000,000 rows!

A great challenge, and the results are even more impressive. They vary with resources, but some results come in under half a second.

And Java’s improvements don’t stop there. Java 24 (released 18 March 2025) includes several JEP’s aimed at making Java faster. For instance, with Ahead-of-Time Class Loading & Linking (JEP 483), you can get a 42% improvement in application runtime for both vanilla and Spring apps. Sure, that figure comes from the JEP itself, but it sounds promising, doesn’t it?

If you need your app to start up blazingly fast, you can turn to GraalVM and build a native image of your app so it runs quickly in cloud serverless functions.

There are plenty of ways to speed up your Java.

Keep in mind: Java isn’t slow anymore, and it keeps getting better.

The more Java grows, the more readable it gets

The previous lesson showed that every Java version is faster than the last. But speed isn’t the only reason to upgrade the Java you run in production. New Java versions also give you cleaner ways to write your code.

Suppose you’re stuck on Java 11 – you may be missing out on lots of great features of newer Java. Here are a few examples:

Switch expressions

Before Java 14: a verbose switch statement full of breaks

   switch (day) {
    case MONDAY:
    case FRIDAY:
    case SUNDAY:
        System.out.println(6);
        break;
    case TUESDAY:
        System.out.println(7);
        break;
    case THURSDAY:
    case SATURDAY:
        System.out.println(8);
        break;
    case WEDNESDAY:
        System.out.println(9);
        break;
}

Java 14+: a switch expression with ‘->’ cases and no need for breaks

switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
    case TUESDAY                -> System.out.println(7);
    case THURSDAY, SATURDAY     -> System.out.println(8);
    case WEDNESDAY              -> System.out.println(9);
}

Switch in place of instanceof

Before Java 21: a chain of instanceof checks

if (animal instanceof Cat c) {
    giveFoodToCat(c);
} else if (animal instanceof Dog d) {
    giveFoodToDog(d);
} else {
    throw new IllegalStateException("Unexpected animat type: " + emp);
}

Java 21+: pattern matching inside switch

switch (animal) {
    case Cat c  -> giveFoodToCat(c);
    case Dog d -> giveFoodToDog(d);
    default -> throw new IllegalStateException("Unexpected animal type: " + animal);
}

Guards let you handle specific cases too

switch (animal) {
    case Cat c when c.hasName("Garfield") -> giveLasagneTo(c);
    case Cat c -> giveFoodToCat(c);
    case Dog d -> giveFoodToDog(d);
    default -> throw new IllegalStateException("Unexpected animal type: " + animal);
}

Records

Record classes, a special type of class, make it possible to model plain data aggregates with less ceremony than ordinary classes.

record Rectangle(double length, double width) { }

This alone replaces:

public final class Rectangle {
    private final double length;
    private final double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    double length() { return this.length; }
    double width()  { return this.width; }
    public boolean equals...
    public int hashCode...
    public String toString() {...}
}

Switch patterns with Records

switch (animal) {
    case Cat(String name, Color _) when "Garfield".equals(name)-> giveLasagneTo(name);
    ...
}

This one line combines a guarded pattern (when), record deconstruction from Java 21, and an unnamed variable from Java 22.

Compared to old Java, there are many more improvements, and I encourage you to discover them and experiment. Good luck and enjoy.

Code gets written once but read many times

My programming adventure began with C++ in high school. I still remember the first rush of typing some text and then seeing the result on the screen – it felt like pure magic.

That experience pushed me to study Computer Science. Over the years I learned more and more about programming, data structures, algorithms, and operating systems. By then I had written plenty of small programs in various languages, mostly to pass my courses.

Running into Java was unavoidable, and it was love at first sight. Java struck me as easy, powerful, and readable. My first larger project was a multithreaded Desktop App simulating a Stock market – quite an adventure!

Still, I tripped over plenty of problems: How should I name classes and functions? How do I tell when something should become a class? How do I avoid getting lost in the code? I began studying Design Patterns, which helped me complete the project, and afterwards I believed I’d seen it all.

Then my first job came along – an internship where I met more experienced programmers and a far more complex system. I was stunned that a code base could be so enormous! (It wasn’t really that enormous.)

You could see a “classic 3-layer architecture” there (presentation, application, data), with services packed with business logic and nested ifs for various special cases. It was hard to read and hard to tell when something would run and when it wouldn’t. The tests didn’t help much either – they were complicated, with unreadable setup and sometimes even harder-to-follow asserts. Luckily, my colleagues saw this as a problem too, so it wasn’t only me not knowing the domain, requirements, and problems – they struggled as well.

We began learning more about Domain Driven Design (DDD), took part in workshops, and introduced a more rigorous code review process. In the end it paid off: new features were easier to read, tests were simpler to understand, and the code was more open to change.

It wasn’t only about DDD, but about the mindset you bring when writing code – how you name methods and how you split responsibilities among classes and modules. For a student who had only done solo projects, it was a fantastic experience to discover that the way you write code matters, and that it will stay with other people for quite some time!

Not everything is as easy as it seems

Failure can be the best teacher, but perhaps not when production is down and you have to roll back your changes.

My team got the task of building a new feature that would push fresh information from the server to the client. We had two options to weigh: Server-Sent Events (SSE) and WebSockets, and we went with SSE because it seemed simpler and a better fit for us.

Here is the sample SSE code:

@GetMapping("/stream")
public SseEmitter streamEvents() {
    SseEmitter emitter = new SseEmitter();

    executor.submit(() -> {
        try {
            int i = 0;
            while (true) {
                emitter.send("SSE message " + i++);
                Thread.sleep(1000);
            }
        } catch (IOException | InterruptedException e) {
            emitter.completeWithError(e);
        }
    });

    return emitter;
}

The code above creates a separate runnable for every emitter, and the ExecutorService then takes care of it.

When you call this endpoint, you get a message every second until you close the connection. How many parallel requests this endpoint can serve depends on the ExecutorService implementation.

Luckily, in this code the emitter is closed as soon as an Exception is thrown, which is what happens when the connection breaks.

Seems simple, doesn’t it?

We thought the same, and one of the developers assured us it would work fine. Our case was somewhat more complex than this example, since we had to check exactly who was requesting the emitter and send them only the data they were allowed to see. Throughout the project, we failed to notice that Tomcat capped our thread pool, and that the threads running emitters weren’t freed when the connection dropped.

Sadly, we only noticed the problem in production, when the server stopped responding. How did we miss it earlier? We can point to many causes: our testing environments were short-lived, there was hardly any traffic, and we had no load or stress tests at all.

Luckily, this mistake taught us to:

  • Research solutions you’re not familiar with, paying attention to the downsides and whether you can live with them
  • Verify your findings with your teammates
  • Stay critical of your own results and those of others
  • Always test the solution you pick, particularly when you’re unsure how it will behave under load

A small Streams API trick

The Stream API is very powerful and makes processing collections more readable. After I learned it, I wanted to use it everywhere. The API is of course not perfect and lacks some features that Gatherers now make possible.

One problem I ran into was picking distinct items based on a given property rather than the equals() method. Luckily, a colleague showed me this neat trick:

    record Book(String title, String author) {}

    public static void main(String[] args) {
        List<Book> books = List.of(
                new Book("Title", "Author1"),
                new Book("Title - next part", "Author1"),
                new Book("Some adventure", "Author2"),
                new Book("Other adventure", "Author2")
        );

        books.stream()
                .filter(uniqueAuthor())
                .forEach(System.out::println);
    }

    private static Predicate<Book> uniqueAuthor() {
        Set<String> state = new HashSet<>();
        return book -> state.add(book.author());
    }

The trick hinges on the uniqueAuthor method returning a Predicate. The predicate is applied in the Stream, so every element goes through it, but the Set holding the state is created only once – when the uniqueAuthor method gets called.

That’s what lets it remember the authorNames across Predicate calls.

For comparison, here’s how the same problem can be tackled with Gatherers:

public static void main(String[] args) {
        List<Book> books = List.of(
                new Book("Title", "Author1"),
                new Book("Title - next part", "Author1"),
                new Book("Some adventure", "Author2"),
                new Book("Other adventure", "Author2")
        );

        books.stream()
                .gather(new UniqueAuthorGatherer())
                .forEach(System.out::println);
    }

    static class UniqueAuthorGatherer implements Gatherer<Book, Set<String>, Book> {
        @Override
        public Supplier<Set<String>> initializer() {
            return HashSet::new;
        }

        @Override
        public Integrator<Set<String>, Book, Book> integrator() {
            return Integrator.ofGreedy((state, item, downstream) -> {
                String author = item.author();
                if(state.add(author)) {
                    downstream.push(item);
                }

                return true;
            });
        }
    }

The Gatherer API is more powerful, and also more complex. UniqueAuthorGatherer implements the initializer method, which provides a new HashSet, and the integrator method, which handles each element and passes it downstream only if its author isn’t in the state yet.

Either way, the methods can be made generic and reused as a Util elsewhere.

Which one do you prefer?

From “It works on my machine” to DevOps: how Java development practices evolved

It’s hard to believe how much Java development has transformed in only a couple of decades.

In the early days, a typical Java project began as a bunch of messy classes, cobbled together with little testing and even less automation. Shipping code meant building a WAR or EAR file and pushing it, often by hand, onto a Tomcat or WebLogic server, hoping it would “just work” in production the way it did on your laptop.

Testing? Usually an afterthought.
Documentation? Frequently stored in someone’s head.
Automation? Writing a shell script (perhaps).

As complexity increased, so did the need for discipline. A modern Java project today looks completely different:

  • Source code is kept in a Git repository, with automated builds, tests, and linters triggered on every push.
  • Unit, integration, and even contract tests are a given.
  • Continuous Integration/Continuous Deployment pipelines (CI/CD) deliver artifacts to cloud-based environments in minutes.
  • Infrastructure is described as code, and containerization (Docker) plus orchestration (Kubernetes) are the norm.
  • Monitoring, alerting, and quick rollback are standard practice.

So what’s the lesson?

The true evolution goes beyond new tools. It’s a cultural change. Today’s Java teams care about code quality, automation, and collaboration just as much as about language features.

The ecosystem provides a wealth of tools for fast delivery and high quality, but it also brings considerable complexity and overhead. Being aware of this is crucial.

Luckily, many organizations now have dedicated infrastructure and platform teams running the deployment pipeline, so developers can concentrate on what really counts: building reliable software and solving actual business problems instead of fighting deployment headaches.

Cool Features: From Boilerplate to Beauty

If you wrote Java in the 2000s, you remember the agony of never-ending boilerplate. A simple data class required writing fields, constructors, getters, setters, equals, hashCode, and toString again and again. Java was powerful, but seldom elegant.

Look at this classic approach:

// Java 7 and earlier
public class User {
    private final String name;
    private final int age;
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() { return name; }
    public int getAge() { return age; }
    @Override
    public String toString() { return "User{name='" + name + "', age=" + age + '}'; }
    @Override
    public boolean equals(Object o) { /* lots of code */ }
    @Override
    public int hashCode() { /* lots of code */ }
}

From Java 16 on, you can simply use a record:

public record User(String name, int age) {}

And that’s only the beginning.

  • Lambdas and Streams (Java 8) transformed the way we process collections:
List<String> names = users.stream()
    .filter(u -> u.age() > 18)
    .map(User::name)
    .collect(Collectors.toList());
  • Pattern matching and sealed classes make code both safer and more expressive.
sealed interface User permits Admin, RegularUser {}
record Admin(String name, int age, int level) implements User {}
record RegularUser(String name, int age) implements User {}
String accessLevel(User user) {
    return switch (user) {
        case Admin a -> "Admin Level " + a.level();
        case RegularUser r -> r.age() > 18 ? "Full Access" : "Restricted Access";
    };
}

And now: Virtual Threads (Java 21+)

For years, serving many concurrent requests in Java was tough – spawning thousands of OS threads was costly, so frameworks relied on thread pools and callbacks, which made the code more complicated.

Traditional Java concurrency:

// Handling tasks with traditional threads
for (int i = 0; i < 1000; i++) {
    new Thread(() -> {
        // Handle some request
        handleRequest();
    }).start();
}
// This approach doesn’t scale well—creating thousands of real threads is costly!

Using Virtual Threads:

// Java 21+ - Virtual Threads make massive concurrency simple and efficient
for (int i = 0; i < 1000; i++) {
    Thread.startVirtualThread(() -> {
        handleRequest();
    });
}
// Now you can easily have thousands or even millions of lightweight threads!

Or with a modern ExecutorService:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1000; i++) {
        executor.submit(() -> handleRequest());
    }
}

Spring Boot makes it even simpler!

With Spring Boot 3.2+ (and Java 21+), moving to virtual threads takes almost no effort.

All you need is this property in your application.properties:

spring.threads.virtual.enabled=true

That’s all – no code changes needed! Spring will begin handling incoming requests on virtual threads, making your app immediately more scalable and ready for modern workloads.

So what’s different?

Virtual threads are managed by the JVM rather than the OS. They’re inexpensive to create and schedule, so you can write concurrent code that is scalable, simple, and readable – no more complicated thread pools or asynchronous acrobatics.

These new features are more than syntactic sugar – they enable better design, fewer bugs, and genuine productivity.

Lesson:

If you haven’t given modern Java a try, you’re missing out. Welcome the evolution: less boilerplate, more business logic, and a language that is at last keeping pace with its younger relatives.

Is a framework really necessary? Java’s never-ending dilemma

Let’s face it: nearly every Java developer tries, at one point or another, to write their own framework.

Perhaps Spring seems like too much for your simple REST API. Perhaps you’d like to understand how dependency injection or routing actually work. Or perhaps you simply want things to stay “clean and minimal.”

So you begin with a handful of classes, maybe wrap some configuration, and add a basic HTTP server. It feels great… until all of a sudden you’re implementing authentication, error handling, logging, validation, testing support… and it begins to look suspiciously like Spring or Quarkus, only without the battle testing and community support.

Here’s a small example:

// Minimal HTTP server in Java, no framework
HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
server.createContext("/hello", exchange -> {
    String response = "Hello, World!";
    exchange.sendResponseHeaders(200, response.length());
    try (OutputStream os = exchange.getResponseBody()) {
        os.write(response.getBytes());
    }
});
server.start();

This works nicely for learning, for hacks, or for really tiny services. But as requirements pile up, so does your need for security, testing, documentation, integrations… and all at once, a framework doesn’t seem so bad after all.

Interested in the new generation of Java frameworks?

Mini Lesson:

Frameworks such as Spring or Micronaut exist for good reason – they tackle difficult, frequently invisible problems: dependency injection, configuration, lifecycle management, and more. They spare us from reinventing the wheel.

Here’s the catch, though: these frameworks tend to be huge, and beneath the surface there’s a maze of abstractions, proxies, and internal mechanisms we seldom understand completely. Adding the annotation is easy; knowing what it sets in motion is harder.

So do we always need a heavyweight framework? Or does keeping things simple still pay off, particularly for small services or greenfield projects? At times, plain Java gives us more clarity, quicker startup, and fewer surprises.

Functional Domain Modelling

When Scala first came out in 2004 as a language blending the functional and object-oriented paradigms, it began spreading functional programming concepts.

Scala was at first regarded as a “better Java”, but today that holds only in part – Java hasn’t fallen behind over the years and has added several language features that make functional programming in some areas nearly as easy as in Scala.

One such area is functional domain modelling, which, just like functional programming in general, is based on modelling the domain with immutable values and pure functions. A central concept here is Algebraic Data Types (ADTs).

ADTs

ADTs come in two flavors:

  • Product types – these represent a combination of properties (for example, a user has a name and an email), where every instance has all of the properties (that is, a Cartesian product of them – which is where the name comes from). In Java they are expressed as records:
record User(String name, String email)
  • Sum/union types – these represent picking one of several disjoint allowed values (for example, a state is either on or off). In Java they are expressed as sealed hierarchies:
sealed interface State {
    record On() implements State {}
    record Off() implements State {}
}

The sealed keyword means every possible variant of State is known at compile time, so the compiler can verify that all values are handled, for example in pattern matching.

A big advantage of ADTs is that illegal states simply can’t be represented – such code just doesn’t compile.

Errors as values

The functional approach to domain modelling treats everything as a value – errors included. So rather than throwing exceptions, it’s better to represent errors as values – with ADTs, naturally. Here’s an example:

sealed interface DomainError {
   record SomeError(String message) implements DomainError {}
   record OtherError(int code) implements DomainError {}
}

sealed interface Try<A> {
    record Success<A>(A value) implements Attempt<A> {}
    record Failure<A>(DomainError e) implements Attempt<A> {}
}

We would then make Try the return type of every function that may produce an error. This gives us one mechanism for representing both successful and failed results. What’s more, the domain errors (the ones we anticipate) are restricted to SomeError and OtherError.

Pattern matching

Combined with pattern matching, this lets us guarantee at compile time that every possible result of a function returning a Try has been handled:

Try<String> result = foo();

switch (result) {
    case Try.Success(var value) -> // use value as a String
    case Try.Failure(SomeError(var message)) -> // use message as a String
    case Try.Failure(OtherError(var code)) -> // use code as an int
}

A few points worth noting:

  • Pattern matching lets us take nested records apart (for example, reach the code directly instead of via e.code).
  • The compiler can infer the types inside nested records.
  • If any of the cases above were missing, the compiler would complain (because of the sealed keyword in the DomainError hierarchy).

Functional domain modelling may seem counterintuitive at first, but I strongly encourage you to try it and see how powerful it is.

Verbosity over Magic

Let’s look at the (simplified) structure of a typical Spring Boot application:

@Service
public class Service {

    @Autowired
    private Repository repository;
}

@Controller
public class Controller {

    @Autowired
    private Service service;

    // request mappings
}

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

It will work right out of the box – no doubt about it. The code looks simple and easy to reason about – but is that really the case? The thing with frameworks such as Spring Boot is that they bring in plenty of magic by doing many things on your behalf.

They clearly follow the convention-over-configuration approach. But do you know every convention? For instance, can you tell:

  • What really happens behind the scenes when you put the @SpringBootApplication annotation on a class?
  • What the lifecycle of repositories, services etc. looks like, e.g., when they get instantiated?
  • What dependencies every component has, e.g., can you see that the Repository needs a database connection?
  • Where the configuration gets loaded from?
  • How the Repository’s database connections are managed?

This approach works great as long as your application behaves. But when something breaks, the hidden conventions stop being helpful. You have to understand at least part of the magic before you can debug your problems.

If you swap an all-in-one framework for a set of libraries, each with one responsibility, you get far more control over what goes on in your application. The code becomes more verbose, but that can pay off over time, because there’s no magic and no hidden conventions left.

Here’s our revised application:

public class Service(Repository repository) {
}

public class Controller(Service service) {
    // request mappings
}

public class Application {
    public static void main(String[] args) {
        final var config = Config.load();
        final var repository = new Repository(config);
        final var service = new Service(repository);
        final var controller = new Controller(service)

        new HttpServer(config, controller).start();
    }
}

The code above shows plainly what it takes to set up the application.

There’s one entry point to examine when you analyze the codebase. You also get more freedom in how you structure your code and which tools you use to solve different problems. Not surprisingly, though, it’s always a matter of trade-offs – this approach may not scale perfectly for very large codebases, so use it with care.

Frameworks like Spring are handy for rapid prototyping, but I’d say that once you’ve moved past the prototyping phase, it can pay to take more control over what your application does behind your back. This can be especially helpful when debugging production problems.

There’s life beyond @SpringBootApplication and Hibernate (ever heard of jOOQ?)!

RPC – from EJB to REST and gRPC

Here’s another angle on keeping things simple. Remote Procedure Call (RPC) is an essential part of every distributed system, and Java has come a long way in this area over the years.

EJB

It all began with Enterprise Java Beans (EJB): a Java-specific standard for invoking code remotely that relied on proprietary RMI (Remote Method Invocation) underneath.

Setting up EJB was anything but easy: you had to write several XML deployment descriptors, for example for the so-called local and remote interfaces. Service discovery (that is, finding the other party) was done through JNDI – yet another Java-specific technology.

Last but not least, running the application required a full J2EE container (such as JBoss or Weblogic).

WebServices

Next came SOAP and WebServices: the first attempt at executing code remotely over a well-known existing protocol, HTTP.

Java supported them via the JAX-WS specification. WebServices didn’t depend on any particular language, so, unlike with EJB, you didn’t need a Java client to talk remotely to a Java application.

WebServices relied on text payloads encoded as XML, with the schema enforced through XSL. A text payload generally makes debugging easier for humans, but XML wasn’t the ideal format, because it added a lot of boilerplate (payload that didn’t carry actual data), which made requests enormous and not so easy to debug.

REST

The next step in HTTP-based RPC had us sending JSON instead of XML over HTTP.

REST (short for Representational State Transfer) is built around managing resources identified by URIs, which you can fetch or change. Although the approach isn’t designed specifically for running arbitrary code remotely, it has been used extensively for that purpose, going well beyond just managing resources.

Since JSON carries far less boilerplate than XML, payloads became much smaller and genuinely human-readable – and therefore genuinely easy to debug.

REST services weren’t supported only by the Java language itself (via JAX-RS). The approach was embraced broadly, with many frameworks (such as Spring) and libraries (for working with JSON or testing the services) appearing around that time.

Given the flexibility of HTTP and text payloads, introducing good API design practices quickly became important.

gRPC

gRPC still relies on a well-known protocol (HTTP/2), but it swaps text payloads for binary ones and uses a separate IDL (Interface Definition Language), Protocol Buffers, or protobuf, to describe the message structure and the signatures of remote endpoints.

So this time the focus isn’t on managing resources but on genuinely running arbitrary code remotely. Binary payloads are harder to debug, but they allow data compression, which cuts network traffic considerably.

Current state

Nowadays, REST and gRPC are the two most popular options, and which one to pick depends on the use case. Whichever you go for, I’d say it will be much simpler than having to deal with EJB (heavyweight and tied to Java) or WebServices (with enormous, barely readable payloads). Simplicity wins!

Wrap up

Over three decades, Java has shown that real innovation comes in equal measure from people, process, and platform:

  • The language keeps getting lighter. Records, lambdas, sealed classes, and virtual threads prove that expressiveness and performance can improve hand in hand.
  • Pick your abstractions carefully. Frameworks such as Spring, Micronaut, or Quarkus tackle hard problems, but knowing what happens under the hood remains the best debugging technique there is.
  • Culture and tooling matter just as much. From bare-metal app servers to DevOps and Platform Engineering, successful teams put as much into collaboration and automation as into IDEs and libraries.
  • Readability is a feature. Spending time on thoughtful, explicit design pays off by making platforms easier to maintain and helping you win every code-review.

If you’re on your own Java journey, whether it’s modernization or green-field cloud-native builds, get in touch with us.

Cheers to another 30 years of delivering reliable, elegant software together!