The Software Commons is the vast body of human knowledge embedded in software source code, that is publicly available and can be freely altered and reused. Free and Open Source Software (FOSS) constitutes the bulk of it. Sadly we seem to be at increasing risk of losing this precious heritage built by the FOSS community over the paste decades: code hosting sites shut down when their popularity decreases, tapes of ancient versions of our toolchain (bit-)rot in basements, etc.
Please let the program committee know what you think!
Click in the "Your Vote" field for each submission. (You must be logged in to vote.)
Financial markets run on complex algorithms. The industry uses several protocols to describe how their systems are expected to communicate with others - effectively, describing their APIs. One such protocol is FIX (Financial Information eXchange) - widely used for quite some time. Financial services firms (e.g. exchanges, hedge funds and investment banks) share such specifications with their counterparts to allow them to connect to their systems. The protocol specification is relatively vague and informal - at AI, we’re changing this.
The p2 API is not known for its intuitiveness and requires an Equinox container at runtime. If repository contents should be accessed programmatically this is a bit overkill. So why not hiding all this in a microservice and make the metadata available through a REST API?
This demo shows how to create a microservice from a headless Eclipse application, integrate JAX-RS and accessing p2 API for querying p2 metadata. It is also a blueprint to make other kind of (headless) Eclipse applications accessible via RESTful services.
EMF Parsley allows for easy and straightforward UI building starting from EMF Models; it provides a set of reusable UI components (trees, tables, forms, editors), which are completely customizable, and an Xtext/Xbase based DSL editor for defining/customizing the UI components, which then can be used by your application with few lines of code.
The talk gives a vision of an open end-to-end architecture providing standard APIs on a cloud platform and a home gateway to host any application and connect any device. Among the standard organizations and industrial alliances, oneM2M standard specifications are being adopted as a reference architecture by the IoT industry. The implementation of oneM2M standard features in eclipse OM2M will be detailed, especially the use of an abstraction layer using oneM2M Smart Device Template and the end-to-end access right management discriminating both applications and users when accessing devices.
We will introduce a Big Data configuration that uses Avro & Parquet for data formats, Hadoop for storage, and Spark / Hive for running queries. All of these projects are from the Apache Software Foundation and are widely used in the Data Science field. We will show how Eclipse provides an excellent foundation for IDE support and tooling to make it easier to develop solutions based on this technology stack.
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.
GEF4 is the fourth generation and brand new API of the Graphical Editing Framework.
As an early adopter, we will show you how GEF4 has been used in Airbus to create a new Eclipse RCP application to define full unconventional fuselage geometry and cabin layout configurations.
You will see:
At the end of the day, your project's installation packages, OSGi bundles, Eclipse plug-ins and features have to be delivered to your users as plain old files. In Eclipse universe, we achieve this with
- Eclipse Downloads and Eclipse Archives sites for clean and fresh installations
- p2 repositories for updating existing and building new applications with Tycho, PDE Build and alike
The way they work now critically depends on the servers storing these files and fast, stable and unrestricted Internet connection between the user and these servers. But…
We are developers in a little company in Austria that specializes on legacy code modernization and we recently started developing an Eclipse plugin.
We do not attempt to call ourselves veterans yet, when it comes to plugin development but there should still be a lot of interesting topics we were confronted with that we would like to share with you.
Anyone who has worked on coding knows the tedium of writing long sections of boring, repetitive boilerplate code. It’s an essential and unavoidable part of our jobs that takes up a lot of time, usually more than we’d like.
This talk intends to explain how the Eclipse IDE can be used as an accelerator at the beginning of a project to improve the kick-off so you don’t have to begin from scratch. The tooling is based on a pragmatic code generator seamlessly integrated in Eclipse and provided as an Open Source plugin available on Eclipse MarketPlace.
In this session, MicroEJ discusses how the Eclipse IoT technologies are involved in the creation of the software stack used in the Sowee Product.
Sowee, a product unveiled by EDF at CES 2017, includes a connected session for which MicroEJ has developed a custom software stack in a very short period of time, thanks to many Eclipse IoT technologies being available off-the-shelf.
The project was started early 2016 and MicroEJ, involded only from May 2016, has built this software stack for a device that only existed in the Fall of 2016 (preproduction started in September).
Nowadays, we are monitoring more and more servers and DevOps Teams expect real-time data with more granularity. Storing and analyzing metrics at scale can be challenging.
In this session, we will present the architecture based on Open Source tools we have deployed at Bleemeo, a servers monitoring solution. An agent installed on servers is connected to the Cloud Platform with MQTT using Eclipse Paho and Mosquitto. Data is consumed by Apache Kafka & Apache Storm clusters: all metrics are analyzed to generate alerts if needed and stored to a Cassandra cluster.
These days implementing code generators has become quite easy.
However, building professional tools supporting you in
- navigating back and forth between the sources and the generated text,
- running and debugging the source models instead of the generated artifacts, and
- transferring changes in the text back to the sources
is a much more challenging task, but also an interesting one.
In the Eclipse ecosystem we find both tools and frameworks for ‘modelling’ and for ‘DSLs’. Should I choose ‘modelling’ if my users ask for diagrams and ‘DSLs’ is they ask for text?
In this talk I will argue that there is more to consider because the architecture of the stacks to choose from is vastly different: Persistence concepts, whether model elements preserve their identity and a variety of transactional access mechanisms. I will explain how it impacts
In this talk I give an introduction to Xpect, a framework that allows to embed test expectations into comments inside your language. The approach is non-intrusive to your code, integrates with JUnit and has an Xtext-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.
For Oxygen, one of the goals of the Platform contributors was to make it easier for adopters to add support for new textual languages in the Eclipse IDE.
After a review of the current state, a new approach of contributing textual support was introduced in the name of a “Generic and Extensible Text Editor”. This new framework allows to contribute specific behaviour to an existing “generic” editor as usual extensions in plugin.xml without having to fully re-implement an editor.
Domain-specific languages implemented with Xtext have proven to be powerful in many areas ranging from requirements specifications to programming languages. One key factor to success is the textual representation of the model which eases creation, maintainance and especially merging. Nevertheless, at some point a graphical representation simplifies the communication by giving a broader overview of the modeled elements.
Nearly every Eclipse user is aware what Xtext is and what it is useful for. It is always a pleasure to see in which kind of areas it is used.
One reason is clearly, that it is really easy to build a first working example in no time. The grammar alone is sufficient and the rest is done by a code generator. Xtext will generate stub classes, that are ready to fill in individual logic for different areas.
By doing that most of the things just work, because Xtext comes with a lot of defaults that suits in most of the cases.
Eclipse Collections is a framework that provides a rich set of useful collection implementations complementary to Java's collection API. Originated at Goldman Sachs, Eclipse Collections adds efficient data structures used in large scale applications where memory consumption and maintainable code is crucial.
In this talk I will give an introduction to the types and the fluent API offered by Eclipse Collections and will compare memory consumption and runtime efficiency against standard API.
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.
Ok, so there is no bar in this session. Maybe a request for the program committee next year?
Actually, a restaraunt would have been a better metaphor for this session: Would you like an order of Polarsys with a sprinkle of IOT and a dash of XText/XTend? Good!
Here's what we're going to cover:
Did you ever stumble across a red line with a cryptic error message in the log when running the Xtext generator? Then it is most likely your grammar is ambiguous. This is bad as some paths through your grammar will never be reachable.
In this session I will explain what ambiguity means, how it emerges and how to fight it without sacrificing the performance of the parser entirely.
After Eclipse Neon the Xtext team decided to split the single repository with huge history into several smaller repositories. Some drivers behind this decision was to have clearer dependencies, shorter build times and dedicated repositories for the different tool integrations. While this sounds totally reasonable and a move forwards, the Xtext team struggled quite a while to finally make the split real and transparent for users. This talk will give some insight on the consequences and issues we faced while performing the repository split for Xtext 2.11.
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.
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.
In this talk we are going to present Sprotty, a new open-source framework to create graphical views for web applications. Sprotty combines modern visuals with smooth animations and a pleasant user-experience.
Xtext's most prominent new feature is its support for the Language Server Protocol (LSP). Visual Studio Code, as the IDE for which the LSP was originally invented, allows the deployment of language servers through its extension mechanism.
In this talk it is explained how VS Code extension is structured, build and bundled with Xtext DSL language servers. An extension to Xtext's code generator will be used to create the necessary glue code for creating the deployable extension. Finally we will explain what needs to be done to get your DSL extension in VS Code's marketplace.
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.
When it comes to building domain-specific modeling tools, two classical competing approaches can be chosen by a tool provider:
- "Pure" domain-specific tools, built on a dedicated meta-model.
- UML tools customized with a dedicated domain-specific UML profile.
From an end user perspective, the most important thing is that such tools be user-friendly, with dedicated editing facilities such as model browsers/explorers, graphical editors, property pages, etc. The technological details that are only relevant for "tool smiths" should be hidden.
EMF Parsley is a GUI renderer built on top of EMF that allows developers to quickly develop User Interfaces. The main goal of the Project is to provide an easy way to build complex applications, hiding some boring details, with simple and powerful APIs. EMF Parsley in fact provides some built-in components like Trees, Tables and Forms that can be easily mashed up and customized.
The Xtend Language with its Rich String concept is a perfect match to build template based code generators. When using Xtext based models, it is quite easy to implement a generator by implementing the IGenerator interface. The Xtext framework enables integration of such generators in standalone and integrated environments with minimal customization effort.
Eclipse's scripting environment EASE provides a pluggable architecture for the integration of scripting engines. Support for some well known languages does already exist, but how about your DSL? Let's see how you could write an interpreter for a language and plug it into the EASE scripting environment!
Ever wonder what it would take to get an Eclipse Sirius diagram editor to work in an Eclipse 4 Application? I took an expedition through Sirius and it's dependencies on a mission to find out! After a few days of ripping things apart, putting them together, making wild guesses, and more than a few "git reset --hard" commands - I made it to my final destination.
We will cover the perils and pitfalls that I encountered on my journey:
Systems dedicated to the Internet of Things (IoT) are complex and characterized by heterogeneity of hardware and software run time systems, software applications, network communications protocols and physical devices (sensors, actuators). The supervision of these systems and the detection of their critical states is also a major challenge.
This ignite talk gives an overview of the activities and projects of the Eclipse Science Working Group. The Science Working Group is now about three years old and this talk gives a summary of the global group's efforts to advance software for science.
Distributed systems are widely spread in many industrial environments. The networking and integration of such heterogeneous systems to achieve a common goal lead to a larger complex system mostly defined as System of Systems (SoS). These systems include the Supervisory Control and Data Acquisition (SCADA) architecture for representing the vertical data exchange from sensors to Human Machine Interface and vice versa.
Measuring water flow is used in variety of industries. From chemical plants to agriculture flow meters are used to realize water management. Usually such devices have industrial grade connectivity options like HART or Modbus protocols. Recently it is highly desired to integrate process instrumentation equipment with IT systems, usually located in the cloud.
Process instrumentation (PI) is used to measure process variables in production or manufacturing areas. Control, safety, monitoring and maintenance applications are usually realized using PI equipment in industrial systems. Industrial Internet of Things and Industry 4.0 concepts promote integration of pure industrial installations with modern IT systems, usually located in the cloud.
Eclipse IoT stack allows to realize different IoT architectures that can fulfill such integration requirements.
Since the advent of lambda expressions in Java 8, Java came closer to a language that is at least tolerable for advocates of functional programming. Of course functional programming is more than just a question of syntax or availability of function literals, but often enough, the syntax and the expressiveness of a language are at least an indicator for the code style that will evolve you do some real coding. And in the end, the code style is what makes a source file readable or implicitly obfuscated
The data science world is split into two parts: the Python and the R community. Both groups offer a plethora of tools and libraries enriching our work-life as a data scientist. Interestingly, many of the offerings are complementary, such that professional data scientists should know both environments to pick the right tool for the job. In many cases, it even makes sense to use Python and R together in the same project. Sadly, today these two worlds don’t integrate very well, so we need to switch back and forth between different tools and environments.
I'm sure you're wondering what a Microsoft DevOps solution can do for you. You are not a .NET developer ! Forget everything you think you know about Microsoft developer tools. Visual Studio Team Services is a DevOps solution for any app, any developer and any platform. We have a first-class integration plugin for Eclipse that allows Eclipse developers to take advantage of VSTS features. In 35 minutes, I will show you how we can setup a continuous delivery pipeline from Eclipse to Azure for a Java application hosted in containers.
Theia is the codename of a new open-source project. It provides a foundation for implementing integrated development environments (IDEs) not only for software developers but all kinds 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. The framework is implemented in TypeScript and leverages Node.js and Electron to support different architectures.
For many of us, Lego is a reminder of our childhood and how much fun it can be to use standardized bricks to build something awesome. In the March 2016 EclipseCon, we have presented an overview how to model a Lego system with UML, including simulation within the tool and execution on the target. In this talk, we like to add two new contributions. (1) We present more details on modeling the behavior of an application by embedding code fragments into the model and using state-machines. (2) A recurrent problem in modeling is that debugging and testing is still often done at the code level.
Today, OpenSource contributions have never been that simple thanks to Git and Pull Requests. The old days when external contributions were done through “patch” files attached to a issue tracker is over!!!!! We can send our contributions with Github Pull Requests.
However, OpenSource projects are not always that simple to setup and submitting a Pull Request may involve a lot of Git manipulations that can discourage external contributors ...
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., “Plug-in tests”) and without functional testing frameworks (e.g., SWTBot) as much as possible, relying only on plain JUnit tests.
There have been talks proposed, and given, about how we should treat the Eclipse IDE as a product - this is a great idea.
This is also an idea promoted in the Papyrus Industry Consortium to manage not only the base Papyrus product but also a product line and all the governance around this.
We will describe how product management techniques from the commercial world were adapted to and used by Eclipse product under the governance of the Papyrus Industry Consortium, the lessons learned from this experience, and also where we think we should be headed.
In the past, Eclipse working group gathered like-minded people and companies to collaborate on sets of projects in a specific field of expertise - and that is a good thing.
In some cases, something more was required, not only the grouping of projects working in the same domain, but a more concerted effort to drive to a common vision of an integrated solution.
And thus came the idea of industry consortia being parts of these working group. And this is what led to the creation of the Papyrus Industry consortium (Papyrus IC).
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 that are coming with Eclipse 4.8 (code name Oxygen, to be released late June 2017). So, even if you're an experienced Java programmer, you will learn some tips and tricks.
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 and you'll leave this session with a good understanding of how CDO achieves scalability and performance and how best to tweak it.
Since 2014, the Eclipse Foundation was invited to join European Research projects to assist them in Dissemination, Community Building and OSS best practices. Today, we are directly involved in 5 EU projects and we are in touch with few others who are interested to join our dynamic community. Some of these projects are just starting, some other are in the middle of their timeline and one of them is finishing in July 2017. Each of these projects has or will have an Eclipse project created in our forge.
This talk presents Eclipse Winery, which offers modeling the architecture of cloud applications. It makes heavily use of the OASIS standard TOSCA. What makes Winery and TOSCA special is that it supports heterogenous application stacks out of the box. This talk will introduce the concepts of TOSCA and demonstrate how Winery supports it. It will aso show how the application can be deployed and instantiated. One will learn about the ideas of application portability and about resuing application components in different settings.
The talk is about helpful tooling available when using GitHub as source hosting platform. The talk is for developers deciding to move from the Eclipse hosted infrastructure to GitHub. This talk will present the tooling we have in place in the Eclipse winery project. Its main focus is the use of pull requests for external (and internal!) contributions. We will discuss automatic quality checks (style guide and code coverage), continuios integration and the automatic publishing of build artifacts.
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.
The typical architecture of any IoT solutions involves constrained devices, IoT gateways and IoT Cloud Platforms. This presentation will provide some insight into the software requirements for this type of architecture and identify three software stacks required for building an IoT solution.
The presentation will also give an overview of open source projects available today for IoT developers and in particular how the Eclipse IoT community is delivering technology for each of the 3 software stacks required for IoT solutions.
Cloud computing is gaining more and more attention with the ubiquity of on-demand Internet-based services and resources, such as Infrastructure as a Service (IaaS), Platform as a Service (PaaS), Software as a Service (SaaS) and more generally Everything as a Service (XaaS). However, the public cloud offers (Amazon, Google, Microsoft, IBM, etc.) and the cloud software stacks (VMware, OpenStack, Docker, etc.) are extremely heterogeneous in terms of provided services, resources, and API.
The formatter is one of the favourite IDE features of many developers. Always having a consistent code style, never having to worry about tabs, spaces, indentation or alignment is a tremendous help. But have you ever wondered how a formatter works?
With release 2.9, Xtext introduced the world to their new formatter2 API. It allows a formatter to access the text and the node model, as well as the AST. This allows the formatter to have a better understanding of the context, which in turn enables complicated conditional and pattern-aware code formatting.
Pushed by the introduction of Intelligent Transportation System communication technology and demands from customers for vehicle connectivity, new e-services are emerging in the automotive industry. However, the service and product definitions are a tremendous issue as neither end-user nor OEMs requirements are mature enough, mainly due to innovation positioning of products and to diversity of connected devices. In addition, the security is a big concern to clarify in system architecture during the requirement elicitation.
InTheMoodForLife is an application to analyse and monitor sleep patterns of people affected by bipolar disorder.
The setup of the application was done during the Eclipse OpenIoTChallenge and also win the first award of the 2017 edition.
The solution is built using an off-the-shelf sleep monitor, Raspberry Pi, Eclipse Vert.x, and Warp 10.
Vert.x interacts with the sensor producing 140 measurements per second in an "elegant" asynchronous way and stores sensor's data into a time series database, Warp10.
In Xtext's grammar language syntax and structure of models are defined at a single location in a very concise way. The nesting structure and the references between objects are expressed which goes beyond plain abstract syntax trees. By just pointing to a type of an object, we describe the shape of a syntax graph. But the grammar alone has no meaning to describe the visibility rules inside of a resource or across resource boundaries. Therefore Xtext has a concept of scopes that are modeled as a chain of responsibility.
Code formatting is an opionionated 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?
Assuming you are an Eclipse RCP application developer, and you need to quickly create a prototype for your customer, ask yourself:
- Which technology stack would you use to quickly prototype an Eclipse RCP application?
- Is your architecture good enough to be customized and to be used in a real world scenario?
In this talk, I'll present my experience as Eclipse RCP Application developer, explaining how to quickly prototype RCP applications with a simple, effective and extensible technology stack, based on:
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?
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.
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.
For two years, Airbus has performed a huge change in their mindset and focuses more and more on Open-Source. Large applications have been developed with Open-Source technologies but also with Open-Source mindset (open ways of working). Airbus becomes more and more digitalized and there is no digitalization without Open-Source: who have ever seen or done Big Data without Open-Source?
Sometimes it is necessary to test your IoT cloud based system without any actual hardware. Setting up a test cluster of 1.000 IoT gateways and 10.000 sensors is possible, but there is a simpler way.
This talk will show how it is possible to simulate Kura gateways in plain software for unit, single device and scale-out testing.
Do you know how to use the E4 Model Editor to create your modular E4 applications?
And, do you know how to extend your Eclipse RCP application using an E4 model fragment.e4xmi?
E4 model fragments are the default mechanism to extend your Eclipse RCP applications, and this talk's aim is to clearly explain how to use the model editor when dealing with fragments and to show the most recent improvements introduced in the model editor itself.
Container oriented developement is a new way to adopt for today's developers. Although base tooling allow easy and simple deployment to be adopted, developers needs more accurate tools to deal with their day to day operations.
Based on the Eclipse Docker and OpenShift tooling, we will discover how developer tasks can be easily managed from the Eclipse IDE:
Many business applications contain a considerable percentage of form-based UIs for data entry and editing. Developing and maintaining these form-based UIs manually is a tedious and error-prone process. The EMF ecosystem provides great support for developing data-centric UIs for the desktop.
Various Eclipse Modeling technologies are trying to empower domain experts in the creation of specific tools. Using EcoreTools and Sirius a domain expert can define languages, graphical modelers and editors without writing a single line of Java code or launching a new Eclipse runtime. However, when come the time to add behaviors to the language structure (e.g., to implement interpreters, compilers, static analysis, refactoring, or generators), the domain expert has to face all the complexity of Eclipse Plugin development, OSGi, Java and much more.
Have you ever dreamt of customizing your Eclipse workbench using your favorite scripting language? Do you want to add new functions to your favorite IDE without having to learn how to develop an Eclipse plugin? Do you want to provide the ultimate flexibility to your users to let them prototype their own Eclipse plugins?
The scientific community of neutrons and synchrotron facilities is looking for more than 20 years for
a common data format to be able to exchange experimental results and applications to analyse them.
The HDF5 physical container quickly raised a large consensus but the big issue remains on how to
standardize the organisation of data within the container. The CommonDataModelAccess (CDMA)
framework introduces a new level of indirection for data access which offers a solution allowing
EMF Ecore is THE declarative data definition standard on the Eclipse technology stack. Based on Ecore a rich ecosystem of EMF components was able to grow including components for comparing, versioning, visualizing, storing data.
What if I tell you that you can write Java code (or take existing Java code), quickly make it compile with any C++ compiler and produce a native executable with no run-time license and running significantly faster than what you would get let's say with a JVM or even a Java compiler?
You will say I am crazy (and you are probably right)! But this is the promise of the Javolution C++ Open-Source library.
No, the CSS is not just coloring!
The power of CSS is often underestimated, this session of Live-Coding will be an opportunity to show a lot of useful tricks usefull for daily web developers.
Today we enter the post-IE era and we can use much more serenely the power that the CSS offers us; Why skip it!
Every year, the Eclipse Simultaneous Release brings together the hard work of dozens of open source projects into a single coordinated release. But you probably already know that. You probably already live that. While most Eclipse committers don't tend to think of the simultaneous release as a product, most of our users do. For millions of software developers, the the installer and many flavours of Eclipse IDE are products. While it's important that we carefully manage expectations, it's also important that we understand and respect the expectations of our massive user community.
Are you a new committer or project lead for an Eclipse, LocationTech, or PolarSys project? Are you thinking about proposing a new open source project? In this tutorial, Eclipse Foundation staff members will walk you through the information that you need to know to be an effective open source project committer. The discussion includes an overview of the Eclipse Development Process, the Intellectual Property Due Diligence Process, and the Tools and IT Infrastructure made available to open projects by the Eclipse Foundation.
An open source project is more than just a code repository. If you want to be more than a single-developer project in an obscure corner of the world, you need to build community around the code. But building communities of users, adopters, and developers requires planning and work.
If you have a Jenkins master with a handful of agents, or no agents at all, and you would like to go to the next level, read more.
In this session, we will present you the new User Experience of Jenkins: Blue Ocean, and will show how to easily create your Declarative Pipeline using the new Visual Editor. From there, we will then demonstrate how to set up a Job in a few seconds to automatically builds all your branches, your Pull-Requests and post back build status.
SW360 lets organizations manage third-party and own software components throughout the entire life cycle. Using SW360 as a one-stop shop for component information, organizations can track the components used in a project or product to:
•assess security vulnerabilities;
•reliably maintain license information;
•enforce software-related policies; generate customized reports;
•manage BOMs of products/solutions/projects;
•are able to automatically generate project or product required license compliance artifacts (e.g. Readme file / disclosure documents).
I will start presenting the basics of Jenkins core architecture, its extension model, and how plugins interact with it.
Then we will create a new plugin, and I will walk you through how to add simple features to it: get callbacks on different events: completed build, register a Pipeline DSL custom step, run tasks in background...
We will see the specific tooling that has been developed for Jenkins development itself, how to write tests, how to easily start a Jenkins instance with your plugin in it, how to to debug it.
The Model-Driven Design approach is centered on the use of a model repository and a modelling tool. A drawback of the approach is that the evolution of derived artefacts (such as documents, code tests) requires to go back to the model. This process involves tracing the source element back in the model editor before triggering the update of the artefact. This can reveal quite inefficient and even causing user rejection.
Our talk presents a reusable mechanism matured over 5 years in model-based tooling (actually for requirements engineering) and deployed in international companie.
You probably heard about Jenkins. But did you know the Jenkins Project? There's a whole Open Source community behind this. Hundreds of people, hundreds of plugins, hundreds of extension points, sounds similar doesn't it? :-)
In this talk, I will explain how the Jenkins Project operates. How it is governed, how it handles committership, maintenance, infrastructure and many other aspects to keep it running.
For many good reasons, Thales made the choice in 2013 to Open Source its field-proven, largely deployed, but proprietary modeling workbench Capella -- embarking all its enabling technologies such as Kitalpha, EGF, EMF Diff/Merge and Sirius in the process. The journey since that strategic decision has been a very challenging one, with no less than two tremendous transformations implemented simultaneously.
Working on evolving EMF Metamodels?
Testing your business rules?
You surely need easy-to-evolve instances of your metamodel!
In classic approaches, you either had the choice of creating static model instances, which are difficult to maintain, or to use the EMF API (hopefully with some custom helpers) to create compiling models, which are hardly understandable and a real reference nightmare.
Tons of outdated resources or boilerplate code to fix, on a simple metamodel modification, don’t let your tests bring you down.
BOEM will make your day.
The CHOReVOLUTION Studio is an innovative Eclipse-based development environment that supports the realization of secure and dynamic service- and IoT-based applications, e.g., in the Smart Mobility and Tourism domains, built as composition of services and things.
Different internal studies performed on previous Airbus aircraft concluded that display enhancement could be done in terms of legibility and reading comfort. Also, due to the use of several different fonts on the different interfaces, the cockpit homogeneity could be improved.
In the frame of an R&T program, Airbus Human Factors conducted a study for the development of a font that would meet the two above-mentioned criteria.
Some preliminary studies were performed:
This demo session showcases our use of UML for Real-Time (UML-RT) and Papyrus-RT in order to drive the Eclipse PolarSys Rover. UML-RT is a profile of UML specifically designed for real-time embedded (RTE) systems. It has a long, successful track record of application and tool support via, e.g., IBM Rational RoseRT, IBM RSA-RTE, and now Eclipse Papyrus for RealTime (Papyrus-RT). Papyrus-RT is an Eclipse-based, open-source modelling development environment for UML-RT systems. It allows the generation of complete, executable code from models.
From the very beginning, we had to deal with models. No problem, EMF was there for us, providing rich and smart solutions: Sirius for diagrams, OCL for checking, edapt for migration, Acceleo for text generation and so many more. There was a time when everything was for the best in the best of all possible worlds'.
The Eclipse Foundation and Board of Directors have been busy making changes to the Eclipse IP Policy in order to better serve the needs of our community!
We take extreme pride in our IP best practices and invite you to come and learn about our recent IP changes and those that we will be rolling out in the next few months!
We are extremely excited to offer Dual IP Streams now (What's your Type), ensure Eclipse Projects understand the faster approach for Minor and Service Releases of Third Party Prerequisites and our plans to modernize the Eclipse Legal Documentation.
Modularization of software is key to handling the inherent complexity of distributed applications like for the Internet of Things (IoT) and provide a flexible environment to evolve applications and manage their deployment effectively. OSGi is a popular framework for dynamic modules for the Java language. Eclipse Concierge provides a clean, small and lightweight implementation of the OSGi core framework specification, specifically tailored to embedded systems and IoT.
Alambic is an open-source framework and service for the management of software development data. It retrieves information from the various repositories used across the development process (git metadata, issues, continuous integration systems, PMD reports) and provides a unified access to data and metrics. A quality model enables users to assess and visualise the project regarding customisable criteria.
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! :)
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.
CBI can mean different things. Not only "Common Build Infrastructure", but also "Continuous Build Improvement". So whether you just joined the Eclipse community or have been around for a long time, this talk will give you an update what's new with CBI and how you can make use of it for your own project.
Collaboration is an essential part of developing complex systems. In model-based engineering, for example when using Capella, it involves working with models in addition to source code and other artifacts.
This talk proposal discusses the Model-Driven Engineering (MDE) of Real-Time embedded (RTE) systems with soft real-time constraints using UML for Real-Time (UML-RT) and Papyrus-RT. UML-RT is a profile of UML specifically designed for RTE systems. It has a long, successful track record of application and tool support via, e.g., IBM Rational RoseRT, IBM RSA-RTE, and now Eclipse Papyrus for Real-Time (Papyrus-RT). Papyrus-RT is an Eclipse-based, open-source modelling development environment for UML-RT systems.
An IT enthusiast discovers the joys of a Services Company. Faced with all the frustrations, she has three solutions:
- Abandon ship
- Grin and bear it
- Make a difference
You guessed it, I'm here to talk about the third solution. If the environment is unfriendly, change it.
I will try to answer the question "Can I transform a big company into a more geek-friendly environment?" and revealing to you my recipe to make this happen.
Apache Camel framework is one of the most used Integration framework in middleware field. What about reusing it in your IoT infrastructure?
During the talk, I will explain the benefits of Apache Camel and how to leverage them in your IoT infrastructure, from gateways in Eclipse Kura to cloud in Eclipse Kapua.
A demo will show how to use existing Eclipse tooling (mainly Docker, Java debugger and Fuse Tooling) to develop your own Camel integration project and deploy/test them on Eclipse Kura.
Over the course of last year and until now we developed a web based UML modeler based on RAP and GMF.
In this talk we want to share our experiences if building a larger RAP application and the challanges of porting GMF to RAP, highliging some of the many adjustments needed for improved usability and performance.
In this talk we want to show how automation can help getting started on a project or creating a new service for an existing platform.
We will show how Maven, Oomph and Docker can be utilized to start with nothing and end up with
Much more than just yet another modelling tool, Capella is a model-based engineering solution that has been successfully deployed in a wide variety of industrial contexts. Based on a graphical modelling workbench, it provides architects with rich methodological guidance relying on Arcadia, a comprehensive model-based engineering method.
This presentation will focus on this methodological guidance, showing main features with slides and demos on a case study:
The Language Server Protocol in a popular IDE-independent and Language-independent interface to provide and consume language edition services - such as code analysis, completion, hyperlinking... It basically lets the language providers implement the protocol as a server, and the IDEs consume the protocol as a client to have the IDEs presenting the language-specific data without having to know about the language.
This protocol already has multiple successful stories. In this talk we’ll demonstrate:
We run data acquisition at the UK's biggest science project using Java. This year we completed a migration of around three million lines of code in our Java servers to OSGi running with Equinox and declarative services. This is the story of how we did it, the pitfalls and real world examples of what happened.
If you love to write code, employers will queue up to employ you. Okay, some social skills are usually required, and I just assume that you are a talented coder – otherwise you would not love it.
But is employment by a French coproation right for you? Maybe you should look elsewhere in Europe, or head to Silicon Valey (in spite of Trump)? On the other hand, maybe that is to constraining: Maybe a research position would give you more fredom? Or maybe you should try to launch your own business to sell your kick-ass software?
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.
The benefits from children's games is undeniable: developing the imagination and allowing confrontation with the real world, it encourages their development. Often in adulthood, games are badly perceived, seen as a waste of time. What if the benefits of games could help us at any age as a tool of learning?
I will try to explain, based on our experience at codingame, how as a teacher we can use games as a tool.
Even there is no direct link to an Eclipse project, we use vert. x and eclipse on our platform!
Java™ 9 is slated to be released in July 2017. 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 then demo the new features that are already available in Eclipse for the upcoming Java™ release. We will also look at the new Java™ 9 runtime images.
Lexical preprocessors, like the C preprocessor, are a nightmare. Unfortunately, quite a few legacy languages have preprocessing, such as C, C++ and Verilog. For the programmer, these lexical macros can make the code hard to understand and they can create all sorts of surprising side effects.
Continuous Delivery is not something specific to GAFA's. You can do it yourself and use Cloud platforms to optimize your build workload.
Discover how to setup a Continuous Delivery pipeline by using Jenkins as a CD engine and Azure as a Cloud platform : a new commit to the source code repository will automatically trigger a Jenkins pipeline to deploy to multiple environments on Azure.
You will discover the new 'shiny' Jenkins UI during this presentation, how to use dynamic Jenkins agents in the Azure Cloud and how to automate a whole Continuous Delivery pipeline.
What is better 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?
It was at the EclipseCon NA 2011 when I first considered a migration of the open source project OpenChrom (https://www.openchrom.net) to the new e4 platform. The new feature set looked really promising and I thought better switching to e4 earlier than later. I asked several people about the new features at the EclipseCon Europe 2011 again. Then I made the decision to start the migration in December 2011 based on Eclipse 4.1.1.
Eclipse 4 is used since more over 4 years as a powerful runtime that uses dependency injection, application model, spies, and some other powerful features. And ... it can run the Eclipse 3 code thanks to the compatibility layer.
Nevertheless, a lot of companies still develop using the Eclipse 3 mechanisms instead of coding directly with Eclipse 4 artefacts. This can only be a short term strategy that will have a cost later.
Eclipse open source projects reflects the work of its community. At their respective level, anyone can contribute without necessarily having to be an advanced developer.
As a committer I will explain how anyone can contribute with different ways, and the benefits you can get for your professional profile.
Following an introduction of the different types of contributions, this talk will focus more specifically on the code contribution process from both the perspective of the contributor and the committer who accepts the contribution.
Software solutions and everyday objects are becoming increasingly "smarter", take over more "responsibility" and know more and more about us and our intentions. But what does that mean for developers, and what impact does this have on the user? How do we convey the understanding and competence for this Internet of Things? Sascha Wolter covers typical IoT challenges and inspires with crazy and sometimes creepy examples. He also introduces a prototypic approach for hardware and software ideation based on visual programming languages, games like Minecraft, and the Eclipse IDE.
Most developers are failing when studying and creating hardware. We will present best practices for creating comprehensive environment for firmware development eliminating setup, configuration, and debugging problems. This presentation will use Openenergymonitor hardware and Eclipse Che workspace server to create a reproducible and consistent workflow for development for both novice and expert developers. We will present an approach that removes dozens of issues
which may be caused by combinations of operating systems, installed libraries and configurations.
Working with developers for years, I saw so many of them doing their mockups directly with code, loosing a lot of time on it, and sometime be disapointed by the result. However, most of the time, you can achieve a great result with a sheet of paper and a pen.
Starting with a mockup helps to focus on content, usability and features, instead of design. When your mockup is tested with future end users and documented for developers, it’s time to think about design.
In this presentation, we will see
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:
Finally the award-winning EclEmma code coverage plug-in for Eclipse became an Eclipse.org project! This is a good opportunity to summarize experiences and best practices, such as continuous inspection, for efficient usage of one of the most popular open-source tool to measure Java code coverage that EclEmma integrates into Eclipse - JaCoCo ( http://www.jacoco.org/jacoco/index.html ).