• September 21, 2016

JavaOne Live Streaming Day 3

Welcome to day 3 of the live streaming from JavaOne. We have been streaming the sessions every day from four rooms at JavaOne. Those sessions start at 8:00am and run until 4:30pm today, leaving time for attendees to get to the appreciation party at AT&T Park tonight. I hope you have joined the conversation on Twitter using #JavaOne and followed us @javaoneconf

At 8:30am PST, Ballroom 4 starts with a Project Jigsaw Hack tutorial. This is your chance to hone your knowledge of the modules. Ask the JDK Architects is a great session to understand the legacy and choices that drove the evolution of the JDK.  

There are sessions for everyone on such varied topics as Raspberry Pi and Java 9, Garbage Collection Logs, Configuration for Java EE 8 and Microservices. Take a look at the sessions and make your picks. The streaming schedule and links are available here 

Session Title  Session Abstract 
Ballroom 4   
Project Jigsaw Hack Session Bring your laptop, your code, and your questions to this informal hack session with members of the Project Jigsaw Team.
Let’s Get Lazy: Explore the Real Power of Streams We can achieve efficiency not just by running things faster but also by avoiding things that shouldn’t be done in the first place. Lazy evaluations are a core feature of many functional programming languages. Your code can benefit from lazy evaluations with lambda expressions and, even more, with the power of Streams. This presentation starts with a discussion of lazy evaluations, with short examples from Haskell and Scala. Then it dives into Java to see how we can achieve similar benefits with lambdas and the Stream API.
Life After Modularity: An Experience Report  “Modularity will break your code!” If you’re concerned that this might be true, come to this session, presented by a JVM engineer, to hear the truth. Find out how to prepare for Java 9, and see examples of the kinds of changes and workarounds required to bring up real applications.
A Few Hidden Treasures in Java 8 Sure, Java 8 has lambdas and streams, but the JDK has gone through a significant makeover to make good use of lambdas and streams. Furthermore, some of the new functional interfaces have far more than abstract methods. This presentation goes beyond lambdas and streams and takes a look at some of the fun-filled, useful elements of the JDK that will help us make better use of lambdas and streams.
Ask the JDK Architects Bring your favorite questions about Java SE and the Java Development Kit—past, present, or future—to this open Q&A session with key architects from Oracle's Java team.
Ballroom 6   
Raspberry Pi with Java 9 This session is designed to help you use your Java programming skills to create hobby projects using the Raspberry Pi as an inexpensive (US$35) interface to the physical world. Among the topics covered:<br>
• Unboxing your Raspberry Pi and setting up Java<br>
• Using the Device Access API<br>
• Programming common I2<i>c</i> devices<br>
• Creating visual and touch UIs<br>
• 3-D-printing custom hardware<br>
• Using Java 9 modules to shrink your app size<br><br>
After the session, you will have the knowledge you need in order to start building your own embedded projects for your home or office and will be able to leverage your Java programming skills to connect it to the Internet of Things. Start building the future now with Java 9 embedded technology.
Java Debuggers: A Peek Under the Hood Ever wonder how the JVM “knows” how to stop at the breakpoint you set? Curious about how the various debug flags affect your application? This session examines the HotSpot’s support for debugging Java code (JVMTI and related APIs) and takes a deep dive into the implementations of some of the more interesting features used by debuggers, profilers, and other tools.
Ten Productivity Tips for Java EE and Spring Developers During this live coding session, we build both a Java EE application and a Spring application, using 10 productivity tools/projects/products that help coders get stuff done. Each tool is introduced live as it’s used in the demo. The session addresses how applications can be developed and tested quickly, providing a development environment that enables us to deliver high-quality, performant code. It covers JIRA, Confluence, Tomcat/TomEE, Arquillian, JBoss Forge, JRebel, XRebel, IntelliJ, Jenkins, Gradle, and more.
Am I Reading Garbage Collection Logs Correctly? There are several formats for garbage collection logs. Depending on the  Java vendor (Oracle, IBM, HP, ...), the Java version (5, 6, 7, 8, 9), the GC algorithm (serial, parallel, CMS, G1), and  JVM options (-X..), the garbage collection log format varies. Analyzing all these formats is not trivial. In this session, you will learn not only how to analyze several different GC log formats but also how to spot problems in them instantly.
The Bytecode Hocus-Pocus Compilers that produce native machine code do a great optimization job, because they know where the code is going to be executed. But because one of the main characteristics of Java is portability, the Java compiler can’t assume anything about where a program is going to run and leaves all the optimizations to be done by the JVM while the code is
loaded or even run. This session explores what can be done to help the compiler produce optimal code, which, in fact, will make life easier for the JVM. Having a better understanding of how the Java compiler works or what the impact of new language constructions is, we can definitely improve our code performance.
Pair Programming with Eclipse Cloud Development Top Projects At Eclipse, new actors are challenging the classic Eclipse IDE:<br>
• Che: the next-gen Eclipse cloud, putting the developer workspace and the IDE on your browser<br>
• Orion: an extensible browser IDE<br>
• Flux: a new message-based architecture for cloud-based developer tooling<br><br>
These technologies open lots of new kinds of features such as real-time live collaboration. This session presents a live demo of a prototype showing real-time collaboration from three IDEs. The prototype uses a Flux server running inside a Che Docker workspace that enables Orion, Eclipse IDE, and Che editors to edit the same file in real time as in Google Docs. Come with your laptop, your phone, or tablet, and join this pair programming session.
Cyrill Magnin II/III  
Leveraging AppCDS to Optimize Application Startup and Memory Footprint in the Cloud With modern-day enterprises looking forward to moving to the cloud from traditional onsite alternatives to make their business more manageable and scalable with reduced costs, it becomes critical to ensure that customers get the same level of performance with cloud-deployed solutions that they do with their on-premises counterparts. Application Class Data Sharing comes in really handy here, where sharing of application-class metadata across multiple VM instances can significantly optimize memory footprint and shorten startup time. AppCDS can be applied to any class loaded from arbitrary locations by a custom class loader, and this category of classes contributes to more than 50 percent of the classes in a typical enterprise application. Learn more in this session.
Configuration for Java EE 8 and the Cloud In the modern world, where apps consist of microservices and are deployed in a cloud, developers are facing many issues related to apps config. How to deploy an app in different environments without cracking its package. How to apply configuration for deployed instances of an app without redeployment. How an app can be notified if some confutation properties changes. This session introduces a standardization effort tasked with solving these problems by defining a Java EE config service. Such a service is aimed at the cloud and provides the ability to create one or more configurations that are independent of and decoupled from apps using them. The session describes how such a service fits into the Java EE family and integrates with other Java EE frameworks.
Java EE Next: HTTP/2 and REST Opportunities New paradigms such as microservices architecture, cloud-native development, and serverless computing suggest enhancements to Java EE going forward. As always, we need to be cautious when adding new technologies to Java EE, in order to avoid the “great technology of the day” trap. The recently announced Java EE effort presents many new opportunities. This session focuses on two areas: HTTP and REST. It discusses what HTTP/2 might bring to Java EE and then looks at some REST opportunities, such as the popular circuit break pattern, protocol buffers, a reactive client API, and NIO improvements. The goals of the session are to present potential improvements involving those two core technologies and to gather feedback.
Extend Your Cloud/Back End to Mobile Devices Companies are facing an increasing demand to make their services available via mobile applications and not only via websites suited for desktop usage. Although the development of a mobile app is often considered a standalone task that ultimately integrates with the company’s back-end infrastructure, it is often much better to integrate the app development into the enterprise architecture. This session explores the requirements for building mobile applications (for Android, iOS, and so on, using cross-device solutions such as Gluon Mobile) in relation to cloud connectivity, including persistence, cross-device synchronization, back-end cloud synchronization, and dealing with connectivity issues on platforms such as Oracle Cloud.
The DevOps Disaster: 15 Ways to Fail at DevOps DevOps is the new black. You need DevOps. Right now. What? You’re not doing DevOps yet? Hurry! You’re going to miss the boat! But wait. There’s a catch. Getting DevOps right isn’t easy. It’s downright hard. This session doesn’t explain how to “do” DevOps in your organization, because there is not just one “right” way to do it. What the presentation can show you, however, is how <i>not</i> to do DevOps. The session shares 15 common misconceptions—call them antipatterns—of DevOps. The speaker draws from his own experiences in getting things wrong and explains why they are wrong, to save you from making the same mistakes. You’ll leave this session with a basic understanding of how (not) to fail at DevOps and, hopefully, a smile on your face.
Euphoria Despite the Despair In this session, the Mad Scientist (Dr. Holly Cummins) and the Diabolical Developer (Martijn Verburg) take an in-depth look at why the highs of zero compiler warnings are quickly canceled out by the pain of long hours, bad requirements, endless configuration, and a litany of other issues that makes death by a thousand cuts seem like a good idea. They answer questions such as “Why is programming an art?” “How can I rediscover the delight I felt when I first started coding?” and “Am I addicted to TDD?” Combining psychology, philosophy, and computer science, they present a series of practical tips to help you rediscover the euphoria you felt the very first time a metal box in front of you came to life and cried out “Hello World.”
Java EE 7 Meets Java 8 The last few years have been pretty exciting for Java, with new versions of the EE and SE platforms. Java EE introduced a new API for building WebSockets; a new API for parsing, processing, and generating JSON; a new client API in JAX-RS for invoking REST services; and the batch processing API for building batch applications. Java SE brought us the long-awaited lambda expressions; the powerful Streams API for performing operations such as filtering, mapping, or sorting in a very easy and fluent way; and a brand-new date/time API for dealing with the complexities of time zones and periods. This session combines all these elements and shows you, with live coding and samples, how to easily develop an application by using Java SE 8 with Java EE 7.
One Microservice Is No Microservice: They Come in Systems Building a complete system out of individual microservices is hard. Microservices-based architecture is gaining attention, but there are trade-offs and drawbacks. Individual microservices are fairly easy to understand and implement, but they make sense only as systems; it’s between services that the most-challenging problems arise—in distributed systems. Slicing a system into REST services and wiring them back together with synchronous protocols and traditional enterprise tools means failure. This session distills the essence of microservices-based systems and covers a new development approach to microservices that gets you started quickly with a guided, minimalistic approach on your machine and takes you to a productive scaled-out microservices-based on the Oracle Cloud system with hundreds of services. 
Handling Eventual Consistency in JVM Microservices with Event Sourcing When you’re building JVM applications in a microservice architecture, managing state becomes a distributed systems problem. Instead of being able to manage state as transactions inside the boundaries of a single monolithic application, a microservice must be able to manage consistency by using transactions that are distributed across a network of many different applications and databases. This session explores the problems of data consistency and high availability in JVM-based microservices and how to use event sourcing to solve these problems.
Java EE Microservices by Example, from Raspberry Pi’s to the Cloud Making the move to a microservice architecture can be pretty daunting. Microservices can solve many architectural and organizational problems, but they come with their own challenges. Getting from monolith to microservices can be even harder. What’s the cleanest way to refactor? How should things be tested? What if things go wrong? Using a pile of tiny computers, cables, and code, this session demonstrates carving a monolith into microservices and deploying—and managing—a microservices application. Because there are limits on how much traffic the data-center-in-a-handbag server topology can handle, the presentation also demonstrates scaling up, out, and away to the cloud.

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.