Jakarta EE / EclipseCon Europe 2019

A quick overview of new features in JDK 13, along with the state of development of JDK 14 and JDK 15. Learn more about new preview Java programming language features in JDK 13 like switch expressions and text blocks, followed by the benefits of dynamic CDS archives and the state of development of JDK 14 at rampdown. We'll discuss JEPs, major RFEs, as well as other changes of interest in those releases.

Speaker:
Dalibert Topic

With the advances in multicore hardware and virtualization technologies, and the demand for highly responsive, resilient, and elastic systems and increasingly sophisticated applications, an array of reactive data stream processing libraries have been born to address the needs. The OSGi Alliance has published the Push Stream specification with a simple streaming API that depends on the OSGi Promises, but without any other OSGi specifications and framework dependencies. At the same time, how does the PushStream API compare with the other popular streaming libraries, such as the ones that are based on the Reactive Streams specification, namely, Spring Reactor, Reactive Extension (Rx)'s Observables, and Akka Streams?

This presentation will go into some details on how streams leverage on the underlying multicore processor to achieve parallelism. It will then explain the push vs the pull streaming model. It will then use a simple use case with code examples to illustrate the different API usages, as well as runtime processing analysis between Push Streams and Reactive Streams.

Speaker(s):
Mary Grygleski (IBM)

IoT is evolving really quickly while the industry is holding back because of (cyber) security and thus requiring on-premise deployments. To create an industrial IoT platform, the concern from the industry has to be addressed. A lot of IoT platforms are available from public cloud providers which makes them unusable.

Eclipse IoT projects enable to build an IIoT platform which can be deployed anywhere, from a private, airgapped installation on a bare metal server to private or public clouds. In this talk, we will show how we used Eclipse IoT projects like Hono and Ditto to build a flexible solution for our customers. We will show how we use kubernetes as a runtime environment going from small single server installations to larger multitenant installations.

Speaker:
Bob Claerhout (Aloxy)

Interview with Sven Erik Jeroschewski (Bosch Software Innovations) and Philip Heisig (Dortmund University of Applied Sciences and Arts) about the APPSTACLE project and the Eclipse KUKSA project.

https://www.eclipse.org/kuksa/

Eclipse Kuksa unifies technologies across the vehicle, IoT, cloud, and security domains in order to provide an open source ecosystem to developers addressing challenges of the electrified and connected vehicle era. The platform is supported by an integrated development environment as well as an app store where device owners can select and install applications.

EclipseCon Europe 2019

In this talk, we report on our general experiences in migrating an industrial automation tool to the Cloud using Eclipse technologies. We provide details on the used components such as LSP, GLSP or Theia and discuss the architectural considerations which were required to achieve our goal of developing a Cloud-based IDE. Last but not least, we will give plenty of live demos to demonstrate several aspects of the migration.

At logi.cals GmbH, we began our journey towards a Cloud IDE with logi.CAD3, a commercial, Eclipse-based engineering tool for industrial automation that enables users to conveniently develop industrial automation applications for Programmable Logic Controllers (PLCs). Alongside many other functionalities, logi.CAD3 provides feature-rich editing support for the programming languages defined in the IEC 61131-3 standard. This industry norm not only includes textual programming languages, such as Structured Text (ST), but also graphical languages, such as Function Block Diagrams (FBD).

Speaker:
Rainer Poisel (logi.cals GmbH)

Currently, most Scala developers use Intellij IDEA as their main tool to write code. While it is a wholesome and tested solution, it might not suit everybody’s needs. A lot of people are using Eclipse as their editor of choice and the current solution, Scala IDE that is based on Eclipse, is no longer actively maintained.

Metals is a Language Server Protocol (LSP) implementation enables users of Eclipse to enjoy rich IDE capabilities such as code completion, rename, diagnostics, goto definition and more. We are working on creating a plugin that easily integrates the Metals into Eclipse LSP4E and we would like to show exactly how it works and why we think it's a superior solution. Metals is open source and available at https://github.com/scalameta/metals, where it is maintained by the Scala Center, VirtusLab along with contributors from the Scala community.

Speaker:
Tomasz Godzik (VirtusLab)

