Where to go next as a Java developer

Understanding Where to go next as a Java developer

Five projects in, you have the language and the shape of a service: files, a database, threads, streams and an HTTP API. What decides your next step is one number rather than a topic list, and that number is the feature release your code has to run on, because Java's compatibility guarantee only runs one way: a class file built for 17 loads on 21, never the reverse. Take that number from the machine that will run the code, not from the JDK on your laptop, and hand it to javac as --release so the compiler refuses newer APIs on your behalf.

With the constraint fixed, the remaining ground splits into three axes, and one axis at a time is the only version that works. The runtime axis treats the JVM as a process you can question: -Xlog:gc for allocation pressure, jcmd Thread.print for a stuck service, a heap dump on OutOfMemoryError, JFR for where time actually goes, and JMH once you accept that a nanoTime loop mostly measures the JIT warming up. The ecosystem axis is one build tool and one framework carried end to end: Maven or Gradle, Spring Boot or Quarkus, JDBC against JPA, Testcontainers so the database under test is the real engine. The language axis is whatever landed after your baseline: records with sealed interfaces and pattern-matched switch in place of visitor classes, virtual threads in place of hand-tuned pools for blocking work, and the preview end of the pipeline such as structured concurrency and scoped values.

The best material for all three axes ships inside the JDK itself. lib/src.zip holds the source of every platform class, so you can read ArrayList.grow or CompletableFuture and see the idioms the library authors trust; every Javadoc entry carries an @since tag that dates an API against your baseline; javap -c shows what the compiler did behind your syntax, such as string concatenation turning into an invokedynamic call into StringConcatFactory. Read those alongside the JEP list for each six-month release and you can judge advice you find online instead of copying it. Then keep one project alive for months, because design decisions only teach you something when you are the one who has to live with them.

None

import java.lang.reflect.Method;

public class NextStep {

    static boolean typeExists(String name) {
        try {
            Class.forName(name);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

    static boolean methodExists(String type, String name) {
        try {
            Method m = Class.forName(type).getMethod(name);
            return m != null;
        } catch (ClassNotFoundException | NoSuchMethodException e) {
            return false;
        }
    }

    static void report(String api, int since, boolean present) {
        System.out.println(api + " (Java " + since + "): " + (present ? "usable here" : "missing here"));
    }

    public static void main(String[] args) {
        System.out.println("Running on feature release " + Runtime.version().feature());
        report("java.net.http.HttpClient", 11, typeExists("java.net.http.HttpClient"));
        report("Stream.toList()", 16, methodExists("java.util.stream.Stream", "toList"));
        report("java.util.SequencedCollection", 21, typeExists("java.util.SequencedCollection"));
        report("java.io.IO", 25, typeExists("java.io.IO"));
    }
}

Worked examples

import java.lang.module.ModuleFinder;

public class ShippedModules {
    public static void main(String[] args) {
        ModuleFinder system = ModuleFinder.ofSystem();
        String[] names = {"java.base", "java.net.http", "java.sql", "jdk.jfr", "javafx.controls"};
        for (String name : names) {
            boolean shipped = system.find(name).isPresent();
            System.out.println(name + ": " + (shipped ? "in the JDK" : "external dependency"));
        }
    }
}

import java.io.DataInputStream;
import java.io.InputStream;

public class TargetCheck {
    public static void main(String[] args) throws Exception {
        try (InputStream in = TargetCheck.class.getResourceAsStream("TargetCheck.class");
             DataInputStream bytes = new DataInputStream(in)) {
            int magic = bytes.readInt();
            int minor = bytes.readUnsignedShort();
            int major = bytes.readUnsignedShort();
            System.out.printf("magic %08X, class file %d.%d%n", magic, major, minor);
            System.out.println("compiled for Java " + (major - 44));
            System.out.println("preview features baked in: " + (minor == 65535));
        }
    }
}

import javax.script.ScriptEngineFactory;
import javax.script.ScriptEngineManager;

public class GoneQuietly {
    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();
        System.out.println("engines installed: " + manager.getEngineFactories().size());
        System.out.println("engine for 'js': " + manager.getEngineByName("js"));
        for (ScriptEngineFactory factory : manager.getEngineFactories()) {
            System.out.println("found " + factory.getEngineName());
        }
    }
}

Important notes

Common mistakes

Try it yourself