Keynote | To Java SE 8 and Beyond! | Simon Ritter
Upcoming SlideShare
Loading in...5
×

Like this? Share it with your network

Share

Keynote | To Java SE 8 and Beyond! | Simon Ritter

  • 10,313 views
Uploaded on

2011-11-02 | 01:30 PM-02:15 PM ...

2011-11-02 | 01:30 PM-02:15 PM
With the recent release of Java SE 7 the Java platform is back on the move, addressing the needs of developers as platforms and applications change. This session will briefly recap recent developments in Java SE 7 and the Java Community Process before moving onto the current ideas for features in Java SE 8. Discussions are underway within Oracle about the main themes for Java SE 9 and beyond. We'll conclude with an open discussion around what features the audience would like to see included in future releases of the Java platform. Key points from this will be passed back to Java SE product management in Oracle.

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
10,313
On Slideshare
6,588
From Embeds
3,725
Number of Embeds
12

Actions

Shares
Downloads
147
Comments
0
Likes
4

Embeds 3,725

http://blog.solidcraft.eu 2,429
http://touk.pl 724
http://www.mybestcv.co.il 358
http://lanyrd.com 120
http://www.openfolks.com 38
http://openfolks.com 26
http://openfolks.org 10
http://8795604888160975763_36ef0acd43c3d8bb953c2e08926d1b29720e8231.blogspot.com 10
http://www.openfolks.org 5
http://mybestcv.co.il 2
http://newsblur.com 2
http://webcache.googleusercontent.com 1

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide
  • Since acquiring Sun Micrososystems, Oracle have determined a set of priorities for Java. Java is the most populsar programming language in the workd today (based on reports from people like IDC as well as more anecdotal evidence like the TIOBE programming community index – Java is still number one as of June 2011). The goal is to continue to increase the number of developers who’s primary development language is Java. Having more developers should hopefully lead to greater adoption of Java for applications. Just as important are the competitiveness of Java in terms of performance and ROI compared to other languages. For these top three things to happen Java cannot stay static and so it is important that Java adapts to changes in both the types of applications being developed as well as how they are deployed (the fork-join framework is a good example of how Java is adapting to the greater prevalence of multi-core and multi-CPU machines). 6/27/11
  • 6/27/11 What is really important to note here is that we are using a slide from JavaOne 2005, this means that from the beginning we have been following the same principles and we are committed to continue to follow these principles as we evolve the language. - We want the code to be easy to read. - The language won't hide anything, and it should do what it seems to do - Even if there are great ideas and features, we are very careful deciding if that feature should be included in the language, some good features add so much weight, it's actually better to leave it out of the language. Again, we are committed to evolved the language, but very cautiously, we want java to be around for very long time.
  • Oracle is commited to the JCP and has successfully made changes that have now alllowed new JSRs to be filed and to start moving forward in a timely manner. The idea of the JCP is to involve companies and individuals who have investment in Java technology in how the platform evolves. 6/27/11
  • To reform the JCP a number of changes have started taking place. Firstly new members have been elected to the Executive committee SouJava, the largest Java User Group in Brazil, Goldman Sachs to help represent the financial community who are very large users of Java, The London Java Community and Alex Terrazas who is filling the empty space on the Java ME executive committee JSR348 will define how the JCP will make improvements in areas of transparency (all discussions through publically accessible mailing lists), participation, agility and governance. 6/27/11
  • This slide show the contents for Java SE 7, and we will go through each of this topics on a separate section, so here is just the list. JSR-336 is called an umbrella JSR and provides the complete set of features that are included in Java SE 7, even though several components have their own JSR 6/27/11
  • Now lets say we want to know the highest scoring student for the 2010 graduation year. Easy just write a for...loop But this only allows the JVM to use only one thread. Only one core gets used in the underlying system and all the other lanes are useless. So a better way to do this is to use a parallel collection that can break down these process into multiple threads. And so we get something like this where, map, filter max are methods on the collection. That is parallelized. And we can use inner classes to expose the functions. filter, map (getting the score), and obtaining the maxmimum. Great, especially if there are hundreds of millions of students - like all the students in a country. But this is kinda ugly. So wouldn ’ t it be nice if we could just extract those functions - into blocks of code that can easiy be reused,and say exactly what they do. These are lambda expressions, and are scheduled for Java SE 8. But you may be wondering how we can add methods to collections
  • Now lets say we want to know the highest scoring student for the 2010 graduation year. Easy just write a for...loop But this only allows the JVM to use only one thread. Only one core gets used in the underlying system and all the other lanes are useless. So a better way to do this is to use a parallel collection that can break down these process into multiple threads. And so we get something like this where, map, filter max are methods on the collection. That is parallelized. And we can use inner classes to expose the functions. filter, map (getting the score), and obtaining the maxmimum. Great, especially if there are hundreds of millions of students - like all the students in a country. But this is kinda ugly. So wouldn ’ t it be nice if we could just extract those functions - into blocks of code that can easiy be reused,and say exactly what they do. These are lambda expressions, and are scheduled for Java SE 8. But you may be wondering how we can add methods to collections
  • Informally, a lambda expression e is convertible-to a SAM type S if an anonymous inner class that is a subtype of S and that declares a method with the same name as S's abstract method and a signature and return type corresponding to the lambda expressions signature and return type would be considered assignment-compatible with S. The return type and exception types of a lambda expression are inferred by the compiler; the parameter types may be explicitly specified or they may be inferred from the assignment context (see Target Typing , below.) When a lambda expression is converted to a SAM type, invoking the single abstract method of the SAM instance causes the body of the lambda expression to be invoked. For example, SAM conversion will happen in the context of assignment: CallbackHandler cb = #{ Context c -> System.out.println("pippo") }; In this case, the lambda expression has a single Context parameter, has void return type, and throws no checked exceptions, and is therefore compatible with the SAM type CallbackHandler.
  • Lambda expressions can only appear in context where it will be converted to a variable of SAM type. These include assignment context, cast target context, and method invocation context.
  • The addition of closures to the Java language in JDK 8 place additional stress on the aging Collection interfaces; one of the most significant benefits of closures is that it enables the development of more powerful libraries. It would be disappointing to add a language feature that enables better libraries while at the same time not extending the core libraries to take advantage of that feature 1 . Runtime dispatch of extension methods is slightly different from that of ordinary interface method invocation. With an ordinary interface method invocation on a receiver of type D, first D is searched for a method implementation, then its superclass, and so on until we reach Object, and if an implementation is not found, a linkage exception is thrown. For an extension method, the search path is more complicated; first we search for actual implementations in D and its superclasses just as before, and if we do not find an implementation of the method in the implementation hierarchy, then we must search for the most specific default implementation among D ’ s interfaces (which is not a linear search), failing if we cannot find a unique most specific default. Method resolution for extension methods is as follows: 1. First perform the standard search, from receiver class proceeding upward through superclasses to Object. If an implementation is found, the search is resolved successfully. 2. Construct the list of interfaces implemented by D, directly or indirectly, which provide a default for the method in question. 3. Remove all interfaces from this list which is a superinterface of any other interface on the list (e.g., if D implements both Set and Collection, and both provide a default for this method, remove Collection from the list.) 4. Construct the set of distinct default methods corresponding to the list of interfaces arrived at in step (2). If the result has a single item (either because there was only one default or multiple interfaces provided the same default), the search is resolved successfully. If the resulting set has multiple items, then throw a linkage exception indicating conflicting extension methods. Resolution need be performed only once per extension method per implementing class. (This makes it an ideal candidate for dynamic linkage with invokedynamic.)
  • This is a picture of this module and its dependencies.
  • Rules for creating Profiles of the Java SE Platform, which may contain subsets of Java SE, additional JCP technologies not part of the Java SE Platform, or both; A Java SE Base Profile, which contains the foundational APIs upon which the rest of the platform and applications depend; A Java SE Base Module, which implements the Base Profile; and A set of component modules for separable technologies such as the AWT and Swing GUI APIs, CORBA, naming, monitoring and management APIs, web services, and the various XML technologi
  • Key points: Expanded Jigsaw and Lambda Oracle JVM convergence, bringing Flight Recorder to more users JavaFX 3.0 included, more on this later Javascript on JVM Support for modern devices such as Multi-Touch and Location Much more
  • Bring up on stage two customers to tell the audience about their experiences. Manpower Associates is a $14.9B global company with 27,000 employees in the temporary staffing business. Manpower runs a combined PeopleSoft Enterprise and JD Edwards EnterpriseOne shop. These experts in human resources use Enterprise HCM for their own staffing and EnterpriseOne Payroll and Service Billing for handling the large volumes of US-based temporary staff. Manpower is very happy with Oracle ’ s support since purchasing PeopleSoft and is looking forward to a long relationship with Oracle. Spokesperson will be Jay Schaudies, Vice President, Global eCommerce. Welch Foods is the food processing and marketing arm of National Grape Cooperative Association. Organized in 1945, National Grape is a grower-owned agricultural cooperative with 1,461 members. The company, headquartered in Concord, Massachusetts, operates six plants located in Michigan, New York, Pennsylvania and Washington. The company was running a mix of legacy, home grown, and manual systems that failed to provide senior management with accurate and timely cost and production information. Welch ’ s required a centralized manufacturing and financial information system to improve management decision making. The solution had to be hot-pluggable with existing technologies, for example, Welch ’ s Plumtree portal. Welch Foods chose Oracle over SAP for this business-critical application. The key to the customer ’ s business problem was their ability to manage costs. The company ’ s costs are driven by fruit solid content in each of their products, and they use a specialized technique called BRIX for measuring and calculating the cost of materials. Welch ’ s compared SAP and Oracle SAP ’ s software was too rigid and, therefore, unable to include the BRIX calculation in their manufacturing solution. Only Oracle ’ s OPM could bind this custom cost method into the Quality Management Process. Technology customer yet to be determined. Current possibilities include eBay and FTD Florists.