Eclipse MicroProfile is a collection of community-driven open source specifications that define an enterprise Java microservices platform. The open source approach of MicroProfile removes reliance on any single vendor’s release cycles and makes the development of microservices a natural extension of Java EE developers existing skill sets.

This session gives an introduction to Eclipse MicroProfile and the tools available to get started building portable microservices with a minimum of effort. The features of MicroProfile will be in explained and demoed live in a down-to-earth and easily understandable way.

Speaker:
Ivar Grimstad (Eclipse Foundation)

Modern microservices applications need to be able to adjust to change. It doesn’t matter whether these changes concern functional requirements, fluctuating load, or more frequently network and service failures. The system should be able to remain responsive in every situation as defined in the Reactive Manifesto. The reactive programming has recently become a popular programming paradigm. In the Java world, there are already a few options the users can choose from when creating reactive applications like Reactive eXtensions or Reactive Streams. In this session, we will introduce a new set of APIs created under Eclipse MicroProfile called the MicroProfile Reactive Streams Operators (the manipulation of Reactive Streams) and the MicroProfile Reactive Messaging (the development model that allows CDI beans to produce, consume, and process messages) together with the rationale why they are needed in the MicroProfile portfolio and a practical live coded demonstration.

Speaker:
Martin Štefanko

EclipseCon Europe 2019

Organizations have complex application environments that include multiple deployment infrastructures, tools, languages, and frameworks, making task, tool and training management a challenge. Having a robust, flexible, future-proof unified application environment in which existing and new applications operate and function across highly-distributed platform is essential. Red Hat Middleware supports a powerful, unified application environment with capabilities that have been engineered together to develop, deploy and cost-effectively run hybrid and multi-cloud business applications at scale, supporting IT and business leadership concerns. Come and learn how you can improve operational reliability, developer productivity with a flexible application environment by Red Hat that supports hybrid and multi-cloud deployments.

Understanding of containers, container orchestration technology, application services and middleware is a pre-requisite.

Speaker(s):
Cesar Saavedra

Save the dates:

ECE 2020: 19-22 Oct, Ludwigsburg

Java based software development has been a winning proposition for the past 20+ years, however, cloud native application development in the form of microservices and serverless apps are challenging the Java deployment model in terms of memory requirements and start up speed. Quarkus is a Kubernetes native Java stack that can tailor your application for GraalVM & Hotspot providing amazingly fast boot times and incredibly low RSS memory usage, making Java great again in this new Cloud Native Era.

Come to this talk to learn about Quarkus, what it brings to the table and how you can get start started with it. Quarkus is built on popular de-facto and standards-based technologies including Eclipse Microprofile.

Speaker(s):
Dimitris Andreadis

Creating cloud-native microservices is common, but which programming model to choose from.

At the moment, MicroProfile and Spring are two popular programming models for developing microservices. What are the differences or commonalities between them?

This session is to focus on comparing the two programming model side by side. If you are Spring developer, after this session, you should be able to grasp MicroProfile very quickly and vice versa.

This session also contains a quick demo of developing a Spring microservice and MicroProfile microservice and then deploy them onto Open Liberty.

Speaker:
Emily Jiang

I'm an OpenJDK developer (http://openjdk.java.net/census#clanger) and seemingly one of the few people in this comunity that use Eclipse JDT for developing the Java libraries of the OpenJDK. So, I'll show how the Eclipse JDT can be set up for Java Development in the OpenJDK. The current status of this work can be found at this link, by the way: https://github.com/RealCLanger/OpenJDKEclipseProjects.

I'll tell a bit about the journey of how to get to a working setup which included fixing bugs in both, Eclipse JDT and the OpenJDK. I'll also share my visions of what could/needs to be added to have an even better development experience for OpenJDK developers.

Attendees that are inclined to OpenJDK development will walk away having learned how to set up the Eclipse development environment for JDT. Other attendees that are just interested in experiences with the Java Platform Module system (JPMS) will hopefully improve their knowledge about organizing JPMS projects with the Eclipse JDT.

The level of knowledge I would presume is a basic understanding of the Java Platform Module System that was introduced with Java 9.

Speaker:
Christoph Langer

