JavaOne 2017 Day 1 Keynote: notes and thoughts

Unfortunately I wasn’t lucky enough to attend JavaOne 2017 this year, so I’m catching up this evening and watching the recording of the Day 1 Keynote here.

A few notes, key quotes and thoughts (screenshots taken from the video):

Mark Cavage, Vice President of software development, Oracle:

  • The next decade: Java first, open, evolving, nimble, scalable
  • Java EE 8. “Is it nimble? Well no, EE7 shipped 4 years ago”
  • Java EE moving to the Eclipse Foundation. What does this mean? It means everything is moving to the Eclipse Foundation
  • David Blevins (Tomitribe), Ian Robinson (IBM) and Mark Little (Red Hat) take the stage to talk about moving EE to the Eclipse Foundation:

  • David Blevins: “EE4J is EE for the next generation”, easy access to the TCKs allows developers to go straight to the tests if you have a problem, “we can all go faster in the end”
  • Ian Robinson: “Eclipse Foundation makes sense, it’s the one we (IBM) picked when we open sourced J9” (IBM’s JVM). “Having the low level JVM (J9) and Enterprise platform with the Eclipse Foundation is a really strong endorsement for Java development top to bottom at Eclipse”, “… the future of Java is strong”
  • Mark Little: “moving EE4J to Eclipse allows these two big communities (microprofile is now also with Eclipse Foundation) to come together and help to drive Enterprise Java into next decade”

Java 9:

  • From this point onwards, all features in Oracle JDK and OpenJDK will be the same, zero difference between them
  • Releases of Java will now be every 6 months.

James Governor, RedMonk:

  • “things have changed more in the Java ecosystem in the last 3 weeks than they have in the previous 13 years”
  • observations about adoption of Java by web companies, most of which rejected Java initially in favor of Ruby and other cooler technologies, only to adopt Java later as they struggled to adapt and scale

Cloud, Niklas Gustavsson, Spotify:

  • 140 million active users, more than 3 billion streams a day, 4 million requests a second
  • Started out as a Python backend
  • “When startups growup they turn into Java shops” : James Governor
  • Spotify: 1200 Java based microservices in production:

    Java and Kubernetes Craig McLuckie, Heptio:

  • “Kubernetes over the last three and a half years has emerged as pretty close to the standard” for container orchestration
  • containers simplify the operations process
  • predictable deployment and portability across environments
  • For the Java community this is significant – “we’re starting to see middleware being teased apart”  – seeing emergence of systems like Kubernetes as a standard way to operate systems, while a lot of other functionality being pushed up into application libraries
  • Your Java apps are now open to a polyglot world, they can co-exist with other systems in other languages
  • Decouples you from your cloud provider and how you want to run your applications
  • Kubernetes – a natural way to run Java applications

Wercker, Java and Kubernetes:

  • build, deploy and operations support for Container based apps
  • wercker.com

Observability and Operations:

  • Java Flight Recorder: now open sourced
  • Container Native development, simpler
  • With microservices, you need to know not just when an issue occurred, but where? (which service, and where is it running)
  • Container Diagnostics Service: runs in production, low overhead

Serverless: The Fn Project

  • Functions as a service
  • Fn server / FDK (Function Development Kit) / Fn Flow
  • Fn Flow – allows you to compose apps from your functions
  • fnproject.io – now open sourced and on github

