New heights

Java 8: Explore the possibilities

TimothyBeneke
high

Timothy Beneke takes you from embedded to cloud possibilities in Java 8 thanks to “the most significant expansion” to date.

From embedded to the cloud, get there with Java
8.

Java 8, which encompasses both Java SE 8 and Java ME 8, might be
the most significant expansion of the Java platform yet.

Lambda expressions and the Stream API increase the expressive
power of the platform and make it easier for developers to take
advantage of modern, multicore processors. Compact Profiles in Java
SE 8 allow developers to use just a subset of the platform, and are
a significant step toward the convergence of Java SE and Java ME.
Java ME 8 itself, meanwhile, has been updated to include
more-recent Java Virtual Machine (JVM), language, and library
features while retaining the focus on small embedded devices. Java
8 allows developers to apply the same skill set across a wide range
of scenarios, from the smallest embedded Internet of Things (IoT)
devices to enterprise servers in the cloud.

As Mark Reinhold, chief architect of the Java Platform Group at
Oracle, put it, “Java 8 is the first truly revolutionary release
we’ve done in a very long time.”

Here, we take a look at eight key pieces of Java 8.

  1. Lambda Expressions
  2. Nashorn and JavaScript
  3. Compact Profiles
  4. Date and Time API
  5. JavaFX 8
  6. Community Involvement
  7. Java ME 8
  8. Java SE 8 and the JVM

1. Lambda Expressions

Lambda expressions are at the heart of
Java SE 8. “Lambda expressions, also known as closures, are
anonymous methods that provide developers with a simple and compact
means for representing behavior as data,” explains Brian Goetz,
Oracle’s Java language architect and Specification Lead for JSR
335, Lambda Expressions for the Java Programming Language. “This
enables the development of libraries that do a better job of
abstracting over behavior, which in turn leads to more-expressive,
less error-prone code.” 

While Java has always provided
reasonable tools such as classes, inheritance, and generics for
abstracting over data, Java SE 8 provides new tools for abstracting
over behavior. As Goetz explains, “If we want to model a workflow
such as ‘do A before you start, do B for every file in this group,
do C if you encounter an error, and do D when you’re done,’ we
don’t have ideal tools for expressing the behaviors A through D,
and this affects the sort of APIs we design. We have to break up
the phases of the workflow, and the client code has to be directly
involved in each phase, rather than saying ‘here’s what I want; go
do it.’ This negatively affects reusability, readability, and
performance.”

According to Goetz, the typical developer’s initial experience
with lambda expressions is likely to be through the powerful new
APIs for manipulating collections. Business logic typically is full
of ad hoc query-like calculations over collections; the core
libraries now make it easier to express the “what” of such a query
without getting bogged down in details about the “how.”

The other major language feature of Java SE 8 is default
methods, which enable interfaces to evolve over time. Default
methods are necessary for Java SE 8 given that some core library
classes, such as Collections, are more than 15 years old. Without
default methods, some core library classes would be unable to
support lambdas.

“More generally,” explains Goetz, “if you want libraries to stay
relevant over long periods of time, they need to be flexible, so we
needed to address this problem while maintaining our commitment to
compatibility.”

When asked about the challenges Java developers face in working
with lambdas, Goetz is optimistic. “The big challenge,” he says,
“is accepting that this is not simply a matter of new syntax; there
are some new concepts that developers will have to learn just to be
able to read Java code, even if they do not plan to take advantage
of these new features in the code they write. There are also big
additions to the core libraries that developers will have to
learn—but these costs should be more than offset by increases in
productivity and expressiveness.”

Goetz makes no effort to hide his enthusiasm for lambdas: “I
think this is the most significant upgrade of the Java programming
model ever—and yet, it still feels like the Java we know and love,”
he insists. “In a few years, developers will wonder how they ever
lived without it. I certainly do!”

2. Nashorn and Javascript

“Nashorn is a part of Java SE 8 that is
intended to provide a version of JavaScript that would run as part
of the JVM—a more modern version of JavaScript using newer JVM
technologies,” observes Jim Laskey, engineering lead for
multilanguages at Oracle. With Java SE 8, Nashorn is being shipped
as a javax .script engine embedded in the
JDK, which means that any Java application can now contain
components written in JavaScript. JavaScript is a popular language
with features similar to Java’s features that is ideal for
transmitting code across networks. In addition, there is now a
command-line tool (jjs) that allows developers to use
Nashorn as a scripting tool. Nashorn, which replaces Rhino, also an
open source JavaScript engine, is both faster and lighter and
integrates JavaScript and Java more tightly. 

As a consequence, JavaScript
developers can take advantage of the wealth of libraries normally
only available to Java developers, and can implement portions of
their application in a simpler, lightweight programming language.
Developers can now implement runtime dynamic features and bypass
build cycles, while users and field engineers can make
configuration changes without having to rebuild the application.
“Nashorn will allow JavaScript to be used in ways that have not
been available before,” he says.