Transcript

  • 1.  
  • 2. To Java SE 8, and Beyond! Simon Ritter Technology Evangelist
  • 3. 8 9 2020? 2012
  • 4. Priorities for the Java Platforms Grow Developer Base Grow Adoption Increase Competitiveness Adapt to change
  • 5. Evolving the Language From “ Evolving the Java Language ” - JavaOne 2005
    • Java language principles
      • Reading is more important than writing
      • Code should be a joy to read
      • The language should not hide what is happening
      • Code should do what it seems to do
      • Simplicity matters
      • Every “ good ” feature adds more “ bad ” weight
      • Sometimes it is best to leave things out
    • One language: with the same meaning everywhere
      • No dialects
    • We will evolve the Java language
      • But cautiously, with a long term view
      • “ first do no harm ”
    also “Growing a Language” - Guy Steele 1999 “The Feel of Java” - James Gosling 1997
  • 6. How Java Evolves and Adapts Of the community, by the community, for the community JSR-348: JCP.next
  • 7. JCP Reforms
    • Developers ’ voice in the Executive Committee
      • SOUJava
      • Goldman Sachs
      • London JavaCommunity
      • Alex Terrazas
    • JCP starting a program of reform
      • JSR 348: Towards a new version of the JCP
  • 8. Java SE 7 Release Contents
    • Java Language
      • Project Coin (JSR-334)
    • Class Libraries
      • NIO2 (JSR-203)
      • Fork-Join framework, ParallelArray (JSR-166y)
    • Java Virtual Machine
      • The DaVinci Machine project (JSR-292)
      • InvokeDynamic bytecode
    • Miscellaneous things
    • JSR-336: Java SE 7 Release Contents
  • 9. JVM Convergence
  • 10. The (Performance) Free Lunch Is Over Image courtesy of Herb Sutter
  • 11. SPARC T1 (2005) 8 x 4 = 32 SPARC T2 (2007) 8 x 8 = 64 SPARC T3 (2011) 16 x 8 = 128
  • 12. Multi-core Clients 2002 2004 2006 2008 2010 2 ... 4 ..... 8 ..... Phone ... Tablet ... Desktop 2012
  • 13. Big Disclaimer The syntax used in the following slides may change Caveat emptor
  • 14. class Student { String name; int gradYear; double score; } Collection<Student> students = ...;
  • 15. Collection<Student> students = ...; double max = Double.MIN_VALUE; for (Student s : students) { if (s.gradYear == 2011) max = Math.max(max, s.score); }
  • 16. Collection<Student> students = ...; double max = Double.MIN_VALUE; for (Student s : students ) { if ( s.gradYear == 2011 ) max = Math.max (max, s.score ); }
  • 17. Collection<Student> students = ...; max = students. filter (new Predicate<Student>() { public boolean op(Student s) { return s.gradYear == 2010 ; } }). map (new Extractor<Student, Double>() { public Double extract(Student s) { return s.score ; } }). reduce (0.0, new Reducer<Double, Double>() { public Double reduce(Double max, Double score) { return Math.max (max, score ); } });
  • 18. Inner Classes Are Imperfect Closures
    • Bulky syntax
    • Unable to capture non-final local variables
    • Transparency issues
      • Meaning of return, break, continue, this
    • No non-local control flow operators
  • 19. Single Abstract Method (SAM) Types
    • Lots of examples in the Java APIs
      • Runnable, Callable, EventHandler, Comparator
    • Noise:Work ratio is 5:1
    • Lambda expressions grow out of the idea of making callback objects easier
    foo.doSomething(new CallbackHandler() { public void callback(Context c) { System.out.println(c.v()); } } );
  • 20. Collection<Student> students = ...; max = students. filter ((Student s) -> s.gradYear == 2011 ) . map ((Student s) -> s.score ) . reduce (0.0, (Double max, Double score) -> Math.max (max, score)); max = students. filter (s -> s.gradYear == 2011 ) . map (s -> s.score ) . reduce (0.0, Math # max ); max = students. parallel () . filter (s -> s.gradYear == 2011 ) . map (s -> s.score ) . reduce (0.0, Math # max );
  • 21. Lambda Expression Examples (Context c) -> System.out.println(c.v()); c -> System.out.println(c.v()); // Inferred int x -> x + 1
  • 22. Target Types
    • Rule #1: Only in a context where it can be converted to a SAM type
    CallBackHandler cb = (Context c) -> System.out.println(c.v()); x -> x + 1; Runnable r = () -> System.out.println(&quot;Running”); executor.submit(() -> System.out.println(&quot;Running”)); Object o = () -> 42; // Illegal, not a SAM type
  • 23. Lambda Bodies
    • Rule #2: A list of statements just like in a method body, except no break or continue at the top level. The return type is inferred from the unification of the returns from the set of return statements
    • Rule #3: ‘this’ has the same value as ‘this’ immediately outside the Lambda expression
    • Rule #4: Lambdas can use ‘effectively final’ variables as well as final variables (compiler inferred)
  • 24. Collection<Student> students = ...; double max = // Lambda expressions students .filter (Students s -> s.gradYear == 2010 }) .map (Students s -> s.score }) .reduce (0.0, Math # max ); interface Collection<T> { int add(T t); int size(); void clear(); ... }
  • 25. How to extend an interface in Java SE 8 public interface Set<T> extends Collection<T> { public int size(); ... // The rest of the existing Set methods public extension T reduce(Reducer<T> r) default Collections.<T>setReducer; } tells us this method extends the interface Implementation to use if none exists for the implementing class
  • 26. Collection<Student> students = ...; double max = // Lambda expressions students .filter (Students s -> s.gradYear == 2010 ) .map (Students s -> s.score ) . reduce (0.0, Math # max ); interface Collection<T> { // Default methods extension Collection<E> filter (Predicate<T> p) default Collections.<T> filter ; extension <V> Collection<V> map (Extractor<T,V> e) default Collections.<T> map ; extension <V> V reduce () default Collections.<V> reduce ; }
  • 27. $ java org.planetjdk.aggregator.Main
  • 28. $ java -cp $APPHOME/lib/ jdom-1.0.jar: $APPHOME/lib/jaxen-1.0.jar: $APPHOME/lib/saxpath-1.0.jar: $APPHOME/lib/rome.jar-1.0.jar: $APPHOME/lib/rome-fetcher-1.0.jar: $APPHOME/lib/joda-time-1.6.jar: $APPHOME/lib/tagsoup-1.2.jar: org.planetjdk.aggregator.Main
  • 29. $ java -cp $APPHOME/lib/ jdom-1.0.jar : $APPHOME/lib/ jaxen-1.0.jar : $APPHOME/lib/ saxpath-1.0.jar : $APPHOME/lib/ rome.jar-1.0.jar : $APPHOME/lib/ rome-fetcher-1.0.jar : $APPHOME/lib/ joda-time-1.6.jar : $APPHOME/lib/ tagsoup-1.2.jar : org.planetjdk.aggregator.Main
  • 30. module-info.java module org.planetjdk.aggregator @ 1.0 { requires jdom @ 1.0; requires tagsoup @ 1.2; requires rome @ 1.0; requires rome-fetcher @ 1.0; requires joda-time @ 1.6; requires jaxp @ 1.4.4; class org.openjdk.aggregator.Main; }
  • 31. jdom-1.0 jaxen-1.0 saxpath-1.0 rome-1.0 joda-time-1.6 tagsoup-1.2 jaxp-1.4.4 org.planetjdk.aggregator rome-fetcher-1.0
  • 32. classpath
  • 33. deb rpm jar jmod mvn // module-info.java module org.planetjdk.aggregator @ 1.0 { requires jdom @ 1.0; requires tagsoup @ 1.2; requires rome @ 1.0; requires rome-fetcher @ 1.0; requires joda-time @ 1.6; requires jaxp @ 1.4.4; class org.openjdk.aggregator.Main; }
  • 34. classpath http://www.flickr.com/photos/thatguyfromcchs08/2300190277 h ttp://www.flickr.com/photos/viagallery/2290654438
  • 35. Java SE Profiles and Modules
    • Rules for creating modules of the Java SE platform
      • Java SE base profile
      • Java SE base module
      • Component modules for separable technologies
  • 36. JDK 8 – Proposed Content
  • 37. Additional Disclaimers
    • Some ideas for the Java Platform are shown on the following slides
    • Large R&D effort required
    • Content and timing highly speculative
    • Some things will turn out to be bad ideas
    • New ideas will be added
    • Still, Java’s future is bright (in our humble opinion)!
  • 38. Java SE 9 (and beyond…)
  • 39. Vision: Interoperability
    • Improved support for non-Java languages
      • Invokedynamic (done)
      • Java/JavaScript interop (in progress – JDK 8)
      • Meta-object protocol (JDK 9)
      • Long list of JVM optimizations (JDK 9+)
    • Java/Native
      • Calls between Java and Native without JNI boilerplate (JDK 9)
  • 40. Vision: Cloud
    • Multi-tenancy (JDK 8+)
      • Improved sharing between JVMs in same OS
      • Per-thread/threadgroup resource tracking/management
    • Hypervisor aware JVM (JDK 9+)
      • Co-operative memory page sharing
      • Co-operative lifecycle, migration
  • 41. Vision: Language Features
    • Large data support (JDK 9)
      • Large arrays (64 bit support)
    • Unified type system (JDK 10+)
      • No more primitives, make everything objects
    • Other type reification (JDK 10+)
      • True generics
      • Function types
    • Data structure optimizations (JDK 10+)
      • Structs, multi-dimensional arrays, etc
      • Close last(?) performance gap to low-level languages
  • 42. Vision: Integration
    • Modern device support (JDK 8+)
      • Multitouch (JDK 8)
      • Location (JDK 8)
      • Sensors – compass, accelerometer, temperature, pressure, ... (JDK 8+)
    • Heterogenous compute models (JDK 9+)
      • Java language support for GPU, FPGA, offload engines, remote PL/SQL...
  • 43. The Path Forward
    • Open development
      • Prototyping and R&D in OpenJDK
      • Cooperate with partners, academia, greater community
    • Work on next JDK, future features in parallel
    • 2-year cycle for Java SE releases
  • 44. Java SE 2012 to Java 12 2011 2015 2019 2014 JDK 7 2013 2021 JDK 12 2017 JDK 8 JDK 9 JDK 10 JDK 11 2012 JVM convergence Mac OS X
  • 45. Conclusions
    • The Java platform will continue to evolve
    • Java SE 8 will add some nice, big features
    • Expect to see more in Java SE 9 and beyond
    • Java is not the new Cobol
  • 46. Further Information
    • Project Lambda
      • openjdk.java.net/projects/lambda
    • Project Jigsaw
      • openjdk.java.net/projects/jigsaw
  • 47. The preceding is intended to outline our general product direction. It is intended for information purposes only, and may not be incorporated into any contract. It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in making purchasing decisions. The development, release, and timing of any features or functionality described for Oracle ’s products remains at the sole discretion of Oracle.
  • 48.