Project Ideas
Please see also https://github.com/coala-analyzer/coala/wiki/Writing-a-Thesis-with-coala 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 aiming your proposal to reasonable goals but we won't proofread it. (You can ask fellow students to do that!)
http://coala.io/newcomers will help you getting started with coala.
You can contact all mentors and admins on our Gitter coala GSoC channel https://gitter.im/coala/coala/gsoc or on #coala-gsoc on IRC (the channels are mirrored).
The following people were primary mentors in 2016:
The following people were secondary (co) mentors:
If you have particular questions or problems with a mentor (or an admin), feel free to approach our GSoC administrators @Makman2, @sils1297 or @fneu privately on Gitter so we can help you resolving it. If you have problems contacting your mentors, contact us ASAP.
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!
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.
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:
- https://github.com/coala-analyzer/coala/commits/master?author=YOUR_USER_NAME for coala repo
- https://github.com/coala-analyzer/coala-bears/commits/master?author=YOUR_USER_NAME for coala-bears repo You may also mention specific issues/commits using the commit id if you want us to take a look at that.
In the extra information section: We'd like the following sub-org specific info for coala:
- Will you be able to join us for a conference such as EuroPython or GUADEC and present your work if at least partial sponsorship will be provided? (See https://github.com/coala-analyzer/coala/wiki/Conferences-Upcoming)
- We love having twitter handles so we can tell people publicly about your great project and successes at https://twitter.com/coala_analyzer! (Not required but recommended.)
If needed, you can get further information about GSoC at http://write.flossmanuals.net/gsocstudentguide/what-is-google-summer-of-code/.
There are a few things you should be aware of:
- 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 :).)
- You should be already aware that we require full test coverage for your code to be accepted.
- We require you to do a blog post at least every two weeks, it will be aggregated on http://planet.coala-analyzer.org/.
- Your mentor will do a weekly meeting with you to make sure none of your questions remain unasked. :)
- 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!
Possible mentor(s): @sils1297
We want the bears to be able to submit multiple possible patches for one problem and patch generators for one problem. In the end, users should be able to choose between different patches (e.g. for different possible spelling corrections) and perform e.g. variable renamings (coala asks them for the new name and the generated function provided by the bear will generate a patch from that).
That needs some concept (to be worked out for the proposal together with us before application submission), implementation in the core infrastructure (the main part) and adaption of editor plugins (if needed) and the CLI.
Difficulty: Hard
Requirements: Talk to us about your proposal! The concept needs to be solid.
Related issue(s): https://github.com/coala-analyzer/coala/issues/1021
Possible mentor(s): @fneu, @Udayan12167
Jenkins has some neat way to show code analysis results - let's use that to provide Jenkins users an awesome usability! The result of this project should be a full fledged Jenkins integration, living in an own repository with a full testsuite.
If you find this fun you'll be the one knowing this component best and will get the chance to maintain it on your own if you want - always with the support of the community guarding your back of course.
Difficulty: Medium
Requirements: Interaction with the Jenkins community and the submission of a patch to Jenkins would be preferred.
Possible mentor(s): @sils1297, @AbdealiJK, @Makman2
A very easy way to cover a broad spectrum of analysis routines is wrapping linters into coala. Currently we have a Lint class which simplifies this integration. Based on this class, a large selection of linters can be implemented rapidly. A tutorial on writing linter bears is available at http://coala.readthedocs.org/en/latest/Users/Tutorials/Linter_Bears.html.
This project proposal should contain a concrete list of linters that are wrapped together with concrete improvement proposals to the Lint class if needed. Because implementing a linter bear is a rather trivial task it is highly recommended to spice up the project with something interesting, like adding automatic dependency installation to the Lint class. Improving integrations by adding more options can also be part of this.
Upstream contributions to linters are encouranged, e.g. to add auto fixing abilities.
Difficulty: Easy
Possible mentor(s): @sils1297, @Makman2, @Udayan12167
If someone writes a bear he/she needs to test it and comes likely to the step where debugging is needed.
In this project the participant shall develop a system to easily step into the analysis code (likely
using the Pdb module already integrated into Python) and step out as soon as the analysis finished.
On this way it would be useful retrieving profiling information while debugging/running.
Difficulty: Medium
Requirements: Familiarity with pdb is a plus.
Related issue(s): https://github.com/coala-analyzer/coala/issues/565, https://github.com/coala-analyzer/coala/issues/1101
Possible mentor(s): @AbdealiJK, @sils1297 (co mentored by Christian Hergert from GNOME)
coala has plugins for gedit, sublime and atom. We'd like to extend this selection. One important thing is the GNOME builder integration that has to be and can be done properly (with settings via some UI, there's an API for that.) This project might be done in cooperation with GNOME and result in a better plugin API for GNOME Builder in which case it will be co mentored by the creator of Builder.
Difficulty: Medium
Requirements: You should sync up with Christian Hergert from GNOME and submit a patch to GNOME Builder.
Possible mentor(s): @AbdealiJK, @sils1297
coala has plugins for gedit, sublime and atom. We'd like to extend this selection. One important thing is the Kate and KDevelop integration that has to be and can be done properly (with settings via some UI). This project might be done in cooperation with KDE. It's majorly meant for developers who currently use KDevelop and KDE based editors to get the capabilities of coala easily!
Difficulty: Medium
Requirements: You should definitely sync up with the KDE people and submit a patch!
Possible mentor(s): @AbdealiJK, @sils1297
This project would need to implement several plugins for several editors. Ideally that list should include vim, emacs, IntelliJ/PyCharm, Notepad++, and many more. Part of this project would be coming up with an efficient strategy to make sure all plugins are tested and maintained properly.
Supporting the plugin
We consider any bit of code "supported" only if we have regular Continuous Integration and tests running to ensure it works. What this involves for this project is to setup tests for the current editor plugins. And then to configure the CI to run these tests once in a few days using the newest coala version. For some editors like sublime and gedit, running tests is not easy and there is no api to do it. In such cases we would want to use dogtail (a GUI tester) or similar to do this.
Documentation
We need better documentation on how to write a plugin and setup the CI for it. We could take 23 plugins and write details instructions on how they were made.
Making plugins
Developers are lazy. Hence, we need to be able to provide coala to them right inside editors and IDEs. This could involve any from the huge list of editors at https://en.wikipedia.org/wiki/List_of_text_editors or any that you personally like :)
Difficulty: Medium
Possible mentor(s): @AbdealiJK, @sils1297
This project involved design skills and front-end programming knowledge. It involves creating a website for coala. First phase would involve ideating on a good design. Once the design is set we would decide on which frameworks to use and implement the design. We have a brainstormed overview of the website and it's structure available at https://etherpad.gnome.org/p/coala-website.
Languages: Core frontend languages - HTML, CSS, JS (Maybe coffeescript, Angular and Less also - but we're flexible about this.)
Difficulty: Medium
Related issue(s): https://github.com/coala-analyzer/website/issues