Project Ideas

Maximilian Scholz edited this page Feb 10, 2017 · 164 revisions

This is our old page. If a link sent you here, we probably forgot to update it. New page is under

Things to Know Before Applying

Please also see if you're interested in scientific work. Students are expected to work out a full project proposal in cooperation with us, especially the mentor. Any application without prior contribution to coala cannot be evaluated and will be rejected. We will help you by aiming your proposal to reasonable goals but we won't proofread it. (You can ask fellow students to do that!) will help you getting started with coala.

Contacting Us

You can contact all mentors and admins on our Gitter coala GSoC channel or on #coala-gsoc on IRC (the channels are mirrored).

The following people will likely be administering GSoC in 2017:

The following people will likely be mentoring GSoC in 2017:

If you have particular questions or problems with a mentor (or an admin), feel free to approach our GSoC administrators privately on Gitter so we can help you resolving it. If you have problems contacting your mentors, contact us ASAP.

Working out a Proposal

See also: An example project from a student in GSoC 2014 (a GNOME+coala project) - link

Please design your project in a way that you have multiple checkpoints. We'd like you to specify at least three partial goals so if something goes wrong for a valid reason, we can rearrange your schedule meaningfully. Each of those goals has to be merged into the main coala codebase in order for it to be considered "complete". You should be aware of what that involves for you (writing tests, going through extensive code review, learning :), reiterating).

You can use any project idea listed here or one that came out of your mind - however be sure to make us aware of your plans and start planning your project with us so we can coordinate and - in the worst case - prohibit waste of time from your side. At all cost make sure you find something that interests you. We want this to be a fun and educating experience for you!

Use the "draft" feature on the GSoC system, submit your draft early, get a lot of helpful feedback from us!

Writing the proposal

Please follow the proposal template at PSF-ApplicationTemplate2016. All fields are required if not explicitly indicated otherwise. While following the application template you can consider doing an illustration of your proposed solution as it makes the application much more intuitive.

For writing your proposal we recommend using Google Docs

In the code sample section: Please list links to your contributions to coala or any other OpenSource project. Your contributions may or may not be available on github or related to coala! For example, to list your contributions to coala you can mention:

In the extra information section: We'd like the following sub-org specific info for coala:

If needed, you can get further information about GSoC at

What Happens When you get Accepted

There are a few things you should be aware of:

  1. In order to pass the evaluations we require your contributions to be reviewed and merged. Your mentor should ordinarily review your work within 24 hours, but be prepared for lots of constructive feedback. If no significant portion of your code is merged by the midterms, we cannot pass you. If your code isn't merged by the final evaluations we cannot pass you. (If something goes wrong unplanned that's all good, just change the exact goals together with your mentor. Things like this happen and we know about that :).)
  2. You should be already aware that we require full test coverage for your code to be accepted.
  3. We require you to do a blog post at least every two weeks, it will be aggregated on
  4. Your mentor will do a weekly meeting with you to make sure none of your questions remain unasked. :)
  5. Sooner or later you will be (or have already been) asked to review PRs of other students and newcomers. Code review is not an activity for some privileged members of the community but an important experience that should be part of your GSoC! Of course especially in the beginning we'll be there to guide you to that so don't worry!

Google Summer of Code 2017 - Possible Projects (UNTRIAGED)

Please follow this template for new projects:

## Project Name

**Possible Mentors:** @someone, @else
**Difficulty:** low/medium/high
**Requirements:** Affinity with the coala core
**Related issues:** https://...

### Description

Describe what needs to be done.

### Midterm Milestone

The midterm evaluation will pass only if:

- what is defined here is achieved.
- all code for the above is reviewed and **merged**.

(There are no exceptions. Code has to be merged. Goals can be redefined if they turn out to be unrealistic by the mentor together with the student.)

### Final Milestone

Your project idea will be approved if:

- at least two mentors are given.
- a difficulty, the requirements and related issues are given.
- at least the midterm and the final milestone are properly defined. More possible!
- the description is concise and not too fuzzy.
- the goals section describes exactly what needs to be achieved for the student to pass.
    - all code has to be reviewed and merged. No exceptions on that.

Python dead code fixer

Possible mentor(s): @jayvdb

Difficulty: medium


Integrate the pyflakes-enhanced AST into coala so that bears can access it, and

  1. create two bear that wrap the flake8 AST plugins flake8-future-import and flake8-string-format using the pyflakes-enhanced AST.

  2. create a native coala bear that uses the pyflakes-enhanced AST for reporting and auto fixing dead code. The Python AST is an AST, however it contains a parse tree, and in most cases can be used to "go backwards" to generate revised source code using the meta package. Where the AST does not have sufficient information to be used for generating a new source file, the portions of dead code can be identified using the AST and then removed from the original source file.

Integrating Antlr v4 into coala

Possible mentor(s): @udayan12167

Difficulty: high


ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files. It's widely used to build languages, tools, and frameworks. From a grammar, ANTLR generates a parser that can build parse trees and also generates a listener interface (or visitor) that makes it easy to respond to the recognition of phrases of interest.

Thus ANTLR allows us to create an AST for any programming language we have a grammar for. Having an abstract syntax tree allows us to write advanced algorithms for static analysis. What we are looking for in this project is to have an AST interface within the Bear class. Basically, the Bear writer provides a flag which lets them traverse the AST of any language source code they provide.

Hence this project has two targets:

  1. Succesful integration of ANTLR into the coala core providing the user with an AST interface when writing a Bear.

  2. Writing a basic Bear which tests this functionality using the AST.


Clone this wiki locally
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.
Press h to open a hovercard with more details.