X
  • September 20, 2016

JavaOne Live Streaming Day 2

Welcome to the second day of live streaming at JavaOne. Like yesterday, we are streaming sessions from four rooms from 8:00am to 8:00pm. As you are watching the sessions, join the conversation on Twitter using #javaone and follow us @javaoneconf. 

At 8:30am PST from Ballroom 4 watch advanced Java 9 sessions like “Project Jigsaw: under the Hood.” Speakers from the community are talking about their first-hand experience working with Java 8, collections and more. Expect a lot of useful tips from those Java 8 related sessions.  

On the Java EE 8 side, there are Cloud-Native Java EE tutorial, JAX-RS 2.1 and Servlet 4.0. They will be updated JSRs in the next Java EE release. Here are lots of sessions about Java, cloud, and methodology to watch. See the streaming schedule and links here  

Session Title  Session Abstract 
Balroom 4  
Journey’s End: Collection and Reduction in the Stream API For streams to do useful work, they must end in a terminal operation. Most often that will be a collector, a new kind of operation invented for the Stream API. To use streams effectively, you need to understand how collectors work, what predefined collectors are available, and the factors that affect collector performance. This deep dive into the Collectors API explores the many predefined collectors and how to combine them for added power. You’ll do practical work, learning how to choose the right composition of collectors to solve practical programming problems. And you’ll see the difference between collection and reduction, how to recognize when you need to write your own collector, and the principles and rules for doing that.
Modules and Services Most Java developers know the saying “Program to an interface, not an implementation.” In JDK 9, the module system introduces “services” to make this concept explicit: modules declare which interfaces they program to, and the module system automatically discovers implementations. This clarifies program structure and helps avoid the need for optional dependencies between modules. Using examples from the JDK, this session shows how to adopt services in your codebase and how to design APIs in a modular fashion.
Refactoring to Functional Style with Java 8  In Java we’ve programmed with the imperative style for a few decades. With Java 8, we can also code in functional style. This style has several benefits: code is concise, more expressive, easier to understand, and easier to change. But the transition from imperative to functional style is a hard journey. It’s not so much an issue of getting comfortable with the syntax; it’s the challenge of thinking functionally. What better way to learn that transition than taking imperative code and refactoring it to more of a functional style. This session starts with multiple code examples written in imperative style and shows how to approach and refactor them to functional style. You’ll learn about some APIs and hidden functions but more so what to look for during your own journey to functional style.
J9: Under the Hood of the Next Open Source JVM This session dives into the design of the J9, IBM’s production JVM. Why might you care about this?  IBM is open-sourcing its JVM! If you want an early peek at how the J9 operates, its data structures, GC policies, and the best way to understand its execution, this is the session for you.
Project Jigsaw: Under The Hood The goals of Project Jigsaw are reliable dependencies and strong encapsulation, but what does that mean precisely? This session explains the process of module resolution in JDK 9 and shows how it avoids errors relative to the classpath in JDK 8. It also explores the double-edged sword of modular accessibility, where the ability to hide a module’s internals must be balanced against the needs of frameworks that perform reflection. Prepare for a deep dive into module graphs; class loaders; unnamed modules; and the once and future king, setAccessible.
Thinking in Parallel The Java 8 Streams library makes it easy to run code in parallel. A common error is code that works when run sequentially but that misbehaves when run in parallel. This is often caused by programmers who are stuck in a mode of imperative, left-to-right thinking. This leads to an iterative style in which data is mutated and where the next result depends on the result of the previous computation, creating barriers to parallel computation. This presentation covers an alternative programming technique called array programming, where operations are applied on data aggregates instead of individual elements. It also includes examples and demonstrations that illustrate these techniques and how they lead to easier-to-understand, parallel-ready code.
OpenJDK Security Group: Discussion and Q&A This BOF is an open, informal discussion and Q&A with members of the OpenJDK Security Group about the security libraries and APIs in the JDK. Come share your ideas for improvements and new features and ask questions about existing features.
Navigating the New Threat Landscape in an Open Source World Building software by using open source libraries is the new normal, but the bad guys have learned that reusable code means reusable vulnerabilities. The threat landscape has fundamentally changed, and the end-to-end open source software supply chain is under attack. Through actual exploits, this session shows what hackers are doing and how Java developers and their teams can protect themselves. It covers<br>
• Bad security advice from Q&A sites<br>
• Malicious code editor plugins<br>
• When bad things happen to good build and package managers<br>
• Trusting binary repositories such as Maven Central<br>
• Vulnerabilities and backdoors in open source libraries<br>
• Hiding bad things in source code management<br>
• Abusing continuous integration systems to mine Bitcoins
Ballroom 6  
How to Generate Customized Java 8 Code from Your Database The best code is the one you never need to write. Using code generation and automated builds, you can minimize the risk of human error when developing software, but how do you maintain control over code when large parts of it are handed over to a machine? In this tutorial, you will learn how to use open source software to create and control code automation. You will see how you can generate a completely object-oriented domain model by automatically analyzing your database schemas. Every aspect of the process is transparent and configurable, giving you, as a developer, 100 percent control of the generated code. This will not only increase your productivity but also help you build safer, more maintainable Java applications.
Java Libraries You Can’t Afford to Miss The Java language has passed its 20th anniversary, and with it comes an incredible range of tools libraries to choose from; sometimes there are actually too many choices for the same task. This presentation covers those libraries that have risen to the top, having proved themselves to be worthy of a place in every developer’s toolbox, for both production and testing code. It also discusses some fairly new libraries that are bound to make a big impact in the ecosystem.
Gradle Support in NetBeans: A State of the Union One of the most important community-driven plugins in the NetBeans ecosystem is support for Gradle. This presentation shows the current state of support for Gradle, including advanced features such as code coverage and debugging. Besides an overview of long-standing features, it includes a sneak peek into the upcoming enhancements, such as support for new Gradle concepts to support JDK 9 modularity as well as long-awaited enhancements to Gradle code completion in NetBeans. The second part of the session focuses on building NetBeans IDE extensions (plugins) with Gradle and how to use Gradle to build your own rich client platform application based on the NetBeans platform.
Java 9 and the Impact on Maven Projects Since the early-access releases of Java 9 became available, the Apache Maven team has been testing this product and enhancing its build management tool to support the new features. Especially the modular system described in JSR 376 requires changes to adopt this specification. The Maven team is involved in the discussions about the refinements of these specifications to improve the adoption of the modular system. This session highlights the JEPs and JSRs that are now supported by Maven and what they mean for all Maven projects. The speaker has been a PMC member and committer of the Apache Maven project since 2011. He has implemented most of the changes required to adopt Java 9/Jigsaw and maintains contact with the related Oracle teams. 
JavaScript Nirvana in NetBeans NetBeans is not just a Java IDE. It supports JavaScript as a first-class citizen and provides a complete integrated development environment. It also provides project types for server-side JavaScript (Node.js) as well as web browsers and mobile (Apache Cordova). In addition, it supports Grunt, Mocha and Selenium, Angular and Knockout, and more. This session provides an update on NetBeans 8.1 and demonstrates the top new JavaScript features. You will see a Node.js application in action, look at the support for JavaScript unit testing, and also see how easy it is to debug an Apache Cordova application running on a tethered iPhone.
Faster Java EE Builds with Gradle It is time to move your Java EE builds over to Gradle! Gradle continues to gain momentum across the industry. In fact, Google is now pushing Gradle for Android development. Gradle draws on lessons learned from both Ant and Maven and is the next evolutionary step in Java build tools. This session covers the basics of switching existing Java EE projects (that use Maven) over to Gradle and the benefits you will reap, such as incremental compiling, custom distributions, and task parallelization. You’ll see demos of all the goodies you’ve come to expect, such as integration testing and leveraging of Docker. Switching is easier than you think, and no refactoring is required.
Write Better Code: Become a More Productive Java Developer with the NetBeans IDE If you want to spend more time getting things done, the NetBeans IDE must be on your desktop. NetBeans works out of the box. Easily accessible are a wealth of integrations, features, tools, and options. You can configure NetBeans to match your preferences, remove unneeded features, and share settings between users. Productivity enhancements in NetBeans include a range of formatting, code completion, hints, templates, and keyboard options that enable you to write, maintain, test, and update bug-free code quickly. The same tools work with JavaScript too. Integration with FindBugs, PMD, and other tools gives you a personal expert code reviewer. Seamless integration with Maven, Git, Junit, smart templates, and code completion make developing and testing quick. Learn more in this session.
Exploring Java Applications with Java Shell and NetBeans Learn how to take advantage of interactive Java snippets evaluation, both to explore Java basic and advanced features and to speed up development of real-world applications. This session presents various scenarios illustrating how Java Shell integration into the NetBeans IDE helps beginners as well as advanced users carry out their tasks. Beginners can use Java Shell to explore basics of the Java platform, whereas advanced users can use Java Shell to interactively test and improve their applications or even inspect and change the state of their applications while they’re running.
Cyrill Magnin II/III  
Cloud-Native Java EE  Many people underestimate the DevOps shift required for running applications in the cloud rather than on-premises. Truly cloud-native applications on Java EE are possible with very little effort, but a shift in mindset is required to really take advantage of the scale that comes with cloud deployments. In this tutorial, the presenters build a full microservice using Java EE APIs, JAX-RS, EJB, CDI, and JPA. They then demonstrate the use of various tools such as Docker, Vagrant, and Amazon Web Services, showing elasticity and resilience, making use of features that are infeasible or not easy with on-premises deployments, and demonstrating 12-factor-app principles and how they can be applied to Java EE deployments.
Migrate Java EE Applications to Microservices and Oracle Java Cloud Microservice architecture focuses on decomposing applications into services and deploying these independently. This session demonstrates how to migrate existing Java EE applications into microservices. It explains how to define microservice boundaries, how to do circuit breakers, and how to pack and bootstrap Java EE microservices. The presentation focuses specifically on interoperability between the application server and microservices and shows how to achieve interoperability for container authentication, CDI, remote EJB calls, remote JMS, datasources, and more. It also shows how to deploy microservices to Oracle Java Cloud Service.
JAX-RS 2.1 for Java EE 8 The current practice of cloud development in Java is founded on REST and asynchrony. For many developers, that means the standard JAX-RS specification and also its reference implementation, Jersey. This session covers suggested enhancements coming to the next version of JAX-RS, including server-sent events, nonblocking I/O, reactive programming, and more-complete CDI integration.
Servlet 4.0: Status Update and HTTP/2 Comes to Java EE 8 For many years, Servlet technology has been at the heart of Java EE/Enterprise Java. Also technologies associated with the cloud—such as containerization, microservices, REST, pay-per-use computing, and Continuous Delivery—have become more relevant. Companies have shifted from using app servers and associated deployment artifacts to newer models that take advantage of the cloud. So, what role can Servlets play in this new world? This session covers how Oracle is listening to the demands of the community to deliver a completed Servlet 4.0/ Java EE 8 that builds on existing strengths while enabling lighter-weight, cloud-ready, composable apps.
How Multidimensional Search Trees Speed Up a Java Connection Pool What do geology, astrophysics, or graphical processing and a connection pool have in common? They all use advanced data structures and search algorithms known as kd-trees. Finding a specific database connection with several properties (p1, P2, P3) such as “give me  a connection with any P1 value, a RANGE of P2 values, and a specific P3 value” is tricky and cannot be easily implemented with the standard/usual Java APIs and data structrures. This session explains approaches to optimizing connection pools with multidimensional searches in kd-trees and provides comparative performance benchmark results showing dramatic performance improvements.
Simple Software as a Service with Docker and jclouds With Docker in cloud offerings such as Carina and other similar services, it is fairly easy to create extremely cheap SaaS solutions. This session explores specifically how to programatically configure Docker (using Apache jclouds) to repeatedly deploy different applications to the cloud and make them available to multiple users.
Scalability and HA with Java EE Containers, JDBC, and Java Connection Pool This session discusses questions related to scalability and high availability for Java applications using Oracle JDBC drivers and Java Connection Pools. It explains the building blocks of scalability and HA at the driver and pool levels and how Java EE containers and frameworks can leverage these mechanisms to scale and deal with planned and unplanned outages. The session relates to all Java EE containers (Tomcat, Websphere, Weblogic, JBoss, and so on).
Embarcadero   
Operational Excellence with Netflix Hystrix Netflix Hystrix is a well-known OSS framework for a circuit breaker in Java. It is less known for its application in operational monitoring and debugging production issues, which is one of the biggest usages of Hystrix inside Netflix. This session focuses on how to apply Hystrix to existing applications with undocumented dependencies and implement DevOps monitoring with Hystrix metrics.
Core Software Design Principles Writing code is easy. Writing good code is hard. If we’re not careful, software turns into a mess and becomes hard to change rather quickly. By learning and using some fundamental design principles, we can alleviate those pains quite easily. In this session, with the help of live code example, learn the core design principles that have the deepest impact on the quality of software you create.
Development Operations in the Cloud: A Use Case and Best Practices  Based on real-world usage leveraging your favorite tools such as Maven, Git, and Hudson, this session covers how a cloud-based DevOps solution can save you time and money through rapid spin-up of an integrated development platform in seconds, as opposed to months. In the session, both Oracle Development and Product Management present their best practices for delivering an enterprise-scale solution through distributed team collaboration leveraging DevOps in the cloud.
Live-Coding No-Ceremony Microservices Java EE is productive and easy to learn and runs smoothly on containers such as Docker and rkt. It has become the perfect microservices platform. Unfortunately, no one in the enterprise is interested in managing thousands of nanoservices “just for fun.” In this session, the presenter hacks on stage a couple of Java EE 7/8 “rightsized” services, links them together, runs them on Docker, and explains the architectural decisions and best practices in real time. 
Java EE: The Most Lightweight Enterprise Framework? A long time ago, J2EE and especially application servers were considered to be too bloated and “heavyweight.” It could be quite tedious and discouraging for developers to use that technology for developing applications. But since the name change to Java EE, that assumption is not true anymore. This session shows the benefits of developing against a well-established standard, what makes a framework “lightweight,” and what a lightweight yet comprehensive solution for enterprise application could look like. Most of the time will be spent live-coding and comparing different approaches and scenarios, including building and deploying applications—on SaaS such as Oracle Cloud or on-premises.
Toward an Evolutionary Design and Architecture Projects that don’t change are the ones that get canceled. Any relevant and useful software has to continuously evolve. Agile development greatly emphasizes an evolutionary approach to design and architecture. That’s because big up-front design and architecture are risky. But the evolutionary approach also has risks. This session starts with a quick discussion of why to employ an evolutionary approach and the risks of doing it or not doing it. Then it looks at some very concrete key practices that can lead us successfully on the path of evolutionary development.
Development Horror Stories We all enjoy hearing a good success story, but in the software development industry, the life of a developer is also made up of disasters, disappointments, and frustrations. Have you ever deleted all the data in production? Or maybe you’ve just run out of disk space and your software failed miserably. How about crashing your server with a bug you introduced in the latest release? We can learn from each other from the mistakes we’ve made. Come to this BOF session, and share your most horrific development story and what you did to fix it.
Gain DevOps Insight with Application Analytics You’ve moved your dev to the DevOps model to become more agile, and yet your ops is still a struggle, due to lack of insight into the performance and availability of your Java applications. Come to this session to learn how Oracle IT Analytics Cloud Service can improve efficiencies of your DevOps operations and optimize the customer experience by leveraging application analytics in your environment. Learn how to predict heap resource demands coming from Java application servers and forecast the storage and CPU needs of your databases before you run out of capacity. Live demos will show you how to analyze your system outages by identifying common failures such as heap issues, garbage collection, and JDBC issues from datasources.

Be the first to comment

Comments ( 0 )
Please enter your name.Please provide a valid email address.Please enter a comment.CAPTCHA challenge response provided was incorrect. Please try again.