The Java platform is maintained by the OpenJDK open-source project. Similar to Linux, multiple vendors provide binary distributions for this project, including Amazon, the Eclipse Foundation, Microsoft, Oracle, or Red Hat. These distributions differ in aspects like availability of commercial support and duration of the same, supported platforms, extent of testing, certain features like available garbage collectors, potentially bug fixes, and others. So which one should you use?

For the beginning, the differences won’t matter too much, and I suggest choosing Eclipse Temurin. It is backed by Adoptium, a working group of companies like Google, Red Hat, Microsoft, Alibaba, Azul, and others. You can download and use it for free, it contains everything you’ll need, passes the test compatibility kit (TCK) of the JDK, and if needed, there is commercial support provided by different vendors.

A new version of Java is released every six months, with the current one at the time of writing this being Java 19. Specific releases are long-term support (LTS) releases, for which vendors provide maintenance for many years. The current LTS release is Java 17 and I recommend you to get started with this one.

While newer non-LTS releases may add useful new features, finding a sustainable update strategy can be a bit tricky, and many of the new features are preview or incubating features, meaning that you would not use them in production code anyways. I recommend you diving into those later on, once you’ve gained some experience with Java and its ecosystem.

If specific 3rd-party libraries don’t work seamlessly with Java 17 yet, you should use the previous LTS (Java 11). Don’t use non-LTS releases apart from the current one, as they are mostly unmaintained, i.e. you may open yourself to security issues and other bugs which won’t get fixed. Also don’t use Java 8 (alternatively named 1.8), which is the LTS before 11, as it’s really ancient by today’s standards.

There’s different ways for installing your chosen Java distribution. Usually, there’ll be a distribution package which you can download from the vendor’s website. Alternatively, package managers of the operating system allow you to install Java too.

For a simplified getting started experience, my recommendation is to take a look at SDKMan. This is a tool which allows you to install software development kits (SDKs) such as Java’s JDK. You can also update your installed SDK versions and easily switch between multiple versions.

If you have SDKMan installed, obtaining the current Eclipse Temurin build of Java 17 is as simple as running the following in your shell:

Having installed Java, it’s time to write your first Java program. Java is first and foremost an object-oriented language, hence everything in a Java program is defined in the form of classes, which have fields (representing their state) and methods (the behavior operating on that state). The canonical "Hello World" example in Java looks like this:

Java source code is compiled into class files which then are loaded into the JVM and executed. Normally, this is done in two steps: first running the compiler javac, then executing the program using the java binary. For quick testing and exploring, both steps can be combined, so you can execute your "Hello World" program like this:

For exploring Java in a quick and iterative mode, it provides jshell, an interactive Read-Evaluate-Print Loop (REPL). You can use it for running expressions and statements without defining a surrounding method or class, simplifying "Hello World" quite a bit:

Similar to jshell, but quite a bit more fancier is jbang, which for instance allows you to easily pull in 3rd party libraries into your single source file Java programs.

Providing an introduction to all the features of the Java programming language is beyond the scope of this blog post. To truly learn the language and all its details, my recommendation would be to get a good book, grab a coffee (or two, or three, …​) and work through its chapters, in order of your personal interests. A popular choice for getting started with Java is "Head First Java, 3rd Edition" by Kathy Sierra, Bert Bates, Trisha Gee, nicely complemented by The Well-Grounded Java Developer, 2nd Edition, by Benjamin Evans, Jason Clark, and Martijn Verburg. A must-read for honing your Java skills is "Effective Java, 3rd Edition", by Joshua Bloch. While this has been updated for Java 9 the last time, its contents are pretty much timeless and still apply to current Java versions.

If you don’t want to commit to buying a book just yet, check out the "Learn Java" section on dev.java, which has tons of material describing the Java language, key parts of the class library, the JVM and its most important tools, and more in great detail.

The authoritative resource on the Java language is the Java Language Specification, or JLS for short. The specification is written in a very concise and well understandable way, and I highly recommend you to take a look if you’d like to understand how specific details of the language exactly work. That being said, when you’re just about to get started with learning Java, you’ll be better off by studying the resources mentioned above.

If certifications are your thing, you might consider learning for and taking the exam for the "Oracle Certified Professional: Java SE 17 Developer" one. I’d only recommend doing so after having worked with Java at least for a year or so, as the exam actually is quite involved. You’ll certainly learn a lot about Java, including all kinds of corner cases and odd details; not everything will necessarily translate into your day-to-day work as a developer, though. So you should consciously decide whether you want to spend the time preparing for the certification or not.

Once you go beyond the basics of manually compiling and running a set of Java classes, you’ll need a build tool. It will not only help you with compiling your code, but also with managing dependencies (i.e. 3rd party libraries you are using), testing your application, assembling the output artifacts (e.g. a JAR file with your program), and much more. There are plug-ins for finding common bug patterns, auto-formatting your code, etc. Commonly used build tool options for Java include Apache Maven, Gradle, and Bazel.