Laskey is quick to point out, “Although Nashorn JavaScript is
not the same as browser JavaScript, and currently lacks DOM
components, it is a full-featured programming language with access
to all of the available Java libraries.”

 3. Compact Profiles

Compact Profiles, three well-defined API
subsets of the Java 8 specification, offer a convergence of the
Java ME Connected Device Configuration (CDC) with Java SE 8. With
full Java 8 language and API support, developers now have a single
specification that will support the Java ME CDC class of devices
under the Java SE umbrella. For many years, embedded developers
have wanted to allow subsetting of the Java SE platform in order to
deploy smaller binaries in their embedded devices. Compact Profiles
enable the creation of applications that do not require the entire
platform to be deployed and run on small devices. Because Compact
Profiles are much smaller than the full Java SE Java runtime
environment (JRE), they enable applications to be deployed on
platforms with limited storage. The smallest of these runtimes is
11 MB, which is more than four times smaller than the equivalent
traditional JRE. 

Java SE applications can now be designed to run on
resource-constrained devices by targeting the specific APIs that
are available in Compact Profiles. The Compact Profiles were
primarily designed for embedded developers who wish to use Java for
the creation of embedded solutions with limited static and dynamic
storage. By keeping the amount of RAM and flash to a minimum, the
bill of materials (BOM) cost for embedded devices is also kept to a
minimum, resulting in increased profit for device distributors.

Bob Vandette, consulting engineer at Oracle, sums it up: “With
the introduction of Compact Profiles, we now have a single Java SE
standard with all of the productivity that Java is famous for that
can truly scale from small embedded IoT devices to large enterprise
server installations.”

4. Date and Time API

Java SE 8 introduces a
new java.time API with a fluent and familiar
style that is easy to read and write without the aid of IDEs. It
provides excellent support for the international ISO 8601 time
standard that global businesses use and also supports the
frequently used Japanese, Minguo, Hijrah, and Thai Buddhist
calendars. Each of the new core Java classes—for date, time, date
and time combined, time zones, instants, duration, and clocks—has a
specific purpose and has explicitly defined behavior without side
effects. The types are immutable to simplify concurrency issues
when used in multitasking environments. In addition, the
extensibility of the API enables the addition of new calendars,
units, fields of dates, and times. Developers can focus on
completing a particular task without being concerned about
unrelated functions.

The new API uses immutable values, with each computation
producing a new value. With immutable objects, an instance can be
shared with a library or a concurrent task without concern that the
value will change unexpectedly, explains Roger Riggs, consulting
member of the technical staff at Oracle. This contrasts with the
current 
Date and Calendar types
that hold a mutable value and are not multithread safe. Using
immutable values eliminates many problems for multithreaded
programming.

“The current APIs
for Date and Calendar combine
many functions in each type, which often results in unexpected
interactions that increase programming complexity,” explains Riggs.
“The new APIs offer greater clarity of purpose, ease of use, and
maintenance.”

5. JavaFX 8

“JavaFX 8 is integrated with Java SE 8 and
works well with lambda expressions. It simplifies many kinds of
code, such as event handlers, cell value factories, and cell value
factories on TableView,” explains Richard Bair,
client Java architect at Oracle. “It brings some much-requested new
UI controls and APIs such
as TreeTableView and APIs that enable modal
dialogs.”

In addition, says Bair, JavaFX 8
offers a powerful rich text node for the scene graph, and the Java
community is fast at work on several projects building rich text
and code editors on top of this support. In addition, the default
look of JavaFX applications has been refreshed with a new theme,
called “Modena.” JavaFX 8 also offers increased support for
third-party components, many of which can now work out of the box.
All of the above will lead to enhanced productivity for JavaFX
developers, he says.

Much progress has also been made on the performance front,
largely due to the effort to bring JavaFX to embedded devices such
as the Raspberry Pi and Freescale i.MX 6 boards. Increased 3-D
support in JavaFX has opened new opportunities for developers, with
AMD contributing COLLADA importer functionality to OpenJFX, which
is a lively and thriving community, Bair adds.

“The new Scene Builder 2, the first Scene Builder actually built
with Scene Builder, has an excellent CSS inspector, so developers
can better understand why things are styled as they are,” explains
Bair. It is also modular and can be embedded in any IDE. Scene
Builder 2 works with FXML, an open and published format, so
developers can hack the FXML file directly. “I encourage everybody
to download JavaFX 8, try it out, and provide feedback to the
team,” he adds.

6. Community Involvement

The Java community has been vital in the
creation of Java 8. It has provided ongoing feedback to
Specification Leads, made requests for new Java functionality,
uncovered bugs, contributed to code fixes, and much more.

Java user groups (JUGs), which are centers of Java community
learning and participation, have been essential. As Java Champion
and SouJava JUG Leader Bruno Souza explains, “Java 8 has set a new
standard of community participation. There are Java user groups all
over the world running programs and providing feedback for the JCP
specifications and being active in OpenJDK.” The OpenJDK community is where
developers collaborate on the open source reference implementation
of the Java SE platform.