Do you want to implement a diagram editor in the web or even in an augmented reality? This talk is for you!

Web-based and browser-based tools pose new challenges to the architecture of language support.
The language server protocol (LSP) has become very popular for text-based editors. Separating the UI of a tool from the actual language logic provides great flexibility on the client and server side.
The Graphical Language Server Protocol (GLSP), a new Eclipse project, follows are very similar approach to enable the same benefits for graphical, diagram-based editors. In this talk, we introduce the overall concept, demonstrate the existing GLSP editor client based on Sprotty, explain how to implement your own GLSP server and therefore, your own diagrams. Additionally, we highlight how and when to use the approach in your custom tool and how to embed it into Eclipse Theia.
Finally, we showcase the flexibility of the approach by rendering diagrams, which you might have never seen diagrams before, on an AR device in space :-)

Comment for PC: GLSP has very recently been accepted as an Eclipse project. As the initial contribution is already pretty comprehensive and mature, we plan to have available releases before ECE 2019.

Speaker(s):
Philip Langer (EclipseSource)
Martin Fleck (EclipseSource)

This Annual Meeting is a place to learn more about the operations and community activities, and to learn more about membership-related activities and benefits.
Of particular note this year, the agenda will include the proposed updates being considered by the the Board of Directors the Eclipse Bylaws and the Eclipse IP Policy. These Bylaws changes will need to be ratified by the Membership At-Large.
Agenda
* Welcome - Paul White
* Executive Director’s Update - Mike Milinkovich
* Governance Renewal - Mike Milinkovich
* IP Due Diligence Process Changes - Wayne Beaton
* Projects Update - Wayne Beaton
* Working Groups Update - Paul Buck
* Marketing Update - Thabang Mashologu
* Ecosystem Development - Gael Blondelle
* Research @ Eclipse Update - Philippe Krief
* Member Services Update - Paul White / Perri Lavergne
* Q&A

Edge computing is all the rage right now. Some people even say it is more important for the future of IT than cloud computing itself. Is this real, or is this just hype? In theory, edge computing helps solve the challenges of bandwidth, latency, resiliency, and data sovereignty. Those benefits, however, will be hard to realize in the real world if you rely on a platform built by people just riding a wave. You need a real platform with real users, rooted in lessons from the trenches.

In this session, you will discover Eclipse ioFog and understand how it will help you reap the benefits of edge computing. You will also see a live demonstration involving the deployment of microservices to an Edge network using Kubernetes and ioFog.

Speaker(s):
Todd Papaioannou (Edgeworx, Inc.)

Please give us a detailed overview of your session and why attendees will be excited to hear about it.

After giving an Intro to Reactive programming- Starting from going over basic tenets of reactive system, why we need it? with real life examples. How are major languages providing support?

I will in details talk about how is Java making it easier to start with reactives. Presenting Java-based reactive frameworks and toolkits in the market today.



Ensure that you let us know:

What level of knowledge should attendees have before walking into your session
Java Basics

What will your session accomplish and what will attendees walk away having learned
A new paradigm feather to your hat.

Speaker(s):
Jayashree S Kumar

In this session, I would like to take you with me on the journey on why and how we built gitpod.io, an online IDE based on Eclipse Theia. It includes:
* why we started
* how we wanted to be different from the Eclipse IDE
* how we integrated Theia
* how Theia can be developed using gitpod.io
* how we integrate with Kubernetes
* why we decided to embrace "dev environment as code"
* our initial architecture and how it evolved over time
* how the architecture allows for new exciting usage patterns that are impractical on the desktop:
prebuilt workspaces, shared workspaces, parallel workspaces, and disposable workspaces.

Speaker: Moritz Eysholdt (TypeFox GmbH)

The Eclipse Foundation’s IP Policy and procedures date back to 2004. Our policies and processes have gradually evolved over time; however, our current due diligence review process for third-party dependencies no longer supports agile development or continuous delivery. Additionally, it is becoming impossible to scale our current processes to modern day technologies such as Node.JS, NPM, etc.

As a result, the Eclipse Foundation is making significant changes to its policies and procedures to address these issues. This talk will walk you through these changes in order to identify the overall benefit to Eclipse Committers and Eclipse Projects.

