Team LiB   Previous Section   Next Section

2.2 Parrot Development

Parrot development is the productive core of Perl 6 development. If you want coding action, this is the place to be.

Organization of the Parrot project is lightweight but efficient. It's a meritocracy—people who make valuable contributions are offered more responsibility. Communication is relaxed and informal. As Dan is so fond of saying, "This is far too important to take seriously." It's a bit like a special forces unit—the work gets done not because of tight control from the top, but because the whole team knows what they need to do, and do it.

2.2.1 Development Cycles

The cycles in Parrot development center on "point releases." A point release is a version change, such as 0.0.8 to 0.0.9. The pumpking decides when point releases happen and what features are included. Usually one or two solid new features trigger a release.

Development proceeds at a steady pace of bug reports, patches submitted, and patches applied. 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. A release is a spike in that activity, but since Parrot tends to follow the "release early, release often" strategy, the spike is relatively small.

Typically, a few days before a release the pumpking declares a feature freeze and all development efforts center on bug squashing. This periodic cleanup is one of the most valuable aspects of a release.

2.2.2 Getting Involved

Just like design work, the first step to participating in Parrot development is joining the list. The topics on p6i tend to stick to practical matters: bug reports, patches, notifications of changes committed to CVS, and questions on coding style. Occasionally there are discussions about how to implement a particular feature. In general, if you have a question about syntax or a speculation about whether Perl 6 should support a particular feature, that question belongs on the language list rather than the internals list. Use the source

The second step to participating in Parrot development is to get a copy of the source code. If you just want to try it out—experiment with a few features and see how it feels—you're probably best off downloading a tarball. For the most stable copy, grab the latest point release from CPAN. The sure way to get the most recent release is to search on for "parrot" in "Distributions." If you want something a little more cutting edge than the packaged release, a new snapshot of the CVS repository is created every eight hours. The most recent snapshot is always available at

If you plan to get involved in development, you'll want to check out the source from the CVS repository. Anyone can get anonymous access. Just log in as the "anonymous" user and check out the source. No password is necessary.

cvs -d login

cvs -d checkout parrot

There's also a web interface for viewing files in the repository at

Now that you've got the source, take a moment to look around. The code changes constantly, so a detailed description of every file is impossible. But a few road signs are helpful starting out.

The most important top-level directory is docs/. The content isn't always up to date, but it is a good place to start. parrot.pod provides a quick overview of what is in each documentation file.

The languages/ directory contains the code that implements various language compilers: Perl 6, as well as Python, Ruby, Scheme, Befunge, BASIC, etc. Most are in various stages of partial completion. If you have a language you're particularly interested to see implemented on Parrot, you might take a peek to see how far along it is.

The lib/ directory contains Perl 5 classes currently used in developing Parrot. The classes/ directory contains the C source code for Parrot classes (PMCs, which you'll read more about in Chapter 6). examples/ contains some example Parrot assembler code, as well as benchmarks.

For instructions on building Parrot, see Chapter 6. Patch submission

Parrot development is a continuous stream of patches. Patches are the currency of exchange in the project—the unit of work. They fix bugs, add features, modify features, remove features, and improve the documentation. Pretty much anything that changes, changes via a patch.

While anyone is free to submit a patch, a small number of people have access to commit changes to the CVS repository. This system works well. It means the project can harness the efforts of a large group, but still keep the same high quality as a small group of experienced developers.

Every submitted patch is automatically forwarded to the p6i list where it's subject to peer review. Patches spark little debate. Parrot developers generally submit code that's clean and well thought-out, so there's rarely any need for debate. Also, patches are typically small modular changes, which makes them easy to evaluate. Occasionally an entire language implementation is submitted in a single patch, but these are the exceptions.

Submitting a patch is fairly straightforward. You create a file listing of all your changes and email it to the ticket tracking system at But a few common-sense guidelines will make your patches cleaner, better, and less likely to give the pumpking hives.

First off, create your patches from a checked-out CVS repository, not from a tarball, so your diff is running against the latest version of the files. Then, make sure the paths listed in the patch match those in the repository. There are two methods of creating patches that will do this for you. You can make changes directly in your checked-out copy of the CVS repository and then create diffs using cvs diff -u. Or you can make a copy of the repository and then create diffs between the two copies with the standard diff -u. For example:

diff -u parrot/README parrot_changed/README

Either method is fine, and both are equally common on p6i. Your working style and the types of changes you make—small and modular versus large and sweeping—will influence which method you choose.

Next, when you're making changes, take some extra time to consider how your patch affects the rest of the system. If your patch adds a new file, patch the main MANIFEST file to include it. If you add a new feature, add a test for it. If you fix a bug, add a test for it. See Section 6.9 for more on writing tests for Parrot. Before you submit a patch, always recompile the system with your patch included and run all tests as follows:

make clean



make test

Then consider the people who will review and apply your patch, and try to make their jobs easier. Patch filenames should be as descriptive as possible: fix_readme_typo.patch is better than README.patch. An attached file is better than a diff pasted into an email, because it can be applied without manual editing. The conventional extension for patch files is .patch.

In the email message, always start the subject with "[PATCH]", and make the subject as clear as possible: "[PATCH] misspelled aardvark in main README file" is better than "[PATCH] typo." The body of the message should clearly explain what the patch is supposed to do and why you're submitting it. Make a note if you're adding or deleting files so they won't be missed.

Here is a good example of a patch submission using the CVS diff method (an actual patch from p6i). It's short, sticks to the point, and clearly expresses the problem and the solution. The patch filename and the subject of the message are both descriptive:

Subject: [PATCH] Pointers in List_chunk not initialized

From: Bruce Gray

On Win32, these tests are segfaulting due to invalid 

pointers in List_chunk structs:

t/op/string.t             97-98

t/pmc/intlist.t           3-4

t/pmc/pmc.t               80

The problem is caused by list.c/allocate_chunk not 

initializing the pointers. This patch corrects the problem.


Hope this helps,

Bruce Gray

With the attached file list_chunk_initialize.patch:

Index: list.c

=  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  ==  

RCS file: /cvs/public/parrot/list.c,v

retrieving revision 1.23

diff -u -r1.23 list.c

--- list.c        27 Dec 2002 09:33:11 -0000        1.23

+++ list.c        28 Dec 2002 03:37:35 -0000

@@ -187,6 +187,10 @@


     chunk = (List_chunk *)new_bufferlike_header(interpreter, sizeof(*chunk));

     chunk->items = items;

+    chunk->n_chunks = 0;

+    chunk->n_items  = 0;

+    chunk->next     = NULL;

+    chunk->prev     = NULL;

     Parrot_allocate_zeroed(interpreter, (Buffer *)chunk, size);


     Parrot_unblock_GC(interpreter); Bug tracking

Bug reports go to the same address as patch submissions ( Similar conventions apply: make the subject and the message as clear and descriptive as possible. There's no set convention on subject lines, but you can't go wrong starting off with something like "[BUG]" or "[P6C BUG]" to make it immediately obvious what the message is about.

If you want to track a bug or patch you've submitted, the current queue of bugs and patches is publicly viewable at Bug tracking for Parrot is handled by the Request Tracker (RT) ticket tracking system from Best Practical Solutions.

    Team LiB   Previous Section   Next Section