Google Summer of Code 2015 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).

Eclipse Communication Framework: Tooling for Remote Services

The ECF project provides an open, standard implementation of the OSGi R6 Remote Services and Remote Service Admin specifications. One of the important themes for the ECF community is adding tooling to help remote service developers define, create, implement, test, debug, deploy, run, discover, and manage their remote services.

Note that one very important area for Remote Services is their use in Internet of Things (IoT) use contexts. ECF has already done significant work in this area, see the Raspberry Pi tutorials and Committer Wim Jongman's EclipseCon Europe 2014 presentation: How to Cook an Egg...

There are several opportunities for student projects in this area, for example: contributing to existing tooling efforts, identifying and pursuing new tooling enhancements, creating example applications using Remote Services, creating new providers, participating in the standardization efforts, etc. For details about areas that are currently under development please see these links

bug 454609 - a bug for coordinating the multiple efforts. Please see the 'Depends On' field on this bug for other bugs

Recent mailing list posting discussing and linking to previous design discussions about Remote Services Tooling

The ecf-dev mailing list. All of the prospective mentors and other ECF committers and community members participate on this list. If you are interested in being involved in this effort you should certainly join this list

ECF's github repositories - Most of the new community efforts are available here

Possible Mentors: Scott Lewis (slewis at composent.com)

Potential Students: Osanda Wedamulla, Sakith Indula, Anis JRIBI(anis@gsa-mena.org)

Error Reporting - Mylyn-like error notifications and other UI candies

• Description: to be provided
• Reporter: Marcel Bruch
• Possible Mentors: Marcel Bruch
• More Info: Notifications Bug Feature Requests
• Eclipse Project: Eclipse Packaging Project
• Potential students: Daniel Haftstein (list closed)

Project News Feeds for / in Eclipse

• Description: News feed aggregator which presents project-specific news in the IDE. It will allow projects to inform it's users (and only it's users) about new releases or anything related (e.g. security issues) as well as polls (e.g. which notification style to use) and more. The purpose is to provide better communication and feedback between projects and it's users.
• Reporter: Marcel Bruch
• Possible Mentors: Johannes Dorn, Marcel Bruch
• More Info: See discussions at ide-dev Bug 459911
• Eclipse Project: To be decided
• Potential students: Pawel Nowak (list closed)

GeoTrellis: Cassandra Backend to GeoTrellis-Spark

GeoTrellis is a Scala-based LocationTech project that is a framework for fast, parallel processing of geospatial data. Recent development efforts have allowed GeoTrellis to give the Apache Spark cluster compute engine geospatial capabilities, focusing on the processing of large scale raster data.

GeoTrellis's integration to spark currently supports HDFS and Accumulo as backends to store and retrieve raster data across a cluster. Cassandra is another distributed data store that could provide a rich set of features and performance opportunities to GeoTrellis running on top of Spark. It's also a popular distributed data store that a number of people interested in doing large scale geospatial computations are already using.

This project would include implementing a GeoTrellis Catalog implementation for Cassandra, which allows us to save and load raster layers as Spark RDD's, as well as metadata. Eventually we will also be storing vector data in these data stores, and depending on how far we are in the development of that functionality, this project should support the storing and saving of vector data as well.

Please get in touch if you are interested in this project. You can reach out to the mailing list or email Rob Emanuele at remanuele@azavea.com.

Possible Mentors: Rob Emanuele, Eugene Cheipesh, Chris Brown

Interested Students: Maduranga Siriwardena

GeoTrellis: Computer Vision algorithms on Satellite Imagery

GeoTrellis is a Scala-based LocationTech project that is a framework for fast, parallel processing of raster data in the geospatial domain. One application of GeoTrellis is to process imagery collected by satellites and other remote sensing sources.

Computer vision (CV) algorithms can be applied during satellite imagery processing to detect and extract geometries such as trees or buildings (also known as image segmentation), or to remove clouds and mosaic images of the same area over time to create the most clear images of land. This project would include implementing one or more CV algorithms in Scala using the GeoTrellis library for the purpose of processing satellite imagery. There will be a focus on parallel algorithms, so that these processes can work on large scale satellite imagery on a cluster.

Please get in touch if you are interested in this project. You can reach out to the mailing list or email Rob Emanuele at remanuele@azavea.com.

Possible Mentors: Rob Emanuele, Eugene Cheipesh, Chris Brown

Interested Students: Anuj Pahuja

GeoTrellis: Kriging Interpolation