The Adopt-a-JSR
program
, created to encourage JUG members, individuals, and
other organizations to get involved in JSRs, has resulted in
increased grassroots and developer participation in not only Java 8
but other emerging standards as well. More than 26 JUGs have
participated in the program.

The Java Community Process (JCP), with its enhanced openness and
flexibility, has made it easier for both organizations and
individuals to contribute to the Java platform. “The JCP now has a
much more transparent process,” says Souza. “It’s a lot easier for
someone to go to the JCP site and get involved. This increased
transparency has made it easier for the community to
participate.”

7. Java ME 8

“Java ME 8 is a major step in the
convergence of Java ME and Java SE and the unification of the Java
ecosystem, enabling Java developers to more easily deploy their
existing skills across a range of embedded devices, drawing upon
the richness and portability of the Java platform,” explains
Terrence Barr, senior technologist and product manager at Oracle
who focuses on the IoT and embedded technologies. “This results in
a faster time to market, as well as cross-platform compatibility
and embedded device scalability.”

With the advent of Java ME 8, developers can take their existing
skills and begin writing applications for the rapidly developing
realm of embedded devices—using the same familiar platform,
language, programming model, and tools. With the embedded space and
the fast-developing IoT in a state of flux, Java ME 8 offers a
flexible and scalable development/deployment environment.

See “Java
ME 8 and the Internet of Things
” in this issue for details.

8. Java SE 8 and the JVM

“Java SE 8 offers an improved, more mature
G1 garbage collector. G1’s scalability is getting better, and more
work is being done concurrently,” explains Jon Masamitsu, principal
member of the technical staff at Oracle. “G1’s basic design is not
changing, but incremental improvements toward more-dependable pause
times have been made in many areas. More generally, in all the
garbage collectors the command-line flags are now more consistent,
with flag discrepancies corrected. This should make it easier for
users to switch among the different garbage collectors and have the
command-line flags have a common meaning where possible.”

In addition, Java SE 8 removes the need to tune the permanent
generation. The Java HotSpot VM’s internal representation of Java
classes has been re-engineered and moved out of the permanent
generation (which has been removed entirely) and moved into native
memory and/or the Java heap. Previously, tuning the size of the
permanent generation was a tiresome, trial-and-error process. The
maximum size of the permanent generation had to be set at startup,
and there was no intuitive way to know how large it should be.
Developers need no longer guess about a size for the permanent
generation.

Finally, Java ME 8 has been updated with the JVM, the language,
and the libraries to be aligned with Java SE 8.

Easier Queries and Calculations with Lambdas

Java Language Architect Brian Goetz shows
how the Java core libraries have been enhanced to enable
more-query-like calculations over collections.

“Consider something like ‘find artists with albums that have
fewer than eight tracks.’ This is easy enough to write with a for
loop, but the resulting code is full of accidental detail about
‘how,’ which obfuscates the ‘what,’” he says. In Java SE 8, it
looks like this:

Set<artists> artists =
        albums.stream()
            .filter(album -> album.getTracks().size() < 8)
            .map(album -> album.getArtist())
            .collect(toSet());</artists>

“Here, we’ve said ‘give us the elements of albums, select the
ones with fewer than eight tracks, for each of those get the
artist, and then collect them into a set.’ The code reads like the
problem statement, which is good because code that is easy to read
also is more likely to be correct,” says Goetz.

This shift from handwritten loops to aggregate operations using
lambdas and streams inverts the control of the computation. “With
the for loop, the client is in control at every step, asking the
Iterator for the next element on each iteration,” Goetz says. “With
lambdas and streams, the library is in control, but still allows
the computation to be easily customized by the client.”

He goes on to explain, “In the albums calculation above, it
might look like we’re doing three passes on the data, but in fact
the three are fused into a single pass. This is possible only
because the client was able to express everything it wanted in one
go, parameterizing the steps with various bits of behavior, rather
than being involved in every loop iteration.”

Take it for a Spin

All in all, Java 8 offers a new
opportunity for enhanced innovation for Java developers who operate
on anything from tiny devices to cloud-based systems. We can expect
increases in developer productivity and application performance
through the reduced boilerplate code and increased parallel
programming that lambdas offer. Java 8 offers best-in-class
diagnostics, with a complete tool chain to continuously collect
low-level and detailed runtime information.

By bringing the advantages of Java SE to embedded development,
developers can transfer their Java skills to fast-evolving new
realms in the IoT, enabling Java to support any device of any size.
It is an exciting time to be a Java developer, so take it for a
spin, and tell us about the ride.

Originally published in the March/April 2014 issue
of Java MagazineSubscribe today.

About the author

 Timothy
Beneke
 is a freelance
writer and editor, best known for his books on gender.

(1) Originally published in
the March/April 2014 Edition of Java Magazine 
(2) Copyright © [2014] Oracle.

Author
Comments
comments powered by Disqus