Put ideas for GSoC 2013 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 student may (and is encouraged!) to alter any project proposal to modify the scope of the project in any way.

A successful project is one which can be completed and merged (if necessary) before or within 30 days 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:

Ideas with the work TAKEN below mean that a student is actively working on a proposal for that idea. You can also do that, but we can only accept one proposal per project, so please consider writing a proposal for another idea.

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

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

• Difficulty: <3/5>
• Links of Interest: http://www.gnu.org/software/gsl/ http://search.cpan.org/~leto/Math-GSL/
• Possible Mentors: dukeleto
• 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.

• Difficulty: 4/5
• Links of Interest:
  • libgit2
  • parrot-libgit2
  • Winxed Unicorns
• Possible Mentors: dukeleto
• Details: This code allows any Parrot language to programatically interact with Git repositories with the new libgit2 library. The code already exists, but has not been updated to the latest libgit2 release.
• Expected Deliverables: Ability to use parrot-libgit2 with the latest stable release of libgit2.

• Difficulty: 2/5
• Links of Interest:
  • Introspection, Disasembly and PACT (GSOC)
  • PACT github
• Possible Mentors: Whiteknight, benabik
• Details: In short, develop a set of classes that can be assembled to and disassembled from a Parrot ByteCode (PBC) file. In detail, see the links above. Note that some of the other ideas listen below refer to this task. (Note: the disassembly portion is largely functional, so there's a distinct head start there.)
• Expected Deliverables: A set of classes to represent a bytecode file and the infrastructure to convert to/from PBC files.

• Difficulty: 3/5
• Links of Interest: <NONE, please add some>
• Possible Mentors: Whiteknight, benabik
• Details: Write a replacement for PASM, implemented in Winxed. The format should be extremely simple to parse and generate, and mirror the PBC format extremely closely. This may be done in combination with the PACT Bytecode classes above.
• Expected Deliverables: A complete compiler able to generate at least simple PBC files from the new assembly format.

• Difficulty: 4/5
• Links of Interest: https://github.com/parrot/PACT
• Possible Mentors: benabik
• Details: Write a framework to allow a compiler to generate code without worrying about details such as register allocation or bytecode positions by instead generating a control flow graph that refers to variables by name and positions in code as references to blocks. A solid understanding of compilers is required. The desired target to compile the CFGs to is the PACT Bytecode Layer above.
• Expected Deliverables: A set of classes that can represent a program as a control flow graph and compile it to the PACT Bytecode Layer mentioned above.

• Difficulty: 3-5/5
• Links of Interest: https://github.com/perl6/nqp
• Possible Mentors: Whiteknight, benabik
• Details: This is listed as a varying difficulty task due to the broad scope. The easier end of this idea is simply to have enough framework in Parrot that 6model objects can be built using only core Parrot. The high end is to have the core use the 6model framework more natively.
• Expected Deliverables: A branch, ready to merge to master, that adds the new "6model" object model to core Parrot. Must include tests.

• Difficulty: 4/5
• Links of Interest:
  • https://github.com/perl6/nqp
  • http://dyncall.org/
• Possible Mentors: <UNKNOWN, please volunteer!>
• Details: dyncall is a library to make calling dynamic libraries simple across many platforms. It is better supported on platforms like Win32 than libffi, and has been tested with NQP and Rakudo for some time. A transparent replacement of the current FFI utilities with dyncall may be impossible, so a path for transition should be considered. Otherwise, Parrot's native call system is pluggable and a version which uses dyncall may be able to be developed in parallel with the existing libffi bindings.
• Expected Deliverables: <UNKNOWN, Please list what the deliverables will be>

• Difficulty: 3/5
• Links of Interest:
  • https://github.com/Whiteknight/jaesop
  • http://whiteknight.github.com/2011/09/03/jaesop_stage_0_progress.html
  • http://whiteknight.github.com/2012/02/15/gsoc_season_starting.html
• Possible Mentors: Whiteknight, lucian
• Details: Jaesop is a Javascript-on-Parrot compiler project that uses node.js to bootstrap the compiler infrastructure. The compiler itself is mostly written in JavaScript, with a bootstrapping "stage 0" to compile JS code into an intermediate form using the Parrot-friendly Winxed language. A "stage 1" of the compiler will use stage 0 to compile itself, the result being a compiler for JavaScript, written in Javascript, running on Parrot. Work to improve the runtime library of stage 0 to enable bootstrapping (especially improvements to the regexes and other built-in types) will be required.
• Expected Deliverables: A working stage 1 compiler for (a subset of) JavaScript, which runs on Parrot.

• Difficulty: 2/5
• Links of Interest:
  • https://github.com/Whiteknight/parrot-linear-algebra
  • http://whiteknight.github.com/2010/06/22/blas_lapack_and_parrotlinearalgebra.html
• Possible Mentors: Whiteknight
• Details: The Parrot-Linear-Algebra project (PLA) is a library for adding matrix and vector support to Parrot. It currently provides native matrix object types and bindings to the venerable BLAS library. BLAS primarily provides optimized implementations of matrix operations such as "Y = aX + b" and "A = BC + xD". For more complicated matrix operations such as calculating determinants and eigenvalues, transformations and decompositions and other operations of interest, the library LAPACK should be used. The goal for this task is to provide bindings to LAPACK either built-in to PLA or fully compatible with PLA.
• Expected Deliverables: Working LAPACK bindings and example code showing eigenvalue/eigenvector calculations and at least one useful transformation or decomposition.

• Difficulty: 2/5
• Links of Interest:
  • https://github.com/letolabs/app-parrot-create
• Possible Mentors: dukeleto
• Details: App::Parrot::Create is a Perl 5 web application built with Dancer 1.3.x and very few other dependencies. Currently we depend on YAML.pm and Archive::Zip from CPAN. App::Parrot::Create allows a casual web user to select a few dropdowns and configuration boxes and then create a skeleton of either a High Level Language (HLL) on Parrot, or a Parrot library that an HLL would use. The result is a zip or tarball that the user can download and start modifying to create their project. This is a really important application in terms of lowering the barriers to entry for using Parrot and could have far-reaching impact in making Parrot more widely-used. The proposal for this idea should include redesigning the main screen to be more intuitive and also directly link or embed useful documentation that will help users make informed decisions. Currently this web application uses jQuery to make the interface dynamic, but much more work is needed.

• Difficulty: 5/5
• Links of Interest: <NONE, please add some>
• Possible Mentors: Whiteknight
• Details: An old project called ModParrot added an embedded Parrot interpreter to the Apache webserver, so that programs using Parrot could be run as handlers for web requests similar to PHP or ModPerl. This project has not been actively maintained and was never upgraded to use the modern Parrot embedding API. Either update the existing ModParrot to use the new embedding API for Parrot or create a new project from the ground up. The project should work on modern Apache variants and allow the execution of handlers from .pbc files in response to web requests. Configuration options should allow loading HLL compilers and executing HLL scripts as well.
• Expected Deliverables: A working ModParrot or a new working ModParrot2 (or whatever you want to call it). A test suite, documentation, and at least one working example website runnable from localhost.

• Difficulty: Variable
• Links of Interest: <NONE, please add some>
• Possible Mentors: Whiteknight
• Details: Parrot has an embedding interface which allows the user to embed an instance of the Parrot interpreter into another program or utility. Currently, there are not too many examples of this interface in use. Embed Parrot into a popular application of your choice, either directly or as a plugin. A good plugin would embed a Parrot Interpreter and allow additional plugins to be written in any HLL that runs on Parrot and compiles to bytecode. Any plugin should make use of Parrot's key features such as dynamic bytecode loading, dynamic compilation, etc. For example, a Parrot plugin in a text editor might allow compilation and execution of code in the current buffer or code currently highlighted by the cursor. Difficulty depends on what program you choose to embed Parrot in, and what features you choose to expose.
• Expected Deliverables: A working Parrot plugin for a popular existing application of your choice. Must include documentation and unit tests (where possible).

• Difficulty: 4/5
• Links of Interest: <NONE, please add some>
• Possible Mentors: <UNKNOWN, please volunteer!>
• Details: Create a security sandboxing system for Parrot so that each sandbox can have separate security settings and limitations. Sandboxes should be able to be created, executed and destroyed without affecting the rest of the process. Each sandbox may have different load and search paths, access to a completely separate list of classes, limited permissions, and insulation from other parts of the system.
• Expected Deliverables: <UNKNOWN, Please list what the deliverables will be>

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

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

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

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

• Difficulty: <3/5>
• Links of Interest: http://trac.parrot.org/parrot/ticket/505 http://search.cpan.org/~mschwern/Time-y2038-20100403/lib/Time/y2038.pm https://github.com/schwern/y2038
• Possible Mentors: Schwern?
• Details: Make Parrot gracefully deal with dates in the far future, as well as past 2038. The date 2038 is important because that is when the unix epoch no longer will fit into a 32 bit integer.
• Expected Deliverables: Intgrate Schwern's y2038 C headers into Parrot core, with documenation and tests.