You are viewing robilad

JavaOne 2013: OpenJDK Edition

« previous entry | next entry »
Sep. 2nd, 2013 | 05:13 pm

The JavaOne 2013 content catalog is now live. As in the previous years, I took the opportunity to look for the talks and BOFs with OpenJDK in their title, or abstract, and pull them together in a list:


  • OpenJDK and JCP: Success Through Contribution - Sunday, Sep 22, 4:45 PM - 5:45 PM
    In January 2013, JUGCologne adopted Contexts and Dependency Injection (CDI) 1.1 and JavaServer Faces (JSF) 2.2 and started working with the community on both JSRs. This session highlights the ups and downs of its decision, how people participated, how others reacted to it, and the results after eight months of participation. The presentation focuses on the Java Community Process (JCP) process and contributions from the community and includes a discussion of the OpenJDK community process.

  • Jump-starting Lambda Programming - Monday, Sep 23, 10:00 AM - 12:00 PM
    You’ve probably heard about the new lambda feature that’s going to be in Java 8. What might not be obvious is why lambda is important and how you can use it effectively. This tutorial begins by taking apart some familiar programming examples and putting them together in a new, idiomatic style, employing lambda expressions. The tutorial then introduces the new Stream library that is also being introduced in Java 8. This new library is entirely based on lambda. The tutorial describes various Stream operations that can be composed into a pipeline and provides working examples of pipelines using lambda that are concise and fluent and facilitate parallel computation.

  • It Takes a Community - Monday, Sep 23, 10:00 AM - 11:00 AM
    Creating the future of Java is a community effort. This session reviews the global participation in OpenJDK. Starting with OpenJDK bugathons and extending to AdoptJSR and AdoptOpenJDK efforts, it showcases the community of developers and projects that support and make up the larger OpenJDK ecosystem.

  • Meet the Oracle Java Client and JavaFX Teams - Monday, Sep 23, 4:30 PM - 5:15 PM
    This BOF is an excellent opportunity to meet development engineers from the Oracle JavaFX, AWT/Swing, Java 2D, and i18n teams. It’s expected to be a lively discussion about the development process, progress over the past year, and future plans for the Java UI. Likely topics include new JavaFX 8 features, Mac OS X support in AWT/Swing/Java 2D and JavaFX, and involvement in OpenJDK and OpenJFX projects.

  • HotSpot Internals: How to Explore and Debug the OpenJDK VM at the OS Level - Monday, Sep 23, 4:30 PM - 5:15 PM
    One of the little-known advantages of having a complete open source Java VM such as OpenJDK is that you can easily build a debug version of the VM. Such a debug VM offers a multitude of tracing, logging, introspection, and configuration possibilities that are not available in the normal product builds. This interactive session demonstrates how you can easily build a debug version of Oracle’s OpenJDK HotSpot VM and how it can be used to see, for example, which bytecode the VM is currently executing, which assembler code the JIT compiler is generating, and if your favorite optimization is really optimizing your code in the expected way.

  • Infrequently Asked OpenJDK Questions - Monday, Sep 23, 6:30 PM - 7:15 PM
    On the Web, just as in OpenJDK BOF sessions at JavaOne, some questions about OpenJDK such as “What is the difference between Oracle’s JDK and OpenJDK?” and “Why does OpenJDK use Mercurial rather then Git?” show up often enough that this session covers a little bit of everything somebody on the internet always wanted to know about OpenJDK and dared to ask.

  • Using Java to Build Java: Revealing the Power of Open Java Technologies - Monday, Sep 23, 8:30 PM - 9:15 PM
    Learn how modern Java-based technologies such as Jenkins, Maven, Play2, and Ant (not to mention JAX-RS, JAX-WS, and other Java EE and Java SE technologies) are being harnessed by the OpenJDK community to create an open build and test infrastructure that is being used to build the Java runtime itself. This session discusses the technical, business, and personal challenges involved in creating a new type of “social” Website where developers from all walks of life can work together on their common passion: helping keep Java great. Building and testing code is something all developers understand. The presentation uses that common understanding of the challenges involved to help demonstrate the design and implementation of a unique system built for Java by Java developers.

  • JDK 8 Compact Profiles for Embedded and Oracle ADF Mobile on iOS Devices - Tuesday, Sep 24, 11:30 AM - 12:30 PM
    JDK 8 has introduced a new Compact Profiles feature that allows for three JDK 8 spec–compliant subsets of Java SE 8 APIs. Compact Profiles will enable the creation of JDK 8 Java runtimes that will be able to support configurations that previously were possible only with the CDC version of J2ME based on the Java SE 1.4.2 language and APIs. This session describes the contents of Compact Profiles, how to build and use them, and the details of the Oracle-provided OpenJDK and binary implementations for Java Embedded and the Oracle ADF Mobile feature of Oracle Application Development Framework (Oracle ADF). It also discusses Compact Profile use cases such as Java Embedded, Oracle ADF Mobile for iOS, and Android platforms and application store packaging.

  • Implement a High-Level Parallel API in JDK - Tuesday, Sep 24, 1:00 PM - 2:00 PM
    This session discusses how to implement a high-level parallel API (such as parallel_for, parallel_while, or parallel_scan) and math calculation based on a thread pool and task in OpenJDK that aligns with the development of multicores and parallel computing. At present, programmers have to use a schedule strategy statically in code instead of choosing it dynamically based on the core number and load balance on the computer with the current Java concurrent package. In the design presented in the session, the function parallel_for(array, task) is a high-level API that can divide the task range dynamically, based on the condition of and load on different computers.

  • Wholly Graal: Accelerating GPU Offload for Java - Tuesday, Sep 24, 3:00 PM - 4:00 PM
    GPU offload is an essential technique for accelerating complex parallelizable programs, but unfortunately it has been slow to penetrate the Java space because production JVMs lack support for GPU code generation. This session discusses a joint effort of the Sumatra OpenJDK project and the Graal OpenJDK project to prototype this support on top of Oracle’s HotSpot VM. The presentation includes an overview of Graal and its status, discusses the technical approach of adding a new compiler back end for GPU architectures, and includes a demonstration of producing and running HSAIL code with Graal.

  • OpenJDK Porting Experiences: The Good, the Bad, and the Downright Ugly - Tuesday, Sep 24, 4:30 PM - 5:15 PM
    The work to port OpenJDK to Linux PowerPC and AIX PowerPC is coming to an end. It’s been an interesting road with many twists and turns, bumps and crashes—even the occasional straight run. The PPC/AIX porting project has been a trailblazer for future porting projects. This session discusses the technical aspects of porting OpenJDK to a new architecture as well as the community and process challenges that have been addressed in making the project a success. It covers the salient points of how to start an OpenJDK porting project, provides an overview of the design of Oracle’s HotSpot from a porting point of view, and explores the wider OpenJDK processes that need to be understood in a porting project.

  • Where Next with OpenJDK Community Build and Test? - Wednesday, Sep 25, 8:30 AM - 9:30 AM
    In this panel session, learn about the work done so far to provide an open, community-accessible build and test system for developers who want to contribute to OpenJDK. It’s a hard problem, but progress is being made. Come hear the participants from various organizations talk about what is happening and what else is needed. A lively debate with many opinions: guaranteed!

  • Lambda Programming Laboratory - Wednesday, Sep 25, 12:30 PM - 2:30 PM
    Interested in trying out the new lambda feature in Java 8? If so, this “higher-order lab” is for you. Participants will use a recent JDK 8 development build and a recent NetBeans build that support the lambda feature and will take part in exercises intended to teach them about the new lambda feature of the Java programming language and the new Streams Library API. The exercises start off very simply, so that beginners can learn the fundamentals. Additional exercises covering grouping and parallel reduction aim to challenge more-advanced participants. Participants need not have any prior knowledge of Java’s lambda feature, although having attended a prior JavaOne lambda session or tutorial will be helpful.

  • Retro Gaming with Lambdas - Wednesday, Sep 25, 4:30 PM - 5:30 PM
    Lambda expressions, coming in Java 8, will dramatically change the programming model. They enable new functional programming patterns that were not possible before, increasing the expressiveness and power of the Java language. In this presentation, you will learn how to take advantage of the new lambda-enabled Java 8 APIs by building out a retro video game in JavaFX. Among the Java 8 features you will learn about are enhanced collections, functional interfaces, simplified event handlers, and the new stream API. Start using these in your application today, leveraging the latest OpenJDK builds so you can prepare for the future Java 8 release.



That's a total of 14 sessions this year. With sessions presented by speakers from AMD, IBM, JClarity, Oracle, SAP and other organizations JavaOne remains the best place this year to learn about the progress made in the OpenJDK community.

Link | Add to Memories | Share