Version 31 (modified by dukeleto, 4 years ago)

--

Google Summer of Code 2011: Welcome to Parrot!

Parrot has applied to be a mentoring organization for the Google Summer of Code program for the summer of 2011. In previous years Parrot has participated in a joint effort with The Perl Foundation (TPF). This year, we have applied individually.

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.

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.

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 into Inkscape

  • Difficulty: <UNKNOWN (x/5)>
  • Links of Interest:  http://inkscape.org/
  • Possible Mentors: <UNKNOWN>
  • Details: <NONE>
  • Expected Deliverables: <UNKNOWN>

Bytecode Emitters for POST

  • Difficulty: 4/5
  • Links of Interest: <NONE, please add some>
  • Possible Mentors: cotto
  • 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. 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.

TapTinder

  • Difficulty: <UNKNOWN>
  • Links of Interest:  milestone M5
  • 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>

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.

LAPACK Bindings for Parrot-Linear-Algebra

  • Difficulty: 3/5
  • Links of Interest: <NONE, please add some>
  • 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.

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

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