Go deep at JavaOne: 20 developer sessions that caught my eye

What are the latest and greatest features of Java? Where is the platform going? How can you leverage Java’s capabilities to build better application—while also enhancing your own skills as a developer?

You’ll find these topics addressed in the technical learning sessions, labs, workshops, and solutions keynotes at the JavaOne Conference, October 17-20, 2022, in Las Vegas.

The conference offers 135 sessions covering all aspects of the language and run-time platform, as well as interoperability and integration with other technologies such as Linux, GitHub, and Spring Boot.

Many of the session leaders are engineers working in the Oracle Java Platform Group, and many also come from the broader community. For example, you can learn from a rock star in the Java world, Venkat Subramaniam, president of Agile Developer Inc., by catching his class “Functional Programming Idioms in Java.”

By the way, JavaOne is collocated with the Oracle CloudWorld Conference, and as an attendee of JavaOne, you can welcome to attend any of the CloudWorld sessions, keynotes, and other events.

Here are some of the JavaOne sessions that I personally find most interesting, but feel free to peruse the entire catalog—or just jump in and register now:

Java First. Java Always.

Modern application development is unrecognizable without Java. For more than 25 years, Java has empowered developers to create the next generation of rich, scalable, and secure applications. In this keynote, learn how Oracle’s ongoing Java leadership and stewardship is creating a contemporary language and platform that helps developer productivity.

Data-Oriented Programming with Records, Sealed Classes, Text Blocks, and More

Java has undergone rapid evolution in the past several years. Many of the new features, while surely useful on their own, are designed to work together. See how three of the recent features—records, sealed classes, and pattern matching—work together to enable a data-oriented style of programming, which is a good match for today's cloud applications.

Developing Long-Lasting Java Microservices

Modern Java development is about simplicity and productivity; the days of ceremony are long gone. We explore what can make an application "modern" and, more importantly, which code practices can help sustain that "modern" feeling—and keep the "legacy" out. See code examples and their consequences (based on code from a global financial super-app), and modern Java Development Kit, naturally.

Evolving the Security of the Java Platform

Maintaining and improving the security of the Java Platform is an essential and continuous process. We discuss recent improvements to the security and cryptographic APIs and libraries, as well as the process and changes made to update releases via the Java Cryptographic Roadmap.

CI/CD, Github Actions, and GraalVM Native Image

For cloud applications, generating a native executable using GraalVM Native Image is often the final build step. Fortunately, new GraalVM Native Image support for GitHub actions makes it easy to incorporate ahead-of-time compilation into a GitHub build pipeline. We look at incorporating GraalVM Native Image compilation into continuous integration and continuous delivery pipelines—including GitHub with GitHub actions—along with generating executables for multiple platforms such as Windows, macOS, and Linux.

Accelerate Java Cloud Native DevOps with Oracle Linux and Oracle VM VirtualBox 

How do you simplify Java cloud native development and deployment? Oracle Linux offers an open, integrated operating environment with application development tools, management tools, containers, and orchestration capabilities. Plus, there are open-source Cloud Native Computing Foundation projects such as Kubernetes, RunC, CRI-O, Kata Containers, and Istio. Learn how to accelerate your DevOps using these resources, and efficiently build reliable, secure cloud native Java applications. See how to create, maintain, and deploy your Java apps across hybrid cloud environments, with an open-source stack that is tested, integrated, and supported worldwide by Oracle.

Functional Programming Idioms in Java

Many developers and organizations are immersed in Java's functional programming capabilities. Writing code is easy, but writing maintainable code takes effort, discipline, and care. What are some of the dos and don'ts we should keep in mind when programming in functional style? Spot the common mistakes you may have seen in your code base and learn several supporting pieces of evidence for why we should avoid these mistakes and how to write better quality functional style code.

How to Avoid Common Pitfalls with Modern Microservices Testing

Have you ever wondered why your microservices break in production after all the tests passed during continuous integration/continuous delivery (CI/CD)? Have you wondered if you're testing too much or too little? Learn about common pitfalls and how to catch them at build time rather than runtime. We share some common battle scars observed in the wild and introduce the testing pyramid—explaining how it allows you to continuously deploy microservices independently without fear. We demonstrate, through a test-driven development approach, how combining Pact contract testing with Quarkus developer joy can help prevent your microservices from breaking in production.

How to Run Your Application up to 60X Faster with Native Images

In a world with more and more distributed applications with no state control, performance is one of the biggest challenges (being related to startup or even to the response to the first request). For a while, this context made Java a dubious choice for approaches like serverless, microservices, and containers. Today we not only have platforms that take Java to a brand-new performance level; we also have something that allows us to take a step further: the native images built using GraalVM. Learn what can and can't be done with native images, and how you can run your code up to 60X faster today.

