Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP

Summer of Code Task Ideas

Whiteknight edited this page · 29 revisions

Put ideas for GSoC 2012 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>

PACT Bytecode Layer

  • Difficulty: 2/5
  • Links of Interest:
  • Possible Mentors: Whiteknight
  • 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.
  • Expected Deliverables: A set of classes to represent a bytecode file and the infrastructure to convert to/from PBC files.

New Assembly Language

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

PACT Control Flow Graph

  • Difficulty: 4/5
  • Links of Interest: https://github.com/parrot/PACT
  • Possible Mentors: <UNKNOWN, please volunteer!>
  • 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.

Integrate 6model into Core

  • Difficulty: 3-5/5
  • Links of Interest: https://github.com/perl6/nqp
  • Possible Mentors: Whiteknight
  • 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.

Add dyncall support

  • Difficulty: 4/5
  • Links of Interest:
  • 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>

Jaesop (JavaScript) Stage 1 Compiler and Runtime

  • Difficulty: 3/5
  • Links of Interest:
  • Possible Mentors: Whiteknight
  • 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.

LAPACK bindings for Parrot-Linear-Algebra

  • Difficulty: 2/5
  • Links of Interest:
  • 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.

Improve Web UI of app-parrot-create

  • Difficulty: 2/5
  • Links of Interest:
  • 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.

New Apache 2 ModParrot and ModRakudo

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

Create a Parrot Plugin

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

Security Sandboxing

  • 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>
Something went wrong with that request. Please try again.