Java 9 – Mark Reinhold

  • Jigsaw now adds modules to the platform
  • Use Java 9 modules to build smaller Docker images, including just the modules your app needs and no more (demo shows Alpine Linux Docker image with Java and app as 266MB, but building the app with only the required modules the image size is down to 39MB
  • rt.jar no longer exists in Java 9, but you can use the nio virtual filesystem jrt:/ namespace to browse available classes if needed (useful for tools developers?)
  • source that uses JDK internal classes will no longer compile on Java 9, but, strong enforcement of internal use only apis is relaxed ‘for now’ to ease transition
  • Java 9 is: open, evolving, nimble, scalable
  • jshell – repl for Java: tab completion shows you available methods, retains history

Eugene Petrenko, Jetbrains

  • demo early access build working with Java 9 modules
  • creating module-info.java using code complete in IntelliJ to help you create your module dependencies

(As a sidenote, is the first JavaOne keynote where the new tech demo was done with an IDE other than Netbeans? Unless I missed it, there was no mention of Netbeans in the keynote this year)

Mark Reinhold

  • new feature releases every 6 months
  • new features will be included only when they are ready (if they don’t make the next 6 month release then they’ll get moved to the next)
  • the next release is only 5 months away!

Brian Goetz: Project Amber: Right-sizing Language Ceremony

  • streamlining the development process, reducing bolierplate
  • local variable type inference: full static typing, but removing the need to declare the type for a local variable because the type can be inferred when you assign it a value, e.g. var url = new URL(“http://www.example.com”);
  • coming in 18.3
  • switch statement to support switching on a type, as alternative for repetitive if statements with instanceof’s

That’s a lot of changes and content, time to go check out those new features!

JavaOne 2016: Oracle’s ‘refocusing’ of the EE8 proposal

Oracle’s planned Java EE ‘announcement‘ at JavaOne 2016 turned out to be (based on the announcement from the Sunday keynote and the Java EE 8 roadmap session by Linda Demichiel, EE spec lead for EE JSRs) a ‘refocusing’, a realignment to bring Java EE more in line with current trends, particularly to support deploying EE applications to the cloud and the development of microservices.

So what exactly is going to change? For the new EE8 spec proposal, with finalization now planned for 2017,  some previously proposed features for inclusion are now going to be dropped, namely:

  • MVC 1.0
  • JMS 2.1
  • EE Management apis 2.0

Given than MVC 1.0 was a new EE web framework as an alternative to JSF (not adding new technology but built on top of what we already have with a Reference Implementation already built out), this is perhaps the most surprising removal. Given the new focus of cloud and microservices however, this makes sense, as it doesn’t really add anything towards supporting the new goals.

Everything else in the original EE8 JSR 366 is going to remain in the new EE8 proposal.

New features to be added include a new feature for supporting Health Checks, and a new Configuration proposal to standardize external configuration of deployments – both of which will be useful to support deployments to the cloud.

Is this ‘refocusing’ enough? Is it going to be finalized soon enough? For an EE8 target of 2017, and EE9 of 2018, is it too little, too late?

Given that you can use current EE features today with frameworks like Spring Boot and Dropwizard to build and deploy microservices, is a standardized cloud/microservice focused EE platform still relevant?

Alternative runtimes like WildFly Swarm and IBM’s Liberty Profile are giving runtime flexibility and allow you to pick just the features your app needs at runtime (and are available today). Rather than an all-in-one EE runtime container, is a ‘pick n mix’ type approach more relevant to support the current popularity of microservices?

Notes from Raspberry Pi with Java 9 session – CON6210 – JavaOne 2016

A few interesting notes from the Java 9 Embedded on Raspberry Pi, session CON6210, presented by Stephen Chin.

Currently streaming live on YouTube: https://www.youtube.com/watch?v=v95y5CzvcZ4&feature=youtu.be

Full live stream schedule is here: https://community.oracle.com/docs/DOC-1005786

  • SE9 Embedded will be available in a ARM build for the Raspberry Pi
  • This ARM specific build will only be available for Pi 2 and 3 (not the original Pi 1 A/B and + models, as it’s been compiled for ARM Thumb-2 instructions, and these are only supported on Pi 2 ARM CPU and above
  • AWT, Swing and JavaFX will all be supported on SE9 Embedded on the Pi
  • Interesting side note about modular Jigsaw in SE9 – apparently the module file packaging and compression is moving away from zip based Jars, to another format that’s more efficient for class lookup/retrieval

Oracle have something to announce re. Java EE 8 at JavaOne this year?

Oracle have been quiet on the Java EE front since around November 2015 according to public minutes from recent JCP Executive Committee meetings,  which has led to the forming of the Java EE Guardians group forming to rally community awareness and promote the future of Java EE.

This story on The Register just popped up in my feed this evening, with an interesting quote from ‘Oracle spokesman’ Mike Moeller, stating:

“Oracle is committed to Java and has a very well defined proposal for the next version of the Java EE specification – Java EE 8 – that will support developers as they seek to build new applications that are designed using micro-services on large-scale distributed computing and container-based environments on the Cloud … Oracle is working closely with key partners in the Java community to finalize the proposal and will share the full details with the broader Java community at JavaOne in September.”

So there you go. Given that there is already an EE8 JSR in flight (JSR 366) encompassing many other JSRs that were planned to be included in EE8, this statement sounds suspiciously like Oracle has “something else” planned for EE8 that is not the EE8 JSR (“a very well defined proposal for the next version of the Java EE specification”).

In a thread on the Java EE Guardians Google Group, seems like no-one over there has any other insight into this news at this point.

Interestingly, microservices, large-scale distributed computing and containers… this is all very much on target for where EE needs to be heading.

If this is all Oracle is willing (or able) to share at this point, then it will definitely be interesting to hear what they have to share at this year’s JavaOne conference.