Google Summer of Code 2014 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 EMO.

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).

There are other sources of ideas. There are numerous bugs in the Eclipse Bugzilla issue tracking system marked as "helpwanted" that may give you ideas.

Eclipse Code Recommenders: Snippet Sharing Infrastructure

Eclipse Code Recommenders comes with a code-snippet search called Snipmatch (developed during previous Google Summer of Codes). Snipmatch allows users to search for and insert code snippets right in their Java editor; all it takes is Ctrl+Enter and a full-text search springs to life.

Under the hood, Snipmatch searches a single snippet repository which is currently backed by a Git repo, to which users can upload new snippets using EGit. Doing so is not supported by Snipmatch's UI yet. Moreover, only a single snippet repository is supported, which makes it impossible to use multiple sources for your snippets.

The goal of this project is to create the necessary infrastructure to manage multiple snippet repositories, possibly with different backing implementations (Git repo, filesystem, Eclipse's built-in templates). Moreover, this project should develop a uniform UI for sharing snippets with other developers.

Additional Resources: Bug 427905

Possible Mentors: Andreas Sewe, Marcel Bruch (contact us on the mailing list)

Interested Students: Olav Lenz,Nishtha Goel, Ashwin Jha (ajha[dot]dev[at]gmail[dot]com), Ji Oh Yoo, Dániel Fülöp (nearnaln[at]gmail[dot]com)

Eclipse Code Recommenders: Livedoc XXL

With version 2.0, Eclipse Code Recommenders made the jump from the Eclipse IDE into the Web: With Livedoc (developed during the Google Summer of Code 2013) it became possible to enrich your good ol' Javadoc with intelligent recommendations on how to use an API.

Livedoc, a stand-alone command-line application makes it very easy to generate enriched Javadoc for your JARs. At the moment, however, it works one JAR at a time.

The goal of this project thus is to create to enhance Livedoc such that it becomes possible to create a large, interconnected web of documentation for different APIs (and in different versions) that can be deployed to download.eclipse.org as a showcase for Eclipse Code Recommenders and Livedoc. Who knows, it may even become the default Javadoc for other Eclipse projects.

Additional Resources: Bug 428066

Possible Mentors: Andreas Sewe (contact me on the mailing list)

Interested Students: Patrick Gottschaemmer, Ashwin Jha (ajha[dot]dev[at]gmail[dot]com)

Eclipse Code Recommenders: Xtext-based Editor for the JFace Template Language

Snipmatch is an incubator project of Eclipse Code Recommenders that makes it easy to search for and insert code snippets into your Java code. It also makes it possible to create new snippets and share these with other developers.

These snippets are written in the JFace template language, a very powerful language which unfortunately not everyone is familiar with. Thus, first-class editor support is needed. This is where Xtext comes in.

The goal of this project is to create a full-fledged editor for the JFace template language usable by Snipmatch (and possibly other projects). It should offer syntax highlighting, code completion, and (last but certainly not least) user-friendly error reporting. One possible stretch goals is the ability to automatically create JFace templates from any piece of selected Java code.

Possible Mentors: Andreas Sewe, Johannes Dorn (contact me on the mailing list)

Interested Students: Stefan Prisca (please note: knowledge of formal grammars and compiler front-ends is very beneficial), Lakmal Muthugama

Eclipse Code Recommenders: Rich Data Visualization for Developer Statistic

Developer Statistics is an incubator project of Eclipse Code Recommenders that tracks how developers use their Eclipse IDE. If you ever wanted to find out how you use code completions or what commands you use most often, Developer Statistics has the answer.

Collecting a wealth of statistical data about a developer's workflow is not enough, however. To produce useful insights this data has to be presented to the developer.

The goal of this project is to develop a rich visualization of the data collected, to enable the developer to drill down and find out how to make more efficient use of the Eclipse IDE's features.

Additional Resources: Bug 429959

Possible Mentors: Timur Achmetow, Andreas Sewe (contact us on the mailing list)

Interested Students: Manan Dey, Akif Etkü, Pubudu Gunatilaka, Jitin Tanwar

GeoTrellis: Multi-band Raster support

GeoTrellis is a project recently submitted to become part of LocationTech. It is a framework for fast, parallel processing of raster data in the geospatial domain. GeoTrellis provides a number of operations to manipulate raster data, including cropping/warping, Map Algebra operations, and rendering operations, as well as vector to raster operations such as Kernel Density and vectorization of raster data.

Multi-band rasters are a group of rasters that have the same spatial extent and resolution. Examples might include rasters of different spectral bands or a time series of rasters. The ability to deal with a group of rasters like this is common in GIS software, for example GRASS GIS and R (RasterStack, RasterBrick) have this capability.

GeoTrellis currently lacks the infrastructure to handle such a collection of rasters as a single entity. The goal of this project is 4-fold:

1. Investigate options for ARG multi-band files (may just be multiple ARG files)
2. set up GeoTrellis to treat a group of rasters as a single entity
3. provide a framework for developing operations on these raster groups
4. implement some number of these operations.

One example of an operation is combining red, green, and blue spectral rasters to output a full-color PNG image. Another example is performing a calculation on a vector of values for each cell. If you imagine the rasters as 'stacked' on each other, the vector would be formed from the stack of values for each cell.

Possible Mentors: Rob Emanuele, Eric.J.Christeson (contact us on our mailing list)

Interested Students: kelum

GeoTrellis: SEXP Operation Parser \ Python Bindings \ Javascript Bindings

GeoTrellis is a project recently submitted to become part of LocationTech. It is a framework for fast, parallel processing of raster data in the geospatial domain. GeoTrellis provides a number of operations to manipulate raster data, including cropping/warping, Map Algebra operations, and rendering operations, as well as vector to raster operations such as Kernel Density and vectorization of raster data.

GeoTrellis is written in and used from Scala. However, recently someone contributed an S-expression (SEXP) parser that could convert strings of SEXP into operation chains that could be executed against GeoTrellis (see https://github.com/ahinz/geotrellis-sexp-example). If this parser is complete, and operation execution could be specified by a string, then a web service (local or remote) could be set up to execute arbitrary GeoTrellis operation chains.

One use for such a service would be to create a python and\or javascript library that allowed idiomatic code to be written for describing the execution chain, that would be compiled down to these SEXP. That SEXP would then be executed by the server, and the result would be sent back to the client. This would allow for bindings to be made for GeoTrellis without having to actually run any JVM code from the target language.

Possible Mentors: Rob Emanuele, Adam Hinz (contact us on our mailing list)

Interested Students: Tharindu Madushanka

GeoTrellis: GeoTiff Reader

GeoTrellis is a project recently submitted to become part of LocationTech. It is a framework for fast, parallel processing of raster data in the geospatial domain. GeoTrellis provides a number of operations to manipulate raster data, including cropping/warping, Map Algebra operations, and rendering operations, as well as vector to raster operations such as Kernel Density and vectorization of raster data.

Currently GeoTrellis requires an additional set of dependencies for reading GeoTIFF files: the geotrellis-geotools project, and GeoTools, which is a large dependency. GeoTrellis has code for writing GeoTIFF files, but we need a Scala-based, fast way to read files of the GeoTIFF format. In this project you will write library functionality to read raster data in the GeoTIFF file file format into GeoTrellis Raster data types. Emphasis will be placed on IO performance, and adhering to the GeoTIFF specification.

Possible Mentors: Rob Emanuele, Erik Osheim (contact us on our mailing list)

Interested Students: Johan Stenberg

Implement Generics support for the JFace viewers and migrate viewers from Eclipse UI

Last year a student migrated the JFace viewer framework partially to generics. In this task you will finish this work and also migrate interesting viewers from org.eclipse.ui to a new bundle to make them available for pure Eclipse 4 applications.

Possible Mentors: Lars Vogel

Interested Students: Jeanderson Candido

Performance work in Eclipse

In this project you will trace the Eclipse platform, identify performance bottlenecks and fix them. You will also configure and setup the platform performance tests to ensure that the performance of Eclipse can be reliable measured.

Possible Mentors: Lars Vogel, Pascal Rapicault (pascal[at]rapicorp[dot]com), Max Rydahl Andersen (manderse[at]redhat[dot].com)

Interested Students: Matthias Mailänder (proposal)

Eclipse Platform SWT: Native Wayland support

Wayland is the next generation display server for Linuxes. The project will port SWT to be native Wayland client from its current X background. The work involved will be:

• porting all direct X* function call to display server agnostic one available from GTK or to Wayland specific if such is not available
• port all gdk_x11_* function call to display server agnostic one or to gdk_wayland_* one if such is not available
• verify that SWT runs on top of Wayland without XWayland installed
• testing and performance optimization to get Eclipse IDE working well.

Additional Resources: Gnome Wayland porting part 1, Gnome Wayland porting part 2

Possible Mentors: Alexander Kurtakov (contact us on the mailing list)

Interested Students: Joshua Barkovic - joshbarkovic@gmail.com

Add CSS support to Nebula NatTable

Nebula NatTable is a flexible framework to compose tables and grids with a lot of custom functionality. It already supports a very flexible styling approach, but currently you need to know about NatTable specific configurations for styling. In the current development state, there is theme styling added to NatTable, to make it easier to change the styling. Creating a plugin that adds CSS support for styling a NatTable would make it even easier to style a NatTable. It would also help on styling Eclipse 4 applications in one place instead of having several styling approaches.

As it would introduce dependencies to the Eclipse framework, the CSS styling engine should be implemented as new NatTable plugin.

Bugzilla Ticket Forum Discussion Extending CSS to handle new widgets

Possible Mentors: Dirk Fauth

Interested Students: Sameera Sampath - sameera.sampath@gmail.com

Add support for new message extension to the Externalize Strings wizard

With Eclipse 4.4 the new message extension was introduced for plugin-development.

Users should be able to select whether they want to externalize the Strings using the old NLS or the new message extension mechanism.

While creating the properties file should be the same, the Java file generation needs to be slightly different.

In the following blog post you should get some ideas on the Java file generation: http://blog.vogella.com/2013/06/25/eclipse-internationalization-part-34-migration-by-dirk-fauth/

In the linked posts there you should get also some more information on the new message extension if needed.

Bugzilla Ticket

Possible Mentors: Dirk Fauth

Interested Students: Manan Dey,Nishtha Goel.

Add TranslationRegistry to support the Eclipse Translation Pattern as a service

With Eclipse 4.4 the possibility for Locale changes at runtime is introduced. While the application model itself solves this via MLocalizable and corresponding internal mechanisms, there needs to be manual efforts in the UI to achieve this.

In the following blog post this is called "Eclipse Translation Pattern": http://blog.vogella.com/2013/08/12/eclipse-internationalization-part-44-new-features-by-dirk-fauth/

To make it easier for developers to add that support, it would be a good idea to have something like a "TranslationRegistry". The idea would be to have such a registry where a user registers a Control with the corresponding translation key or Messages field. On a Locale change this registry would iterate over all registered controls and update the localized attribute accordingly.

I first thought it should be some extension for JFace, but as E4 is UI toolkit independent, a better idea would be some service in e4.ui.services. This way the definition would be UI toolkit independent, and every UI toolkit could create a custom registry that take the UI tookit control specifics into account.

Bugzilla Ticket

Possible Mentors: Dirk Fauth

Interested Students: Nishant Gupta

Eclipse IoT: MQTT test and simulation plug-in (Paho)

The initial contribution of the Eclipse Paho project contained an Eclipse plug-in that provides a very basic UI for connecting to an MQTT broker and publish/receive MQTT message. However that tool is not very intuitive and the proposed project would basically consist in revamping it.

The work involved would include:

• Take the existing plug-in and provide an automated build so as possible adopters can easily install it via an update site,
• Propose and implement improvements to the existing UI such as: use dialog settings to persist some values, ability to save settings (e.g. "connect to broker X and subscribe to /Y and /Z") so as it is easy to test a given communication scenario
• Propose and implement simulation-like features, e.g. "publish a random integer value between 1 and 3 on topic X every 5 sec"

Code of the current tool is available here: http://git.eclipse.org/c/paho/org.eclipse.paho.esf.git/tree/org.eclipse.paho.client.eclipse.view

Possible Mentors: Benjamin Cabé

Interested Students: Buddhika Dilhan

Eclipse Sirius: JavaFX based Diagram Editor

Eclipse Sirius is using GEF + GMF as underlying frameworks to provide a generic and configurable diagram editor.

JavaFX on the other hand could enable a whole new approach to user interactions by leveraging effects, transitions and animations for instance.

The proposed project would consist in prototyping a generic diagram editor only using JavaFX, EMF and Sirius.

The work involved would include:

• List the current interactions a user can do (create an node, an edge, enable / disable a layer) and design the user interaction in the JavaFX based editor
• Work with the team through bugzilla and gerrit/
• Develop the Eclipse plugins hosting this editor

Possible Mentors: Maxime Porhel, Alex Lagarde, Cédric Brun (contact us on the mailing list)

Interested Students: João Martins (joaomartins27396@gmail.com) Shashank vadali (shshnkvadali@gmail.com) Nupur Mittal (nupurmittal10@gmail.com)

Eclipse Sirius: Specification model initializer

A modeling workbench created with Sirius is composed of a set of Eclipse editors (diagrams, tables and trees) which allow the users to create, edit and visualize EMF models.

The editors are defined by a model which defines the complete structure of the modeling workbench, its behavior and all the edition and navigation tools. This description of a Sirius modeling workbench is dynamically interpreted by a runtime within the Eclipse IDE.

The proposed project would consist in prototyping a generic initializer tool to help the specifier initialize its representation descriptions. It could be a set of wizards/actions:

• to automatically create a mapping/style/tool structure from the metamodel (or a subset of it) according to a representation template/type.
• to complete the specification model directly from the modeler in a live specification mode

This could be a use case for EEF, the Extended Editing Framework.

The work involved would include:

• List generic representations types/templates a specifier could need to fastly initialize a VSM.
• List the current interactions a specifier could do (create or modify a mapping, a style, a tool) in a live specification mode.
• Design the corresponding wizards/actions/...
• Work with the team through bugzilla, gerrit and the mailing list.
• Develop the Eclipse plugins hosting this initizalizer.

Possible Mentors: Maxime Porhel, Alex Lagarde, Cédric Brun (contact us on the mailing list)

Interested Students: João Martins (joaomartins27396@gmail.com)

Eclipse IoT: MQTT Google Chrome App

There are few desktop client for MQTT and tools that might help debugging MQTT applications. Google Chrome App can use full TCP, so we can have a full MQTT client inside Chrome http://developer.chrome.com/apps/app_network. As an example, the CoAP community have Copper (https://addons.mozilla.org/it/firefox/addon/copper-270430/), and most people find it extremely useful for testing their apps and things.

The work involved would include:

• Adapt Paho Javascript client or MQTT.js to run inside a Google Chrome App over the exposed TCP API.
• Design and develop a user interface for MQTT, which can even be open sourced on its own and run with MQTT over Websocket. It might be based on AngularJS or any other popular JS framework.
• Develop the MQTT Google Chrome App based on the adapted MQTT client and designed UX.

Possible Mentors: Matteo Collina, somebody from Paho or Mosquitto?

Interested Students: Rahul Kadyanhaddada seif Sandro Kock

Project Explorer and Common Navigator

This not so much an idea itself, but more a pointer to a whole bunch of ideas for ways that students can make real contributions to the Eclipse community.

There are a large number of bugs (of varying complexity) open against the Project Explorer and Common Navigator. There is some discussion on a recent blog post. Consider selecting one or more of these as the basis of project proposal.

Possible Mentors: unknown

Students: please be mindful that as long as the "possible mentors" above is empty, the chances of having a proposal based on this entry accepted is generally smaller than that of a suggestion that does have possible mentors.

Implement an SLF4J-based Logging Center for Eclipse

Eclipse projects use a wide variety of Logging Frameworks like Log4J, Logback, Apache Commons Logging, OSGI Logging and probably many others more. While logging per se is a good thing, there is no central instance in Eclipse that allows to configure the logging system for *all* plugins. This proposal aims to find a student who implements a small logging center that allows to dynamically (re-)configure a logging system based on Logback (i.e, changing log levels for categories at runtime, adding new appenders, displaying logging events in a separate logging view, and finally persisting these settings).

See Bug 358968 for a comprehensive discussion on this issue.

Possible Mentors: Marcel Bruch

Students: Pawel Nowak (siersciotluk at gmail . com), Ashwin Jha (ajha[dot]dev[at]gmail[dot]com), Charles Hsia(charleshsia at yahoo dot com)

Notification Center for Eclipse

Today, when a long running task completes in Eclipse, the only way to notify the user about the success or failure of the task is to open a dialog. Unfortunately, this type of interaction breaks the user's flow since the dialog has to be dealt with. Instance of such dialogs are the Eclipse restart dialog, the git 'end of push dialog', and many others. Another approach used to to notify the user is in the form of popups. However depending on the implementation, the popup may not stay long enough on the screen, thus forcing the user to act quickly, breaking its flow.

In the context of this project, I would like to explore the addition of a notification center. Like on phones and tablets, this notification center will offer a unique place for notifications to be posted, and thus provide users with one place to see the notifications. The expected deliverables are:

• An actual notification center presenting all the notifications (details to be discussed)
• An API to post notifications

Functionality wise, a notification should have a severity, have a short and long description, be actionable (e.g. the user should be click to get a view or a ), have a way to decide if a popup can be opened, etc.

Possible Mentors: Pascal Rapicault (pascal[at]rapicorp[dot]com), Max Rydahl Andersen (manderse[at]redhat[dot].com)

Students: Mayank Sharma (imptodefeat[at]gmail[dot].com). Manan Dey (manandey1[at]gmail[dot]com). Sukrit Handa (sukrit.handa[at]gmail[dot]com .

Simplification of the import wizards

Importing a project in the IDE is one of the first thing a user has to do. Yet the experience is far from being smooth as it takes a lot of habits or lot of luck to pick the right wizard to use (e.g. Am I importing a maven project, an eclipse project, files into an existing project, etc.).

In order to help improve the situation, I would like to explore the creation of a smarter import wizard that only takes the URL or a filesystem path, does all the magic of figuring out what type of project it is, and finally import it.

Possible Mentors: Pascal Rapicault (pascal[at]rapicorp[dot]com), Max Rydahl Andersen (manderse[at]redhat[dot].com)

Students: Mayank Sharma (imptodefeat[at]gmail[dot].com) . Jian Wei Chuah (jianweichuah[at]gmail[dot]com), Ashwin Jha (ajha[dot]dev[at]gmail[dot]com) , Marco Mancini (marco[dot]mancini[dot]mm[at]gmail[dot]com

Filesystem centric view of the projects

When it comes to project management, the concept of projects in IDEs can be considered a "leaky abstraction" since in many situations the user has to resort to deal with the filesystem. For example, this happens when one directly needs to perform tasks such as run their automated build (e.g. Maven, Gradle, etc.), edit files whose format is not supported by Eclipse, or simply edit files that are not in a project itself.

In this project, I would like to explore the addition of a file-system centric view to the project explorer. The key difference with the existing project explorer would be that rather than having projects (or working sets) be top level entries in the view, the top level entry of this navigator would be a folder on the filesystem (e.g. the clone of a git repo) thus showing all files. In this context, projects would appear has decorated entries and would let the user perform the operations that can usually be performed on the project.

Note that some work has been done to support nested projects and there may be work to reuse there. Also this work likely has intersection with the "project explorer" project.

Possible Mentors: Pascal Rapicault (pascal[at]rapicorp[dot]com), Max Rydahl Andersen (manderse[at]redhat[dot].com)

Students: Mayank Sharma (imptodefeat[at]gmail[dot].com) . Dumira Athukorala(dumira1990[at]gmail[dot]com), Pawel Nowak (siersciotluk at gmail . com)

Eclipse IoT: CoAP support in Kura through Eclipse Californium

Kura is a Java and OSGi based application framework for IoT/M2M service gateways. Kura components are designed as configurable OSGi Declarative Services. Kura built-in services target Java developers building M2M applications; they include common building blocks like I/O access, network configuration, data services, and remote management. Kura communication with remote servers is isolated into an abstraction layer. Its current implementation is based on the MQTT protocol and it leverages the Eclipse Paho library. The goal of this project is to provide an alternative implementation of the transport layer using the CoAP protocol and the Eclipse Californium library.

Possible Mentors: Cristiano De Alti (cristiano.dealti[at]eurotech[dot]com). Marco Carrer (marco.carrer[at]eurotech[dot]com).

Students:

Eclipse IoT: Port Eclipse Kura over Eclipse Concierge OSGi runtime

Kura is a Java and OSGi based application framework for IoT/M2M service gateways. Kura components are designed as configurable OSGi Declarative Services. Kura built-in services target Java developers building M2M applications; they include common building blocks like I/O access, network configuration, data services, and remote management. Kura currently leverages the Eclipse Equinox OSGi framework for its runtime. The goal of this project is to port Kura to Eclipse Concierge, an implementation of the OSGi core specifications that is well suited for embedded and mobile devices. Concierge will target a footprint with a jar file size of less than 400KB, allowing it to run on devices that have limited resources.

Possible Mentors: Wes Johnson (wes.johnson[at]eurotech[dot]com). Marco Carrer (marco.carrer[at]eurotech[dot]com).

Students:harini.sirisena[at]gmail[dot]com

Eclipse IoT: Kura Web Administration UI on Apache Vaadin

Kura is a Java and OSGi based application framework for IoT/M2M service gateways. Kura components are designed as configurable OSGi Declarative Services. Kura built-in services target Java developers building M2M applications; they include common building blocks like I/O access, network configuration, data services, and remote management. Kura comes with a built-in web administration UI. It provides the administration of its services including a dynamic UI for the configuration of the installed OSGi applications. The goal of this project is to port the implementation of the existing GWT/GXT UI to a new UI framework like Apache Vaadin or Eclipse Rich Client Platform.

Possible Mentors:' David Woodard (dave.woodard[at]eurotech[dot]com). Marco Carrer (marco.carrer[at]eurotech[dot]com).

Students: Mihiri Gunatunge (mihiri528[at]gmail[dot]com)

ECF (Eclipse Communication Framework)

The following are summarized from a discussion initiated on the ecf-dev mailing list. For full details please see this posting. ecf-dev Join the mailing list to discuss with ECF team members. The project team is open to ideas not listed here.

OSGi Remote Services

ECF implements the OSGi R5 Remote Services/Remote Service Admin (RS/RSA) spec (chapter 100,/122 in the enterprise spec). ECF's implementation of RS/RSA runs on all OSGi frameworks.

Testing Infrastructure

Create a distributed 'junit-like' framework for testing and debugging remote services.

Tooling

New Eclipse-based tooling for helping people create, test, debug, document, and deploy OSGi Remote Services.

New Discovery and Remote Services Providers

ECF has a number of Discovery providers (e.g. zookeeper, zeroconf, slp, dnssd) and remote service/distribution providers (generic, r-osgi, jms, mqtt, REST, jasorb) already. We need more provider impls, however.

Improve Provisioning into Non-Equinox Frameworks

ECF's RS/RSA implementation runs on all OSGi Frameworks, and we have the means (through karaf-features) to install into non-Equinox frameworks. We would like to have more/better provisioning...and tutorials, examples, docs...for non-equinox frameworks.

There are further ideas articulated in the posting to ecf-dev . Possible Mentors:' Scott Lewis, Markus A. Kuppe, Wim Jongman

Students: Sakith Indula (gmsakith@gmail.com)

Eclipse Xtext: Implementing a Code Generator for Sublime Text Plugins

The idea is to generate a Sublime Text plugin from an existing Xtext grammar file. This plugin should support the DSL from the Xtext grammar, keyword highlighting etc. Additionally a build configuration should be included, if the Xtext project contained an Xtend or Java code generator. To support the code generator for the Sublime Text plugin, a command line code generator project can be generated for the Xtext grammar like the UI and Tests project, or the command line code generator can be generated into the core Xtext project.

The goal of the project is to generate a Sublime Text plugin for an existing Xtext grammar file.

Possible Mentor: Sven Efftinge

Interested Student: Thomas Fischl (fischl.thomas[at]gmail[dot]com)

Eclipse Scripting/EASE

Implementing an integrated Python debugger

EASE provides script interpreter integration in the IDE. For the Jython interpreter currently no debugger support is provided. The idea is to use common components from the JavaScript Debugger and extend its functionality to connect to a Jython debugging instance.

The goal of the project is to generate a Sublime Text plugin for an existing Xtext grammar file.

Possible Mentor: Christian Pontesegger (contact me on the eclipse-scripting-dev mailing list)

Students(Interested): Manas Joshi (futurejoshi15@gmail.com), Martin Kloesch (martin.kloesch@gmail.com), Lukas Florea (lukas.florea@googlemail.com)

Implementing a plugin dependency resolver for scripts

EASE scripts may provide metadata further defining the script. As such scripts may use IDE Java classes they might have dependencies to dedicated (Eclipse) features. The idea is to establish keywords that define feature dependencies along with optional update sites. When running such scripts dependencies should be resolved and eventually an install dialog should be launched.

The goals of this project are:

• define dependencies in scripts
• verify dependencies upon scipt startup
• provide means to install missing features

Possible Mentor: Christian Pontesegger (contact me on the eclipse-scripting-dev mailing list)

Students(Interested): Manas Joshi (futurejoshi15@gmail.com)

The Orion Project: Adding additional Git features to Orion

During GSoC 2013 our student successfully added a great feature to the Orion editor for Git Blame. The team would encourage students to apply to add additional features to our Git workflow. Two ideas off the top are adding Git Bisect capabilities to our Git page. This would involve ensuring the functionality is there and providing a compelling user interface and experience that makes it easy to use. The second idea is to provide Git Stash capabilities. This is the ability to quickly park your changes and switch to maybe checking another change or branch and then coming back to your stashed state. You must be capable in Java, JavaScript, HTML5/CSS3 and have a very good working knowledge of Git.

Possible Mentor: Ken Walker and Bogdan Gheorghe

Interested Student: Paul Fahrenkrug(fahrep58 at uwosh edu)

The Orion Project: Implementing responsive pages for Orion

Orion is not specifically written to handle the reduced content area available on mobile devices or tablets. It is usable on an iPad or Google devices however some of the pages would be better served by responsively reacting to the content area. While the editor would require space, using a mobile device to check on activity for your project, deploying a refresh to CloudFoundry or committing a change in should be possible without having to zoom various areas of our current pages. This is a fairly complex task and involves the potential re-write of some pages for mobile devices. Understanding of CSS, layouts and JavaScript are a must.

During GSoC 2013 our student successfully added a great feature to the Orion editor for Git Blame. The team would encourage students to apply to add additional features to our Git workflow. Two ideas off the top are adding Git Bisect capabilities to our Git page. This would involve ensuring the functionality is there and providing a compelling user interface and experience that makes it easy to use. The second idea is to provide Git Stash capabilities. This is the ability to quickly park your changes and switch to maybe checking another change or branch and then coming back to your stashed state.

Possible Mentor: Ken Walker and/or Anton McConville

Interested Student:

The Orion Project: Implementing local history of changes for the Orion editor page

Orion has two methods for editing files. One is to save when save it invoked, the other is when auto-save is on and a time delay has passed with no activity. While the editor has quite a large set of undo stack capability it's not quite the same as the desktop equivalent of local changes. These are change states in between your last commit and the present. This task is to enable the tracking of local changes by time stamp, allow the ability to compare and load from local history, and to provide the UI for enabling and configuring this option. Since this should be able to be written completely client side, good JavaScript, HTML5, CSS3 skills are a must.

Possible Mentors: Ken Walker and Bogdan Gheorghe

Interested Student: Manan Dey (manandey01@gmail.com).

The Orion Project: Add visualisation of git history to the Orion log page

Orion has a log page that displays the history for one branch at a time. This project involves adding the ability to display multiple branches simultaneously (with filtering options available to allow you to select what branches to show) as well as adding a graphical representation of the commits/rebases/merges etc. in order to allow users to better understand the true history of a resource. Something like this. This project idea comes from Bug 425243.

Possible Mentors: Ken Walker and Bogdan Gheorghe

Interested Student: Vidura Mudalige - vbmudalige@gmail.com

The eTrice Project: Target language aware editors for the modeling tool eTrice

eTrice is a modeling tool for (typically but not restricted to) real-time software systems. It adopts the ROOM language [1] developed in the early 1990's for telecommunication systems. The tooling offers an Xtext-based editor for the textual model and Graphiti-based diagram editors for structure and behavior (hierarchical finite state machines) of the modeling elements. Embedded in the state machine there are fragments of code that are executed when a transition is traversed or a state is entered or left. This code is written in the target language of the code generator which is called detail level language in ROOM.

Currently the model editor for this code is just a plain text editor. The goal of this project is to provide a more advanced language aware editor with the minimal set of features

• syntax highlighting
• content assist on the model level, i.e. it should propose an actor's attributes and messages that can be sent
• it should be embedded into the property dialogs of states and transitions (as a control replacing the text edit field)
• it should be possible to maximize the editor for more convenient editing
• an additional dialog is needed to edit operations and user code of actors
• an additional dialog is needed to edit port classes

The project requires familiarity with the Eclipse editor framework and SWT. On the other hand a basic understanding of the purpose and possibilities of the eTrice tooling is necessary.

[1] Bran Selic, Garth Gullekson, Paul T. Ward: Real-Time Object Oriented Modeling, New York: John Wiley, 1994 (ISBN 0-471-59917-4)

Possible Mentors: Henrik Rentz-Reichert

Interested Student: Jayant Gupta