Functional programming has arrived in Java language and it has plans to stay. In this talk I will introduce Apache Aries Component DSL, a proof of concept functional library that aims to ease the way in which we can interact with OSGi in a composable and safe way.
REST microservices are a powerful tool for composing large-scale systems, and now, with the new features of OSGi R7, it has never been simpler to create a modular microservice. Combining the new features in Declarative Services, the JAX-RS Whiteboard, Transaction Control and PushStreams we can create a simple, transactional, persistent, streaming microservice with a minimum of code and a maximum of function.
This talk will use practical code examples to show how new OSGi R7 features can save you time and effort when building microservices, letting you focus on business logic, not boilerplate.
Smart cities need open platforms and tools to help their local ecosystem to exploit available data from various sources such as IoT devices, legacy devices, social networks, mobile applications, etc. and build innovative applications improving the quality of life and security of their citizens.
OSGi, with its modular and service-oriented approach, is an excellent opportunity to boost open innovation for tomorrow's smart cities.
In this talk Markus will share hands-on project experience for building and maintaining CI processes applicable in small and large enterprises projects.
After a short introduction to the project context Markus will focus on best practices, lessons learned and tools used within automated deployment chains based on state-of-the-art Jenkins pipelines.
Are you tired of null pointer exceptions, unwanted side effects, SQL injections, broken regular expressions, concurrency errors, mistaken equality tests, and other runtime errors that appear during testing or in the field? Do you wonder why every production code base needs its own implementation of money and currency types, physical units, or string processing? Aren’t all these simply indicators for missing features in Java’s typesystem? Turns out they are. And even better: Annotation processing to the rescue - there is a standardized way to fix it!
Writing good code is the most important task of software development and this does not complete without debugging and fixing bugs. The Eclipse Java IDE provides many debugging tools and views for users to debug effectively and efficiently. Eclipse users spend a lot of time in debugging code and every new debugging feature in Eclipse helps the users to be productive in fixing bugs. Debugging in Eclipse Platform and JDT is continuously evolving to provide tooling which can help users debug complex scenarios and spend less time in routine tasks.
In this talk we show you how to customize your personal Eclipse setups in a few clicks and present the newest Profiles for Eclipse features.
We also discuss our thoughts about a leaner user interface for the Eclipse IDE with our Sandbox for Eclipse initiative, and how you can be a part of it using Profiles.
In the latest versions, Tuleap confirms its ALM strategy: providing tooling for all the software teams members: for developers, here are Git Pull Requests, for Project Leads, the Advanced Tracker Query Language, for Agile people, Mattermost Scrum reports.
This talk will explain you how to use these valuable features now available on the tuleap.eclipse.org platform put at all Eclipse projects' disposal.
The Eclipse Modeling infrastructure and tools have evolved to be a de-facto standard in the context of modeling in general: lots of important and interesting systems have been built with Eclipse technologies such as EMF, Xtext, and GEF.
As Eclipse RCP developer, you have different options to create prototypes for your customers quickly.
In this talk, I will share my experience in building RCP applications by using a simple, efficient and extensible technology stack based on:
Data collection, filtering and processing is a growing concern for all sorts of applications. A variety of different libraries have been created, all looking to solve the same sorts of problems. The OSGi Alliance has defined the PushStream with a simple streaming API, but Reactive Streams and Java 9’s Flow API use a the Observable model. Which is better? Do I have to use OSGi if I choose Push Streams? Do I have to choose one library or can I use both?
This talk will describe the basic design differences between Push Streams and Observable streams, showing side-by-side examples using both APIs. It will also show how one stream type can be converted into the other, and back meaning that you can always choose the appropriate tool for the job.
Reactive frameworks allow to implement non blocking asynchronous processing in a convenient way. This talk explores how to apply reactive patterns to typical use cases on OSGi like REST services, MQTT Message processing, computations over sliding windows.
We combine messaging and reactor.io streams like also used in Spring 5 to create services that are highly scalable while not tying the user to the technologies being used.
In this talk we will demonstrate how ThyssenKrupp Steel’s Manufacturing Execution System, which targets the production planning and control of steel plants, incorporates GEF-based views in its Eclipse-based development environment. We will start with a short introduction to the application domain, then demonstrate the relevant parts of the development environment’s user interface, focussing on the diagrammatic views that integrate automatic layout, image export, as well as JSON-based persistence.
How to build configurable, resilient, monitorable Java Microservices? Eclipse MicroProfile (https://microprofile.io/) is the answer. Eclipse MicroProfile has rapidly become a rich set of technologies essential for writing configurable, fault tolerant, secure and production-ready Java Microservices.
Recent and upcoming OSGi specifications such as Promises and PushStreams provide great tools for asynchronous programming in Java. This is particulary useful for programming robots, where issuing a command is inherintly aync from observing the effect. In this talk we will present an asynchronous OSGi service for controlling a Kuka robot. Moreover, OSGi modularity allows us to easily integrate our robot with other systems.
Theia is a new open-source project providing a foundation for implementing integrated development environments (IDEs) not only for software developers but all kind of engineers. Based around a flexible layout engine and by leveraging industry standards such as the “Language Server Protocol” clients shall be able to design rich software tools for engineers that run both as a desktop app and in the browser connected to a remote backend (e.g. in Eclipse Che using containers).
Device connectivity is one of the most common issues IoT developers need to solve. Having an open source solution based on the standardized protocols that solves recurring connectivity problems is a very useful tool to have. Meet Eclipse Hono, a cloud-based IoT connectivity platform which provides remote interfaces for device connectivity and mechanisms for uniform interaction with devices regardless of the communication protocol.
OSGi offers developers excellent tools for creating modular applications. We have come to have a good understanding of the runtime impact of modularity, but less have been spoken of the impact of modularity on the development process.
This talk will discuss the details of moving a large OSGi project from a single monolithic codebase to multiple repositories in terms of the development process. We will present the impact of modularisation on source control, continuous integration, code reviews, IDEs and public discussion on chat/email.
This talk gives an overview of the activities and projects of the Eclipse Science Working Group. The Science Working Group is now three years old and this talk gives a summary of the internation group's efforts to build scientific software at scale together.
This talk describes some of the key projects in these areas. In particular we look at the common data structures project Eclipse January, the 'numpy for Java'. We go into why there is a need for scientific computing in Java, how this project works and how to get involved.