Project Overview

The heart of Parrot is a language-neutral runtime environment for dynamic languages, such as Ruby, Python, PHP and Perl.

The language-neutrality of the interpreter is partially a design decision for modularity. Keeping the implementation independent of the syntax makes the codebase cleaner and easier to maintain. Modular design also benefits future language designers, not just designers of current languages. Instead of targeting lex/yacc and reimplementing low-level features such as garbage collection and dynamic data types, designers can leave the details to Parrot and focus on the high-level features of their language: syntax, libraries, capabilities. Parrot does all the necessary bookkeeping, exposing a rich interface with capabilities that few languages can make full use of.

A robust exceptions system, a capability to compile into platform-independent bytecode, and a clean extension and embedding mechanism would be just some of the necessary and standard features.

Since Parrot would support the features of the major dynamic languages and wasn't biased to a particular syntax, it could run all these languages with little additional effort.

Language interoperability is another core goal. Different languages are suited to different tasks, and picking which language to use in a large software project is a common planning problem. There's never a perfect fit, at least not for all jobs. Developers find themselves settling for the language with the most advantages and the least noticeable disadvantages. The ability to easily combine multiple languages within a single project opens up the potential of using well-tested libraries from one language, taking advantage of clean problem-domain expression in a second, while binding it together in a third that elegantly captures the overall architecture. It's about using languages according to their inherent strengths, and mitigating the cost of their weaknesses.

The name "Parrot" started with an April Fools' Day joke in 2001. Simon Cozens published an article titled "Programming Parrot", with a fictional interview between Larry Wall and Guido van Rossum detailing their plans to merge Python and Perl into a new language called Parrot (http://www.perl.com/pub/a/2001/04/01/parrot.htm).

The Parrot Team

The Parrot development team is broken down into several distinct roles, which people assume according to their merits and their talents. This is a list of those roles.

Architect

The architect has primary responsibility for setting overall direction of the project, and to facilitate team communication and understanding of architectural issues. The architect is primarily, but not solely, responsible for making design decisions and documenting them in Parrot Design Documents ; responsibility for design and documentation of project subcomponents may be delegated to other members of the Project Team, or may be held jointly. The Architect also works with the Release Managers to develop and maintain the release schedule. Allison Randal currently leads the Parrot project as chief architect.

Release Managers

Release managers have responsibility for executing a product release according to the release schedule. The release schedule is developed and maintained jointly with the project Architect.

Metacommitter

All Metacommitters are responsible for managing commit access to the Parrot repository. Once a contributor is selected commit access, a Metacommitter performs the necessary magic to give the new committer access to the SVN repository and the bugtracker. The Architect is a Metacommitter, but other Project Team members may also hold this role.

Committer

Contributors who submit numerous, high-quality patches may be considered to become a Committer. Committers have commit access to the full Parrot repository, but generally work only on one or more subprojects; Committer categories are described below. Contributors may be considered for commit access either by being nominated by another Committer, or by requesting it.

Core Developer

Core Developers develop and maintain core subsystems such as the IO subsystem, the exceptions system, or the concurrency scheduler.

Compiler Developer

Compiler Developers develop and maintain one or more Parrot front-end compilers such as IMCC, PIRC, PGE and TGE.

High-Level Language Developer

Developers who work on any of the high-level languages that target Parrot such as TCL, Lua or Perl 6, are High-Level Language Developers. Some of these language projects are located in the Parrot repository, although most are maintained in separate locations.

Build Manager

Build Managers maintain and extend configuration and build subsystems. They review smoke reports and attempt to extend platform support.

Tester

Developing, maintaining, and extending test suite coverage and testing tool are the key tasks for the Testers. Testers are also responsible for testing goals, including complete coverage of core components on targeted platforms.

Patch Monsters

Hackers and developers submit patches to Parrot every day, and it takes a keen eye and a steady hand to review and apply them all. Patch Monsters, as they are affectionately known, are in charge of checking patches for conformance with coding standards and desirability of features.

Cage Cleaners

Parrot's cage, the development working environment, has a tendency to get messy and disorganized over time. It's the responsibility of the aptly-named Cage Cleaners to ensure that coding standards are followed, that documentation is complete and accurate, that all tests are functioning properly, and that there are plenty of coding examples for new users to learn from. A class of tickets in the issue tracking system has been created especially for use by this group. This position encompasses tasks that run the gamut from entry-level to advanced, and is a good entry point for new users who want to get more familiar with Parrot internals.

General Contributor

Contributors are volunteers who write code or documentation patches, take part in email or online conversations, or contribute to the project in other important ways. All volunteer contributions are appreciated.

Development Cycles

The Parrot development cycle centers on monthly releases. Most monthly releases are development releases, and two releases a year are production releases. The production releases are numbered X.0 and X.5, while the development releases take a major or minor version number between each production release.

Development proceeds at a steady pace with bugs reported, patches submitted, patches applied, and all sorts of other regular development tasks performed. The pace isn't so much a result of careful planning as it is the law of averages; on any given day someone, somewhere, is working on Parrot. In periods of high activity there are often many more people working on Parrot Or related tools, or high-level language compilers, etc. then just one.

Activity tends to spike when a release is approaching to close tickets, fix bugs, clean up documentation, and prepare the supporting files for the release. Immediately after the release, there is generally a flurry of branch merges, feature additions, or removal of deprecated features, since the week after the release allows the maximum time for testing before the next release. Releases also encourage feedback as casual users and testers get their hands on the newest version. These regular swells of activity are one of the major motivations for monthly releases.

Getting Involved

The first step to getting involved in the Parrot project, whether you want to hack code, write documentation, or help in other ways, is to join the mailing list. The topics on the list tend to revolve around practical matters: bug reports, notifications of changes committed to the subversion repository, questions on coding style, and how to implement particular features.

The primary mailing list for Parrot is called "parrot-dev", and you can subscribe to it or view the archives through the web interface at http://lists.parrot.org/XXX. The archives are also available on Google Groups at http://groups.google.com/group/parrot-dev and via NNTP at nntp://news.gmane.org/gmane.comp.compilers.parrot.devel.

Parrot information and documentation can be accessed on the web in a variety of locations. The main website is http://www.parrot.org, where you'll find recent news, and information about the project and foundation. The heart of development is http://trac.parrot.org, Parrot's ticket submission and tracker, wiki, source code browser, and project roadmap.

Parrot developers, volunteers, and well-wishers also congregate on IRC at #parrot on the irc://irc.parrot.org server. It's a good place to get real-time answers to questions, or just to see how things are progressing.