My recommendation is to stick with Maven for the beginning; it’s the most widely used one, and in my opinion the easiest to learn. Installing it is as simple as running sdk install maven with SDKMan. While it defines a rather rigid structure for your project, that also frees you from having to think about many aspects, which is great in particular when getting started. Maven has support for archetypes, templates which you can use to quickly bootstrap new projects. For instance you can use the oss-quickstart archetype which I have built for creating new projects with a reasonable set of pre-configured plug-ins like so:

A lesser known yet super-useful companion to Maven is the Maven Daemon, which helps you to drastically speed up your builds by keeping a daemon process running in the background, avoiding the cost of repeatedly launching and initializing the build environment. You can install it via SDKMan by running sdk install mvnd.

Alternative build tools like Gradle tend to provide more flexibility and interesting features like "compilation avoidance" (rebuilding only affected parts of large code bases after a change) or distributed build caches (increasing developer productivity in particular in large projects), but I’d wait with looking at those until you’ve gathered some experience with Java itself.

Many Java developers love to fight over their favorite build tools, and it’s the same with editors and full-blown integrated development environments (IDEs). So whatever I’m going to say here, it’s guaranteed a significant number of people won’t like it ;)

My suggestion is to start with VSCode. It’s a rather light-weight editor, which comes with excellent Java developer support, e.g. for testing and debugging your code. It integrates very well with Maven-based projects and has a rich eco-system of plug-ins you can tap into.

As your needs grow, you’ll probably look for an IDE which comes with even more advanced functionality, e.g. when it comes to refactoring your code. While I’m personally a happy user of the Eclipse IDE, most folks tend to use IntelliJ IDEA these days and it’s thus what I’d recommend you to look into too. It comes with a feature-rich free community edition which will help you a lot with the day-to-day tasks you’ll encounter as a Java developer. Make sure to spend a few hours learning the most important keyboard short-cuts, it will save you lots of time later on.

The ecosystem of 3rd party libraries is one of Java’s absolute super-powers: there is a ready-made library or framework available for pretty much every task you might think of, most of the times available as open-source.

Perhaps counter-intuitively, my recommendation here is to try and be conservative with pulling in libraries into your project, and instead work with what’s available in Java’s standard class library (which is huge and covers a wide range of functionality already). Next, check out what your chosen application framework (if you use one, see below) offers either itself or provides integrations for.

Adding a dependency to an external library should always be a conscious decision, as you might easily run into version conflicts between transitive dependencies (i.e. dependencies of dependencies) in different versions, more dependencies increase the complexity of your application (for instance, you must keep them all up-to-date), they may increase the attack surface of your application, etc. Sometimes, you might be better off by implementing something yourself, or maybe copy a bit of code from a 3rd party library into your own codebase, provided the license of that library allows for that.

That said, some popular libraries you will encounter in many projects include JUnit (for unit testing), slf4j (logging), Jackson (JSON handling), Hibernate (object-relational persistence, domain model validation, etc.), Testcontainers (integration testing with Docker), and ArchUnit (enforcing software architecture rules). The "awesome-java" list is a great starting point for diving into the ecosystem of Java libraries.

Most open-source dependencies are available via the Maven Central repository; All the build tools integrate with it, not only Maven itself, but also Gradle and all the others. The MVN Repository site is a good starting point for finding dependencies and their latest versions. If you want to distribute libraries within your own organization, you can do so by self-running repository servers like Nexus or Artifactory, or use managed cloud services such as AWS CodeArtifact.

Most Java enterprise applications are built on top of an application framework which provides support for structuring your code via dependency injection, seamlessly integrates with a curated set of 3rd party libraries in compatible versions, helps with configuring and testing your application, and much more.

Again, there’s plenty of options in Java here, such as Spring Boot, Quarkus, Jakarta EE, Micronaut, Helidon, and more. My personal recommendation here is to use Quarkus (it’s the one I’m most familiar with, having worked for Red Hat before, who are the company behind this framework), or alternatively Spring Boot.

Both are widely popular, integrate with a wide range of technologies (e.g. web frameworks and databases of all kinds), come with excellent developer tooling, and are backed by very active open-source communities.

In particular when you are going to work on an enterprise application, chances are that you’ll publish your application in form of a container image, so people can run it on Docker or Kubernetes.

Sticking to the recommendation on using Eclipse Temurin as your Java distribution, I suggest to use the Temurin image as the base for your application images, e.g. eclipse-temurin:17 for Java 17. Just make sure to keep your image up to date, so you and your users benefit from updates to the base image.

One base image you should avoid is the OpenJDK one, which is officially deprecated and not recommended for production usage.

The points above hopefully can help you to embark onto a successful journey with the Java platform, but they only are a starting point. Depending on your specific needs and requirements, here is a number possible next topics to explore and learn about:

Finally, a few resources which should help you to stay up-to-date with everything Java and learn what’s going on in the community include the Java News on dev.java, inside.java ("news and views from members of the Java team at Oracle") the JEP Search (for searching and filtering Java enhancement proposals, i.e. changes to the language and the platform) and Foojay (Friends of OpenJDK).

Many thanks to Nils Hartmann, Andres Almiray, and Oliver Zeigermann for their input and feedback while writing this post!