While this talk will be particularly interesting to Eclipse Committers as they learn about “What’s Coming (Our Modernization Plan for IP Mgmt)”, this talk will also be of interest to anyone who wishes to learn more about IP best practices and how the Eclipse Foundation is moving to a license compliance model for third party dependencies!

Speaker:
Sharon Corbett (Eclipse Foundation Inc.)

There is a new platform in town: Kubernetes. And it is establishing itself as the common denominator for public and private clouds with unprecedented momentum. This talk explains its core concepts, architecture, how to use it and how to run apps in Kubernetes. It also demos the main benefits, such as self-healing, scaling-up/down and rolling out updates of your application without downtime. Also, I will give an overview of availability in public clouds and the massive ecosystem around Kubernetes, including tools and workflows relevant for developing and deploying applications to Kubernetes.

Speaker:
Moritz Eysholdt (TypeFox GmbH)

Everyone deploying an OSGi bundle on a running system will have encountered a Resolution failed exception, due to some missing import packages. Although it may seem as a pain in the ass, the OSGi resolver can actually make your life a lot easier when used properly. In this talk we will go through the process of resolution, explain the requirement-capability model, and show how you can automatically assemble your application by using the resolver at build time. It's time for the re(s/v)olution!

Code examples of the talk available at: https://github.com/tverbele/resolution

Speaker(s):
Tim Verbelen (imec)

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. No matter your project size, you can take it to the next level today.

Speaker:
Werner Keil

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 needed? 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. No matter your project size, you can take it to the next level today.

///GET SOCIAL!
Subscribe: https://www.youtube.com/user/EclipseFdn
Follow us on Twitter: https://twitter.com/JakartaEE
Like us on Facebook: https://www.facebook.com/JakartaEE/
Join us on LinkedIn: https://www.linkedin.com/groups/13597511/
Tag us: #JakartaEE

Want more great Eclipse Community webinars?
Become a member of our Jakarta Tech Talks Meetup:
https://www.meetup.com/meetup-group-DAaStLqu/

We have finally made some real progress with Jakarta EE in 2019! Specifications, APIs, TCKs, Maven artifacts, Implementations, Releases, and, yes, even a little bit of required process. If you want to get caught up quickly on all of the activities, this session is for you. We will discuss the potential impact to both implementors as well as application developers as we move away from the JCP-defined javax world to the open-source world of Jakarta EE.

Speaker:
Kevin Sutter

Are you a Java developer wondering what it means to have your application running in the cloud. This session will provide a peek into how the JVM is adapting to running in the cloud and what Java developers need to be aware to ensure they get the most of running in the cloud.

The session will pick an example spring application and tune it stage by stage at the end of which we have an application that is fully optimized and takes advantage of every aspect of the running in a cloud.

It includes the following stages

- Tuning your Java app build process to generate the smallest possible docker image
- Tuning your Docker image for fast startup
- Tuning your Docker image for throughput vs resource usage
- Tuning your Docker image for when the App is idle
- Tips for debugging Java applications in a kuberenetes cloud

This will include github based on demos wherever appropriate. If you are a Java developer or an IT admin looking to deploy Java apps to the cloud, do not miss this session !

Speaker(s):
Dinakar Guniguntala

This talk provides an overview and a state of the nation for JVM directions from a Cloud perspective

It will cover the various technical and economic challenges being placed upon modern Java Virtual Machines and how there challenges are being tackled. From serverless to super-large clusters, from small devices to new hardware, from containers, VMs and even baremetal : The JVM of today has so much it has to do and , as we're finding out, multiple ways to get there. Even the way we develop code is changing for cloud and the JVM has a part to play in making the developers life (and tools) better.

This session will celebrate the open source projects that are doing cool stuff with JVMs and pushing the boundaries on the art of the possible. From new things in OpenJDK, amazing things with GPUs, practical things with OpenJ9 , different directions with Quarkus and left field technologies such as Dockers CRIU.

Objective of the presentation:
Some say Java's dead, others that it's just resting. In fact it's exactly the opposite. Java and the JVM are moving into brave new worlds. This talk will explain why and how JVMs are being stretched, twisted and reformed to meet the new workloads that make up the modern challenge of Cloud.

