Wednesday Jan 14, 2015

More concise try-with-resources statements in JDK 9

As part of milling Project Coin in JDK 9, the try-with-resources statement has been improved. If you already have a resource as a final or effectively final variable, you can use that variable in the try-with-resources statement without declaring a new variable in the try-with-resources statement.

For example, given resource declarations like

        // A final resource
        final Resource resource1 = new Resource("resource1");
        // An effectively final resource
        Resource resource2 = new Resource("resource2");

the old way to write the code to manager these resources would be something like:

        // Original try-with-resources statement from JDK 7 or 8
        try (Resource r1 = resource1;
             Resource r2 = resource2) {
            // Use of resource1 and resource 2 through r1 and r2.

while the new way can be just

        // New and improved try-with-resources statement in JDK 9
        try (resource1;
             resource2) {
            // Use of resource1 and resource 2.

An initial pass has been made over the java.base module in JDK 9 to update the JDK libraries to use this new language feature.

You can try out these changes in your own code using a JDK 9 snapshot build. Enjoy!

Thursday Jan 19, 2012

Project Coin Rocks!

After many years of speaking at JavaOne, I was happy to get notification yesterday that for giving The Heads and Tails of Project Coin this year, I was inducted as a 2011 JavaOne Rock Star.

With Project Coin successfully shipped as part of JDK 7, I'm looking forward to exploring speaking about other topics at JavaOne this year. Perhaps I'll sumbit a proposal for a "lessons from mathematics" talk I've long wanted to give. I've found approaches and results from fields like stocastics and linear algebra can be helpful in other contexts, including language design and API work.

Rockin' Duke

Tuesday Jan 10, 2012

Project Coin Fixes in 7u2

Last month, JDK 7u2 was released. The release has a few correctness fixes for the Project Coin features, two diamond fixes courtesy Maurizio and one fix to strings in switch:

  • Diamond inference with nested classes had an improper interaction. For example, in code like

    class X {
      class Y {
        Y(T a, Z b) {...}
      public static void main(String... args) {
        X<String>.Y<String> x1 = new X<String>().new Y<String>("",""); //ok
        X<String>.Y<String> x2 = new X<String>().new Y<>("",""); // Failed!
    diamond was not allowed at the second constructor call, but such code is accepted as of 7u2. (7046778)

  • The compiler erroneously allowed constructs like

    Foo<String>[] fooArr = new Foo<>[]{...};
    Such code is now properly rejected. (7057297)

  • If extra parenthesis were used around the case label of a string switch statement, as in

    switch (s) {
      case ("a"):
    javac would throw a NullPointerException when compiling the code. (7071246) Previously, the workaround was to remove the unneeded "(" and ")", but javac has been corrected to accept this valid syntax. (We received multiple reports of this bug, so parenthesis around case labels is much more common style than I would have expected!)

If you're using the Project Coin language features, I recommend upgrading to 7u2 to get these fixes and to minimize source compatibility concerns going forward.

Wednesday Nov 16, 2011

Project Coin at Devoxx 2011

Returning to Antwerp, earlier today Maurizio and I presented a talk on Project Coin at Devoxx and the slides are now available.

The talk was streamed live on Parleys and will be available for download and viewing on the Devoxx 2011 channel in due course.

Now that my major Devoxx speaking obligations are over, more attention can be paid to Belgium waffles and beer!

Tuesday Oct 04, 2011

Project Coin at JavaOne 2011

Update: A video of this talk is now available on Parley's.

Earlier today, I presented my JavaOne session on The Heads and Tails of Project Coin (slides). The talk included some retrospectives from developing the Coin features which I hope to write up in more detail in the near future.

Turning toward the future, the talk also spent a little time discussing possible language changes coming in JDK 8. First, planning for JDK 8 is on-going and the feature list is subject to change; the JEP process will be used to help define the roadmap going forward. With those caveats, small language changes we're considering proposing for JDK 8 include:

  • Refinements to JDK 7 Coin features
    • try-with-resources on an effective final variable
    • removing restrictions on usage of diamond
    • @SafeVarargs on private methods
  • Collection literals(?)
  • Repeating Annotations(?)
  • Method and constructor parameter names at runtime(?)

Personally, I would welcome programming with collection literals. Repeating annotations and the ability to retrieve the names of method/constructors at runtime are both long-standing requests from our colleagues in EE.

However, with the broad scope of language and platform changes coming into JDK 8 courtesy Lambda and Jigsaw, all these smaller language changes have to be made somewhat opportunistically. For that reason, for JDK 8 we are not planning on having another open call for proposals as was done for Project Coin in JDK 7.

Tuesday Aug 30, 2011

Coming soon: JavaOne 2011

While enjoying some post-JDK 7 GA rest and relaxation, a hotel I stayed at offered this different image of JavaOne, one cup at a time:

JavaOne coffee maker

In the meantime, the usual JavaOne 2011 conference is fast approaching!

JavaOne 2011 Flair

My talk on The Heads and Tails Project Coin is just over a month away on Tuesday, October 4. Later that day, I'll be available for questions at the Meet the Java Language Team bof. If you already have a question you want answered about Project Coin at or before JavaOne, please leave it as a comment on this blog.

For more on Project Coin, based in part on his "coinificaiton work, Stuart will be giving a talk on Using New Java SE 7 Language Features in Real Code.

See you in San Francisco.

Thursday Aug 18, 2011

JDK 7: Small Library Treats

With JDK 7 out the door, many writeups of the release have naturally focused on its larger features like Project Coin, NIO.2, the fork/join framework, and invokedynamic. However, there are a number of small but useful library conveniences in JDK 7 that shouldn't be overlooked. Library changes I think are handy include:

  • To allow more informative assertion errors to be constructed, AssertionError now includes a constructor taking a string message and a Throwable cause, which is one of the four conventional constructors for exception types.

  • The methods which convert strings to numeric values differed in whether or not a leading plus, "+", was regarded as valid input. Float, Double, and BigDecimal accepted a leading plus while Byte, Short, Integer, Long, and BigInteger did not. As of JDK 7, all those types consistently accept a leading plus in their parseFoo, valueOf, and decode methods.

  • To help write more efficient comparators, Boolean, Byte, Character, Short, Integer, and Long each have a two-argument static compare method that performs the desired comparison operation without boxing overhead.

  • This six checked exception types that can be thrown by core reflection now have a common supertype, ReflectiveOperationException. This additional type complements the improved exception handling available with multi-catch and more precise re-throw from Project Coin.

  • The java.util.Objects class contains a number of small, but commonly used methods, many of them for coping with null inputs. For example, Objects contains a two-argument static equals method which does the right thing on null inputs. I've replaced a half-dozen copies of that method's logic in the JDK; I'm sure many more instances can be removed in other code bases as JDK 7 is adopted.

  • Part of NIO.2, I expect over time the utility methods in java.nio.file.Files to copy, read, and write the contents of file will see heavy usage.

Tuesday Aug 16, 2011

A Pictorial View of a JSR Progressing through the JCP

While JSR 348 is working on making changes to the JCP process JSRs pass through, for those working on or following JSRs understanding the state transitions of the current process, JCP 2.7, is helpful. As shown below, after an approval ballot to initiate the JSR, the expert group convenes and produces a series of draft specifications, currently an early draft, followed by a public review draft, a proposed final draft, and the final specification. If needed, an expert group can actually produce multiple early drafts or proposed final drafts.

States in italics involve votes from the executive committee (EC). Given a successful vote, the JSR advances; otherwise, there can be a reconsideration ballot to address issues raised by the EC, after which a JSR can get back on track of close down.

As reported on this blog, JSR 334 duly went through all the mainline phases from initiation to completion (approval ballot, early draft review, public review, proposed final draft, final approval ballot, final release).

Not shown is the separate, and simpler, set of state transitions for maintenance reviews, as done for JSR 269, Pluggable Annotation Processing API, this spring.

Monday Jul 25, 2011

OSCON: JDK 7 in a Nutshell

Update: The slides.

If all goes according to plan, at 10 am PST on Monday, July 25 I'll be giving a keynote talk about JDK 7 in a Nutshell at OSCON Java in Portland and the talk is slated to be streamed live. After the keynote, I'll post the slides.

Monday Jul 18, 2011

Project Coin: JSR 334 Finale!

Slightly more than eight months after its JSR review ballot was first filed, JSR 334 has just successfully passed its final approval ballot. Along with the other portions of the Java SE 7 umbrella JSR, the language changes done under JSR 334 are now officially part of the Java SE platform, the first Java programming language changes since JDK 5 shipped way back in 2004.

Thanks go to the members of the JSR 334 expert group for their service, to the langtools team at Sun and Oracle for their integral participation in Project Coin and JSR 334, and to the interesting proposals and thoughtful comments on the coin-dev alias.

I'm happy with how the suite of six features turned out and I'm especially pleased with the degree of IDE support available even before JDK 7 has officially shipped.

I'm looking forward to Java programmers being able to use the new language features and to the additional changes that may come with "coin, the flip side" in JDK 8.

Thursday Jul 07, 2011

Project Coin at the Java 7 Launch

Update: Video now available from the Project Coin link on this page.

Somewhat before the scheduled GA at the end of the month, today at Oracle headquarters and elsewhere we celebrated the launch of JDK 7. The webcasts of my half-hour breakout session on Project Coin and three other technical breakouts will be available for replay later. In the meantime, I've posted the slides.

One comment I made during the session made an impression on twitter: after a glitch going back from the NetBeans demo to PowerPoint slides I noted "its always impressive how computers know when you are running a demo." This chronic technological reaction to demos may even last longer than Moore's law!

Tuesday Jul 05, 2011

Project Coin: JSR 334 reaches Final Approval Ballot

With the proposed final draft available, JSR 334 has progressed to the next stage: final approval ballot. The members of the executive committee have two weeks to evaluate the specification, testing status, and reference implementation before rendering their votes. Assuming a positive vote, the mainline of JSR 334 will then be complete!

Tuesday Jun 28, 2011

See you at OSCON!

In just under a month, I'll be speaking at the OSCON Java conference about various OpenJDK and JDK 7 matters:

More detailed talks on those topics include Stuart's session on Coin in Action: Using New Java SE 7 Language Features in Real Code and Dalibor's OpenJDK – When And How To Contribute To The Java SE Reference Implementation.

See you in Portland!

OSCON 2011

Friday Jun 24, 2011

Project Coin: JSR 334 has a Proposed Final Draft

Reaching nearly the last phase of the JCP process, JSR 334 now has a proposed final draft. There have been only a few refinements to the specification since public review:

  • Incorporated language changes into JLS proper.

  • Forbid combining diamond and explicit type arguments to a generic constructor.

  • Removed unusual protocol around Throwable.addSuppressed(null) and added a new constructor to Throwable to allow suppression to be disabled. Added disclaimers that OutOfMemoryError, NullPointerException, and ArithmeticException objects created by the JVM may have suppression disabled.

  • Added thread safely requirements to Throwable.addSuppressed and Throwable.getSuppressed.

Next up is the final approval ballot; almost there!

Tuesday May 24, 2011

Project Coin: Documenation at Rampdown

As a follow-up to the Project Coin documentation posted for the JDK 7 developer preview and with work on JDK 7 officially ramping down, I've posted documentation on the semantics of the Project Coin features as implemented in JDK 7 b143 at:

If you have comments or questions about a feature, after reviewing the relevant discussion sections, feedback can be sent to the coin-dev mailing list.

Friday May 06, 2011

Project Coin: Diamond and Generic Constructors

To address an issue in the specification, the JSR 334 expert group has decided to ban the combination of diamond together with explicit constructor type arguments. For background, a constructor can have two sets of type arguments. In a parameterized class, constructors can have type arguments corresponding to the class's type parameters. This is the common case and the type arguments appear to the right of the class name and "new" as in "new ArrayList<String>()". In addition, if a constructor declares its very own type parameters (which can be done whether or not the enclosing class is parameterized), then those type arguments appear between the "new" token and the class name as in "new <Integer> ConstructorWithTypeParameter(Integer.valueOf(42))".

As with generic methods, the type arguments of generic constructors are usually inferred and not explicitly passed. However, generic constructors are much less common than generic methods.

After the specification change, using diamond to infer the class type parameters but explicitly passing the constructor type parameters is forbidden. However, the other three combinations of explicitly passing type arguments versus inferring them are supported, as shown in the table below.

class Foo<T extends Number> {
      <S extends T> Foo(S s) {super();}
Class Constructor Supported Example
Explicit Explicit Yes new <Integer> Foo<Number>(null);
Explicit Inferred Yes new Foo<Integer>(null);
Inferred Explicit No new <Integer> Foo<>(null); // compile error
Inferred Inferred Yes new Foo<>(null);

The substitution that was used to formally describe the semantics of diamond did not fully propagate constraints if there was a typing relationship between the type parameters of the constructor and the type parameters of the class. Lifting the imposed restriction on the banned combination of explicit and inferred type arguments can be revisited in future work in the context of broader type inference getting added to the Java language.

Since generic constructors are so uncommon, adding this restriction about combining them with diamond should have little effect to most programs. For example, none of the uses of diamond in the JDK had to be updated as a result of this change. A changeset implementing this specification change has been pushed and will appear in subsequent promoted builds of JDK 7.

Monday Apr 25, 2011

Project Coin: JSR 334 Public Review Approved

After due consideration by the JCP SE/EE Executive Committee, the public review of JSR 334 has been approved.

Onward to the proposed final draft!

Thursday Apr 21, 2011

Project Coin: IDE support

All three of the NetBeans, IntelliJ, and Eclipse IDEs have some level of support in progress for Project Coin's language features.

The recently released NetBeans 7.0 has support for all the Coin features. As explained in its release notes, beyond just recognizing the features in the editor NetBeans 7.0 provides auto-completion to diamond and gives hints to apply the new features to existing code.

As previously announced for IntelliJ IDEA, the builds of IDEA 10.5 EAP (early access program) provide similar quickfix support.

Finally, an Eclipse branch is hosting their efforts to support Project Coin.

As JSR 334 is not quite done yet, I'd expect the IDEs to be updated after JSR 334 is completed to account for any specification changes made in the interim.

Friday Apr 01, 2011

Project Coin: Disabling exception suppression

As part of the library support for the try-with-resources statement, several API changes were made to Throwable including an addSuppressed method to allow suppressed exceptions to be recorded. As discussed on coin-dev, to support VM needs for reusable exception objects, a protocol was devised to disable the suppression mechanism so that a zero-length array would be returned from getSuppressed even if addSuppressed was called with a valid argument. The mechanism was a bit of a kludge, relying on an initial call to addSuppressed with a null argument, and the design was called out as such. I'm happy to report the JSR 334 expert group has devised a more elegant protocol to disable exception suppression: a new constructor is added to Throwable which supports disabling suppression. The existing constructors of Throwable always enable suppression and addSuppressed(null) now always throws a NullPointerException. A few exception and error types in the platform are allowed by behave as if their objects were created with suppression disabled. The fix was recently pushed and will appear in a future JDK 7 build.

Thursday Mar 24, 2011

Project Coin: JSR 334 in Public Review

After successfully going through early draft review, JSR 334 has now entered another phase: public review. Compared to the earlier draft review specification (v0.75), the main changes in the public draft review specification (v0.875) are:

  • The specification for diamond was expanded and clarified. Using diamond on a non-generic class is explicitly forbidden.

  • The specification for multi-catch was expanded and made more precise.

  • Several changes related to the try-with-resources feature:

    • The try-with-resources statement has dropped support for a resource to be given as a general expression without an accompanying explicit variable declaration.

    • An optional trailing semicolon is allowed to terminate the sequence of resources in a resource specification rather than producing a syntax error.

    • The compiler-generated calls to the close method of a resource in a try-with-resources statement only occur if the resource is non-null.

    • Strong warnings were added to the javadoc of AutoCloseable about having the close method throw InterruptedException.

  • The @SafeVarargs annotation was applied to appropriate places in the platform libraries.

  • JLSv3 changes were provided for the simplified varargs method invocation feature.

The public review draft of JSR 334 is the last expected JCP milestone before proposed final draft, so get your comments about the public review in soon!




« June 2016

No bookmarks in folder