GeoTrellis is a Scala-based LocationTech project that is a framework for fast, parallel processing of raster data in the geospatial domain.

Interpolation of raster data values from a set of points is a valuable set of geostatistical methods. Currently we only have inverse-distance-weighted interpolation implemented in GeoTrellis core. A more advanced interpolation called Kriging interpolation has been a highly desired feature in GeoTrellis for a while now.

This project would include implementing Kriging Interpolation in the core raster library (operating in a single threaded environment). I could also include implementing a distributed version of the algorithm so that large collections of points in space could be turned into a collection of rasters in a distributed manner, using Spark enabled with GeoTrellis.

Please get in touch if you are interested in this project. You can reach out to the mailing list or email Rob Emanuele at remanuele@azavea.com.

Possible Mentors: Rob Emanuele, Eugene Cheipesh, Chris Brown

Interested Students: kelum

GeoTrellis: Hydrological operations on Spark

GeoTrellis is a Scala-based LocationTech project that is a framework for fast, parallel processing of raster data in the geospatial domain.

GeoTrellis can be used to perform hydrological operations on elevation data. This includes operations such as flow accumulation, flow direction, watershed discovery, and sink fill. These operations are essential to modeling terrain in a way that aides land use planning, road building, watershed modifications, and a host of other important work.

This project would include implementing various hydrological operations in a distributed way to be used with GeoTrellis on top of Spark. This project could also include the creation of a DEM (Digital Elevation Model) format reader, which is a raster format that is used often with elevation data.

Please get in touch if you are interested in this project. You can reach out to the mailing list or email Rob Emanuele at remanuele@azavea.com.

Possible Mentors: Rob Emanuele, Eugene Cheipesh, Chris Brown

Interested Students: M. Perera

EASE: Command completion support

EASE is the eclipse scripting project, allowing to interact with the IDE using scripts in various languages.

• Description: Integrate code completion to the script shell and the JS interpreter. In the shell code completion should provide loaded functions from modules along with methods from java objects. The shell allows to read out the datatype of variables, so all information is there at runtime. For the JS interpreter things get harder as we have no runtime information on the object type. Here reduced support for code completion would be sufficient (eg. methods from loaded modules only).

• Reporter: Christian Pontesegger
• Possible Mentors: Christian Pontesegger
• Get in touch: ease-dev
• Potential students: Vipula Dissanayake, Martin Kloesch

EASE: Help hover tooltips

EASE is the eclipse scripting project, allowing to interact with the IDE using scripts in various languages.

• Description: Integrate help tooltips for module methods. Help is available as html pages within the eclipse help. The task is to identify the correct help topic, extract the relevant html part and display it as a tooltip within the modules explorer view. L&F should be similar to the help hovers one gets for java code. Optional target would be to reuse the help tooltips and also display them in the JS editor.

• Reporter: Christian Pontesegger
• Possible Mentors: Christian Pontesegger
• Get in touch: ease-dev
• Potential students: Vidura Mudalige, Nilaksha Perera

GeoWave HBase: HBase Extension to GeoWave

GeoWave is new to Eclipse's LocationTech working group. GeoWave is a framework for leveraging the scalability of distributed data stores to effectively store, query, and analyze huge vector and raster geospatial datasets. For interested students to find more information see GSoC 2015 Ideas.

Explanation: Currently, GeoWave is built to use Apache Accumulo to store spatial data and expose web map and web feature interfaces from GeoServer. Apache HBase has strong similarities to Accumulo as both are based on Google’s BigTable paper. The team will support the student in extending GeoWave’s capabilities to Apache HBase. The goal for the student will be to develop a module that adheres to GeoWave’s data store interface for HBase. Additionally, common geospatial benchmarks can be run for both data stores and provide valuable metrics for the community to compare the data stores. The student will complete the following tasks:

• Research the key differences between Accumulo and HBase
• Update the existing codebase to support an HBase implementation
• Ensure existing unit and integration tests support the HBase implementation
• Run existing benchmarks, and apply new ones to characterize performance differences between HBase and Accumulo

Expected Results: A usable HBase data store plugin extending geospatial support to the open source community.

Prerequisites: A good grasp of Java and object-oriented programming, an interest in GIS applications and distributed computing systems, and good problem solving skills.

Mentor: Rich Fecher

Selected Student: Vignesh Prabhu

GeoWave Cassandra: Cassandra Extension to GeoWave

