Google Summer of Code 2011: Welcome to Parrot!

Parrot Foundation is a GSoC organization for 2011!!! Woot!!!

This page will serve as a landing page for interested students and mentors to help plan and prepare for the summer program. Details about what prospective students can do right now, as well as lists of potential projects will appear on this page. PROTIP: You can always submit a proposal for a project idea that is not on this list, but PLEASE, talk to Parrot developers first.

Mentors: Review the information on this page, including project proposals. Sign up as a prospective mentor for any projects you would be willing to help with. We would like to have a primary and a backup mentor for every project in this list. Anywhere you see the words "NONE" or "UNKNOWN" in the project idea listings below is your invitation to start filling in information. Project ideas with many empty fields will be deleted.

It is OK if you don't know who your mentor will be. Awesome proposals will draw mentors like a magnet, so concentrate on your proposal and an awesome mentor will appear.

Students: Review the information here and start getting into contact with community members. Get involved! Don't wait for GSoC to begin, you can start getting involved with Parrot right now!

First steps

Getting your bearings

Get Involved!

Project Ideas

Put ideas for GSoC 2011 Projects here. Difficulty values are estimates, sometimes uninformed, on the scale of 1-5 where 1 is considered the easiest and 5 is considered the hardest to complete. These are only base-line estimates. A project proposal may opt to alter the scope of the project to make it more or less difficult to complete successfully. A successful project is one which can be completed and merged (if necessary) before or shortly following the end of the GSoC program.

Note that these project ideas are only suggestions. Students may propose ideas which are not listed here, or which are only loosely based on ideas mentioned here, and those proposals will be given full consideration.

When adding a new idea or modifying one, try to follow the existing format. Here's a template that you can copy+paste to insert a new idea:

<New Project Idea (Copy this template)>

  • Difficulty: <UNKNOWN>
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • Details: <NONE, add details inline, or link to a page that has them>
  • Expected Deliverables: <UNKNOWN, Please list what the deliverables will be>

Embed Parrot in Mozilla Firefox

Make Parrot Y2038 Ready

Embed Parrot into Inkscape

  • Difficulty: <4/5>
  • Links of Interest:  http://inkscape.org/
  • Possible Mentors:
  • Details: Embed Parrot inside of Inkscape, to allow Inkscape to be scripted with any language Parrot understands.
  • Expected Deliverables: Load and run bytecode with new Embed API from within Inkscape. Documentation and tests that show that the code works and how to use it.Students are expected to coordinate with both Parrot and Tor developers to come up with a plan that both communities find feasible.

Parrot bindings to Tor

  • Difficulty: <2/5>
  • Links of Interest:  http://torproject.org
  • Possible Mentors:
  • Details: Embed Parrot inside of Tor, to allow Tor to be scripted with any language Parrot understands.
  • Expected Deliverables: Load and run bytecode with new Embed API from within Tor. Allow the basic creation and destruction of Tor circuits. The student should concentrate on the API to create an internal Tor node (not an exit node) to reduce the scope of the project. If the student has extra time, the exit node API can be worked on. Documentation and tests that show that the code works and how to use it. Students are expected to coordinate with both Parrot and Tor developers to come up with a plan that both communities find feasible.

LAPACK Bindings for Parrot-Linear-Algebra

  • Difficulty: 3/5
  • Links of Interest:  https://github.com/whiteknight/parrot-linear-algebra
  • Possible Mentors: Whiteknight
  • Details: Parrot-Linear-Algebra (PLA) provides bindings and wrapper PMC types for the BLAS library. This provides access to basic matrix and vector operations, but does not provide access to the full range of algorithms implemented by LAPACK. Implement bindings to use LAPACK (CLAPACK, etc) routines with PLA matrix types from a Parrot application. Since LAPACK provides so many interfaces, only a relatively small subset of routines must be made accessible. The student should be able to perform common operations from Parrot including finding eigenvalues and eigenvectors, performing common matrix factorizations and decompositions, and Solving systems of linear equations including least-squares solutions.
  • Expected Deliverables: LAPACK bindings for PLA, including necessary build and test infrastructure improvements, new unit tests, code examples to cover cases mentioned above, and necessary documentation.

