Java

In short: An object-oriented programming language that isn’t compiled directly to machine code but to bytecode, running on the Java Virtual Machine (JVM).

In more detail: The JVM principle enables “write once, run anywhere” — the same bytecode runs on any operating system a JVM exists for. Frequently used for large enterprise applications, Android apps (historically), and backend systems. Compiled and run using tools from the JDK.

In Depth

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

The central difference from languages like C++ is the two-stage execution: javac compiles the source code into platform-independent bytecode (.class files), and the JVM only translates this bytecode into the native machine code of the respective operating system at runtime (via a just-in-time compiler). This costs some startup time and overhead compared to directly compiled languages, but brings real platform independence — the same .class file runs unchanged on Windows, Linux and macOS, as long as a JVM is installed.

Java is strictly object-oriented (almost everything is a class, see OOP), statically typed (data types are fixed at compile time), and manages memory automatically via a garbage collector. This combination of stability, maturity and a large ecosystem still makes Java one of the most widely used languages for large, long-lived enterprise applications (banks, insurance companies, enterprise backend systems).

Origin at Sun Microsystems

Java was originally developed at Sun Microsystems between 1991-1995 under the leadership of James Gosling, initially intended for interactive television sets (“Oak”), before the focus shifted to web applets with the rise of the World Wide Web. The guiding motto “Write Once, Run Anywhere” (WORA) was a central selling point from the start compared to C/C++, where you had to compile separately for every target platform. Oracle acquired Sun in 2010, and with it Java; since then, new major versions have appeared on a fixed six-month cadence (instead of irregularly every few years as before), which has developed the language considerably faster than in its first decade.

The Java ecosystem beyond the language

A major reason for Java’s ongoing enterprise dominance is less the language itself than the huge ecosystem grown over decades: build tools like Maven and Gradle, frameworks like Spring (practically the de-facto standard for enterprise backends) and Hibernate, and an enormous number of mature, well-maintained libraries for practically every use case. Other languages like Kotlin and Scala also run on the same JVM and can interact seamlessly with existing Java code — a company can thereby gradually introduce new languages, without completely replacing its existing Java codebase.

Common criticisms

Despite its widespread use, Java also faces noticeable criticism: the language is considered “verbose” (you have to write comparatively a lot of code for simple things, such as lengthy getter/setter methods — modern Java versions with records and var now mitigate this), the JVM’s memory usage is higher than with directly compiled languages, and a JVM application’s startup time is noticeably slower than native programs — a disadvantage especially for short-lived cloud functions, where projects like GraalVM (native, ahead-of-time compiled Java binaries) specifically counteract this.

See also: JDK, OOP, Garbage Collector, Kotlin