JavaOne Live Streaming Day 1

Enjoy JavaOne sessions from your desk as JavaOne attendees are living the content in San Francisco. We are streaming live from four rooms during the full week of JavaOne, September 19th to 22nd. All the sessions are streamed at San Francisco local time, which is Pacific Time (PST) in the U.S. Join the conversation on Twitter using #JavaOne and follow us @javaoneconf

At 8:30am PST tune to Ballroom 4 and watch first a tutorial about Java 8 Lambdas and Functional programming. The rest of day is about Java SE 9 sessions from 11:00am to 6:30pm. Those sessions will provide you with a good understanding of the new module system in Java 9. 

Don’t miss the Java EE 8 Update session at 2:30pm today. With the Java EE 8 focusing on the cloud, you might consider watching Enterprise Java for the Cloud session and the Java EE for the Cloud BOF. There are also lots more sessions about Java, cloud, methodology and more to consider watching. The streaming schedule and links are available here

Session Title Session Abstract 
Ballroom 4  
Learn Java 8: Lambdas and Functional Programming This tutorial walks through tons of examples. You will learn everything you need to know about lambdas and functional programming in Java 8. I'm the supplier. You’re the consumer (and you will get the joke after the session).
JDK 9 Language, Tooling, and Library Features Modularity support from Project Jigsaw is the largest change coming in Java SE 9, but many other improvements are coming to the Java programming language, related tooling, and libraries in JDK 9. On the language front, some polish is added to the Project Coin features and the number of uninformative warnings has been reduced. The javac tool can now accurately cross-compile to older platform versions and has improved attribution engineering to better support type inference. Javadoc is getting a search box, a new modernized doclet API, and HTML5 support. The libraries offer better process control, improved collections, and more-compact strings. Learn more in this session.
Prepare for JDK 9 The modularization of the Java SE Platform in JDK 9 will bring many benefits but also many changes. Existing code that uses only official Java SE Platform APIs and supported JDK-specific APIs should continue to work without change. Code that uses certain deprecated features or any JDK-internal APIs is likely to break, however. This session shows you how to prepare existing code for JDK 9 and takes a look at new features designed to help migration, such as JDK versioning, multirelease JARs, and enhanced deprecation.
Introduction to Modular Development This session provides a gentle introduction, with examples, to the Java Platform Module System in JDK 9. You will learn the basic concepts of the module system and be introduced to the modules that are built into the Java platform. You will also find out how to develop a module from scratch and how to compile, test, and run it.
Using Oracle Java Flight Recorder in an Autonomous Robotic Vehicle This session shows how the speaker used the Oracle Java Mission Control and Oracle Java Flight Recorder features of Oracle Java SE Advanced to record large quantities of data from the sensors in a little hobby project: a small autonomous robotic vehicle running Oracle Java SE Embedded. The session focuses on how to use Oracle Java Flight Recorder to great advantage where resources are scarce and where overhead can cause significant problems. It also discusses how to build custom integration for Oracle Java Flight Recorder, using APIs already available in Oracle’s HotSpot JDK, and how the speaker went about designing, 3-D-printing, and building the actual hardware and software.
Advanced Modular Development This session focuses on developing modules with the Java Platform Module System in JDK 9. Using well-known libraries as examples, you will learn how to develop libraries and applications as modules and will also find out how to migrate existing code to modules. Migration poses many challenges, and in addition to learning about “bottom-up” migration, you will learn about “top-down” migration, where libraries and applications are migrated to modules without waiting for libraries they depend on to migrate first.
Using Type Annotations to Improve Your Code Java 8 provides the ability to add annotations to all uses of types in a program. Type annotations can be used to improve code quality by adding fine-grained documentation and supporting pluggable type systems. This BOF brings together people and projects using type annotations to exchange experiences and brainstorm possible use cases and applications.
Ballroom 6  
Rapid Development Tools for Java EE 8 The NetBeans IDE brings the speed of enterprise applications development to a new level. You can create a fully operational Java EE 8 application in few minutes from scratch, and you can select the technologies based on preferences such as REST API, MVC 1.0, JSP, and AngularJS. The solution features a rich web UI, business logic, security, batch API, a REST API, and more. Don’t miss this session if you are serious about saving time.   
Developing Java Applications with Eclipse Neon Every year, the Eclipse simultaneous release brings together the hard work of dozens of open source projects into a single coordinated release. This session walks through some of the new IDE features and surveys some of the other technologies being developed by open source projects at Eclipse, including application frameworks, runtime technology, and modeling tools. It also highlights some of the features coming with next year’s Eclipse Oxygen release.
Docker Support in NetBeans, Eclipse, and IntelliJ A typical tool chain of a Java developer consists of an IDE such as NetBeans, Eclipse, or IntelliJ. These IDEs help you easily write and debug the Java application. They also provide features such as syntax highlighting and code completion, which make you more effective. All three IDEs provide support for building, pulling, and pushing Docker images and running containers. This enables you to run your application or database server as a Docker container from within the IDE itself. This live coding session shows the current state of Docker support in the three IDEs.
JUnit5: Features, Architecture, and Extensibility JUnit5 (JUnit Lambda) is a project to update the de facto standard in Java testing tools. This session describes how the framework has evolved to enable the modern features of the JVM as well as the underlying architectural changes that make JUnit5 ready for the modern era of Java. Test parameters and dynamic test generation are now supported. Other key facets of the new architecture are modularity and the inclusion of callbacks to allow extensibility from many points in the test lifecycle. After an introduction to JUnit5, demonstrations include how to write JUnit5 tests, how to run JUnit5 tests, and how to write extensions to alter the default test engine behavior. No familiarity with automated testing is assumed.
Introduction to Troubleshooting in JDK 9: Serviceability Tools Are Your Friends OpenJDK has very useful serviceability tools for debugging and troubleshooting: jmap, jstat, jcmd, jdb. Especially since JDK 9, those tools have gotten useful new features. However, we need a lot of time to learn how to choose and use those tools differently in various versions and for various issues. This session’s speakers have used these tools for troubleshooting and have contributed to OpenJDK to make them more convenient. They also developed HeapStats, for gathering detailed runtime information continuously for after-the-fact analysis. This session is a quick boot camp on how to troubleshoot in JDK 9 with serviceability tools such as jhsdb, jcmd, and HeapStats. Hear how those tools have helped the speakers in their six years of experience in an OpenJDK technical support service.
Automated Tuning of the JVM with Bayesian Optimization Tuning the performance of a JVM is hard, maintaining optimal performance in the face of hardware and software upgrades even harder. As a result, services often leave a lot of performance on the table. We apply state-of-the-art machine learning technology to continuously optimize the performance of a JVM-based microservice. Initial results show that machine learning-based Bayesian optimization can be used to solve an otherwise intractable high-dimensional combinatorial optimization problem. In one case, we obtain over 80% improvement in performance efficiency, measured by requests served per unit of GC time. We discuss initial results, lessons, pitfalls, and how to integrate such automation into a microservices-based production environment.
Java 9 Module System Support in the NetBeans IDE This introduction to the Java 9 module system covers use of the NetBeans IDE to create, build, test, and package modular Java applications; recommended patterns for modules; using the IDE to convert existing Java code to modules; approaches to module black box and white box testing; and Apache Ant and Maven support for Java 9 modules.
Tools for High-Performance Polyglot Programming on the JVM Love it or hate it, being productive as a developer today means that you need tools that work seamlessly between Java, JavaScript, other dynamic languages, and even custom DSLs. Using the new JVM-based Truffle/Graal framework, NetBeans supports those scenarios—including integrating custom DSLs. This session describes how high-performance scripting language runtimes can be implemented with Truffle/Graal and how Truffle/Graal makes it straightforward to create IDE support for those languages—including support for debugging—with minimal language-specific adaptation. You’ll see a cross-language debugging session demo (including Java, JavaScript, Ruby, and R) that shows just how seamless and performant a polyglot development environment can be.
Cyrill Magnin II/III  
Building a Java Recommender System in 15 Minutes with Graph Technologies Recommendation engines are so ubiquitous that we can easily find them in almost every aspect of our lives: ecommerce, search engines, ad placements, social media, publishing, education, finance, real estate—to name just a few. Building a production-quality recommendation engine is very nontrivial. This session presents a graph-based workflow to tackle this challenge with a graph database powered by Oracle technologies. It discusses how Java and graph analytics are used to build a recommendation engine quickly and effectively. It also covers the graph concept and the property graph data model and provides a description of core Java APIs and REST interfaces. 
Microservices Minus the Hype: How to Build and Why Few topics in software architecture discussions yield as much heat as that of microservices, deploying functionality in granular, API-driven modules. This session uncovers the upsides and downsides of adopting a microservices architecture and why, with certain exceptions, the pros far outweigh the cons. Topics include domain-driven design and bounded contexts, increasing quality and velocity, horizontal versus vertical scaling, portability, and more. The presentation then shows how to build and integrate microservices applications with Spring Boot, various datasources, and REST resources built to task. Load balancers, circuit breakers, tests, and other risk mitigation mechanisms are demonstrated and discussed. Leave this session knowing how and why to max out on microservices.
Java EE 8 Update This session presents Oracle’s plans for updating the Java EE Platform to reflect recent and emerging trends in the areas of the cloud and microservices. Topics covered include
• What’s been accomplished in Java EE 8 so far
• Reasons for the shift in Oracle’s focus for the Java EE Platform
• New areas Oracle needs to address and updates to current JSRs
Go Reactive with Vert.x in Oracle Application Container Cloud Digging into the microservices world? Considering reactive programming? Then you should learn more about Vert.x, a lightweight, fast, modular, high-performance, and unopinionated toolkit for building reactive applications on the JVM. Come to this session to see how we can use Vert.x to solve common business use cases for enterprises and how to deploy Vert.x applications packaged as containers in Oracle Application Container Cloud.
JCache and Java EE: Bridging the Gap JCache is scheduled for inclusion in Java EE 8. Although JCache 1.0 or a maintenance release can be included as an API in the umbrella specification, some work is required to make JCache easy to use from within a Java EE application. Several integration points to consider are CDI of caches and cache managers, configuration and deployment of cache managers and caches, class loader interactions when using events and event processors, and many more. This BOF gives you an opportunity to get together with other developers interested in how JCache can be used and to throw out some ideas to see if it’s possible to gather a group of people who would like to drive JCache forward in Java EE.
Advanced PrimeFaces PrimeFaces enables you to build modern, powerful, and attractive Java EE UIs with dozens of off-the-shelf components. You can build new functionality very quickly by using its built-in capabilities as well as the power of JavaServer Faces. But what about when you need some customization, or additional features built on top of an existing component? That’s when you need to understand exactly what’s happening behind the scenes. This session deconstructs PrimeFaces from the Java layer (component code, Ajax integration, and so on) all the way through the JavaScript browser layer (CSS, JavaScript widget API, and jQuery). You’ll gain a deeper understanding of how to implement complex custom features with PrimeFaces.
Docker for Java Developers Docker is the developer-friendly container technology enabling creation of your application stack: OS, JVM, app server, app, database, and all your custom configurations. So you are a Java developer, but how comfortable are you and your team taking Docker from development to production? Do the developers say, “But it works on my machine!” when code breaks in production? And if they do, how long do you spend creating an accurate test environment to research and fix the bug? Docker’s PODA (package once, deploy anywhere) complements Java’s WORA (write once, run anywhere). It also helps you reduce the impedance mismatch between dev, test, and production environments and simplifies Java application deployment. This tutorial shows how to package, deploy, and scale Java applications with Docker.
The Hitchhiker’s Guide to Open Source Open source is everywhere, no matter where you look. It’s in your personal computer, your mobile device, your car, maybe even your fridge. Open source has become a viable solution for many individuals and organizations, but not everyone will “get it” from the start. An open source project works best when a community is built around it. There are certain etiquette guidelines to follow from team to team. Tools have appeared to make it easier to build such communities, and what’s best is that many of those tools are open source too, adding more goodness into the feedback loop. This session discusses some community-building guidelines and tools that make working in open source a delightful experience.
Contributing to Open Source Virtually all software developers use open source software, but only some of them actually contribute back. The very best sort of contribution to an open source project is a patch with tests for a documented issue, but getting to that point requires some navigation skills. You need to get connected to the community and learn how it works, including obvious things such as coding standards and style and less obvious things such as sorting out how to get the existing project team to invest in you. You need to understand your rights and responsibilities, licensing and copyright concerns, contributor license agreements, and more. This session covers these topics and others to help you get more directly involved in open source software. 
Managing Open Source Contributions in Large Organizations In contrast to just a few years ago, most large enterprises are now contributors to and maintainers of open source projects.  For many, there are aspects to the contributions that slip through the cracks, causing headaches for legal teams and unnecessary risk for the organization. Things like managing code licenses, contributor license agreements, and patent-related issues are often not addressed. This session describes how your organization can tackle these issues and covers some of the tooling Salesforce has built to help ensure legal compliance with incoming and outgoing contributions.
Delivering Unicorns “Brand-new shiny” project(s), no legacy, everything being built and designed from scratch…. Dream scenario, isn’t it? Well, it can be a nightmare when under this description is hidden a few-years-old project that is still under construction and can’t be used by businesses/users even though it’s kinda “working.” Yep, this means a lot of mess and a few more years of addressing legacy code even before going to production. Yay, what fun! But even if you’re lost in the darkest forest, there is hope. Always. This session covers the sins that lead to situations such as no product vision, gold-plating, and too big a backlog and prescribes cures for them.
The Diabolical Developer’s Guide to Performance Tuning Martijn Verburg (a.k.a. the Diabolical Developer) is the CEO of JClarity, a company that uses machine learning for performance analysis of Java/JVM applications. In this session, he introduces Kirk Pepperdine’s “Performance Diagnostic Methodology” (PDM) to help you quickly get to the root cause of a performance problem. As a teaser, here are some of the points he covers:
• What is your cloud made of?
• Draw diagrams!
• Measure each architectural layer
• What is the CPU doing? Overworked or bored?
• Linux command-line tools are pure awesomeness
• Garbage collection logs
• Oracle’s JMH framework for microbenchmarking
• VisualVM, NetBeans
The presentation sometimes focuses on the cloud but treats it with caution.
Java EE for the Cloud Come to this BOF session to interact with the Java EE specification leads to discuss future directions for Java EE for the cloud. Give your feedback and discuss the proposal at this community event.
Start a JUG Right with a Good Charter, Mission Statement, Values, and Schedule Thinking of starting a JUG? Maybe you’ve just started one or are leading one that is struggling? Running a successful JUG can be rewarding for you and your community, but it isn’t always easy to know where to start or how to improve. This session shows you how the speaker and his colleagues used a good charter along with a mission statement, a set of JUG values, and a consistent schedule to start and maintain a successful JUG in a less-than-friendly environment. They will give pointers on how to develop your own charter, mission statement, JUG values, and schedule and will then show you how to use them to help your JUG grow and succeed. They will also share other tips they have learned to help your JUG grow and will have a question-and-answer session.

Join the discussion

Comments ( 1 )
  • Ivo Thursday, February 23, 2017

    anybody knows if these videos are available somewhere now? Thanks
Please enter your name.Please provide a valid email address.Please enter a comment.CAPTCHA challenge response provided was incorrect. Please try again.Captcha