OpenCL bindings for Parrot

  • Difficulty: <4/5>
  • Links of Interest:  http://www.khronos.org/opencl/
  • Possible Mentors: dukeleto
  • Details: OpenCL is the first open, royalty-free standard for cross-platform and parallel programming, mostly for Graphical Processing Units (GPUs). Parrot would like bindings to OpenCL, which will allow high-performance computing from Parrot languages. This will have far-reaching potential for scientific computing, cryptography, number theory and any computationally intensive tasks.
  • Expected Deliverables: OpenCL is a large standard, this GSoC project will be confined to providing the smallest set of bindings to OpenCL that can be built up. Most likely, access to integer calculations should be done. More details to follow.

Refactor PL/Parrot to use the new Parrot Embed API

  • Difficulty: 4/5
  • Links of Interest:  http://pl.parrot.org,  https://github.com/parrot/parrot/tree/master/src/embed,  https://github.com/parrot/parrot/blob/master/docs/embed_new.pod
  • Possible Mentors: dukeleto, Whiteknight
  • Details: PL/Parrot embeds Parrot Virtual Machine into PostgreSQL. It was written before the new Parrot embed API was written, which has a much nicer interface. This project will consist of refactoring the PL/Parrot codebase to use the new API. In the process of converting to the new embed API, many bugs in PL/Parrot will be fixed, since PL/Parrot inherits many bugs from the old embed API.
  • Expected Deliverables: A new implementation of PL/Parrot that uses the new embed API. The PL/Parrot and PL/Perl6 test suite should pass, more tests should be added, and developer docs should be written so that it is easier for other developers to contribute to PL/Parrot.

Bytecode Emitters for POST

  • Difficulty: 4/5
  • Links of Interest:  newPOST branch
  • Possible Mentors: cotto, bacek
  • Details: Several languages compile down to an abstract syntax tree type called POST. POST is the last stage of analysis and transformation before output code generation. Update existing POST, or create a new POST library capable of outputting bytecode directly. Update PAST to create new POST tree. You should not output PIR and rely on the PIR compiler to generate the bytecode. Emphasis for this project is placed on the ability to output working bytecode, not necessarily on the quality of the generated bytecode nor the throughput performance of the converters.
  • Expected Deliverables: A POST extension or POST replacement which is able to generate bytecode. Includes necessary unit tests and all necessary documentation.

GNU Scientific Library (GSL) bindings for Parrot

  • Difficulty: <3/5>
  • Links of Interest:  http://www.gnu.org/software/gsl/  http://search.cpan.org/~leto/Math-GSL/
  • Possible Mentors: ?
  • Details: This project can be thought of as porting a subset Math::GSL to Parrot.
  • Expected Deliverables: There are many GSL subsystems, so this project should focus on binding to Special Function, Random Distributions and Cumulative Distribution Functions (CDFs), which have the simplest function signatures. Deliverables will be the implementation, examples, docs and tests.

TapTinder

  • Difficulty: 4/5
  • Links of Interest:  dev.taptinder.org,  tt.taptinder.org,  #taptinder on freenode.org
  • Possible Mentors: Michal Jurosz (mj41)
  • Details: TapTinder is watching and  building Parrot and Rakudo projects. There is long  ToDo list so we are waiting for Perl 5 programmers. Dependency projects support is probably most wanted feature. Client-server protocol isn't finished yet. Watchdog and fork support on clients and reporting to mailing list are another tasks on our list.
  • Expected Deliverables: Continuous integration (building, testing, reporting) for dependency projects.

LALR Parser Generator

  • Difficulty: 5/5
  • Links of Interest:  http://en.wikipedia.org/wiki/LALR_parser,  http://www.devincook.com/goldparser/articles/lalr.htm
  • Possible Mentors: Whiteknight
  • Details: Create an LALR parser generator tool. The tool should be written in one of the lower-level languages which run on Parrot (PIR, NQP, Winxed, other) for maximum portability. The parser generator should take a language specification and compile it into an LALR parser in a manner similar to YACC/Bison. The generator parser likewise can be in any suitable language. For this project, a working LALR parser generator engine is more important than the ability to understand a huge number of input patterns and pattern modifiers.
  • Expected Deliverables: A working LALR parser generator capable of converting a language specification into an LALR parser. Necessary unit tests, examples, and documentation must be included.