GeoWave is new to Eclipse's LocationTech working group. GeoWave is a framework for leveraging the scalability of distributed data stores to effectively store, query, and analyze huge vector and raster geospatial datasets. For interested students to find more information see GSoC 2015 Ideas.

Explanation: Currently, GeoWave is built to use Apache Accumulo to store spatial data and expose web map and web feature interfaces from GeoServer. Apache Cassandra is another distributed key-value store that has similarities to Accumulo/HBase, as well as similarities to DynamoDB. The team will support the student in extending GeoWave’s capabilities to Apache Cassandra. The goal for the student will be to develop a module that adheres to GeoWave’s data store interface for Cassandra. Additionally, common geospatial benchmarks can be run for both data stores and provide valuable metrics for the community to compare the data stores. The student will complete the following tasks:

• Research the key differences between Accumulo and Cassandra
• Update the existing codebase to support a Cassandra implementation
• Ensure existing unit and integration tests support the Cassandra implementation
• Run existing benchmarks, and apply new ones to characterize performance differences between Cassandra and Accumulo. Benchmark Cassandra performance with different partitioning strategies.

Expected Results: A usable Cassandra data store plugin extending geospatial support to the open source community.

Prerequisites: A good grasp of Java and object-oriented programming, an interest in GIS applications and distributed computing systems, and good problem solving skills.

Mentor: Rich Fecher

Selected Student: Nivethika Mahasivam

GeoWave Monitor: Map-Based Accumulo Status and Health

GeoWave is new to Eclipse's LocationTech working group. GeoWave is a framework for leveraging the scalability of distributed data stores to effectively store, query, and analyze huge vector and raster geospatial datasets. For interested students to find more information see GSoC 2015 Ideas.

Explanation: Currently, GeoWave uses Apache Accumulo to store spatial data. The Accumulo Monitor is a useful interface for monitoring the status and health of the underlying Accumulo components. The team will support the student in creating a web-based monitoring interface utilizing GeoWave. The interface will be used to dynamically represent map-based Accumulo status and health. The student will complete the following tasks:

• Research and understand the underlying REST interface which provides data for the Accumulo Monitor
• Use Accumulo and GeoWave to determine a geospatial extent for each tablet within a tablet server
• Use the Accumulo Monitor REST interface to retrieve status and health for each tablet which will in turn be mapped to its corresponding spatial extent
• Create a customizable, interactive GeoWave Monitor web interface which can be configured to display user-selected stats on a map
• Additionally, the student may develop a module to dynamically expose feature/tablet mappings via GeoServer

Expected Results: An interactive, map-based web interface which provides Accumulo status and health information catered towards GIS applications like GeoWave.

Prerequisites: A good grasp of JavaScript, Java and object-oriented programming, an interest in GIS applications and distributed computing systems, and good problem solving skills.

Mentor: Whitney O’Meara

Selected Student: Rukshan Chathuranga

Map Request Analytics: Web Map Service (WMS) Metadata Capture and Analysis

GeoWave is new to Eclipse's LocationTech working group. GeoWave is a framework for leveraging the scalability of distributed data stores to effectively store, query, and analyze huge vector and raster geospatial datasets. For interested students to find more information see GSoC 2015 Ideas.

Explanation: GeoServer supports OpenGeospatial Consortium‘s Web Map Service (WMS) specification. The goal of this effort is to capture metadata on each WMS request, including request time, bounding box and resolution in pixels, store the metadata within Geowave, and perform kernel density analysis of WMS request data leveraging GeoWave’s kernel density estimation framework. The team will coach the student through the interface of a GeoWave data store and the kernel density estimation components. The student will complete the following tasks:

• Build a WMS plug-in in GeoServer to capture WMS meta-data, storing the meta-data as simple features into any select active GeoServer Data Store
• Create a GeoServer administration page using Wicket to configure the WMS capture service
• Using GeoWave as a select GeoServer Data Store, depict captured data in a heat map using GeoWave’s kernel density estimation framework

Expected Results: A usable WMS metadata capture service supporting geo-temporal analysis of map requests.

Prerequisites: A good grasp of Java and object-oriented programming, an interest in GIS applications, and good problem solving skills.

Mentor: Eric Robertson

Selected Student: Joao Martins -> joaomartins27396@gmail.com

JDT UI: Improved code completion in JDT