Jakarta EE 10: Simplicity for Modern and Lightweight Cloud Applications

Jakarta EE 10 is packed with new features that make it easy to develop modern, lightweight enterprise Java applications for the cloud. The new Jakarta EE Core Profile helps develop microservices with Jakarta EE technologies with runtimes smaller than ever. It even makes compiling Jakarta EE applications to native images possible—to reduce the footprint even further. We explore Jakarta EE 10's new features in an interactive way packed with live code demos. We also talk about what we can expect from the future of Jakarta EE.

Java and the Promise of Quantum Computing

We've all heard the hype: Quantum computers will leave our current machines wallowing in the dust. Quantum algorithms will crack our existing encryption schemes in seconds. Will it really happen? The answer depends on engineering problems that have yet to be solved. But for those who write code, many insights are already available. This lab lets you run Java code using Johan Vos's Strange platform. We use the code to learn about quantum computing's revolutionary approach to problem solving.

Java + Project Loom = Synchronous Performance

We long were forced to choose: either use complicated and performant reactive code, or use a simple (yet limited) synchronous approach. Thanks to Project Loom, the paradigm can shift once more—even for applications that require high concurrency. We introduce a server designed for Loom with fully synchronous routing that can block as needed, yet still provide high performance under heavy concurrent load. We then dive a bit deeper to show the advantages of Project Loom, design choices made, and the implementation of other protocols, such as HTTP/1.1, HTTP/2, gRPC, and WebSocket.

(Mis)Understanding Cloud Native Java

Cloud is great, and cloud native is really nice. However, some misconceptions and terms are often thrown around—from JDK distributions and memory footprints to startup times, health probes, observability, serverless Java apps, zero downtime, and many more. Some can be confusing, and some even intimidating. We try to bust a few myths about cloud native development and give you some pointers on how you can develop better and more modern applications.

New Java features: Simplified Design Patterns

Java is often accused of being too verbose. We show how new and announced features and syntactic improvements in Java are helping to reduce the truth of this. We examine how newly added features and semantic improvements contribute to our code's simplification, maintainability, and efficiency. Find out how to use these new features to solve everyday challenges. We show a beauty of pattern matching, Records, Sealed classes and more on commonly used design patterns.

Refactoring Rules: How and When to Refactor Java Code

Test-driven development (TDD) is a multistep process, but most developers skip the last step (refactoring) because they aren't confident in how to do it. The test is green, right? Isn't that what's supposed to happen on TDD? Not really... Thinking like this leads to a fragile pile of code that ends up causing more harm than good. This fast-paced, action-focused presentation shares refactoring guidelines you can quickly apply to any piece of code—letting you turn your first draft into a flexible and maintainable design. With a little practice, the refactoring step will be another fun part of the development cycle.

Supercharge Your Java Code for Optimal Database Performance

Java is lightning-fast and powerful but, when a database is part of the stack, application performance can quickly hit a bottleneck. For years, databases have been seen as the slow, monolithic backends that limit throughput. But are they the real culprits? Not necessarily. Most of the time, the code—using autocommit, too many network round-trips, and unnecessary work on the database end—is the issue. We show some of these pitfalls and how to avoid them using code refactoring and simple tricks to supercharge your application. Learn the fundamentals of database performance and never wait for a reply from your DBA again.

Training and Tracking Machine Learning Models in Java with Tribuo

Tribuo is a Java machine learning (ML) library, developed by Oracle Labs, used inside Oracle since 2017, and open sourced in 2020. It has several features that make it suitable for enterprise deployments of ML models. It can train and deploy ML models in Java and tracks the provenance of the models it trains. Each model is self-describing; it knows its training data, how that data was processed, and all the algorithmic details that went into building it. Tribuo also can export models in ONNX format and integrates with popular libraries like TensorFlow and XGBoost. Get introduced to Tribuo, learn how to use it for a variety of ML tasks, and watch as we demonstrate its integrated provenance features.

Your Guide to OpenJDK Development

Java, its libraries, and Java HotSpot VM are all built through OpenJDK, an open-source project. The OpenJDK Developers’ Guide aligns developers around terminology and process. Learn how you can contribute to the project.

The Future of Java Is You

Not only does Oracle take our Java leadership seriously, we also embrace our stewardship of the Java community. As the Java language and platform evolves to rapidly address modern application development, Oracle continues to invest in the Java community to ensure it remains one of the strongest developer ecosystems on the planet. In this keynote, learn about the many Java community programs from Oracle that give developers a voice in shaping the future of Java.

Source: oracle.com