A New Kind of Java

Java 8 is almost here. You can play with the early access -previews right now, and I think you -should, even if you don't like Java very much. There's so much potential in -there.

The “One More Thing”

The Java 8 release comes with a slew of notable library improvements: the new -java.time package, designed by the folks -behind the extremely capable Joda time library; reflective -access to parameter names; Unicode -6.2 support; numerous others. But all of -these things are dwarfed by the “one last thing”:

Lambdas.

Ok, So..?

Here's the thing: all of the “modern” languages that see regular use - C#, -Python, Ruby, the various Lisps including Clojure, and Javascript - have -language features allowing easy creation and use of one-method values. In -Python, that's any object with a __call__ method (including function -objects); in Ruby, it's blocks; in Javascript, it's function() {}s. These -features allow computation itself to be treated as a value and passed -around, which in turn provides a very powerful and succinct mechanism for -composing features.

Java's had the “use” side down for a long time; interfaces like Runnable are -a great example of ways to expose “function-like” or “procedure-like” types to -the language without violating Java's bureaucratic attitude towards types and -objects. However, the syntax for creating these one-method values has always -been so verbose and awkward as to discourage their use. Consider, for example, -a simple “task” for a thread pool:

pool.execute(new Runnable() {
-    @Override
-    public void run() {
-        System.out.println("Hello, world!");
-    }
-});
-

(Sure, it's a dumb example.)

Even leaving out the optional-but-recommended @Override annotation, that's -still five lines of code that only exist to describe to the compiler how to -package up a block as an object. Yuck. For more sophisticated tasks, this sort -of verbosity has lead to multi-role “event handler” interfaces, to amortize -the syntactic cost across more blocks of code.

With Java 8's lambda support, the same (dumb) example collapses to

pool.execute(() -> System.out.println("Hello, world"));
-

It's the same structure and is implemented very similarly by the compiler. -However, it's got much greater informational density for programmers reading -the code, and it's much more pleasant to write.

If there's any justice, this will completely change how people design Java -software.

Event-Driven Systems

As an example, I knocked together a simple “event driven IO” system in an -evening, loosely inspired by node.js. Here's the echo server I wrote as an -example application, in its entirety:

package com.example.onepointeight;
-
-import java.io.IOException;
-
-public class Echo {
-    public static void main(String[] args) throws IOException {
-        Reactor.run(reactor ->
-            reactor.listen(3000, client ->
-                reactor.read(client, data -> {
-                    data.flip();
-                    reactor.write(client, data);
-                })
-            )
-        );
-    }
-}
-

It's got a bad case of Javascript “arrow” disease, but it demonstrates the -expressive power of lambdas for callbacks. This is built on NIO, and runs in a -single thread; as with any decent multiplexed-IO application, it starts to -have capacity problems due to memory exhaustion well before it starts to -struggle with the number of clients. Unlike Java 7 and earlier, though, the -whole program is short enough to keep in your head without worrying about the -details of how each callback is converted into an object and without having to -define three or four extra one-method classes.

Contextual operations

Sure, we all know you use try/finally (or, if you're up on your Java 7, -try()) to clean things up. However, context isn't always as tidy as that: -sometimes things need to happen while it's set up, and un-happen when it's -being torn down. The folks behind JdbcTemplate already understood that, so you -can already write SQL operations using a syntax similar to

User user = connection.query(
-    "SELECT login, group FROM users WHERE username = ?",
-    username,
-    rows -> rows.one(User::fromRow)
-);
-

Terser and clearer than the corresponding try-with-resources version:

try (PreparedStatement ps = connection.prepare("SELECT login, group FROM users WHERE username = ?")) {
-    ps.setString(1, username);
-    try (ResultSet rows = rs.execute()) {
-        if (!rows.next())
-            throw new NoResultFoundException();
-        return User.fromRow(rows);
-    }
-}
-

Domain-Specific Languages

I haven't worked this one out, yet, but I think it's possible to use lambdas -to implement conversational interfaces, similar in structure to “fluent” -interfaces like -UriBuilder. -If I can work out the mechanics, I'll put together an example for this, but -I'm half convinced something like

URI googleIt = Uris.create(() -> {
-    scheme("http");
-    host("google.com");
-    path("/");
-    queryParam("q", "hello world");
-});
-

is possible.

- - - -

- - -comments powered by Disqus -

- - - - - -