You may know the story: you develop OSGi applications with PDE and you are willing to give Bnd a try, but you can't find access to the different concepts they are using. The reasons to change, can be plenty and the hazards on the way as well. Here you will get a quick view in the world of Bnd with dos and don'ts and an idea on how to migrate your project.
The Eclipse Foundation will be publishing a new version of the Eclipse Public License in 2017. This talk will explore:
- Why was a new version necessary ?
- What are the significant differences between the original and new versions?
- What are the new features of the license that may matter to my project?
- How can I apply the EPLv2 to my existing EPL-licensed project?
The Internet of Things (IoT) revolves around the development, mass-production and deployment of wireless embedded sensor devices. A plethora of prototyping platforms for exploring and developing those sensor nodes exists. However many of those toolkits do not scale beyond prototyping or offer an inferior development experience compared to other domains, e.g. mobile-apps or the web.
Yes, you know this happens in quite a few cases. Like in companies that open source and contribute a significant part of what they create for their own needs - think Google, Facebook, PayPal and the like. Like in companies with a primary focus on an open source product as Mozilla for example. Like in companies that make heavy use of a specific open source platform or tool - and decide to give back through contributing to its development. Or like in working on academic projects funded by public money where the outcome is open sourced. But...
This talk shares our experience about setting up Tycho and Maven. Using Tycho and Maven in your build infrastructure can be very beneficial, but first it needs to be set up. In fact, this is the real challenge. Unfortunately, there is no real state-of-the-art or best practice about how to use this technology. Particularly, only little documentation exists. Most likely this is a consequence of everyone’s individual project requirements and thus not allowing for the one ultimate answer.
Creating good Oomph Setups is not trivial, but from the existing setups in Oomph's default catalogue users can learn much about some advanced features of Oomph. In this session I will show several examples from available Oomph setups that can be used for the definition of own setups. Attendees will learn about multi-project setups, collecting useful workspace preferences, dynamic working sets, launching initial builds after project import, managing modular target platforms and other useful stuff.
Your Sirius designer has the ability to leave a lasting impression on your end users, and every detail counts. In this presentation, you will see the new features to improve the user experience of your own Sirius-based designers.
This talk will start by reviewing how to improve Sirius diagrams with a consistent style guide to quickly communicate your intent to your users and tips and tricks to speed up common tasks.
Software developers spend much of their time exploring the source code of their software systems, seeking to understand how it works and to assess the implications of making a change. But many developers report occasionally becoming disoriented during this exploration, where they become "lost" and are unable to recall what they were doing and why they were looking at some program element. Becoming disoriented is frustrating, and recovering from disorientation is difficult.
One of the basic requirement to enable big-data analytics is a rational and effective approach to data ingestion. In long running projects the need arises to evolve the domain model and this potentially affects data quality. As a consequence, the concept of versioning is crucial to keep data centric systems consistent: the importance of service dynamicity and good modularity support in a sound data ingestion workflow implementation cannot be easily overestimated.
This session is geared towards an audience interested in blockchain technology that would like learn more with a hands-on approach.
First, some background on basic concepts as peer-to-peer networks, mining and distributed consens is provided. Then, smart contracts and the Solidity language are introduced and demonstrated using a local/private blockchain.
The Bndtools project is the foremost IDE for OSGi development, with a powerful workspace model and interactive debug sessions. Historically Bndtools has been opinionated (and restrictive) about how you build your workspace, but with the new releases of bnd and Bndtools 3.4.0 things have changed dramatically.
Using the new Maven plugins from the bnd project you can now get all the bnd goodness you know and love when using Maven, and when using Bndtools you still get incremental building and interactive debug! This talk will walk you through the new Maven plugins from bnd, and how to get the most out of your new favourite IDE.
EMF Forms is a framework for developing high-quality, form-based UIs quickly and easily. The forms support general data entry and modification, be it for business applications or development tools. EMF Forms dramatically reduces the effort of UI development while providing a rich feature set that can handle very complex use cases.
EMF Forms is already widely use by a large developer base in various application domains, but we do not want to overlook potential new developers!
SWT is a cross platform UI toolkit written in Java and is the backbone of the Eclipse platform. This tutorial will offer beginners to SWT a chance to use their Java skills in order to build a meaningful SWT application.
The tutorial will be run by two full-time SWT contributors and will offer:
CDI is a cornerstone of JavaEE development. The OSGi Alliance's Enterprise Expert Group has undertaken to develop a specification for how CDI should interact with the OSGi framework and service registry. This talk will review the current progress of this specification and try to lightly demonstrate it's utility.
The IDE world is changing rapidly. There are some strong new IDEs that try to support C++, but as much as I like them for other languages and platforms, they just can't compete with CDT at working with native (real native) code. However, at the same time, we realize that our lead won't last forever and we have to consider where we need to go next to remain competative.
The CHOReVOLUTION Studio is an Eclipse-based environment providing automated support to business users, DevOps teams and service providers. It helps them composing new dynamic applications out of existing services and things. The first use cases are related to Urban Traffic Control and Smart Tourism. CHOReVOLUTION has received funding from the European Union’s Horizon 2020 research and innovation programme.
In this talk we will present a unique dashboard for a prototype electric car that is used for displaying basic information such as motor functionalities, speed, charging visualization, as well as novel real-time data visualization for our embedded data stream processor with complex event processing capabilities.This dashboard is more than a graphical interface because of its strong back-end functionalities with the help of Eclipse plugins.
Declarative Services is the best way to provide and consume OSGi services when writing bundles. The OSGi Alliance continues to improve this key specification with new features making it better and more simple to use. For the R7 release, Declarative Services (DS) 1.4 will add constructor injection to the existing method and field injection support. Component property types can now be used to annotate components to set component property values in a type-safe manner. Learn about these and other new features in DS 1.4 to see how OSGi services are easy to use!
This talk is about the solution that building a domain specific language (DSL) can bring. The problem that many companies are facing right now is not being able to communicate with their system efficiently.
Using the language workbench JetBrains MPS, you can create powerful DSLs. I will show how the development of a software product is done today and examples of DSLs improving the whole process. We will analyze the situations when building a DSL add value and when not.
The IoT arena is exploding with a diverse set of technologies, features, standards, and architectures, each of which promises to be the panacea and the path forward for future enterprise adoption. However, given the speed of change, innovation, and the wide variety of use cases that IoT enables, it would be highly unlikely for any single proprietary IoT solution maintained by any one vendor to keep up with all the new standards, requirements, and technologies to be incorporated.
Augmenting connectivity and device management with certain data analytics features helps you to bring your IoT projects to the next level. In principle, there are two major integration paths: (1) Get the data from the devices (i.e. the edges), transfer it to a backend, and run analytics jobs on top. (2) Run simple analytics jobs e.g. on the edges and transfer only the results to (device managing systems in) the backend. In the past months, we have explored these options by integrating some of the Bosch IoT Analytics functionalities with the ProSyst stack.
Writing code only comes second when talking about the developer work. The main and first task is reading and debugging. For that purpose, the Eclipse Java development tools are wonderful. Its most powerful tools are often unknown though. This talk will help you unleash this power and help you debug your Java code like a pro. The talk will also cover the new debugging features coming with Eclipse 4.8 (code name Oxygen, released last June). So, even if you're an experienced Java programmer, you will learn some tips and tricks.
Many business applications are data-driven and require viewing and entering data in forms… countless forms. Unfortunately, writing HTML5-based web forms manually is still error-prone and tedious, even with the help of modern web application frameworks like Angular. A form may seem simple at first, but you usually need to add live validation and error markers, rule-based visibility, input restrictions, and the like. As you can imagine, it quickly gets out of hand. Finally, when you have many of these forms the code becomes unmaintainable.
In this tutorial we'll use components provided by e(fx)clipse to develop an e4 application on top of JavaFX.
Things you'll learn in the tutorial:
- Get started with with Eclipse 4 on JavaFX
- What's the difference between Eclipse 4 on SWT and Eclipse 4 on JavaFX
- Use advanced features like Animation, Real and Fullblown Theming support and much more
But this tutorial is not just for those who want to learn about Eclipse 4 on JavaFX because we'll tackle things generally import to develop professional e4 applications:
Digitalization is here. It is real and it affects all aspects of human life. The use of digital innovations creates different consequences for humans, organizations, and societies. Some of these consequences are intentional and calculated, while others are unintentional and unforeseen.
At a certain stage of your technical career journey you usually reach a crossroad with two main options ahead. One leads to engaging more and more with team leadership and project management responsibilities. The other option is the path to the architect's role - and it is broadly regarded as the "pure" technical way forward. I've seen that IT professionals choosing the second path very often underestimate the fact that the Architect role differs a lot from all other technical implementation roles.
This talk will discuss the new plug-in support being added to the CDT project to build C/C++ projects in Docker Containers for Linux, MacOS, and Windows. After building, the user can run the executables in a Docker Container just as if they were built locally. The new support is completely optional and allows building existing CDT projects either locally or in one or more Docker Containers. C/C++ indexing of the source code is supported using the Docker Container header files where appropriate.
There is a current trend in the IoT domain to redefine the role of the IoT Gateway - once a simple communication relay with some application specific processing - into a generic purpose edge device supporting diverse device protocols, multiple applications, a variety of cloud connections, and sometimes even multi-tenant situations. In fact, recent low-cost hardware based on multi-core ARM and Intel SoCs (such as the Raspberry Pi 3, the Odroid-C2, or the UP board) seems to have the required capabilities.
Not everyone uses modeling tools and the awesome work one can do with these tools must be conveyed to the outside world, for instance, in the form of documents.
The M2Doc technology enables the generation of Office Open XML documents from Ecore models and Sirius representations.
This talk is a feedback on the use of the Eclipse Remote Application Platform (RAP) for the development of web applications and workbenches. We will present the work we have carried out so far, in particular the initial contribution of the styled text widget, the integration of Domain-Specific Language (DSL) editors with Dirigible Web IDE, and the integration with other frameworks such as EMF, Xtext, Diff/Merge, and Phaser. Finally we will give our feedback on the advantages and the limitations that we met.
IoT and Smart Home are hot topics today, and their popularity has spawned a lot of nice frameworks for developing applications, such as Eclipse Smart Home. However, real smart homes tend to be complex systems that pose hardware-software and systems integration challenges, which can provide a lot of headache to software developers lacking significant hardware experience.
Last year I showed where we, i.e. JDT, are with Java™ 9. This was well received and got a lot of positive feedback . We added many features since then and Java™ 9 is supposed to go GA on September 21.This session will present the most important new stuff in Java™ 9, especially project Jigsaw, which introduces modules into Java™. I will show how to get started developing Java™ 9 code with Eclipse and demo the new features that are provided by the upcoming Eclipse release for Java™ 9.
Eclipse APP4MC provides an open source tool platform for optimization of embedded multi- and many-core systems. During two years as an Eclipse project we extended the project scope, set up a structure for supporting tools and established a process with quarterly releases.
The talk will describe the current status of the APP4MC tool platform, the application in the automotive industry and also our activities to promote the platform.
What is more comprehensible: a table with tons of values or a chart? The answer depends on the point of view. The computer better "understands" the table. But we humans are very good when it comes to image recognition. Personally, I prefer the image too. Next question: Is a lightweight charting library available in the Eclipse ecosystem? Sure, solutions exist like Eclipse BIRT or the Eclipse Nebula visualization widgets.
Eclipse MicroProfile Config defines a Java programming model for microservices. It offers the capability of configuring microservices without repacking the microservices; microservices reacting differently based on the deployment environment; dynamic configuration feeding into the microservices without restarting the microservices. OSGi Config Admin exists for many years and offers an efficient configuration model to OSGi applications. MicroPorfile Config can work well in OSGi applications. It doesn't contradict but instead compliments Config Admin.
Eclipse RAP is a framework to write Web application based on a Java API. This API is based on SWT, and allows to run existing SWT/RCP application as web applications from the same code base. With RAP 3.2 (Oxygen), there is a integration of e4 available and supported by the project team that allows to run Eclipse 4 applications in a web browser.
This talk is for Eclipse RCP developers who want to learn the OSGi way of developing bundles.
If you are tired of setting targets and debugging PDE or target issues ;-) come and have a look at the alternative - bndtools.
Bndtools offers a great alternative with powerful concepts and opportunities.
We explain how to start developing a Eclipse 4.x application from scratch inside bndtools.
You see how you can deal with your dependencies in target setups on p2, file or maven based repositories.
Eclipse Scout is an open source framwork to build business applications that is hosted at the Eclipse Foundation. This introductionary session is intended for participants that are not yet familiar with the framework. The goal of this talk is to provide an overview of Scout's current state, optimal use cases and limitations of the framework.
The talk covers the following aspects
This presentation will give an overview about the Eclipse sensiNact platform and present how it has been used in development of smart city applications in several collaborative projects involving in particular European and Japanese cities, such as Santander, Genova, Grenoble, Fujisawa, Mitaka and Tsukuba. Particular focus will be given to outcomes from two ongoing projects: BigClouT (http://bigclout.eu) and FESTIVAL (http://www.festival-project.eu/).
Eclipse TEA is a new Eclipse project, just recently approved and incubated. This talk gives a quick overview of what it is all about, and what to expect in the next few months from the project, as well as hands on demo-ing the strengths with real life examples.
Eclipse TEA is a project that has been developed for the past years at SSI Schaefer in Austria. It has been open sourced now as a result of discussions with the community after presenting what we are doing with this technology at the past EclipseCons.
In this talk I give an introduction to a new Project at Eclipse (1): Xpect, a framework that allows to embed test expectations into comments inside your Xtext language. The approach is non-intrusive to your code, integrates with JUnit and has a smart editor for the Xpect-specific syntax.
Since Xpect separates DSL-Documents from Java-Test implementations, it becomes incredibly easy to add real-world code snippets to your test suite. You even can use your languages’s Xtext-Editor to edit your test cases.
Writing good tests is as important as writing good code for mastering high-quality software development. The JUnit framework is one of the most valuable skills a developer can learn to achieve that. JUnit 4.0 was first released over a decade ago after the introduction of annotations in Java 5. The world of Java and testing has evolved a lot since then. To take advantage of the new features like lambda expressions in Java 8 and to support the advanced testing needs, JUnit 5 is emerging as the next generation test framework and is expected to be released during Q3 2017.
Software is impacting every area of our lives, and will be even more omnipresent in the future. We have seen during the last few years on many occasions how a small glitch can have unprecendented consequences, from data leaks to people being harmed. As software developers and members of a community, we have responsibilities towards our users, our fellow developers, and the world. In this talk we will consider the ethical implications of software development and production, why it is important, and how we can do it better for the world and for ourselves while still being pragmatic.
Code formatting is an opinionated beast. It always has been a matter of taste, and it always will be a matter of taste. This is the reason, why professional formatting tools, such as Eclipse JDT, offer a gazillion number of options. Which is still not sufficient enough. After all, you can override them inline with tag-comments to make the formatter shut up. Can't we do better than that? What if we could use machine learning techniques to detect the preferred code style that was use in a codebase so far? Turns out, we can.
We at Fiducia & GAD IT AG have been using Code Generation as a tool to develop our Banking Software "agree BAP" for about 15 years. As the codebase grew up to about 80 Mio. LOC the modeling tools that were used changed over time: from proprietary XML-based formats to UML models with MID Innovator and IBM RSA. On top of that, in-house developed Xtext DSLs are used for several purposes.
In a highly distributed world it is crucial to have the best possible insights into your application.
In the old days we achieved this using plain logging and jmx. This does not scale well to highly distributed processing like in microservices though.
The Eclipse RedDeer project is an extensible framework used for development of automated SWT/Eclipse tests which interacts with application’s user interface. It is completely written in Java language and uses a purely programmatic approach like SWTBot. The RedDeer project has been developed for 5 years and in recent years it is used as a main testing framework for testing Red Hat JBoss Developer Studio.
Since the first graduation of the next generation code base (a.k.a. GEF4) in June 2016, we have worked intensively on making GEF even more robust and concise. And we have added some nice end-user features that make GEF applications fun to use. In this talk I will give an overview from an end-users perspective, especially pointing out what has been added during the 5.0.0 (Oxygen) release timeframe. I will also give a short outlook about our plans for Eclipse Photon.
So, you need an application development environment that fits your domain perfectly, like a glove. You want to be able to build various application scenarios without coding, in a matter of minutes. You want to deploy and run them, update and improve them and constantly monitor them, while keeping your hands clean, protected by those perfectly fitting gloves.
Developing form-based UIs for tools or business applications is typically a great deal of manual effort, especially considering requirements such as input validation, rule-based visibility, consistent layouts, copy/paste, tables with cell editors, tool tips, copy/paste, undo/redo, and domain-specific input controls.
Nowadays, most recent advances in artificial intelligence are powered by neural networks, also coined "deep learning". But what exactly is a neural network, how does it work, and where can you use it for? We will give you the answers in this talk, and demo a number of examples using DIANNE, a deep learning framework built on OSGi. We will cover a number of key use cases where neural networks really shine, such as image classification, text generation and reinforcement learning.
In today’s world, HiDPI monitors are becoming increasingly popular and they are here to stay. With more and more users moving to higher resolution displays, it’s important to ensure that your application renders nicely on these displays. Eclipse provides the required support to make your application ready for the HiDPI displays.
Developers are facing big changes in the way they are working since the raise of Docker. It’s terribly trendy and popular. Containers are heavily used to build, ship and run softwares.But what are the biggest impacts and values for the Developers?
Developers can benefit from portable developer environments leveraging the Docker containers technologies. It’s the main purpose of Eclipse Che. During this session we will discuss the various changes containers have provided to the developers, why dockerizing your projects and what are the best tactics to achieve that with Eclipse Che?
Test automation projects can have a bad tendency to go awry, most especially when higher-level automation (e.g. via the UI) is involved. At some point, automated tests just become too hard to understand, extend and maintain.
This doesn’t have to be the case though. In software development, there are systematic methods and patterns for addressing recurring challenges – and similar approaches also exist for test automation.
This talk summarizes our experiences from building language servers and integrating and using them across Eclipse, VS Code, and Atom. We talk about the good parts, e.g.:
- building lightweight tooling
- the freedom of starting fresh
- building the tooling once and reusing it across various environments
- isolated testing
The bad parts, e.g.:
- no communication among language servers
- do the work twice or more, ship libraries twice or more
And the really ugly parts, e.g.:
A model can be represented graphically and textually. While text is able to carry more detailed information, a diagram highlights the relationship between elements much better. In the end, a good tool should combine both, and use each notation where it suits best.
Since its birth, IoT has been developed for more than 20 years and yet the Internet of Things is still filled with devices and data that are not connected. Fragmentation happens between applications, verticals and systems. The fragmentation is locking data inside devices so that their true value cannot be dug out.
For years IBM has developed an independent implementation of the Java Virtual Machine which fostered rapid improvements in the Java ecosystem. IBM has open sourced language agnostic components such as JIT and GC technologies as part of the Eclipse OMR project. The next step in this evolution is open sourcing the rest of the J9 Java VM in the newly created Eclipse OpenJ9 project. Come to this session to learn about Eclipse OpenJ9, what it can do for your Java application's performance, how to try it out, and even how to build it yourself!
Embedding support for expressions into Xtext based languages has become easy when Xbase is chosen as base language. However, deriving a language from Xbase implies the usage of a Java based type system with dependencies on JDT. For language implementations that need to be independent from Java or that should have a different type system it is required to embed an own expression language.
In this talk we give an overview of the Eclipse Deeplearning4J ecosystem. Skymind builds open source machine learning tools for the JVM and with a focus on deep learning. We give a quick introduction into the basics of deep learning and discuss a practical use case for illustration. Among other libraries, we introduce ND4J for powerful tensor operations and DL4J for building and deploying deep neural networks.
Eclipse Yasson is a Json Binding framework, reference implementation of new Json Binding API in Java EE 8. This session provides a deep dive into Yasson, JSON-B and JSON-P APIs, explains how they are connected and can be used together and compare it similar features of other popular frameworks. Hereby I will demonstrate how Yasson can be used for simple use cases as well as its more advanced features such as customized mapping, adapters and serializers.
Internals of Java Virtual Machine based on challenges and experience in implementation of one of the most popular code coverage tools for Java - JaCoCo ( http://www.jacoco.org/jacoco/index.html ) that is backbone of award-winning Eclipse EclEmma Plugin ( https://www.eclipse.org/eclemma ).
In this presentation we will dive into bosom of JVM (bytecode, restrictions, classloaders) answering on following questions:
Java Enterprise Edition (Java EE) is a rich, mature and widely used open platform for developing and deploying server-side applications. Java EE 8, the latest version of the platform was recently finalized. Multiple open source implantations of the Java EE specifications already co-exist today: GlassFish, Red Hat WildFly and Apache TomEE.
Oracle has also announced its intention to move the Java EE development to the Eclipse Foundation; a bold move welcomed by the community and supported by multiple companies such as Red Hat, IBM, etc.
Java SE 9 has just been announced with it's major feature of modularity, also known as Jigsaw. If you listen to Oracle, you would think that moving to this totally different JDK and JRE is as simple as writing your first "Hello World!" program. Depending on your application's needs, it may turn out to be this straight-forward. But, as we continue to experiment with this new Java SE 9 paradigm, we are discovering several hiccups, hurdles, and surprises.
The core underlying technology driving most of the Eclipse Ecosystem is Java SE. Yet Java SE is often misunderstood, even by the most savy and experienced of developers. This talk will start by disambiguating the various JVM, JRE and JDK implementations available, and outline how OpenJDK plays a key part in Java SE evolution. We'll review some common packaging, technical and licensing FAQs for the various builds available. Finally, we'll overview the history and evolution that got us to where we are now -- Java SE: Current Status.
The JDT team is dedicated to delivering full support for Java™ 9 right when the new version is released, just as we did for every version. In this session we will share some of the things we learned while working from an evolving specification. We will also discuss the impact of this new version specifically on tool-smithing for Java.
By the time you see this talk, Java 9 should have been released with its flagship feature: the Java Platform Module System (JPMS), also known as Jigsaw.
It goes without saying that Jigsaw will have a big impact on the entire Java ecosystem, and particularly on OSGi developers who have an 18 year head start on modularising Java applications. However, while OSGi and Jigsaw ostensibly solve similar problems, they do so in very different ways. In this talk I will address questions such as...
Open Security Controller (OSC) aims to increase the security of workloads running in cloud and data centers by orchestrating security virtual network functions (VNFs). To achieve that, one of the main design goals of OSC is to allow vendor customization while keeping its core code neutral.
How to contribute to existing Eclipse project? How do I move my project to the Eclipse Foundation? Why? What do I do after the move? What is Simultaneous Release and how to join release train? etc... Even being a mature open-source contributor / developer / project lead , you might feel like a newbie, lost and scared. I know how it feels. But you should not be scared! Existing members of Eclipse Foundation are here to help you. On the example of Eclipse EclEmma project, let's have a look on a journey from project proposal to inclusion into Eclipse Oxygen Packages.
The Oxygen release train has introduced new approaches to more efficiently support editing of textual languages in the Eclipse IDE: a Generic and Extensible Text Editor was introduced in Platform to minimize boilerplate, Language Server Protocol for Eclipse (LSP4E) which allows to quickly hook into the IDE the power of Language Servers and TextMate for Eclipse (TM4E) allows to as easily delegate the syntax highlighting in the IDE to a TextMate grammar.
In several projects, we have been building automotive toolchains based on EMF models and model transformations with Xtend. In this talk, we will introduce our "lessons learned" from projects, in which we integrate automotive engineering data from different sources (relational databases, specific configuration files, EMF) into a consolidated model for product lines of electronic control units (ECUs) for cars and then transforming it to AUTOSAR. These models easily exceed a size of 1mio elements.
As a company, we’ve been working on Eclipse Technologies for the past 10 years and we have built a lot of application on top of them. We recently faced a big challenge by migrating one of our biggest application from Client-Server to a Web architecture. We developed this app by adopting some EMF technologies (such as EMF Edit, Parsley, CDO, etc..) and some good practices like Inversion of Control (with Google Guice) and MVP pattern. And we were really surprised how easily we realized this porting, since we replaced both UI and persistence layers in a matter of a few days.
Data can be like water flowing along the river. Its a stream never ends.
Especially the many IoT devices can produce such endless flow of data, pushing it using various asynchonous messaging protocols like e.g. MQTT, Websockets, JMS, STOMP, XMPP or whatever you imagine. The OSGi frameowrk provides a lot of stuff to get such streams handled!
Smart home setups are as heterogenous as their users, whose desires, expectations and habits are highly individual. Eclipse SmartHome addresses this situation at various levels. It is a very flexible framework to build tailored smart home solutions that are easily extensible and customizable. End users of such solutions have the possibility to set up personal automation logic to cover their specific use cases.
Correct handling of Open Source in a commercial context is a challenge. Every company needs to build up and maintain their own IP process to face this challenge. A sophisticated tooling seems to be inevitable. While managing Open Source every day it seems reasonable to also collaborate with the Open Source Community on the Open Source Management System itself.
Whether you're building large enterprise applications or writing code for IoT devices, the new R7 release has a lot to offer for you. Learn in this session about the various new and updated specifications and how they will make your developer life easier. Starting with new features in Declarative Services for component development, dealing with configurations, using JAX-RS with OSGi and finishing with useful libraries for object conversion and event streaming, this session is packed with information for OSGi development.
In this talk we will explain how to collaborate with other team members by storing your models and diagrams in a shared repository.
This approach will be compared to traditional file-based collaborative mechanism.
By using a repository managed with CDO our solution provides a fine-grained locking mechanism that allows you to simultaneously work on visual representations for the same data, without losing time managing conflicts and without any technical skills.
Most data have a location component that, once enabled, opens previously unseen avenues of analysis and understanding. This is especially relevant for Big Data management purposes.
Looking at data from a geographical perspective often suggests new insights and explanations often unrecognized without a spatial eye, but vital to understanding and managing activities and resources: to see the unseen.
The Crazyflie 2.0 is a nano quadcopter and a flying open source development platform. It's firmware has been developed with Eclipse CDT. Since there is also a Java API available it seems only natural to use it in an Eclipse plugin. Will there be a live demo and a flying quadcopter? Absolutely! :)
Everything begins with a great project, but to really succeed and grow it's not enough. This session will share the approach and some specific tactics that were used by the Eclipse Che project to grow to >4000 GitHub stars and >12M hours of usage in one year.
You'll leave the session with advice on
- Setting up your repo to foster and grow a community
- Define your project's value and get your voice heard in the market
- Encourage users to experiment with your project...and encourage users to contribute
OSGi declarative services exist for a long time and are used to implement a modular service-oriented architecture. Because of the supported dynamics, the easy way to define, register and consume services, declarative services can be found in various scenarios. Using several of the long time existing specifications like Declarative Service, ConfigurationAdmin, EventAdmin and Remote Service Admin, it is also easy to setup the currently hyped micro services by using OSGi declarative services.
The modeling community is among the most active and diverse in Eclipse's ecosystem. The modeling symposium aims to provide a forum for community members to present a brief overview of their work. We will encourage 10-minute lightning talks to facilitate a broad range of speakers. The primary goal is to introduce new and interesting technology features. We will open up an informal call for submissions from the community. Depending on the number, we will select submissions that will create a diverse slate of talks.
DevOps puts a huge emphasis on test quality: while it promises to drastically reduce delivery cycles, hasty deployment entails the hazard of propagating a regression bug into production due to lack of sufficient testing. Statement coverage is the most popular metric to determine the adequacy of a test suite. Yet, this metric is known to be a poor indicator of a test suite's capacity to detect bugs.
We’ve been successfully using annotation based null analysis for more than 5 years on a code base that is now more than 15 years old. In this talk I’d like to share our experiences and give some details on how we use them in practice.
This session shows how UI test automation can work in practice using a tool based on Eclipse. The speaker presents a practical implementation of UI test automation with the Saas-platform TestChameleon™ by Testbirds and the Eclipse component Jubula by Bredex. Jubula is a tool for automated functional GUI tests for various types of applications. TestChameleon™ is a Cloud based Saas-platform that offers testing with emulators and in virtualized environments to cover a multitude of device types, browser and OS versions.
Java EE is currently going through its biggest change in a decade as it moves to an open foundation. If this works out well it will accelerate the platform's evolution towards microservices through the work started in the Eclipse MicroProfile a year ago. The MicroProfile initiative was formed to inject new pace and innovation into the enterprise Java landscape and is having the desired impact. This session will describe the technologies defined in MicroProfile, how we expect them to define the next version of Java EE, and how to take advantage of them with WebSphere.
Oracle, in partnership with IBM and Red Hat, has announced its intention to move Java EE technologies to the Eclipse Foundation, following the delivery and completion of Java EE 8. The Eclipse EE4J top level project charter has just recently been published. Attend this session to hear from representatives of Oracle, IBM, Red Hat, and the Eclipse Foundation on the status of the project, what to expect over the next three to six months, and how this will benefit the Java EE community. Come learn how you can participate.
The https://twitter.com/EclipseJavaIDE account has become a source of daily tips on the Eclipse IDE used by thousands of developers every day. Every month we get between 300'000-350'000 impressions through Twitter alone. That's progress from our days with 4 followers some months ago and shows this was missing.
Sopot Cela is the one taking care of its strategy and will take us into a journey of how it came to be, how it is managed every day and what its plans are.
This talk will introduce some use cases of real world solutions that Bosch Software Innovations customers have implemented for electric vehicle charging stations,heating systems and home appliances using OSGi and EEBus.
EEBus is a German initiative that aims to standardize a global language for devices communicating with each other about energy. Bosch Software Innovations implemented the EEBus SHIP and SPINE specifications for its OSGi based ProSyst Gateway Stack.
The talk will conclude with a review of the benefits that are achieved with a joint OSGi and EEBus solution.
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.
Eclipse Kapua is modular micro service-based IoT cloud platform that provides management for Internet of Things (IoT) gateways and smart edge devices. Kapua bridges the gap between Operation Technology with Information Technology, between the complex and fragmented world of the IoT devices with the enterprise IT infrastructure. This session introduces the Eclipse Kapua project focusing on its architecture, service model and blueprint, modularity, and deployment options.
With CDO you can turn any file-based single-user model application into a repository-based multi-user application by changing just a few lines of bootstrap code. In order to get the best performance out of your system and to avoid some common misconceptions that are inherent to multi-user scenarios you should not miss this talk. You'll be guided through the seven most important CDO recipes.
SUMO (Simulation of Urban Mobility) is a microscopic traffic simulator. It has been developed by the German Aerospace Center since 2003 and published as Open Source (see http://sumo.dlr.de). In this talk, SUMO and its capabilities for the realistic simulation of cars, busses, bikes, pedestrians, trains and even ships in cities, such as Berlin, are presented in an overview. A short and hands-on tutorial for the live creation of a simulation scenario is provided.
IoT solutions are becoming more and more common in the market and new devices and gadgets are showing up on a daily basis. Additionally, the networks and protocols used by the devices can be highly specialized for use cases such as minimal energy consumption or for long range connectivity. If you want your IoT system to be future proof while being able to take advantage of new technologies without having to change your system every time, then the OSGi Device Abstraction Layer can help. It provides IoT APIs independent of the underlying technology.
There are many technical aspects to keep in mind when developing and testing software: Functional correctness of the features, technical excellence of the code, robustness, performance, maintainability, ...
However there's also the "people" aspect of software development: People use the software and people create it as well.
In this talk I'll show why empathy is an important skill for testers to deal with both kinds of people.
In the first part of the talk you'll learn why usability matters and how personas can help to build features that match your users needs.
Imagine you could navigate through your data graphically directly in the web browser. Imagine you could easily equip your web application with visualisations of complex relationships. Imagine a graphical modeling tool in the web.
T-Labs and Orange Labs are showcasing with some of their respective partners a community prototype around standard cloud APIs. In the Smart Home domain, the oneM2M standard restful interfaces are emerging as a unique service layer API standard at the cloud level backed by a worldwide organization and open source communities. Showcased partner applications use standard APIs implemented by Deutsche Telekom and Orange. T-Labs and Orange Labs have implemented identical oneM2M cloud interfaces on their respective platform prototype. Each of the two implementations integrates part of their respective industrial product – Qivicon, Orange Datavenue - and part of Eclipse OM2M open source artefacts.
Executing automated tests of every reasonable scope as a fixed step of every build job is mandatory. Some testworthy situations can’t be simulated with a mocked environment. Therefore, multiple test scopes - including integration tests - have to be part of the buildstep, as well. In this talk, I will demonstrate some different testscopes for microservices.
In this talk we want to share some tips and tricks on how to test Eclipse plug-ins at several stages during the development. In particular, we will show how to do without a running workbench (i.e., without “Plug-in tests”) and without functional testing frameworks (e.g., SWTBot) as much as possible, relying only on plain JUnit tests.
Captain Static, Runnable Boy and the rest of the "League of Extraordinary Anti-Pattern" is sitting exhausted in their fortress of solitude, the "Singleton Factory". They would love to retire, but again the alarm signal sounds and they are called for help. What will our heroes confront this time?
Eclipse MicroProfile (MP) aims at bringing Microservices to Enterprise Java by developing common standards that MP-compliant vendors then implement. The more classical specifications have often left out many details as vendor-specific - especially in the area of set up and running of the applications and servers. MicroProfile has decided that aspects of running the applications like telemetry and health checks should not be vendor specific but be part of the base specifications.
Whether you are developing smart products, enabling new connected services, or instrumenting factory production lines you face the challenges of designing, building, and deploying an IoT solution. This session will first summarize the leading reference architectures and blue prints for Industrial IoT and then, it will map those architectural components onto the activities of the Eclipse IoT community.
On Linux based platforms, SWT runs on the GTK2 or GTK3 backend. GTK3 is currently approaching the end of its development cycle, leaving us with a significantly changed API and aggressive deprecations compared to GTK2.
This talk will provide a historical insight into SWT and GTK, namely it will:
This talk will explain how OSGi is used in a large bus fleet
system. Every bus has one or more on-board computers running an
embedded OSGi platform (Knopflerfish) performing services such as
ticketing, driver console, and passenger information. The system is
remotely managed by Makewave's Ubicore system, responsible for
provisioning new or updated services to the embedded OSGi
platforms. The talk will present an overview of the overall software
architecture, some of the challenges we faced and the benefits gained
by using OSGi.
In this session, I’ll highlight the easiest ways for Java developers to deliver their code to the cloud using Eclipse plugins and tools, and the best ways to reliably make updates and maintain production cloud code. The focus will be on real-world examples using Linux command line tools, open source plugins from the Eclipse marketplace, and other free SDKs and tools available on GitHub. The examples, tools and demos that I show will be applicable to any cloud platform, and all are available on GitHub.
Join Markus and Alex in this tutorial to learn how to use the Jubula Client API to write good UI test cases for your application. UI tests aren’t often a favourite pastime for developers, but they do provide useful feedback from the user perspective: they let us know whether the desired workflows are possible via the UI. They are a great addition to other test levels for a well-designed test strategy.
Connecting embedded devices to the Internet is not trivial. But an even harder-to-solve problem follows, once the devices are deployed.
The issue is how to manage remotely updating IoT devices with solid tools to minimize deployment failures.
Updating remotely an IoT device condenses solid knowledge of server-side applications, DevOps and expertise with different embedded operating systems: it requires knowledge of a full IoT pipeline from embedded devices to back end applications.
Slowly but steadily, selected developer tools are being migrated to web technology using emerging technologies such as Atom, Eclipse Che, Monaco, Thea, or LSP. Those technologies are mainly dealing with textual editing (source code, DSLs), but what about non-textual modeling? Many existing tools are essentially modeling tools. They allow you to create models that can be manipulated in tree- and form-based editors as well as in graphical editors.
The language server protocol is a terrific way for any IDE to provide and consume language support such as code analysis and completions. In a short space of time it has gained momentum and has support for >30 languages. But what about when it comes to debugging those languages?
Modeling in general - the Eclipse Modeling Framework in particular - are purely academic and overcomplicated. They provide no value except generating some kind of Java Beans!?
Can this really be true?
Absolutely not! EMF is a very pragmatic and very efficient approach for creating data entities for tools or applications. More importantly, it enables you to apply a huge variety of additional frameworks, which can massively save you time and effort when compared to manual custom implementations.
This tutorial will give you a jumpstart on the concepts of the Eclipse 4 Application Platform. If you have previous experience developing with RCP 3.x but limited or no experience with e4, this tutorial is designed for you. Using a sample application, we introduce the most important features of the Eclipse 4 platform, such as the Application Model, Dependency Injection and the Programming Model based on Annotations. We complete the introduction with an overview of the most important services available. All topics include hands-on examples that we’ll work through together.
Eclipse Che is going to get expanded capabilities for large teams and enterprises. In May, Red Hat acquired Codenvy and it’s a great news for Eclipse Che project: the Codenvy’s capabilities and source code is going to be open sourced with EPL on Che!
OSGi provides specifications for HTTP whiteboards as well as JAX-RS whiteboards. This talk will give you an real world insight of how these specifications can work together.
Are you familiar with the the problem when you quickly need a site setup consisting of whiteboard services such as static web resources, servlets and REST services for integration testing or a customer review?
So we got Jetty and Jersey in the team, they provide sample implementations for both of the specifications.
While creating languages and IDEs with Xtext is a breeze, it may become a little bumpy when you want to provide headless tools. Even though there exists decent support to generate and compile Java code from DSLs with Gradle or Maven, build systems for other target languages are still uncharted waters. Navigating through them depends a lot on your own technological decisions and of course on the target language of your choice.
Java concurrency has evolved a lot from Java 1 to Java 9. Very sophisticated tools became part of the JDK providing developers with various design opportunities.
Still many of these tools and the underlying concepts are unknown to many of us.
In this talk I’m gonna show a brief overview about the evolution of concurrency tools and concepts findable in the JDK, explain some scenarios for the tools I recommend and show the new Reactive Streams concept coming up with Java 9.