Language Interop

  • Difficulty: 2-3/5
  • Links of Interest: <Add links to the hll interop PDD, previous discussions on the topic, specific source files>
  • Possible Mentors: Tene
  • Details: Implement the documented language interop API (and extend or modify where appropriate) for Parrot core languages and other Parrot HLLs; add core parrot tests of the language interop API and add cross-language interoperability tests to the parrot smoke testing server.
  • Expected Deliverables: Core Parrot languages and libraries usable natively from high-level-languages implemented on Parrot. Installed Parrot HLLs and libraries can all use each other natively. <more?>

POD parser

  • Difficulty: 1/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • Details: Implement a library or tool to parse POD documentation from standalone .pod files and code files containing intermittent POD. The successful project should be able to translate POD documentation into other formats such as LaTeX, HTML, man pages, raw text, or others. Special focus should be on both compliance with the Perl 6 POD specification (Synopsis 26 - Documentation) and interoperability with other HLLs besides Perl 6. The successful project will have a system with pluggable backends for outputting documentation in the formats listed above and others.
  • Expected Deliverables: <UNKNOWN, Please list what the deliverables will be>

New Parrot Debugger

  • Difficulty: 4/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: Whiteknight, cotto
  • Details: Parrot needs a new debugger. There exists a toolset called "parrot-instrument" which can be used to insert introspection, analysis, and manipulation functions into Parrot internals. You may optionally (preferrably) use Parrot-Instrument as the basis for your new debugger or create a new one from scratch. A successful debugger will have the ability to set break-points on subroutines at the PIR and HLL level, set watchpoints on registers or individual PMCs, and introspect state information from a running program. The debugger should read information from annotations so that it can be used to work with various HLLs. Performance of code executing under the debugger is not a primary concern for the initial deliverable.
  • Expected Deliverables: A working debugger with the capabilities listed above. In addition, the successfull student should provide adequate unit tests, code examples, and documentation.

Subroutine-Level Profiler

  • Difficulty: 3/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: cotto
  • Details: Several HLLs, especially Rakudo Perl 6, have need of a profiling tool that can generate information about subroutine call patterns and execution times. This will help to identify bottlenecks and areas where optimization is needed, among other things. There exists a project called "Parrot-Instrument" which can be used to add analysis, introspection, and runtime manipulation tools to Parrot. Parrot-Instrument may be used as the basis for a successful code profiling tool. Ideally, the code profiling tool will operate on PIR/PBC and will be agnostic to the specific HLL in which the code was originally written.
  • Expected Deliverables: A working code profiling tool including unit testing and user documentation.

Green Threads and Tasks

  • Difficulty: <UNKNOWN>
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: Whiteknight
  • Details: Create an implementation of preemptive-switching green threads for Parrot. The successful project should be designed with an eye towards eventual M:N thread hybridization.
  • Expected Deliverables: <UNKNOWN, Please list what the deliverables will be>

Thread-Safe Data Sharing Mechanism

  • Difficulty: <UNKNOWN>
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • Details: <UNKNOWN>
  • Expected Deliverables: <UNKNOWN, Please list what the deliverables will be>

Parrot Backend for ANTLR

  • Difficulty: 3/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • Details: Create a new code generation backend for ANTLR to produce parsers which run on Parrot. Target languages can be any language which runs on Parrot, although lower-level languages are preferred for performance and portability (PIR, NQP, Winxed, etc). The backend should be able to create working code for the full range of ANTLR features.
  • Expected Deliverables: An ANTLR code generating backend or plugin for ANTLR which "works". Includes all necessary unit tests, code examples, and documentation.

Code Metrics Utility

  • Difficulty: 2/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: Whiteknight
  • Details: Create a tool or toolset for calculating code maintainability metrics for Parrot. The toolset should operate on PIR or PBC, and be usable for any HLL which runs on top of Parrot (using code annotations to get information about the HLL). The toolset should be able to calculate total lines of code (in the original HLL, in addition to the generated PIR/PBC), per-sub cyclomatic complexity (including nested lexical subs), and inter-class coupling.
  • Expected Deliverables: A library, stand-alone tool, or complete toolset for analyzing PIR or PBC and calculating various metrics from it. The successful project will be able to count total lines of code in an HLL-independant way and calculate at least one other important metric.

