Skip to content
This repository

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.

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

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.

GNU Scientific Library (GSL) bindings for Parrot

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

Update parrot-libgit2 to libgit2 latest release (TAKEN)

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

PACT Bytecode Layer

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

New Assembly Language

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

PACT Control Flow Graph

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

Integrate 6model into Core

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

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

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 (TAKEN)

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

OpenCL bindings for Parrot

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

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.

POD parser

  • **Difficulty: 1/5
  • **Links of Interest:
  • **Possible Mentors:
  • **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:

Parrot Backend for ANTLR

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

Make Parrot Y2038 Ready

Something went wrong with that request. Please try again.