Speaker:
Steve Poole

Today I will discuss a curious collection of Java code snippets that do have surprising, amusing or simply confusing results. If you ever wanted to test your knowledge about Java, feel free to accept the challenge and come to this interactive session of puzzling pieces of code.

The presented examples are partly taken from the infamous books “Java Puzzlers” and “Effective Java” as well as from a backlog of interesting bugs that I have chased in the past. As a grain of salt, I also added a few findings about Java that came to my attention when building Xtend and the Java integration for Xtext in general. If you just keep digging, you cannot avoid the Balrog of Java semantics.

But the real question is: Are you brave enough to accept the challenge and come to this talk to solve a bunch of riddles?

Speaker(s):
Sebastian Zarnekow

The use of Serverless computing has reached a point where any serious company would be foolish to ignore its cost savings and other benefits against a wide array of proven use cases. From API Management, Artificial Intelligence (AI) and Cognitive to DevOps, Mobile and the Internet-of-Things (IoT), Serverless is proving itself as an accessible means for efficiently processing and transforming data in large volumes, on-demand, with little or no operational considerations for developers. As Serverless adoption increases, what are the considerations and implications for the Java developer and as a language going forward? We will explore this question from the perspective of the speaker, who was an early Java fan and developer, but whose path diverged to projects that used other popular languages and today serves as a Serverless technologist who understands the mind-set and expectations of Serverless developers.

Speaker:
Matt Rutkowski (IBM)

The purpose of this presentation is to show to attendees the problems you might face when deploying services into Kubernetes, usually when you are coming from a monolith architecture and how you can face all these problems using Eclipse MicroProfile spec. The talk is focused on fixing specific problems you might encounter when deploying to Kubernetes.

Kubernetes is becoming the de-facto platform to deploy our application nowadays. But this movement also implied some changes on the way we code our applications, where we just develop a monolith application where everything was up and running up front, now we are breaking down this monolith into (micro)services architecture. Although it might seem easy, done properly is not an easy movement as there are some challenges to address that were not there before, at monolith architecture time. In this session, we’re going to start discussing what are these challenges (ie fault tolerance, service discovery, open tracing, or health checks) and demonstrate how they can be solved using the specifications within Eclipse MicroProfile in a vendor-neutral way.

Speaker:
Alex Soto (Red Hat)

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. JAX-RS is the right choice for professional Microservices, and this talk shows why.

The speaker, a former JSR 339 and JSR 370 expert group member, is one of the most active committers to Jakarta's REST API, authored most of the features demonstrated in this presentation, and knows JAX-RS since more than a decade. So this is talk is the definitive source to learn about the latest features.

Speaker:
Markus Karg

Learn from a Bootstrap team member how you can take your career to the next level.

During this presentation, you will learn how you can begin a career in the open source world, starting from scratch until becoming a core committee of some of the biggest projects in the world.

You will learn:

How to find your community;
What tools do you need to know;
How to take your first steps;
What are the different ways in which you can participate;
How to turn your hobby into your future work.
Once you know the secrets of the open source world, your career will skyrocket!

Slides (External URL):
https://speakerdeck.com/andresgalante/open-source-eclipsecon
Objective of the presentation:
Motivate people to contribute to open source project and show them the tools and ways there. this talk is based on this article: https://alistapart.com/article/make-something-great-become-an-open-source-contributor/

Speaker(s):
Andres Galante

Eclipse Che introduces a new kind of developer workspaces that are running directly on Kubernetes and accessible through a web based IDE. And the new version of Eclipse Che 7 supports a codified definition of developer tooling needed to work on a project, called “Devfile”.

Until now Eclipse Che workspaces are created and managed by a single central server that also manages authentication, user-management,monitoring, tracing, workspace management UI... but of course requires a database, authentication server, and a significant amount of resources.

Thanks to the Kubernetes operator framework it is now possible to start and manage Che developer workspaces directly with Kubernetes. Starting a workspace can take as little as a standard Kubernetes command. Fully-featured Che workspaces can now be started in a standalone and very lightweight way, without any central server, dedicated database and authentication server.