Parrot in Apache

  • Difficulty: 4/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • Details: Implement a plugin for running Parrot code in an Apache webserver. The plugin may be a plugin module similar to the old mod_parrot project, it may be a FastCGI module, or anything that works and is portable and well-supported. The plugin should be able to execute raw PIR code and code running in one of Parrot's HLLs, including the ability to load Parrot extension libraries. Preference is for projects which work on newer Apache 2 releases over older Apache 1. Compatibility with the older line is nice but not a strict requirement.
  • Expected Deliverables: The successful project will provide both the Apache plugin module, example code showing webpages generated using the plugin, a unit test suite and full user documentation.

Safe Text Templating Engine

  • Difficulty: 2/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • Details: A text templating engine, similar to Liquid or Lua-Codegen which runs on top of Parrot. The templating engine should follow good design and best practices and be "safe" (or have a "safe" mode) for use in public environments like the web. A good templating library will work with Parrot's immutable strings implementation to produce a high-performance and flexibile templating and formatting solution. This project should be implemented in a lower-level Parrot language for maximum portability (PIR, NQP-rx, Winxed, etc).
  • Expected Deliverables: A templating library, example code, unit tests, and user documentation.

GCC Translator

  • Difficulty: 5/5
  • Links of Interest:  http://gcc.gnu.org/wiki/plugins,  http://nestedvm.ibex.org/
  • Possible Mentors: Peter Lobsinger
  • Details: A means of using GCC to translate static language inputs (eg: C, Fortran, Pascal), into Parrot Bytecode. This may take the form of a GCC backend plugin, or machine-code post-processor (similar to NestedVM).
  • Expected Deliverables: A translator script, examples and tests, user documentation.

Java on Parrot

  • Difficulty: 4/5
  • Links of Interest:  http://java.sun.com/docs/books/jls/,  http://www.gnu.org/software/classpath/
  • Possible Mentors: Peter Lobsinger
  • Details: An implementation of the Java language on Parrot. To reduce this project's scope, the standard library should be taken from an existing project (for example, GNU Classpath).
  • Expected Deliverables: A Parrot HLL implementation including registered HLL runtime compiler and fakecutable, examples and tests, user documentation.

GNU Multi-Precision Library (GMP) bindings for Parrot

  • Difficulty: < 3 / 5>
  • Links of Interest:  http://gmplib.org/  http://search.cpan.org/dist/Math-GMPz/
  • Possible Mentors: dukeleto
  • Details: Porting Math::GMPz (integer functions) to Parrot. This will allow many cryptography and number theory libraries to be written on top of this. Parrot currently knows how to detect GMP and uses a small subset of GMP functions for BigInts and BigFloats, but more functions are needed to implement libraries on top of it.
  • Expected Deliverables: Pure PIR PMCs that wrap NCI calls to GMP, tests, documentation

Python3 on Parrot

  • Difficulty: <3/5> ?
  • Links of Interest:  http://python.org/
  • Possible Mentors: allison
  • Details: Implementation of Python3 on Parrot, written in pure python as much as possible, that targets PIR or Winxed.
  • Expected Deliverables: pure python compiler + core python types (likely written in winxed).

Javascript on Parrot

  • Difficulty: 4/5
  • Links of Interest:  https://github.com/leto/jaspers,  http://whiteknight.github.com/2010/12/07/javascript_on_parrot_plan.html
  • Possible Mentors: Whiteknight
  • Details: Implement a JavaScript compiler on Parrot, written either mostly or entirely in JavaScript. The student may start with an existing project (such as Jaspers), or create a new project from scratch. The successful project will attempt to use as much existing JavaScript code as possible to implement the compiler. This can include parser generator utilities such as PEG.js or jison. If the student can find a suitable compiler frontend written in JavaScript, he/she could opt to implement a PIR/PBC backend for the existing frontend. Jaspers is a project which has not proceeded far past the design state which intends to use the PEG.js parser library and an existing JavaScript language grammar to produce such a compiler. Other projects such as Cafe, provide much of the needed compiler infrastructure but would require a suitable PIR/PBC backend. The overall difficulty of this project will be determined by the path the student wishes to take, and the amount of existing JavaScript the student is able to reuse.
  • Expected Deliverables: A working JavaScript compiler, written in whole or in part in JavaScript itself. The compiler should be able to "bootstrap" and compile itself. The compiler need not come with any particular set of runtime libraries, although being able to conform to the common.js spec or other standards would be an added bonus.