• Description: Provide improved code completion and postfix code completion in JDT
• Reporter: Lars Vogel
• Possible Mentors: Lars Vogel, Noopur Gupta
• More Info: Currently JDT code completion does not perform any regular expression mapping. The main task of this project is to ensure that substrings which map the entered text are also included in the matching. For example currently the user has to type o.setS[Ctrl+Space] to match setSelectionListener. With this development o.Sel would also match selection listener. Note: The code recommender project has even more advanced functionality, the goal of the project is not replicate its functionality but provide a simple substring matching which also supports camelCase matching.

Examples for that

.SelectionListener-> CTRL Space -> matches .addSelectionListener but not .addSelectionTestListener .SL -> CTRL Space -> matches .addSelectionListener and .setSelectionListener and not .addSelectionTestListener

The second phase will be the integration of postfix completion into JDT. See Bug report for details.

• Eclipse Project: Eclipse JDT
• Potential students: Gabor Kovesdan, Oscar Postlethwaite

PDT: Composer support for PDT

• Description: Composer has become the de-facto packaging standard for php. Support for composer is currently available via a plugin. The subject of this project is to contribute this plugin to PDT to enrich PDT with its meta information about code to unlock better IDE support.
• Reporter: Thomas Gossmann
• Possible mentor: Dawid Pakuła
• Eclipse Project: PHP Development Tools (PDT)
• Potential students: Thomas Gossmann

JDT UI: Convert Constants to Enum refactoring

• Description: Java 5 introduces several new features that offer significant improvements over older Java technology, e.g., the new enum construct, which provides language support for enumerated types. Prior to Java 5, programmers needed to employ various patterns (e.g., static final int ...) to compensate for the absence of enumerated types in Java. Unfortunately, these compensation patterns lack several highly-desirable properties of the enum construct, most notably, type safety. The Convert Constants to Enum refactoring for Eclipse is a research prototype plugin that provides an automated approach for transforming legacy Java code to use the new enumeration construct. The semantics-preserving tool increases type safety, produces code that is easier to comprehend, removes unnecessary complexity, and eliminates brittleness problems due to separate compilation.
• Proposal Focus: The focus of this proposal is to finally incorporating this refactoring into the standard distribution of Eclipse. There is also a possibility to add additional refactoring support, e.g., support for String constants to enumerated types. The current status of the plugin can be found at our google code site. Please see the issue list there. The original Eclipse bug is Bug 200152.
• Reporter: Raffi Khatchadourian
• Possible mentor: Raffi Khatchadourian
• Eclipse Project: Java Development Tools/User Interface (JDT/UI)
• Potential students: Ajay Vishwanathan, Joseph Graham, Bogdan Iancu

JDT UI: Convert XML to Annotations refactoring

• Description: Annotations have been introduced in Java to enable developers to simply and directly annotate various source code elements with metadata. Metadata helps facilitate proper communication between clients and frameworks by allowing client developers to further specify how frameworks should behave when the overall program is to be executed. Prior to modern JDKs, frameworks offered clients a variety of ad hoc annotation mechanisms, often lacking in uniformity and ease of use. Despite the advantages of annotation types, many popular and useful frameworks have yet to incorporate them.
• Proposal Focus: This proposal is for an automated approach to refactoring legacy Java frameworks to process annotation type metadata from clients (e.g., XML files).
• Reporter: Raffi Khatchadourian
• Possible mentor: Raffi Khatchadourian
• Eclipse Project: Java Development Tools Core (JDT Core)
• Potential students: Md Arefin, Ajay Vishwanathan, Pierlauro Sciarelli, Shafiqul Islam

JDT UI: More general convert to lambda expression Java 8 refactoring/quick fixes

• Description: Java 8 is one of the largest upgrades to the popular language and framework in over a decade. There are several new key features of Java 8 that can help make programs easier to read, write, and maintain. Java 8 comes with many features, especially related to collection libraries. These include such new features as Lambda Expressions, the Stream API, enhanced interfaces, and more.
• Proposal Focus: Where JDT Core/UI has incorporated many Java 8 quick fixes and refactorings, there are still many features left to be done. For example, NetBeans has a refactoring that converts loops to Lambda expressions. This proposal is to explore porting the such mechanisms in NetBeans to Eclipse.
• Related bugs:: Bug 462725
• Reporter: Raffi Khatchadourian
• Possible mentor: Raffi Khatchadourian
• Eclipse project: Java Development Tools Core (JDT Core)
• Potential students: Md Arefin, Ajay Vishwanathan, Shafiqul Islam

JDT UI: Additional Java 8 refactorings

