Java 9 Duke

What are the most exciting features that are expected to be released in Java 9?

Don’t get distracted by the relative silence lately around Java 9. The JDK committers are hard at work preparing the next release, expected to be feature complete just a few months away on December 2015. After that, it will go through rigorous tests and bug fixes preparing it for general availability, which is scheduled for September 2016.

Today we have a pretty clear picture of the features we can expect in Java 9. If Java 8 could be described as the major release of lambdas, streams and API changes, then Java 9 is all about Jigsaw, extra utilities and changes under the hood. In this post we’ve gathered some of the features we believe are the most exciting ones that are targeting Java 9 – Apart from the usual suspect, project Jigsaw, which took on the mission of breaking down the JRE and bringing modularity to Java’s core components.

Here some of the features which are an absolute must to know about in Java 9, some of these are already ready for you to tinker with in the early release version.

1. Java + REPL = jshell

Yes. Previously we had doubts that project Kulla would make it in time for Java 9 but now it’s official. The next release of Java will feature a new command line tool called jshell that will add native support and popularize a Java way to REPL (Read-Eval-Print-Loop). Meaning, say, if you’ll want to run a few lines of Java on their own you won’t have to wrap it all in a separate project or method. Oh and semicolons – you can forget about those:

-> 2 + 2
| Expression value is: 4
|     assigned to temporary variable $1 of type int

There are some alternatives like REPL add-ons to popular IDEs and solutions like the Java REPL web console, but no official and right way to do this so far. jshell is already available in the early release and waiting for you to give it a test run.

2. Microbenchmarks are coming

The Java Microbenchmarking Harness (JMH) by Alexey Shipilev is taking the next step in its evolution and joins Java as an official benchmarking solution. We really love doing benchmarks here at Takipi, so a standardized way of performing them is something we look forward to.

JMH is a Java harness for building, running, and analysing nano/micro/milli/macro benchmarks. When it comes to accurate benchmarking, there are forces in play like warmup times and optimizations that can have a big impact on results. Especially when you’re going down to micro and nano seconds. So today JMH is your best choice if you want to get the most accurate results to help you reach the right decision following your benchmarks – And now it’s becoming a synonym with Java 9.

3. Will G1 be the new default garbage collector?

A common misconception we often hear is that Java has only one garbage collector when in fact it has 4. With Java 9, there’s a running proposal that’s still in debate to replace the default garbage collector (The parallel / Throughput collector) with G1 which was introduced in Java 7. For a bite sized overview about the differences between the different collectors, you can check out this post right here.

Generally, G1 was designed to better support heaps larger than 4GB and has been known to cause less frequent GC pauses, but when a pause do comes, it tends to be longer. Recently we’ve discussed all things GC with Haim Yadid, head of performance at Outbrain, to help you learn more about the different trade offs between the collectors. Also, if you’d like to have an inside view of this debate, the hotspot-dev and jdk9-dev mailing lists are a great place to start.

Find the Crap in Your Java App

Show me how >>

Fred

4. HTTP 2.0 is the future

The official HTTP 2.0 RFC was approved just a few months ago, building on top of Google’s SPDY algorithm. SPDY has already shown great speed improvements over HTTP 1.1 ranging between 11.81% to 47.7% and its implementation already exists in most modern browsers.
Java 9 will have full support for HTTP 2.0 and feature a new HTTP client for Java that will replace HttpURLConnection, and also implement HTTP 2.0 and websockets.

5. The process API just got a huge boost

So far there has been a limited ability for controlling and managing operating system processes with Java. For example, in order to do something as simple as get your process PID in earlier versions of Java, you would need to either access native code or use some sort of a magical workaround. Moreover, it would require a different implementation for each platform to guarantee you’re getting the right result.

In Java 9, expect the code for retrieving Linux PIDs, that now looks like this:

public static void main(String[] args) throws Exception {
Process proc = Runtime.getRuntime().exec(new String[] {
"/bin/sh",
"-c",
"echo $PPID"
});

if (proc.waitFor() == 0) {
InputStream in = proc.getInputStream();
int available = in.available();
byte[] outputBytes = new byte[available];

in.read(outputBytes);
String pid = new String(outputBytes);

System.out.println("Your pid is " + pid);
}
}