When Che workspaces are started this way, it makes simpler to reuse the common infrastructure services (authentication, routing, monitoring) provided by the underlying Kubernetes platform.
In fact it allows Che 7 workspaces to become components that can be integrated into broader solutions more easily - in a very lightweight manner.

In this presentation we will showcase how the new *Che Workspace Operator*, still in early development, allows:
- Defining a Che workspace as a simple Kubernetes custom resource that leverages the
user-friendly "Devfile" syntax,
- Starting / stopping this workspace with a single kubernetes command, or from the Openshift
OperatorHub user interface.
- Enhancing a workspace with services provided by the underlying Kubernetes platform such as
authentication
- Integrating a workspace with third-party Kubernetes components

Speaker:
David Festal (Red Hat, Inc.)

The objective of this presentation is to share many invaluable tips & tricks that will allow the developers to better use the Eclipse IDE and be more productive in their routine development tasks. It will include productivity tips & tricks along with some new features in Eclipse IDE and tips for the latest Java releases.

Eclipse IDE provides a lot of powerful features and capabilities. With so much functionality at disposal, many users don't use the full potential of the IDE. To be productive, mastering your IDE is as important as mastering your source code.

During this talk, you will have many "Ah, I didn't know Eclipse can do that!" moments.
Some of the examples include:
* Determining who last modified a line of code and when, plug-in spies
* Popping up an in-place outline of the element at current position
* Bookmarks and Tasks
* Grouping, sorting and sharing breakpoints
* Trigger points and trace points
* Tagging and filtering JUnit Jupiter tests
* Finding the functional method from lambda expressions and method references
* Quickly adding the missing module dependencies
* Identifying the inferred type for ‘var’
* Quickly enabling preview features and working with latest Java constructs like switch
expressions

Speaker:
Noopur Gupta (IBM)

Nowadays microservice infrastructures are widely used. OSGi is a very good choice realizing such projects. But somehow there is a missing link to show how existing build and deployment tools work seamlessly together with OSGi applications.

The talk shows an exemplary, existing OSGi application for managing traffic-information. This application runs in a Docker-based environment, with additional other services. You will learn, how OSGi a perfect base in this scenario, without having a OSGi only infrastructure.

No matter if your challenge is to connect your OSGi application to a messaging system like RabbitMQ or MQTT or a database cluster like Mongo or Influx. Beside that, the talk will also cover topics e.g. using OAuth with the JaxRS Whiteboard or distributing your services over different machines using the RSA. Especially when it comes to application configuration, it is important to fit the needs of container-based infrastructures, to be able to run the OSGi application in these environments.

Based on a real-world application, you will get an idea, why OSGi perfectly fits in those use-cases, with no magic involved.

Speaker(s):
Mark Hoffmann (Data In Motion Consulting GmbH)

Many people have the feeling or experience that OSGi is hard to use as a developer. Most of this comes down to either the modular classpath or the dynamic nature of OSGi. This talk shows best practices for coping with those special properties of OSGi in an elegant and simple way.

Some highlights:
- OSGi class loading is easier than you think
- Creating bundles with zero configuration
- How to avoid the need for start levels and still get proper ordering on startup
- Loose coupling and easy application assembly. Can both be achieved?
- Hidden gems in declarative services

Speaker(s):
Christian Schneider (Adobe)

EclipseCon Europe 2019

In this talk, we’ll have a deep dive into MicroProfile OpenTracing, discussing the key points of the specification, including naming conventions, the @Traced annotation, the ability to add explicit instrumentation in business code or even extend scope of tracing by adding OpenTracing compatible instrumentations. We’ll then build a simple MicroProfile application with the MP-OpenTracing module and see how the reported telemetry data looks like in Jaeger an OpenTracing compliant distributed tracing system. Finally, we will talk about the successor project - OpenTelemetry and more advanced topics like tracing in service meshes and multi-cloud environments.

Speaker:
Pavol Loffay

Jakarta EE with MicroProfile is the platform of choice for building applications for private and public clouds. The nature of microservice architectures allows significant design and architectural shortcuts. The code reduction increases the productivity and shrinks the codebase at the same time. In this session, I'm going to code a few microservices "from scratch" and explain the design choices on-the-go.

