Despite the huge number of studies carried out and tools developed for role oriented programming and concurrent programming, there are only a few studies addressing the interoperability of concurrent objects in concurrent contexts.
The OSGi framework, and the service specifications, is a powerful and simple way to build modular software. However writing modular software is hard and even a simple framework doesn’t necessarily make things easy, especially when you are writing an application server consisting of over 100 discrete features. When that application server needs to dynamically respond to configuration changes, provisioning (or deprovisioning) features as required. Even worse when it has to support Java EE applications which are written with a totally different modularity (cough-cough) model.
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.
This session will walk through several reference architectures that solve common edge and IoT situations. The audience will gain a solid understanding of how to place many popular Eclipse IoT technologies in a software stack and form a complete set of solutions.
Developers are a queer bunch when it comes to marketing. They have developed an amazing smell for 'corporatey' marketing techniques and guess what - they don't like it.
In this presentation we'll turn things upside down - you'll see what a developer can do when he decides to do marketing.
You'll be surprised.
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.
Eclipse Theia is a framework to build next-generation web IDEs, leveraging components such as language servers, debug adapters, and even VS Code Extensions now!
Though all these moving parts may seem confusing, we should first take a look at how it all connects together, and how you can benefit from it when making your solution based on Theia.
In this session, hear how containers are changing the way developers code, test, and deliver solutions. Learn about techniques being designed that will help reduce the knowledge burden and that are beginning to provide dev environments more suitable to the world of cloud native. From new platforms such as Knative and Jenkins X through event-based application architectures to new open source dev tools like Eclipse CodeWind, j
ust writing code is here to stay.
You're given the task of writing a microservice AND providing a documentation in OpenAPI format. You already know that there are two main approaches:
- design-first : write the OpenAPI document (a.k.a. the
openapi.yamlfile) and then generate the code
- code-first : write the code, using OpenAPI annotations, and then generate the OpenAPI document
Which approach do you choose?
I'll compare the two approaches by showing a simple Java microservice implemented twice, once design-first and once code-first.
Talking with clients and team members about chalenges for testing the conversation is often steering in the way of regression testing. This talk is for everyone who feels regression testing is challenging.
"How do we keep up in a 2 weeks sprint cycle?"
"How can we be sure everything works as it used to?"
"Agile is not an option because we need to execute our 500 test cases before every release."
Liberty Bikes is a four player, elimination game built using the latest technologies of Java EE 8 and MicroProfile 3.0. Come build your first (or 100th) microservice as you create an AI to compete in a battle royale against your fellow attendees. In this lab, you will develop a complete microservice, leveraging MicroProfile Rest Client to seamlessly integrate and communicate with an existing application. Can you become champion of the grid?
We've been talking about the concept of an API Economy for a while now. Over the past few years we've seen most software products move away from individual installations, into the Cloud, providing a "software-as-a-service" model for the consumption of their features. When one starts refering to software as a service, APIs become indispensible.
Programs involving communication over a network are the best examples of asynchronicity. Once a request is sent over a network, waiting for the response by blocking is bad design. Instead, programs must be able to execute other code fragments during this wait period. This design is particularly essential in web-servers. How can we achieve this? Non-blocking IO is the answer.
The target audience are Software Engineers and Architects that have a basic understanding of Java, containers and the cloud and are keen of sustainability.
I will take a very simple example Java application and demonstrate how it can be refactored to adhere to cloud native principles. Thereby, I will focus on aspects that are relevant for making the application more sustainable: More flexible usage of resources.
This session will guide you through the creation of a custom Eclipse Dirigible stack for production purposes:
- Prepare a project structure
- Add the required dependencies based on your scenario
- Add your custom Java modules
Xtext is the de facto standard framework for the development of sophisticated domain specific languages (DSLs) in the Eclipse ecosystem and beyond. Even though the framework already provides a buckload of important features, we won’t become tired rethinking the architecture at scale or smaller features in isolation. Since Xtext version 2.20 is in the works, it’s about time to unveil a few of the planned features and work items.
JHipster is a development platform that allows to generate, develop and deploy Web applications leveraging on some of the best Open Source technologies.
The server-side can rely on frameworks like Spring Boot, Hibernate, Liquibase, Elastic Search, etc. and provide a REST implementation without doing any work. For the frontend, it can scaffold your project using your preferred UI framework (Angular, React or Vue) and building a basic (but working) UI. It supports several types of authentication and brings along with it profilation and many other facilities.