The technical sessions of this track is filled with content covering everything you need to know about developing applications and cloud native microservices using Java. The topics include best practices, experiences, and recommendations using technologies and frameworks such as Eclipse Vert.x, Eclipse MicroProfile, and Jakarta EE as well as reactive programming, containers, and orchestration.
Let’s be honest: the amount of data collected by applications nowadays is growing at a scary pace. Many of them need to handle billions of users generating and consuming data at an incredible speed. Maybe you are wondering how to create an application like this? What is required? What benefits can you take from this reality to your project? This session shows how Jakarta EE can meet these needs when you’re working with NoSQL databases in the cloud. It’s the same approach used by some of the biggest companies in the world to store, analyze, and get results from really crazy amounts of data.
Eclipse MicroProfile helps developers quickly get started cloud-native app development using Jakarta EE capabilities. But what does this really look like if you're, say, a Java developer? What else the developer joy for Java application? Quarkus not only brings a cohesive, fun to use full-stack framework by leveraging best of breed libraries likeEclipse MicroProfile you love and use wired on a standard backbone but also combining imperative and reactive codes based JVM and/or GraalVM.
It seems that more and more enterprise technology is emerging that is based on Java EE. There are a lot of options to choose from, between Java EE, what is now Jakarta EE, MicroProfile, and combinations of their APIs. If we look at available application containers the number of possibilities is even higher. Which platforms, particular standards and runtimes should enterprise developers base their applications on in year 2019?
Testing is still a topic that most developers would like to avoid. Even though it is crucial for working software, developing and maintaining tests takes certain time and effort — especially for distributed applications or when changes in existing functionality forces test scenarios to adapt. Omitting software tests can’t be the solution; therefore, how can we tackle enterprise tests in an effective and productive way?
Enterprise Java has come a long way. Let’s not focus on the old, darker days, but modern approaches on how to do enterprise applications. Where do we start? What technologies, tools, and approaches are a good choice for our applications and what allows us to effectively implement business logic and to deliver value to our users?
Java assumed the whole computer belonged to itself, that it could consume all available memory and CPU. In this presentation, we will demonstrate the problems associated using Java for “microservices”, and how the open source ecosystem is working to insure the future of Java by being cloud first, container native, serverless focused and Kubernetes optimized. This is where GraalVM meets Quarkus (https://quarkus.io), bringing server-side and enterprise-capable Java to enable you to build truly cloud native apps.
Historically Java was able to handle the biggest enterprise problem(s) with its Write once,run anywhere(WORA) paradigm. With Cloud Native Applications grown to popularity, things like running applications as linux containers, serverless taking centre stage -- Java was pushed back by languages like golang, node.js as the forerunner to build Cloud Native Applications as they are smaller, quicker and arguably more nimble.
In reactive services is an essential that a request is not blocked anywhere during processing. Accessing databases is a tricky part here because there are currently not many databases providing reactive drivers. Come learn about Helidon Database Client - thin persistence layer in Helidon SE allowing working with relational and NoSQL databases the reactive way.
It's a challenge to choose Java microservices framework which satisfies your requirements. Some developers prefer reactive, functional style of APIs and other developers give preference to inversion of control, declarative style APIs offered by MicroProfile. In this session I will explain the differences and pros and cons of each approach. I will demonstrate how the functionality of MicroProfile APIs such as HealthCheck, Metrics and OpenTracing can be implemented in reactive-style applications.
With Microservices as its target, the programmer sees a gap between the typical old-school approach (deploying to an application server) and modern approaches.JAX-RS 2.2 allows to natively startup a web server, even in-process in an IDE, so it allows to simply start it as a Java main() method and debug its startup and requests processing just as easy as Hello World! No more slow build and deploy cycles! This talk demonstrates how to do that, and what more to expect from JAX-RS 2.2 and the further roadmap.