Speaker:
Adam Bien

Interview with Estibaliz Arzoz Fernandez (Trialog) about the project PDP4E

https://www.pdp4e-project.eu/

Communications is error prone. Connections time out, servers fail to respond, returned data can be incomplete or corrupted. Bnd, the OSGi tooling project, has an HttpClient class which is used for communications including with remote repositories like Maven/Nexus and P2 repositories. The Bnd CI builds started having significant failures due to communications problems with the Eclipse download servers, so with some light code restructuring, I was able to add retry support to HttpClient using the Promises package from OSGi. This session will take a look at the Promises package and how it was easily used to recover from communications failures.

Speaker(s):
BJ Hargrave (IBM)

In order to reduce technical debt and maintenance cost, it is important to measure code quality, visualize critical components, identify disharmonies, low and high-quality code parts. Analysing and measuring overall software quality is challenging. The presentation gives an opportunity to attendees about how to easily analyse overall software quality and architectural quality insights by demonstrating case studies on some open source projects by using Eclipse plugins.

Speaker(s):
Ural Erdemir
Sinan Eski

Testing OSGi applications is a little different from other platforms. This talk aims to get people started with testing on OSGi and provide an overview of the options as well as practical examples.

**Unit testing**

Testing starts at the unit test level. Every project should have a good coverage by really fast tests ( under 10s for all tests). The talk will show practical cases of unit testing declarative services based code and how to shield your business code from OSGi API. We will also look into some typical pitfalls.

**Integration testing**

There is a variety of integration testing frameworks for OSGi. We will look into some of the frameworks (pax-exam, karaf testcontainer, bnd tests) and give advice which to choose in your environment and which best practices to follow. One hidden gem is how to debug OSGi tests without remote debugging and without a manual build.

**System testing**

As last part the talk shows how to package your OSGi application in docker and do a system test on docker level with the help of the testcontainers framework.

Speaker(s):
Christian Schneider (Adobe)

In this talk, we will show our initial findings and the methodology for answering the long-standing question if adhering to the best practices of modularity in OSGi has a provably positive impact on the quality and sustainability of software development.

We discuss several software quality metrics that we identified as good indicators for this research and how OSGi can have an impact on them. We then present our initial findings on the impact of OSGi on real-world software projects that we determined by a broad empirical study of code available from open source projects. We additionally discuss the added value of the service model, which is adopted by some but not all projects that have adopted OSGi.

Attendees of this session will learn about the practical benefits of OSGi and to which extent an investment into a stricter programming model like OSGi's modularity pays off in the long term. Familiarity with the OSGi module is expected, but practical experience is not required.

Speaker(s):
Jan S. Rellermeyer (TU Delft)

For the last several years, cloud-computing related architectures and technologies have dominated open source projects. And, these projects will continue to remain strategic for quite some time.

However, AI is quickly becoming the most important and impactful technology for our next decade and beyond, and it is reshaping everything from how we architect and construct computing platforms to where and how we run software and process data. This means that we need a new generation of open platforms and open source software to support a world of pervasive intelligence.

Huawei has been creating such a next-generation set of technologies, from new AI computing chipsets and processors to microkernel distributed operating systems to next-generation AI frameworks and tools to AI-enabled software and services. And, Huawei is opening and contributing all of these technologies as the next wave of open for an AI-everywhere world.

Objective of the presentation:
To share current status and future trends of open source development in China and at Huawei

Speaker: BRYAN CHE

Executive Director Mike Milinkovich's annual talk on what's going on with the Eclipse community and with the Eclipse Foundation

How can you make different pieces of your unit of work consistent in the distributed setup of your micro-service application? You associate the term transaction probably with a database, but the data source can be anything including a database in the micro-service world.

The MicroProfile Long Running Actions specification is based on sagas and the OASIS LRA transaction model specification. It defines the framework to guarantee the eventual consistency requirement using compensating actions for example. This session will explain to you the challenges and concepts of the MicroProfile LRA framework. And of course, you can see it in action with various demos.

Speaker:
Rudy De Busscher (Payara Services Limited)

Java Modules are here to stay, and ignoring them in your code is gradually becoming impossible.

