=pod

=head1 Introduction

Parrot is a language-neutral virtual machine for dynamic languages such as
Ruby, Python, PHP, and Perl. It hosts a powerful suite of compiler tools
tailored to dynamic languages and a next generation regular expression engine.
Its architecture is fundamentally different than existing virtual machines such
as the JVM or CLR, with optimizations for dynamic languages included, a
register-based system rather than stack-based, and the use of continuations as
the core means of flow control.

The name "Parrot" was inspired by Monty Python's Parrot sketch. As an April
Fools' Day joke in 2001, Simon Cozens published "Programming Parrot", a
fictional interview between Guido van Rossum and Larry Wall detailing their
plans to merge Python and Perl into a new language called Parrot
(U<http://www.perl.com/pub/a/2001/04/01/parrot.htm>).

=head2 Parrot Resources

The starting point for all things related to Parrot is the main website
U<http://www.parrot.org/>. The site lists additional resources, well as recent
news and information about the project and the Parrot Foundation, which holds
the copyright over Parrot and helps guide development and the community.

=head3 Documentation

Parrot includes extensive documentation in the distribution. The full
documentation for the latest release is available online at
U<http://docs.parrot.org/>.

=head3 Mailing Lists

X<parrot-dev (Parrot mailing list)>
X<mailing lists>

The primary mailing list for Parrot is I<parrot-dev@lists.parrot.org>.  If
you're interested in getting involved in development, you may also want to
follow the I<parrot-commits> and I<parrot-tickets> lists.  Information on all
the Parrot mailing lists and subscription forms for each is available at
U<http://lists.parrot.org/mailman/listinfo>.

The archives for I<parrot-dev> are also available on Google Groups at
U<http://groups.google.com/group/parrot-dev> and via NNTP at
U<nntp://news.gmane.org/gmane.comp.compilers.parrot.devel>.

=head3 IRC

X<#parrot (Parrot IRC channel)>
X<IRC channel (#parrot)>

Parrot developers and users congregate on IRC at C<#parrot> on the
U<irc://irc.parrot.org> server. It's a good place to get real-time answers to
questions or see how things are progressing.

=head3 Issue Tracking & Wiki

X<github.com wiki>
X<issue tracking (github.com)>

Parrot developers track issues using the Github issues system at
L<https://github.com/parrot/parrot/issues/> Users can submit new tickets and
track the status of existing tickets.  Github also provides a wiki used in
project development and a source code browser.

=head2 Parrot Development

X<development cycles>

Parrot's first release occurred in September 2001.  It reached 1.0 in March
2009. The Parrot project makes releases on the third Tuesday of each month. Two
releases a year E<mdash> occurring every January and July E<mdash> are
"supported" releases intended for production use.  The other ten releases are
development releases for language implementers and testers.

Development proceeds in cycles around releases. Activity just before a release
focuses on closing tickets, fixing bugs, reviewing documentation, and preparing
for the release. Immediately after the release, larger changes occur, such as
merging branches, adding large features, or removing deprecated features. This
allows developers to ensure that changes have sufficient testing time before
the next release.  Releases also encourage feedback as casual users and testers
explore the newest versions.

=head2 The Parrot Team

Parrot developers fulfill several rules according to their skills and interests.

=over 4

=item Architect

X<architect role>

The architect has primary responsibility for setting the overall direction of
the project, facilitating team communication, and explaining and evaluating
architectural issues. The architect makes design decisions and documents them
in Parrot Design Documents, and oversees design and documentation work
delegated to other members of the team to provide a coherent vision across the
project. The architect also works with the release managers to develop and
maintain the release schedule. Allison Randal currently leads the Parrot
project as architect.

=item Release Managers

X<release manager role>

Release managers manage and produce monthly releases according to the release
schedule. Parrot has multiple release managers who rotate the responsibility
for each monthly release. The release managers develop and maintain the release
schedule jointly with the project architect.

=item Metacommitter

X<metacommitter role>

Metacommitters manage commit access to the Parrot repository. Once a
contributor is selected for commit access, a metacommitter gives the new
committer access to the repository and the bugtracker. The architect is a
metacommitter, but other team members also hold this role.

=item Committer

X<committer role>

Contributors who submit numerous, high-quality patches may be considered to
become a committer. Committers have commit access to the full Parrot
repository, though they often specialize on particular parts of the project.
Contributors may be considered for commit access either by being nominated by
another committer, or by requesting it.

=item Core Developer

X<core developer role>

Core developers develop and maintain core subsystems such as the I/O
subsystem, the exceptions system, or the concurrency scheduler.

=item Compiler Developer

X<compiler developer role>

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

=item High-Level Language Developer

X<HLL developer role>

Developers who work on any of the high-level languages that target
ParrotE<mdash>such as Lua, Perl, PHP, Python, Ruby, or TclE<mdash>are
high-level language developers. The Parrot repository includes a few example
languages. A full list of languages is available at
L<https://github.com/parrot/parrot/wiki/Languages>

=item Build Manager

X<build manager role>

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

=item Tester

X<tester role>

Testers develop, maintain, and extend the core test suite coverage and testing
tools. Testers are also responsible for testing goals, including complete
coverage of core components on targeted platforms.

=item Patch Monsters

X<patch monster role>

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 check
patches for conformance with coding standards and desirability of features,
rework them as necessary, verify that the patches work as desired, and apply
them.

=item Cage Cleaners

X<cage cleaner role>

The cage cleaners ensure that development follows the project's coding
standards, documentation is complete and accurate, all tests function properly,
and new users have accurate and comprehensive coding examples. A special class
of Trac tickets is available for these tasks.  Cage cleaning tasks run the
gamut from entry-level to advanced; this is a good entry point for new users
to work on Parrot.

=item General Contributor

X<contributor role>

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

=back

=head2 Licensing

X<license>

The Parrot foundation supports the Parrot development community and holds
trademarks and copyrights to Parrot.  The project is available under the
Artistic License 2.0, allowing free use in commercial and open source/free
software contexts.

=cut

# Local variables:
#   c-file-style: "parrot"
# End:
# vim: expandtab shiftwidth=4:
