Google Summer of Code 2016 Ideas

Existing bugs marked "helpwanted" are a good source of project ideas.

Feel free to contribute the discussion on an Eclipse bug. Keep the discussion on bugs technical. The bugs are not a good place to talk about Google Summer of Code participation. Use the soc-dev mailing list for that.

Rules

• Be creative
• Be specific: what do you want to be implemented
• If you are willing to mentor those ideas, add your name and email to the idea.
• GSoC project ideas should align with an existing Eclipse project
• If you're an interested student, add your name and email next to the idea. It is ok to have several students interested in one idea.
• Aspiring students and mentors need to register and submit their proposals on Google´s Melange

Mentors info

If you were a mentor last year then you are automatically in the list this year (the GSoC site may require that you re-register, but we think of you as "in").

Note that we only accept as mentors people who are known to us. This includes Eclipse committers. If you would like to be a mentor, please either introduce yourself to the group using the soc-dev mailing list, or send a note to Jelena.

Ideas submission

Idea proposal should contain the following information:

• project title, like "WTP - Improve auto-complete in xml editor"
• description with links to bug reports, project wiki pages, etc
• Reporter: who submitted idea (optional e-mail)
• Possible Mentors: who would like to mentor the students
• More info: other links or e-mail
• Eclipse Project: link to main eclipse project that improvement is targeting
• Potential students: who is interested (with optional e-mail). This one completely informal, to actually be interested you need to submit the proposal. Contact the idea owner or possible mentor to get some details before submitting it.

Ideas

