Java Stage

GraalVM is a pluggable and embeddable VM designed for running programs written in multiple different languages. Supported programming languages could be combined together within a single program, where data structures are shared among these languages efficiently without any additional serialization overhead.
In this session i will shortly introduce GraalVM architecture and Truffle framework that is used to provide individual language support. I will then demonstrate existing language implementations provided by Oracle Labs using several examples including a simple polyglot web application. Attendees who will bring their own laptops with GraalVM downloaded in advance from https://www.graalvm.org/downloads will have a chance to follow up instructions and get some hands-on experience with becoming polyglot programmers using GraalVM.

Takeaways
• Polyglot programming is made easy using GraalVM (https://www.graalvm.org)
• Combining multiple languages does not undermine performance.
• Want to implement a high performance VM for your language? Use Truffle and GraalVM!

Preparation steps for participants should be as follows:

1) Download GraalVM from https://www.oracle.com/technetwork/oracle-labs/program-languages/downloads/index.html
(in case you run on Windows OS, please use some sort of virtualization technology, e.g. VirtualBox (https://www.virtualbox.org/), to get GraalVM running on your machine, inside a virtual Linux box)
2) After unpacking GraalVM to your computer, run the following command:

$GRAALVM_HOME/bin/gu install R ruby

in order to get R and ruby support installed to your machine ($GRAALVM_HOME stands for the GraalVM installation directory).

In this workshop, I will explain how to build a secure delivery pipeline for your Java application implementing automation security early in the process and building security in the product rather than applying it to a finished product.

After a 20 minutes introduction and explanation of the topic using some slides we will dive in, installing and configuring the required software components one by one and see how, at each stage, the pipeline is able to detect different problems offering you the ability to solve them early. We will be using Jenkins as our CI solution and on top of that we will add the various pieces needed to build our pipeline, including but not limited to static code analysis (SAST), dependencies analysis (SCA) and sensitive information scanning,

You will learn:
• why DevSecOps and continuous security are important
• how embed early in the development process security controls
• what are the commercial and open source tools available for the job

For this session, if you want to take active part you will need a laptop with Java and Maven configured (the one you use to code basically) and where you can install software. It’s okay also to just follow and take notes. You should also generally be familiar with Jenkins.

Class Data Sharing (CDS) helps to improve startup performance and reduce memory footprint by storing preprocessed class metadata on disk and sharing it between VM instances. You’ll learn how to use it, how it works, which improvements you can expect and what the future plans for CDS look like.

Description (links are in Markdown format):

Class Data Sharing (CDS) is a feature introduced in Java 5 to improve startup performance and reduce the memory footprint of Java by storing the preprocessed class metadata of system classes on disk and sharing it between virtual machines. During the last years, CDS has been constantly improved. In OpenJDK 10, CDS has been extended by AppCDS which additionally allows sharing of application classes between VM instances (see [JEP 310: “Application Class-Data Sharing”](http://openjdk.java.net/jeps/310 )

In this talk I will briefly introduce CDS and AppCDS and demonstrate how it can be used. While CDS is well documented, the usage of AppCDS with application classes and custom class loaders still requires a lot of hand crafting so I’ll introduce a small tool which helps automating these tasks. After presenting some memory consumption and performance numbers, I will do a short deep-dive into the implementation details and describe some of the challenges. I will also show how [Strings and Symbols can be stored in the CDS archive](http://openjdk.java.net/jeps/250 ) and shared across VM instances since OpenJDK 9. Finally I’ll detail on some of the latest developments like live archive creation and multiple archive support.

After the talk, the audience should have a better understand of CDS/AppCDS and be able to decide whether it makes sense to use it for their own applications.

Cloud native applications are popular these days. They promise superior reliability and almost arbitrary scalability. They follow three key principles: they are built and composed as microservices. They are packaged and distributed in containers. The containers are executed dynamically in the cloud. But all this comes at a price: added complexity! Suddenly you need to consider important cloud native design principles such as service exposition, configuration, resilience, health checks, metrics, monitoring and tracing.

This session is a comprehensive hands-on guide showing how to develop state-of-the-art cloud native applications with Java EE 8 and MicroProfile APIs. We will start by giving a brief overview of the latest API additions and improvements. Then we will implement, build, package and deploy our first working microservice.

Next, we will dive into the details of implementing enterprise-ready microservices and cover topics such as synchronous and asynchronous service exposition via JAX-RS and JMS, data binding and content marshalling using the JSON-B 1.0 and JSON-P 1.1 APIs, handling state and persistence in a cloud native context, and addressing configuration, resiliency and diagnosability using MicroProfile APIs.

Takeaways

•Basic knowledge of how to design and build cloud native applications using Java EE 8

•Basic knowledge of how to deploy and run Java EE 8 microservices using Docker and Kubernetes

• Hands on experience with the latest APIs and cloud native technologies

Prerequisites for the session

• Basic programming skills and Java knowledge
• IDE with Java and Java EE 8 support (e.g. IntelliJ IDEA or Visual Studio Code)
• Working Java 8 installation. (e.g. https://adoptopenjdk.net)
• Docker for Windows or Mac installed (with Kubernetes enabled)
• Payara Micro Docker Image (docker pull qaware/zulu-centos-payara-micro: 8u181-5.183)
• Git Client (e.g. SourceTree or any console Git client)

What is the right attitude when facing performance issues, with technical examples from personal experience.