To turn into something like this (that also supports all operating systems):


System.out.println("Your pid is " + Process.getCurrentPid());

The update will extend Java’s ability to to interact with the operating system: New direct methods to handle PIDs, process names and states, and ability to enumerate JVMs and processes and more.

6. Debugging in Production

While not exclusive to Java 9, we thought this post would be a good opportunity to share some of the new progress we’ve been making at Takipi. Solving errors in production has always been a messy practice, grepping for clues over huge log files, and trying to identify the state that caused each exception or logged error. But what if you could avoid logs altogether? Here’s how it’s done.

What you’ll not be seeing in Java 9?

Two interesting features that we assumed will make a part of the upcoming Java release – but now we know they will be skipped this time are.

1. A standardized lightweight JSON API

On a survey we conducted with 350 developers, the JSON API was just as hyped as Jigsaw but looks like it didn’t make the cut due to funding issues. Mark Reinhold, chief architect of the Java platform, on the JDK 9 mailing list:

“This JEP would be a useful addition to the platform but, in the grand scheme of things, it’s not as important as the other features that Oracle is funding, or considering funding, for JDK 9. We may reconsider this JEP for JDK 10 or a later release. ”

2. Money and Currency API

In other news, it also looks like the expected Money and Currency API is also lacking Oracle support. This is the answer we got from Anatole Tresch, the APIs spec lead:

Did we miss anything? Let us know in the comments below.

Further reading:

Bug line

5 Error Tracking Tools Java Developers Should Know

