Patrick Michaud provides us with this brief recap of Perl 6. Patrick and I are going to be working on the Perl 6 development dashboard in the next few days to try to get a “what’s done” and “what’s needed to release” story to tell. — Andy

Andy Lester asked:

Is there any way we can say “Here’s what we’ve done
and here’s what’s left?” At least that’s a story I can tell. At
least that kind of leaves us with “See, you can see the shape of
the house and the roof is on, and we’re working on the wiring
and the plumbing.”

I probably can’t tell the full story of “Here’s what we’ve done”, but I
think I can give an outline for one. Apologies in advance for any
factual errors or omissions here — many parts of the “story” occurred
before I became an active participant of Perl 6 development.
Also, this shouldn’t be taken as an official story of the Perl 6
community or development team, it’s just my answer to the question
that Andy posed.

First, we have a Perl 6 language specification, as given by the
synopses.
People who have looked and played with the language given
by that specification seem to really like it. We can’t say that
the specification is complete or frozen, because as we work on
implementing the language we’re finding places where the spec
needs improvement. Some people express that the answer is to
freeze the specification so we can get at least one implementation
working; I entirely disagree with that. It’s important that we retain
flexibility to continue to improve the specification in response
to things learned from the implementation(s).

We have at least one substantial Perl 6 implementation, known as
Pugs. In fact, it’s the experience of writing and using Pugs that
has prompted important changes to the language specification. Pugs
is available from pugscode.org.

There’s is another implementation of Perl 6 being done for Parrot,
called “perl6”. Parrot is a virtual machine intended to support
Perl 6 and other dynamic languages, such as Python,
Ruby, PHP, and
the like. Some people may feel that Parrot is an unnecessary
distraction from Perl 6, but it’s clear that Perl 6 will need
some sort of virtual machine under it, just like Perl 5 has.
Early in the Perl 6 development, the available virtual machine
options were basically: reuse the Perl 5 VM somehow, try to use
another VM, or build a new one. Early efforts at writing Perl 6 on
top of Perl 5 didn’t appear to be working out so well, thus when
I started development in 2004 I was advised by the design team to
start afresh with Parrot, and that’s the approach that perl6 has
taken.

Having a virtual machine isn’t sufficient — we also need tools
for building programs for that virtual machine. For a couple of years
we’ve had a grammar engine to build parsers in Parrot, and that seems
to be working well. Within the past few months we’ve also completed
a code generator for abstract syntax trees (part of the “Parrot
Compiler Toolkit”) and a simple transformation language (“Not Quite
Perl”). The completion of these tools appears to have boosted
development speed on Parrot languages, including Perl 6, PHP, Python,
etc., by at least an order of magnitude. The tools are also dramatically
widening the scope of people who can productively participate in
compiler development. We still need work on documentation and
tutorials for the new tools so that we can increase the pace of
development even further, and that’s a primary focus for me at
the moment.

We have an implementation of Perl 6 on Parrot called “perl6”.
There has been an implementation of Perl 6 on Parrot for over a year
now, but progress on it had stalled because we needed improvements
to Parrot and to the compiler tools. As of mid-December those
improvements are now complete, and within the past two weeks the
perl6 compiler has been completely rewritten to make use of the
new Parrot compiler tools. Even though the new implementation
is only a couple of weeks old, we already see huge gains in
the quality and extensibility of the compiler, and in the ability
for others to participate in its development. Because the current
implementation is so new, I’m reluctant to hazard a guess as to
an anticipated pace of development going forward, other than to
say it should be much faster than what has been. I do tend to
think that we’ll be reaching the “workable implementation” stage
in a matter of weeks instead of months or years.

Lastly, there is a substantial suite of tests written for Perl 6
language features, currently held in the Pugs repository. These
tests are about to undergo substantial review and revision for
correctness, completeness, and cross-compatibility among the
implementations that are in various stages of development.

Looking to the future

Looking to the future and what I expect to see happen in January 2008:

  • some sort of working (perhaps primitive) perl6 installation where a person can download a tarball, build perl6, and type something like “perl6 foo.pl” to execute a Perl 6 program.
  • documents and publications describing the architecture of the perl6 compiler and how the various Parrot compiler tools fit together
  • substantial progress on reorganization and development of the official test suite
  • implementation of more Perl 6 language features

As for me, my primary focus has always been on getting a working
Perl 6 implementation on Parrot. To me, Perl 6 is not just an
interesting research project — it has a clear deliverable. If
we complete a usable implementation of Perl 6, we succeed; if we
don’t, we fail. It’s that straightforward to me.

However, it’s also important to have Perl 6 in a reasonable timeframe,
and I agree with others that we’re certainly pushing our luck there.
Many people say that the long development time for Perl 6 has
caused it to miss its window of opportunity. Time will tell if
this is true, but personally I don’t think this will be the case.
Yes, Perl 6 has taken far longer than any of us imagined, but
Perl 6 and Parrot are also poised to do things that many of us
hadn’t even dreamed about when we first started. And that’s
what keeps me working on Perl 6 even when it seems to be taking
so long to get to the goal. I find Perl 6 to be such a profound
and fundamental improvement in programming that I think the
extra time we’re all spending at the front end will have an
impact and reap rewards measured in terms of decades. So while
the delays are hard to take, the end result is worth it to me.

Patrick Michaud is the pumpking for the Perl 6 compiler. He holds a Ph.D. in Computer Science and was formerly a Professor of Computer Science at Texas A&M University-Corpus Christi. He is currently a software developer and consultant focused on open source development and applications, including Perl, PmWiki, and Linux.