On the other hand, no-one should expect to arrive in a 100% modularized nirvana any time soon. The Java community will live in a muddled world, that's no longer here but not yet there, either, and this for some time to come. In this period, he is king who brilliantly masters the available tools for tweaking modularity.

This presentation will go in three stages:
(1) Re-iterating the rules for a legal modular application.
(2) Explaining the different flavors of modules, including system modules, automatic modules and unnamed modules.
(3) Presenting in depth all those options that JEP 261 defines for the explicit purpose of tweaking a modular application.

In particular, stage (3) will show-case a completely revamped UI, which JDT provides since 2019-06. Finally, we'll spend a few moments on the correspondence between build time tweaks and runtime tweaks.

Speaker:
Stephan Herrmann (GK Software SE)

Java agents are a little-known but extremely powerful part of the Java ecosystem. Agents are able to transform existing classes at runtime, allowing scenarios such as logging and monitoring, hot reload or gathering code coverage. However, their usage presents a number of pitfalls as well.

In this talk we will present the steps of writing a java agent from scratch, indicate various common mistakes and pain points and draw conclusions on best practices. Special care will be taken to discuss how running in an OSGi environment affects Java agents and how we can best approach integration testing in a modular environment.

After this talk participants will have a better understanding of the Java instrumentation API, how it fits in with OSGi runtimes and about should / should not be done with it.

Speaker(s):
Robert Munteanu (Adobe)

This presentation shows how easy and fast it is to create a graphical modelling workbench based on Eclipse Sirius and to deploy it to the cloud.

Sirius is a well-established Eclipse project to create graphical modeling workbenches as quick as a flash. The technology has been used in production for more than 10 years and led to the creation of an impressive number of graphical modelers. The Sirius website gallery demonstrates 45 of those workbenches recorded over the years and a new era is starting now that we can such deploy tools on the web.

During this talk we will present :
* how to define your domain based on EMF and Ecore,
* how to use Sirius to specify a tooling composed of graphical modelers, trees and form based
editors in a glimpse,
* how your tooling look and behave in Eclipse RCP,
* how you can deploy from the same definition, your tooling on the cloud,
* a demo of the capabilities of the resulting web modeling workbench.

We will walk through the features available on this modeling environment as of the latest Sirius release through a demo and then present the roadmap.

Speaker:
Melanie Bats (OBEO)

Migrating a tool to the web or implementing a web-based tool chain from scratch is not like upgrading to a new Eclipse version. It is a major shift and requires a good strategy to be successful. While most talks at developer conferences directly dive into how to implement a solution, we take one step back and talk about developing a good strategy first. Based on our experience from observing several real world application projects we try to provide good guidance for questions such as:
- When is the right time to start with such a project?
- What are the first steps?
- How to develop an incremental time-line and how to prioritize the development?
- What are good patterns and best practises?
- Should I reuse or deprecate existing components?

In addition, we also compare the potential benefits of web-based tooling with the disadvantages, as migrating everything to the cloud is not necessarily the best decision for every project. Finally, as we come from a highly technical background, we provide an overview of the available technologies to help you with your endeavors, in- and outside the Eclipse ecosystem, e.g. Eclipse Che, Eclipse Theia, Visual Studio Code, Atom, Eclipse Drigible, and Eclipse Orion. Where applicable, we provide pointers to resources and other interesting talks at the conference to learn more details about such technologies and in general about web-based tooling.

Speakers:
Maximilian Koegel (EclipseSource)
Jonas Helming (EclipseSource)

Are your applications running on Java 8? Thinking about switching your application to run on Java 11 or Java 12 and wondering about where to start? Come to this session to learn about the most significant changes that went into Java 11 and 12 that will impact your application migration. Topics will include the removal of APIs (such as Java EE packages) and behaviour changes resulting from moving an application from running on Java 8 to running on Java 11 and 12.

Speaker(s):
Dalia Abo Sheasha

Join us for the Cloud Native Java Town Hall and BoF. Get the latest news on Jakarta EE, Microservices and meet the working group community. The session was held in a Town Hall format to have an exchange with the community. If you have suggested topics, please add them to the Community Evening wiki.