Some kind of monster @ OverOps, GDG Haifa lead.
  • http://www.jooq.org Lukas Eder

    The irony in #5 is that using the low-level InputStream API is still such a PITA in standard JDK API 🙂

    • magicsign

      pita and falafel ?

      • Xavier

        no, pita and katniss !

  • Jake Schwartz

    Surprising that a standard JSON library is not going to be included, with that being one of the more popular ways to send data these days via APIs.

    • http://www.takipi.com/ Alex Zhitnitsky

      Looks like we’ll keep relying on 3rd party libraries, at least until Java 10 if JSON will remain popular 😉

  • Binh Thanh Nguyen

    Thanks, nice post

    • http://www.takipi.com/ Alex Zhitnitsky

      Thanks Binh! Glad you liked it

  • http://www.codelytics.io Adrian Bartlett

    The REPL looks good for prototyping. I often write new code in the debugger, so I can access the current application state. I hope there will be IDE integration, provided by the vendors.

  • saasira

    can we load the jshell into linux shell like #!/usr/bin/jshell and run our java/jshell scripts from the terminal? or these scripts need to be run by jshell alone?

    • http://www.takipi.com/ Alex Zhitnitsky

      JShell is a command line tool, you run it from the terminal, and it also allows you to save the code you typed in and load it again through JShell. Spoiler alert: We’ll be publishing a post soon covering JShell, so stay tuned 🙂

  • Alvaro Urbaez

    Why is so hard get native JSON support?? Uh.. 🙁

    • http://www.takipi.com/ Alex Zhitnitsky

      With so many 3rd party libraries doing a good job, it seems like a lower priority at the moment. The expectations from native library support are definitely higher though, and the feedback we’ve seen from the community shows that many developers want to see that in the near future. Guess we’ll have to wait for Java 10, or 11, or 12 😉

  • Valaki2

    Most of those things are not very important in my opinon. Most of the functionalities could be achieved using external libraries (like http2) or are simply minor. I would be more interested in new language elements….

  • http://pliterki.pl pliterki.pl

    Is it just me or it is quite a boring list of updates for a major version upgrade?

    • http://freeldssheetmusic.org rogerdpack

      Yeah no actual language syntax changes?

  • http://xenoterracide.com/ Caleb Cushing

    well at least we’re getting jigsaw, I’m now kind of interested in what will be coming in 10, since lambda’s and jigsaw seemed like the big thing. I’m sad that Money isn’t getting any.

  • Nissi T

    wasted 10 minutes of my time reading this, are you kidding developers. whats up with this whole boring list of features in a major release, we are in 2016 guys

  • Randy Pancetalk

    What a shame. Native JSON support would be vastly more helpful than some java shell or Microbenchmarks. The microbenchmark system already exists as a standalone API.

    Guess the java architects are out of touch with how people are using java.

    • http://xenoterracide.com/ Caleb Cushing

      funny, I was just thinking how with Jackson I don’t actually need JSON in core, in fact I’ve never had a problem with lack of JSON in core, but a REPL? I want a good REPL at least once a month.

      • Jacob Beasley

        Agreed, with good IDE integration I wonder if you could not just do a breakpoint, but actually execute code in your breakpoint from a console. I mean, that would be great for debugging and trying things out stand-alone.

  • gacl

    Instead of native JSON, I’d prefer what Python has: super clean list and dictionary/map syntax with simple one-line conversion to/from JSON text. Preferably with list/dict comprehensions.

    Most of these features are quite tiny or petty. The one big one is Jigsaw, I’m not sure how good or bad that will be. A native REPL is nice. Tons of other minor updates. Hopefully Jigsaw will benefit Scala too.

    Project Valhalla has high-performance immutable value types, which is very important. That is already well in development and I presume it will be JDK 10.

    • http://freeldssheetmusic.org rogerdpack

      I can only wish

  • http://slidenerd.com slidenerd

    well honestly i was expecting java to cut short code like Swift, lets see if they go in that direction anytime soon

  • https://github.com/download13/ download13

    Does that popover need to be bothering us while we try to read? It makes for a kind of unpleasant experience.

  • Ram S

    I think Java is missing the point and not focusing on language feature development… As someone pointed out these features are not that important (except REPL which is cool)… What about speed, compilation, unsigned numbers, etc… that is more prevalent and getting popular in other languages… and may be AI? IOT enabled etc..

    • gacl

      JDK 8 added unsigned integer functions to the standard library in java.lang.Integer. These are inlined and the JVM will run at full native performance. This solves 99% of the need for unsigned integers.

      • sanosuke001

        the Integer unsigned methods really don’t help; try working with wrapped native libraries like OpenGL.

        • gacl

          I haven’t used OpenGL or other native libs from Java. But the unsigned integer functions do give you performance benefit for regular Java ecosystem code working with unsigned ints.

          Better FFI with C-based “native” code is coming in Project Panama (JDK 11?)

  • Carlos Daniel Cañón Carrero

    Well, think this isn’t much important.
    Anyway, the jdk8( and Lambda was amazing upgrade), but actually i am working with Scala, if you wanna have more productivity try learn this language, this run on the same JVM.

    • gacl

      JDK and JVM features benefit Scala too. The main purpose of Scala 2.12 is to take full advantage of the JVM improvements in JDK 8. Jigsaw in JDK 9 will definitely impact Scala and hopefully provide large benefit. Project Valhalla value types in JDK 10 will be of huge benefit to Scala and any other JVM language.

  • Paul Bartlett

    I think this has proven how little love Oracle have for Java. As many have mentioned, none of this is enhancement to the core language. Compare C# to Java with features such as implicit typing, property definitions, null coalescing, string interpolation, partial classes, tuples, multiple return types (C# 7), LINQ, object initializers etc. I was hoping Java would kill the need for Groovy, but Java is an embarrassingly 1990’s language. Where is the stuff that makes programming exciting. Java is the most boring modern language. Whilst C#, Swift, Javascript, Python are all innovating, Java has lost it and I can only see it lose it’s crown in the next few years.

  • gacl

    Wow, these features are lame. This article is over a year old an no updates? Consider #2: I like the jmh microbenchmark system, but bundling it with the jdk versus being a separate add-on is small potatoes.

  • sanosuke001

    I’d rather see unsigned primitives

  • Pranas

    Looks like 0 future for UI in Java …

  • Clinton Selke

    Units of Measure API? I thought it was promised for Java 9 too, but I could be wrong.