• Description: Java 8 is one of the largest upgrades to the popular language and framework in over a decade. There are several new key features of Java 8 that can help make programs easier to read, write, and maintain. Java 8 comes with many features, especially related to collection libraries. These include such new features as Lambda Expressions, the Stream API, enhanced interfaces, and more.
• Proposal Focus: Where JDT Core/UI has incorporated many Java 8 quick fixes and refactorings, there are still many features left to be done. This proposal is to explore remaining Java 8 features for which no current refactoring support exists in Eclipse. The exact topic can be discussed with potential students. Once a topic is decided upon, a corresponding refactoring tool will be designed, implemented, and evaluated.
• Reporter: Raffi Khatchadourian
• Possible mentor: Raffi Khatchadourian
• Eclipse Project: Java Development Tools Core (JDT Core)
• Potential students: Gabor Kovesdan, Ajay Vishwanathan

Eclipse Code Recommenders: Visualized Statistics from the Developer Workspace

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, what commands you use most often, how much time you spent in Eclipse, 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 analyze some loaded data from the developer workspace: e.g. number of loaded plugins, quantity of EGit commits, loaded tasks in Mylyn etc. With these statistics the developer could provide an overview of its workspace and maybe find out, how to make more efficient use of the Eclipse IDE.

Workspace Data:

• Statistic from the workspace
  • #plugins, #files, etc
• Statistic from EGit
  • #Commits, #Repos, etc.
• Statistic from Mylyn
  • #Tasks, #Fixed, #Reopened, etc.
• Statistic of loaded plugins/features
  • #plugins, #features, etc.

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

Interested Students: Akif Etkü

Bug: 463175

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

• Reporter: Kai Kreuzer
• Possible mentor: Kai Kreuzer
• Eclipse Project: Eclipse SmartHome
• Interested Students: Anis JRIBI(anis@gsa-mena.org)

Eclipse SmartHome: Integrate with AllJoyn

• Description: Eclipse SmartHome is an integration framework that allows the interconnection of diverse home automation protocols and systems. AllJoyn is an open-source protocol maintained by the AllSeen Alliance and hosted at the Linux Foundation. AllJoyn has a strong focus on peer-to-peer communication between devices. For the integration with other systems, for remote access and for centrally managed automation rules, a gateway brings valuable synergies. As the AllJoyn code is written in C(++), the integration with Eclipse SmartHome would have to be done through either JNI or a native daemon process.

• Proposal Focus: The project could suggest the following features and use cases to be implemented:
  • A generic binding for AllJoyn can be implemented. This would allow to discover AllJoyn-compatible devices on the network and add them to the Eclipse SmartHome inbox. Devices could be queried for their functionality and the Thing structure could be dynamically constructed in order to expose their functionality to the Eclipse SmartHome applications.
  • The binding can be enhanced to support the Lighting Service Framework (LSF) to more specifically support lights, such as the LIFX bulbs.
  • The binding can be enhanced to support the Audio Service - this includes music and volume control, but at the same time, this can be integrated with the text-to-speech features of Eclipse SmartHome, so that AllJoyn speakers can be used for spoken notifications and messages.
  • The integration can also be done the other way round: Things that are available on Eclipse SmartHome can be exposed as AllJoyn-compatible devices to the network, so that other devices can discover and use them. This would be along the idea of the proposed AllJoyn System Bridge.

• Reporter: Kai Kreuzer
• Possible mentor: Kai Kreuzer
• Eclipse Project: Eclipse SmartHome
• Interested Students:

PolarSys rover demo

• Description: PolarSys is the Eclipse Working Group for Open Source tools for Embedded Systems. It includes Modeling tools (Capella, Papyrus), development tools (CDT, Trace Compass), and testing tools (Titan). In order to help users getting started with all these tools, PolarSys is working on the PolarSys rover demo that consists in using the tools to model a rover system and develop software for this rover.

• Proposal Focus: The first step is to write the software that will run the Rover in a simple use case like exploring a room. Then, the student will create the models that allow generation of this code. It will be important to notice what obstacles the student meet as the Rover demo should help new people test and understand PolarSys tools.

The student will receive a kit with the Rover platform and a raspberry pi in order to test the software. The software, models, etc... will be contributed to the PolarSys top level project as a sample of using the PolarSys tools.

• Reporter: Gaël Blondelle
• Possible mentor: Gaël Blondelle
• Eclipse Project:PolarSys
• Interested Students:

Other Sources of Ideas

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