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.
How would you like to run integration tests on the exact docker container you are already building and pushing into production?
With the use of Testcontainers, this becomes reality. No longer do you have to mock your way to success! Testcontainers allows you to use the same container environment you would use in production. Sleep well at night knowing you’ve tested your real application.
Work in the field of automated driving and autonomous mobility requires many multi-faceted processes incorporating a variety of software tools. In particular, any software that will be used in a vehicle must undergo rigorous testing, increasingly including vehicle and traffic simulation, as part of the verification and validation (V&V) strategy.
The Rust programming language is an amazing step forward. And it is designed to eliminate a good portion of programming errors, already during compile time. It is a language designed for systems programming, and that makes it so valuable in the context of embedded software development.
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.
Since 2014, the Eclipse Foundation has been invited to join European Research projects to assist them in dissemination, community building, and OSS best practices. Today, we are directly involved in several EU projects and are in touch with several others who are interested in joining our dynamic community. Some of these projects are just starting, others are in the middle of their timeline and one is finishing in December 2019. Each of these projects has or will have an Eclipse project created on our forge.
Understanding the economics of the cloud
Problems with JVMs not designed for running on the cloud (slow startup, over resource utlitization)
Explain OpenJ9 and its background
Live demo of OpenJ9 being compared to other popular JVMs
Ways to tune openJ9 for better performance
Going through the different types of tuning; startup, throughput, resource utilization
Deeper cut into OpenJ9's architecture
OpenJ9's roadmap over the next year
This session will give you an update on many of the new features that have been added to Eclipse Platform in the past year. Eclipse now successfully ships with the new release cadence every 3 months, so we will cover the feature set of the past 4 releases.
The new release cycle has also some impact on the development process of Eclipse projects. We will give our learnings on these impacts from the Eclipse Platform’s view point.
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.
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 behavior changes resulting from moving an application from running on Java 8 to running on Java 11 and 12.
The OSGi Alliance via enroute.osgi.org and bndtools.org teams have spent a number of years focused on improving support for OSGi development in Maven. This talk will demonstrate the latest innovations demonstrating features such as quick setup, minimal configuration, use of bundle annotations, BOM support, integration testing, assembly and running, live coding, dual OSGi/JPMS library development.
The OSGi Alliance has developed a specification describing integration between OSGi and CDI. The combination of these two powerful development technologies opens the door to new possibilities. This talk will walk through the most essential features of the specification and show some code and running examples.
In an ever increasing race to increase scalability, reduce configuration and decrease hosting costs “Serverless” computing promises to run your business logic “on demand” without the need for fixed infrastructure. As a dynamic, modular platform OSGi makes an ideal platform upon which to deploy your serverless functions. Furthermore, OSGi’s Requirements and Capabilities model allows for more complex serverless functions to be dynamically assembled and deployed in response to incoming events.
In the search for a convenient, flexible and extensible OSGi deployment model for use by Apache Sling, the Apache Sling Feature model was created. Over the past 2 years this Feature Model has been taking shape in the community. The components developed include the model itself with a JSON serialisation, analysers that can check models for semantic consistency, and a Maven plugin that supports various tasks, such as producing minimal Docker images based on model definitions, and creating model aggregations.
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?
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.