These are some ideas. Students feel free to base your GSoC proposals on these ideas (note that you are more likely to find a mentor for an idea that has been proposed by a mentor). Some of these ideas can be factored into multiple projects; a GSoC project proposal can work on parts of these ideas (i.e. you don't necessarily have to do it all).

Package Drone: Implement new repository adapters

Package Drone is a Java/OSGi based software artifact repository with a focus on OSGi.

Although the focus of Package Drone is on Java and OSGi, there are a few repository adapters already which support other repository systems like RPM/YUM, DEB/APT or NPM.

There are lots of other repository systems out there like NuGet, Docker, Python … which could be added to Package Drone. For adding a repository system to Package Drone there is a remote interface required (like a servlet accepting new binaries), meta data extraction from the uploaded content and finally another remote interface for serving these artifacts.

This task would including selecting a repository system, identifying the different use cases and implementing the default use case of this repository system into Package Drone.

To get in touch with the project see the GitHub repository eclipse/packagedrone or contact Jens Reimann. Package Drone is an OSGi (Equinox) application written in Java 8. It uses Jetty, JSP and Bootstrap as Web UI.

Possible Mentors: Jens Reimann

Interested Students: Pubudu Fernando, Ben Navetta, Aditya

Package Drone: Create a REST-based API

Package Drone is a Java/OSGi based software artifact repository with a focus on OSGi.

As of now Package Drone does not really provide an external API to the system. Of course a decent, state-of-the-art, fancy API definitely is a must-have.

This task would include selecting a REST framework which can be used within OSGi and possibly the OSGi HTTP Service. Defining and implementing a few basic APIs. Covering the aspect of authentication and authorization. Providing a few automated unit tests for the API. Optionally providing a client implementation either in Java or any other programming language (as a library and as a command line tool).

Existing Java REST frameworks should be considered for this task and evaluated for implementation. Also in regards to the Eclipse IP policy.

Also see:

• eclipse/packagedrone#9: Open up API for better integration

To get in touch with the project see the GitHub repository eclipse/packagedrone or contact Jens Reimann. Package Drone is an OSGi (Equinox) application written in Java 8. It uses Jetty, JSP and Bootstrap as Web UI.

Possible Mentors: Jens Reimann

Interested Students: Imaculate Misha, Krishni Andradi, Shashank Motepalli , Atishay Jain, Chris Gavanas, Aditya

Package Drone: Mirror artifacts on cloud storage

Package Drone is a Java/OSGi based software artifact repository with a focus on OSGi.

Package Drone does store binary artifacts on the local file system. When artifacts are requested by HTTP requests, these are served from the local file system to the client.

The task would be to enhance Package Drone in a way that artifacts get uploaded to some cloud store like Google Cloud Storage or Amazon S3 in addition or as a replacement to the local file system. When artifacts have to be served to a client the server will send a HTTP redirect (if possible) instead of streaming the binary data.

Of course binary management on the cloud storage has to be managed by Package Drone in a way that transactional update still work, that consumers of the data which require a stream instead of a HTTP requests still work and that storage space gets cleaned up at some point.

To get in touch with the project see the GitHub repository eclipse/packagedrone or contact Jens Reimann. Package Drone is an OSGi (Equinox) application written in Java 8. It uses Jetty, JSP and Bootstrap as Web UI.

Possible Mentors: Jens Reimann

Interested Students: Atishay Jain, Prajakta, Aditya V

Package Drone: Gather and store metrics for artifacts

Package Drone is a Java/OSGi based software artifact repository with a focus on OSGi.

Package Drone stores and serves binary artifacts. For some parts the "current" statistics can be generated. Like the number of artifacts, the number of bytes etc.

For gathering long term in information Package Drone should be enhanced for having some sort of metric storage, which can in addition render nice charts in HTML. Information should be stored over time and adding new metrics inside Package Drone should be easy. Also should there be an internal API for reading metrics.

In addition a few new metrics should be implemented, like number of downloads, number of logins, time for processing, ...

If possible time series storage and HTML charts should not be implemented completely, but appropriate open source solutions should be integrated.

To get in touch with the project see the GitHub repository eclipse/packagedrone or contact Jens Reimann. Package Drone is an OSGi (Equinox) application written in Java 8. It uses Jetty, JSP and Bootstrap as Web UI.

Possible Mentors: Jens Reimann

Interested Students: Chamil Elladeniya, Aditya

Package Drone: Implement a secondary index

Package Drone is a Java/OSGi based software artifact repository with a focus on OSGi.

At the moment Package Drone stores all information in-memory and on disk. But without generating any index information with that. It is planned to implement some indexing at a later time.

For this task a secondary index for user interaction should be implemented which takes in account all data gathered and extracted by Package Drone in order to manually search for artifacts. This search should also be integrated into the Web UI.

As a backend for indexing we had Apache Lucene/Solr in mind. But this was only a first guess. Maybe there is a different open source solution for this task.

To get in touch with the project see the GitHub repository eclipse/packagedrone or contact Jens Reimann. Package Drone is an OSGi (Equinox) application written in Java 8. It uses Jetty, JSP and Bootstrap as Web UI.

Possible Mentors: Jens Reimann

Interested Students: Atishay Jain, Aditya

EASE: Add support to sign and verify scripts

EASE is the scripting project for eclipse. It allows to execute scripts from local and remote resources. To increase security (especially for remote scripts) we want to support script signing and verification.

Your task would be to

• create a signing mechanism for scripts (arbitrary text files)
• verify signed scripts upon execution
• provide preferences to enable/disable execution of unsigned scripts
• provide UI to warn users of unsigned scripts/invalid signatures

When you think of applying for this project, you should have experience on signature creation and verification. Further it would be beneficial to get accustomed to EASE.

If you are interested, you need to introduce yourself on our mailing list which you find on the project page.

Possible Mentors: Christian Pontesegger Interested Students: Danoja Dias dilshan kanchana

EASE: Support generic script keywords

EASE is the scripting project for eclipse. It allows to execute scripts from local and remote resources. Users may write their own scripts and augment them with keywords, that trigger custom actions, eg bind scripts to dynamically generated buttons in toolbars or menus. Currently the keyword mechanism is limited to fixed keywords. The idea is to allow users to add their own keywords and also allow them to detect, change and react on them.

Your task would be to

• create a UI for the Properties view to display and change keywords of a script
• change the current Publisher/Subscriber pattern for keywords to use the event bus of eclipse
• Adapt current keyword listeners for toolbars to use the event bus
• provide a new keyword handler to enable scripts to run at a certain time, like a cron job.

When you think of applying for this project, you should be familiar with the usage of EASE scripts, so you should know about the keyword mechanism and what it does. Further playing around with the event bus might be helpful.

If you are interested, you need to introduce yourself on our mailing list which you find on the project page.

Possible Mentors: Christian Pontesegger

Interested Students: Jayamine Alupotha, Vidura Mudalige

Vorto: Web based Graphical IoT System Modeling Tool

Vorto is an IoT toolset for eclipse that allows users to describe characteristics and services of real world devices in a technology agnostics language, so-called information models. The information models are hosted in a centralised Information Model Repository. Vorto Code Generators then translate the information models into platform - specific code.

The Vorto Web based IoT System Modeling tool provides user to design/model the IoT solution in a graphical way using web browser (Chrome/Firefox) using HTML5 canvas.

List of stories would be,

• With the browser canvas, user should have ability to drag and drop IoT elements with appropriate icons from artifact browser.
• Connect the different IoT elements with flow lines and add text/notes for each elements.
• The library can use any open source javascript library compatible with EPL. (Some Inspirations jointJs, D3)

A sample Ui mockup that can be generated from this tool should look something like https://vorto.mybalsamiq.com/projects/vorto/IoT%20System%20Modeler%20Concept

To get in touch with the project source code, please check out the source code repository on Github (https://github.com/eclipse/vorto).

Possible Mentors: Nagavijay Sivakumar

Interested Students: Tharindu Madushanka, Peter Szabolcs Nagy

Vorto: Web-based Editor to describe IoT devices

Vorto is an IoT toolset for Eclipse that allows users to describe characteristics and services of real world devices in a technology agnostics language, so-called information models. The information models are hosted in a centralized Information Model Repository. Vorto Code Generators translate information models into platform - specific code.

The key aspect here is that brings the Vorto DSL to the web that lets user to easily describe devices with Vorto in a webbased fashion. In this context the new xtext eclipse project's feature can be leveraged to simplify the implementation.

Your task would be:

• Implementation of a web-based IoT Information Model Editor using Eclipse Xtext that can be directly reached from the Information Model Repository. The editor should have syntax highlighting, code-completion and model validation features, similar to the Eclipse-based Vorto toolset.
• Allow users to save their models in draft state in a development workspace of the Information Model Repository.
• Allow users to publish models in completed state to the release workspace of the Information Model Repository.

I created a UI mockup, of how it could possibly look like: https://vorto.mybalsamiq.com/projects/vorto/Information%20Model%20Web%20Editing

To get in touch with the project source code, please check out the source code repository on Github (https://github.com/eclipse/vorto).

Possible Mentors: Alexander Edelmann

Interested Students: Aaron Cho,Rishabh Banga,Ítalo Batista

ChemClipse: Chemical Pattern Recognition

ChemClipse is an open source framework for chromatography/mass spectrometry. It aims to be an alternative for analytical chemistry in the same way as LibreOffice is for office suites. It is based on Eclipse RCP technology and can be extended by plugins in many different ways. We will have a look at the topics:

• Statistics and machine learning
• Chemistry and Life Science

Students will learn how to use different technologies like SWT, Eclipse e4, Dependency Injection, Event Broker, OSGi to create functionality that extends the ChemClipse framework as well as Maven/Tycho and JUnit to enable automated tests and builds. We will explore real world data sets, e.g. wood or whisky samples, for statistical analysis and machine learning purposes. The goal is to characterize unknown samples in a similar way pictures are classified by machine learning algorithms. Therefore, we will re-use existing libraries (e.g. Apache Math, EJML, ...). Moreover, we will write code to extend and improve existing functionalities in the PCA (Principle Component Analysis) plugin. Nowadays, analytical chemistry is already an important technique in many areas. Moreover, it will become more important when it comes to analyze healthcare data or to protect our environment.

Please follow the tutorial how to check out the source code: https://wiki.openchrom.net/index.php/Development

Possible Mentors: Philip Wenig

Interested Students: Rafael Aguayo

Interested Students: Akshika Wijesundara

Eclipse SmartHome: Integrate with Google's Physical Web

• Description: Google's Physical Web is a new approach to make things easily discoverable and usable based on proximity information. As Eclipse SmartHome deals with many "Things", it would be nice to smoothly integrate with the Physical Web, i.e. an Eclipse SmartHome instance can announce itself and could potentially make subsets of things available based on the user's location. The project could also target openHAB 2 and its Android app and iOS app, where BLE beacon support could help on indoor location and writing urls to the beacon.

• Proposal Focus: A project proposal could include the following features:
  • An Eclipse SmartHome instance (e.g. the openHAB 2 runtime) should announce itself through mDNS in the local network. Any smartphone that is in the same network and has the Physical Web app installed should directly find the instance and open the web client (Eclipse SmartHome Classic UI) of it.
  • A concept for persons and locations should be introduced, which allows tracking user locations, so that rules can compare and relate user and beacon locations.
  • BLE beacons could be programmed with (local) URLs that are location specific (e.g. "living room") and which open the web client with this context, i.e. directly display the page for the living room. As this uses local URLs, this obviously only works for smartphones that are on the local network.
  • As an extension, the BLE beacons could use public URLs that point to https://my.openHAB.org (or some other reverse proxy mechanism), which can provide access to certain functionality for guests that are NOT on the local network. The tricky part of this is how to ensure the proximity of the guest (it should only provide access, if he is physically present). The beacons might have to broadcast a temporary access token with the URL that needs to be validated by the reverse proxy service.
  • As openHAB 2 is the main open source solution that uses Eclipse SmartHome, its native smartphone clients could be enhanced to directly support the Physical Web: BLE beacons could be directly programmed with a location-aware URL (similar to programming NFC tags) through the smartphone app.
  • Additionally the native apps could use the BLE beacons to determine the current location of the user (at the granularity of a room, if there is at least one beacon inside) and provide this information to the runtime, so that rules can make use of this information for context-aware use cases.
  • Last but not least, the last two features can be combined: The smartphone app (in the background) reports the user location to the runtime, which in turn sends local mDNS (or global BLE) announcements for the room or even for relevant devices within this room.

• Possible mentor: Kai Kreuzer
• Interested Students: Upekshe Jayasekera
• Interested Students: Daniel Ndzo

EMF Forms goes AngularJS: A web-based editor for UI schemata

EMF Forms is an Eclipse framework to efficiently develop form-based UIs (see http://eclipse.org/ecp/emfforms/). It also provides a renderer for web applications called “JSON Forms”. JSONForms transfers the concepts of EMF and EMF Forms to a JSON Schema and AngularJS based web stack. EMF Forms provides extensive tooling support for the development of declarative UI descriptions (“view models”). However, the existing tooling is focused on desktop UI toolkits, such as SWT or JavaFX. The goal of this project is to develop a web-based UI schema editor for JSON Forms, the new renderer of EMF Forms. As the Eclipse-based desktop version, the UI schema web editor should allow to load UI descriptions (“UI schemata”), specify form-based UIs, preview them and modify the underlying data model. To achieve a modern look and feel, the editor shall be implemented as an AngularJS application. It should also integrate with the typical toolchain, such as Eclipse and Git. The existing desktop editor can be used as a template, however, we aim an optimal usability for the web, so any creative ideas for a innovative user concept are welcome.

• Possible mentor: Jonas Helming
• Interested Students: Francisco Capalbo

EMF Forms goes AngularJS: Backend integration with OpenAPI

EMF Forms is an Eclipse framework to efficiently develop form-based UIs (see http://eclipse.org/ecp/emfforms/). It also provides a renderer for web application called “JSON Forms”. JSONForms transfers the concepts of EMF and EMF Forms to an JSON and AngularJS based web stack. While integration of desktops applications with backends is often done in Java and transparent for the UI, web applications are typically connected to REST services. The state-less and asynchronous way how single-page web applications typically operate, requires framework support for an efficient integration of form-based UIs with RESTful backends. The state-less and asynchronous way how single-page web applications typically operate often requires framework support: One prominent example is OpenAPI for documenting and describing such APIs, Having a description of an API also allows for a wide range of use cases , such as rapid prototyping or scaffolding. Our goal is therefore to integrate JSONForms with OpenAPI in order to derive declarative Web UIs for REST endpoints, which are ready-to-use while still being highly customizable.

• Possible mentor: Maximilian Koegel
• Interested Students: Hector Gabaldon
• Interested Students: Suharsha Fonseka [[1]]

Eclipse CHE: Pair programming with Eclipse Che Cloud IDE

Eclipse CHE is an open source developer workspace server and cloud IDE.

The goal is to improve the existing POC of a pair programming plugin for Eclipse Che. At the moment, the POC shows a live pair programming experience between multiple IDEs at the same time. https://drive.google.com/a/codenvy.com/file/d/0B9vGYZYE8V2xaVI1MUxQRGpyd0U/view

The plugin has been demoed during:

• Eclipse Con Europe 2015
• Eclipse Con NA 2016

Student will help me in adding new features:

• Display cursors of other participants
• Chat feature
• Show notification when other files not opened are being modified

In addition, we will make it "production ready"

• cleaning code
• packaging
• unit testing

Eclipse Che uses Orion as an embedded editor and connects to a flux server for the pair programming session, so we will focus on these 3 projects.

• Possible Mentors: Sun TAN
• Interested Students: Randika Navagamuwa , João Martins, Xin Wei Xin Wei Umang Shah,Rakesh Bute

Eclipse CHE: JUnit and TestNG test runner for Eclipse Che

Eclipse CHE is an open source developer workspace server and cloud IDE.

At the moment, there is no test runner in Eclipse Che. Developers can run their tests through maven or the command line.

To goal is to write a plugin to have a test runner that is similar to the one for Eclipse IDE

• with a nice UI View to see the test that has been launched
• right click on a class that is testable should shows the action "Run as Junit test"
• the ability to see the stacktrace and go to the failing class
• see the differences when using assertions
• the framework should avoid duplucation: testng and junit implementation should use the same UI and services, and we should be able to add more.

• Possible Mentors: Florent Benoit
• Interested Students: Wang Zhipeng
• Interested Students: Jayamine Alupotha
• Interested Students: Mirage Abeysekara
• Interested Students: Amila Irosh
• Interested Students: Huang Mincong

Eclipse CHE: Datasource plugin for Eclipse Che4

Eclipse CHE is an open source developer workspace server and cloud IDE.

Previously we had a datasource plugin for Che3. See demo https://drive.google.com/file/d/0B9vGYZYE8V2xUF9XcHRTOG5oV0k/view?usp=sharing

To goal is to rewrite this plugin for Che4.

• Find a replacement to Schema crawler which is LGPL and can't be used in Che
• Adapt UI
• Adapt datasource discovery to detect the Che runtime process rather than Docker runner

• Possible Mentors: Stéphane Tournié
• Interested Students: Nishadi Kirielle

Eclipse FLUX: Improve Eclipse Flux

Eclipse Flux is an open source project to connect development tools in the Cloud such as cloud IDEs. Several demos demonstrate pair programming, file system synchronization and JDT usage over the cloud features.

The goal is to improve the existing demos and move the project status from POC to Production ready.

Student will help in improving the project by adding more tests, refactoring code and packaging the product. Here are some ideas of improvement:

• Flux FS sync in java. A work have been done by Kevin Pollet Flux file watcher. The idea would be to move this library to flux and try to reuse the same java library in the Eclipse plugin.
• Upgrade Socket IO client and server
• Improve flux packaging
  • have a Flux plugin in Eclipse Market Place
  • move the java socket io lib to maven (current build is a pain, no way to have this as a dependency)
• Use the FS sync in a Eclipse Che workspace
• Re-implement the real-time editing to use operational transformations. This requires some research in the area of operational transformations and good coding skills in Java and JavaScript. The goal would be to implement a solid test suite for operational transformations and implement it both as a library in Java and JavaScript.
• Implement an "instant collaboration" feature for Eclipse: [2] - this requires knowledge in Java, learn how to build Eclipse plugins, knowledge in JavaScript is a plus, maybe some experiences with Node.js

• Possible Mentors: Martin Lippert

The Rover Project - Basic Autonomous robot behavior

The rover is an autonomous tracked vehicle equipped with capable hardware and different sensors and actors (see also: [3]). It is used to demonstrate the potential of different tools in the Eclipse eco system, for example Papyrus and Xtext. The rover is remotely controlled over a wireless network using a rather low-level web socket API. In this scenario one has to deal with slow or interrupted connections. In order to mitigate the effect of a flaky connection, the rover shall be able to execute high-level commands on its own. This should make remote controlling easier and also help the rover to stay safe.

The goals are:

• Implement a high-level API for motion control of the rover with features such as obstacle detection, path planning etc.
• Expose the new API using web sockets.

Not all of the functionality has to be implemented from scratch. The use of third-party libraries is encouraged if they are compatible with the EPL.

• Possible Mentors: Martin Jung, Ralf Ellner

The Rover Project - DSL for autonomous behavior

The rover is an autonomous tracked vehicle equipped with capable hardware and different sensors and actors. It is used to demonstrate the potential of different tools in the Eclipse eco system, for example Papyrus and Xtext. At the moment the rover is remotely controlled by an operator. In the future the rover shall be able to operate autonomously. To describe the autonomous behavior in an abstract and concise way, a textual Domain Specific Language (DSL) shall be created using Xtext. The DSL shall contain elements to express conditional behaviour, stateful behaviour, event handling and failure handling

The goals are:

• Create a Xtext-based DSL to model the autonomous behavior of the rover. The editor should provide syntax-highlighting, code-completion, and model validation.
• Implement a codegenerator or interpreter to execute the models using the existing API for the rover.
• Implement infrastructure to deploy models to the rover.

• Possible Mentors: Martin Jung, Ralf Ellner

The Rover Project - Code generation from SysML

The rover is an autonomous tracked vehicle equipped with capable hardware and different sensors and actors. It is used to demonstrate the potential of different tools in the Eclipse eco system, for example Papyrus and Xtext. The software and system architecture of the rover and its remote controller is modeled using Papyrus, UML, and SysML. The model already contains information about the communication API which can be used to generate platform-specific code.

The goal is to implement a codegenerator to generate basic runnable code from the architecture model. The generated code shall have extension points to add implementation specific behavior.

• Possible Mentors: Martin Jung, Ralf Ellner