Today, Larry Wall posted more or less a Perl 6
timeline, Apocalypse wise. I found this very
interesting and thought it would be
interesting to some Perl monks (at least the
ones who believe they'll see Perl 6 in their
lifetime).

Larry said: "Here's the chapter-by-chapter
list of RFCs so you can see the kind of stuff
in the later chapters. I'll comment briefly
on the undone chapters."

ch01/016.bdb

Keep default Perl free of constraints such as warnings and strict.

ch01/026.ccb

Named operators versus functions

ch01/028.acb

Perl should stay Perl.

ch01/073.adb

All Perl core functions should return objects

ch01/141.abc

This Is The Last Major Revision

ch02/005.cdr

Multiline Comments for Perl.

ch02/009.bf

Highlander Variable Types

ch02/010.rr

Filehandles should use * as a type prefix if typeglobs are eliminated.

ch02/034.aaa

Angle brackets should not be used for file globbing

ch02/038.bdb

Standardise Handling Of Abnormal Numbers Like Infinities And NaNs

ch02/043.bcb

Integrate BigInts (and BigRats) Support Tightly With The Basic Scalars

ch02/051.ccr

Angle brackets should accept filenames and lists

ch02/071.aaa

Legacy Perl $pkg'var should die

ch02/102.dcr

Inline Comments for Perl.

ch02/103.rr

Fix $pkg::$var precedence issues with parsing of ::

ch02/105.aaa

Remove "In string @ must be \@" fatal error

ch02/109.rr

Less line noise - let's get rid of @%

ch02/111.aaa

Here Docs Terminators (Was Whitespace and Here Docs)

ch02/133.bcr

Alternate Syntax for variable names

ch02/134.bcc

Alternative array and hash slicing

ch02/139.cfr

Allow Calling Any Function With A Syntax Like s///

ch02/161.adb

Everything in Perl becomes an object.

ch02/162.abb

Heredoc contents

ch02/175.rr

Add list keyword to force list context (like scalar)

ch02/192.ddr

Undef values ne value

ch02/196.bcb

More direct syntax for hashes

ch02/201.bcr

hash slicing

ch02/212.rr

Make length(@array) work

ch02/218.bcc

my Dog $spot is just an assertion

ch02/222.abb

Interpolation of object method calls

ch02/226.acc

Selective interpolation in single quotish context.

ch02/237.adc

hashes should interpolate in double-quoted strings

ch02/245.rr

Add new empty keyword to DWIM for clearing values

ch02/251.acr

Interpolation of class method calls

ch02/252.abb

Interpolation of subroutines

ch02/263.rr

Add null() keyword and fundamental data type

ch02/327.dbr

\v for Vertical Tab

ch02/328.bcr

Single quotes don't interpolate \' and \\

ch03/024.rr

Data types: Semi-finite (lazy) lists

ch03/025.dba

Operators: Multiway comparisons

ch03/039.rr

Perl should have a print operator

ch03/045.bbb

|| and && should propagate result context to both sides

ch03/054.cdr

Operators: Polymorphic comparisons

ch03/081.abb

Lazily evaluated list generation functions

ch03/082.abb

Arrays: Apply operators element-wise in a list context

ch03/084.abb

Replace => (stringifying comma) with => (pair constructor)

ch03/104.ccr

Backtracking

ch03/138.rr

Eliminate =~ operator.

ch03/143.dcr

Case ignoring eq and cmp operators

ch03/170.ccr

Generalize =~ to a special "apply-to" assignment operator

ch03/283.ccc

tr/// in array context should return a histogram

ch03/285.acb

Lazy Input / Context-sensitive Input

ch03/290.bbc

Better english names for -X

ch03/320.ccc

Allow grouping of -X file tests and add filetest builtin

ch04/006.acc

Lexical variables made default

ch04/019.baa

Rename the local operator

ch04/022.abc

Control flow: Builtin switch statement

ch04/063.rr

Exception handling syntax

ch04/064.bdc

New pragma 'scope' to change Perl's default scoping

ch04/083.aab

Make constants look like variables

ch04/088.bbc

Omnibus Structured Exception/Error Handling Mechanism

ch04/089.cdr

Controllable Data Typing

ch04/106.dbr

Yet another lexical variable proposal: lexical variables made default

ch04/113.rr

Better constants and constant folding

ch04/119.bcr

Object neutral error handling via exceptions

ch04/120.bcr

Implicit counter in for statements, possibly $#.

ch04/167.bcr

Simplify do BLOCK Syntax

ch04/173.bcc

Allow multiple loop variables in foreach statements

ch04/199.abb

Short-circuiting built-in functions and user-defined subroutines

ch04/209.cdr

Fuller integer support in Perl.

ch04/262.cdr

Index Attribute

ch04/279.cdr

my() syntax extensions and attribute declarations

ch04/297.dcr

Attributes for compiler hints

ch04/309.adr

Allow keywords in sub prototypes

ch04/330.acc

Global dynamic variables should remain the default

ch04/337.bcc

Common attribute system to allow user-defined, extensible attributes

ch04/340.dcr

with takes a context

ch04/342.bcr

Pascal-like "with"

ch05/072.aaa

Variable-length lookbehind.

ch05/093.abb

Regex: Support for incremental pattern matching

ch05/110.bbb

counting matches

ch05/112.acc

Assignment within a regex

ch05/135.acr

Require explicit m on matches, even with ?? and // as delimiters.

ch05/144.aaa

Behavior of empty regex should be simple

ch05/145.acr

Brace-matching for Perl Regular Expressions

ch05/150.acc

Extend regex syntax to provide for return of a hash of matched subpatterns

ch05/156.aaa

Replace first match function (?...?) with a flag to the match command.

We know AUTOLOAD needs some work to be able to return a ref without
actually calling a routine. And a "next method" mechanism is
already in the works for A12 so that AUTOLOAD can decline to work.

ch11/062

Wildcards for multiple module imports

ch11/074

Proposal to rename import and unimport

ch11/078

Improved Module Versioning And Searching

ch11/233

Replace Exporter by a better scaling mechanism

ch11/253

UNIVERSAL::require()

ch11/257

UNIVERSAL::import()

ch11/289

Generate module dependencies easily

ch11/291

Detecting Perl Core Modules Should Be Easy

Mostly decided already. Some of it comes out in A12, such improved
versioning and searching.

ch12/032.abb

A method of allowing foreign objects in perl

ch12/067.abb

Deep Copying, aka, cloning around.

ch12/092.abb

Extensible Meta-Object Protocol

ch12/095.acc

Object Classes

ch12/101.bcc

Apache-like Event and Dispatch Handlers

ch12/126.aaa

Ensuring Perl's object-oriented future

ch12/137.bdd

Overview: Perl OO should not be fundamentally changed.

ch12/147.rr

Split Scalars and Objects/References into Two Types

ch12/152.bdd

Replace invocant in @_ with self() builtin

ch12/163.bdd

Objects: Autoaccessors for object data structures

ch12/171.rr

my Dog $spot should call a constructor implicitly

ch12/174.bdd

Improved parsing and flexibility of indirect object syntax

ch12/187.abb

Objects : Mandatory and enhanced second argument to bless

ch12/188.acc

Objects : Private keys and methods

ch12/189.abb

Objects : Hierarchical calls to initializers and destructors

ch12/190.acc

Objects : NEXT pseudoclass for method redispatch

ch12/193.acc

Objects : Core support for method delegation

ch12/223.bdd

Objects: use invocant pragma

ch12/224.bdd

Objects : Rationalizing ref, attribute::reftype, and builtin:blessed

ch12/244.cdr

Method calls should not suffer from the action on a distance

ch12/254.abb

Class Collections: Provide the ability to overload classes

ch12/256.abb

Objects : Native support for multimethods

ch12/265.abc

Interface polymorphism considered lovely

ch12/277.bbb

Method calls SHOULD suffer from ambiguity by default

ch12/307.rr

PRAYER - what gets said when you bless something

ch12/335.acc

Class Methods Introspection: what methods does this object support?

ch12/336.bbb

use strict 'objects': a new pragma for using Java-like objects in Perl

A12 is mostly written.

ch13/020.cd

Overloadable && and ||

ch13/049

Objects should have builtin stringifying STRING method

ch13/097

prototype-based method overloading

ch13/098

context-based method overloading

ch13/108

Scope of Polymorphic References and Objects

ch13/115

Overloadable parentheses for objects

ch13/159

True Polymorphic Objects

ch13/180

Object Class hooks into printf

ch13/234

Data: overloading via the SECOND operand if needed

ch13/235

Data: sprintf() with overloaded objects

ch13/258

Distinguish packed data from printable strings

Mostly covered already, or in A12.

ch14/015.cf

Stronger typing through tie.

ch14/200

Objects: Revamp tie to support extensibility (Massive tie changes)

ch14/243

No special UPPERCASE_NAME subroutines

ch14/319

Transparently integrate tie

The main decision about tie is that you can't tie a variable
unless it's been declared as tie-able. Otherwise the optimizer
is hamstrung. Perhaps more importantly, tie has been generalized
to container typing, which we already have decided most of.

ch15/050

BiDirectional Support in PERL

ch15/069

Standardize input record separator (for portability)

ch15/131

Internal String Storage to be Opaque

ch15/294

Internally, data is stored as UTF8

ch15/295

Normalisation and unicode::exact

ch15/296

Getting Data Into Unicode Is Not Our Problem

ch15/300

use unicode::representation and no unicode

ch15/311

Line Disciplines

ch15/312

Unicode Combinatorix

ch15/322

Abstract Internals String Interaction

Most of this is already done right in recent Perl 5, except the
parts that are done wrong...

ch16/060

Safe Signals

ch16/086

IPC Mailboxes for Threads and Signals

Parrot issues.

ch17/001.ac

Implementation of Threads in Perl

ch17/027

Coroutines for Perl

ch17/031

Subroutines: Co-routines

ch17/047

Universal Asynchronous I/O

ch17/087

Timers and Timeouts

ch17/178

Lightweight Threads

ch17/185

Thread Programming Model

ch17/293

MT-Safe Autovariables in perl 5.005 Threading

ch17/321

Common Callback API for all AIO calls.

ch17/345

Putting an Event Loop in the Core

Parrot issues, mostly. If the underlying mechanism is there,
it's trivial to expose the API at the language level. If it's not,
well, that makes it a little harder...

ch18/004.bd

type inference

ch18/012.af

variable usage warnings

ch18/018.ad

Immediate subroutines

ch18/040

Module Scope Control

ch18/068

Eliminate the optional sub for BEGIN etc block declarations

ch18/070

Allow exception-based error-reporting.

ch18/172

Precompiled Perl scripts.

ch18/214

Emit warnings and errors based on unoptimized code

ch18/264

Provide a standard module to simplify the creation of source filters

ch18/314

A parser is a many-layered thing

Much already decided, either on Perl level or Parrot level.

ch19/114

Perl resource configuration

I don't mind if Perl has a -r switch, as long as it's not default.

ch20/184

Perl should support an interactive mode.

ch20/292

Extensions to the perl debugger

Not a language issue. I don't mind if other people work on this.
(I almost never use the debugger.)

ch21/035

A proposed internal base format for perl variables

ch21/046.rr

Use features of portable, free compilers and libraries

ch21/061

Interfaces for linking C objects into perlsubs

ch21/121

linkable output mode

ch21/125

Components in the Perl Core Should Have Well-Defined APIs and Behavior

ch21/210

Data/Binary Dumping and Freezing

ch21/270

Replace XS with the Inline module as the standard way to extend Perl.

ch21/281

The Perl 6 Development Log

ch21/301

Cache byte-compiled programs and modules

ch21/310

Ordered bytecode

ch21/315

Kick out all ops - libprt

ch21/318

Handling environment setting in extension modules

ch21/323

Perl's embedding API should be simple

ch21/326

Symbols, symbols everywhere

ch21/338

shareable bytecode

ch21/349

Perl modules should be built with a Perl make program

ch21/352

Merge Perl and C#, but have default Main class for scripting.

Mostly Parrot issues.

ch23/130

Transaction-enabled variables for Perl6

ch23/227

Extend the window to turn on taint mode

ch23/353

A Sandboxing mechanism for Perl 6

We have "let" for transaction-enabled variables. Sandboxing is a rathole.

ch24/183

"=for testing" - Embedded tests

Up to the qa folks.

ch25/036

Structured Internal Representation of Filenames

ch25/099

Standardize ALL Perl platforms on UNIX epoch

ch25/100

Embed full URI support into Perl

Library issues, not language design issues.

ch26/011.cf

Examples encoded with =also for|begin|end POD commands

ch26/044

Bring Documentation Closer To Whatever It Documents

ch26/065

Add change bar functionality to pod

ch26/079

The Predefined POD Streams are perl, data, and doc

ch26/216

POD should tolerate white space.

ch26/217

POD needs a reorder command.

ch26/280

Tweak POD's &lt &gt

ch26/286

Add a "emit pod" runtime option to Perl

ch26/306

User-definable POD handling

ch26/325

POD and comments handling in perl

ch26/357

Perl should use XML for documentation instead of POD

POD definitely needs some tweaks, some of which we've already
published. What it doesn't need is to be turned into TeX or XML.

ch27/013.aa

The Copyright and Licensing Working Group

ch27/182

JART - Just Another Regression Test

ch27/211

The Artistic License Must Be Changed

ch27/219.rr

Perl6's License Should Be a Minor Bugfix of Perl5's License

ch27/240

Form a documentation working group to edit, clean, and produce

ch27/343

New Perl Mascot

ch27/346

Perl6's License Should be (GPL|Artistic-2.0)

ch27/354

A Trademark on Perl Should be Acquired in Larry Wall's Name

Licensing has to be decided soon--probably we'll go with
(GPL|Artistic-2.0), more or less. We're not changing the Perl
Mascot-I own too many stuffed camels for that. Trademarks are a
royal pain. Do you really always want to say "the Perl programming
language" everywhere you now say "Perl"? Otherwise we lose
trademark status.

Oh, sorry, make that "the Perl® programming language".

ch28/017.bd

Organization and Rationalization of Perl State Variables

ch28/030

STDIN, STDOUT, STDERR, ARGV, and DATA should become scalars

ch28/033

Eliminate bareword filehandles.

ch28/094.rr

Rename @ARGV to @ARGS

ch28/129

Replace default filehandle/select with $DEFOUT, $DEFERR, $DEFIN

ch28/151

Merge $!, $^E, $@ and $?

ch28/158

Regular Expression Special Variables

ch28/236

Change the way $SIG{__WARN__} and $SIG{__DIE__} are used

ch28/284

Change $SIG{__WARN__} and $SIG{__DIE__} to magic subs

ch28/299

@STACK - a modifyable caller()

ch28/305

$^C should be true when compiling

ch28/347

Remove long-deprecated $* (aka $MULTILINE_MATCHING)

ch28/355

Leave $[ alone.

Most all of these have been accepted already.

ch29/007.ab

Higher resolution time values

ch29/014.ab

Modify open() to support FileObjects and Extensibility

ch29/029

unlink() should be left alone

ch29/037

Positional Return Lists Considered Harmful

ch29/048

Replace localtime() and gmtime() with date() and utcdate()

ch29/052.rr

List context return from filesystem functions

ch29/053

Built-ins: Merge and generalize index and rindex

ch29/055

Compilation: Remove requirement for final true value in require-d
and do-ed files

ch29/056

Optional 2nd argument to pop() and shift()

ch29/058

chomp() changes.

ch29/076

Builtin: reduce

ch29/077

Suggested isa() operator.

ch29/090

Arrays: merge() and unmerge()

ch29/091

Arrays: part and flatten

ch29/127

Sane resolution to large function returns

ch29/146

Remove socket functions from core

ch29/148

Arrays: Add reshape() for multi-dimensional array reshaping

ch29/155

Remove mathematic and trigonomic functions from core binary

ch29/157

Delete dbmopen and dbmclose commands.

ch29/179

More functions from set theory to manipulate arrays

ch29/195

Retire chop().

ch29/208

crypt() default salt

ch29/213

rindex and index should return true/false values

ch29/215

More defaulting to $_

ch29/220

wait() and waitpid() should return false on failure

ch29/221

system() should return useful values

ch29/229

Variable interpolation on demand.

ch29/239

IO: Standardization of Perl IO Functions to use Indirect Objects

ch29/246

pack/unpack uncontrovercial enhancements

ch29/248

enhanced groups in pack/unpack

ch29/249

Use pack/unpack for marshalling

ch29/250

hooks in pack/unpack

ch29/255.rr

Fix iteration of nested hashes

ch29/259

Builtins : Make use of hashref context for garrulous builtins

ch29/267

Eliminate dump() function

ch29/269.rr

Perl should not abort when a required file yields a false value

ch29/272

Arrays: transpose()

ch29/339

caller->eval BLOCK

ch29/351

Beyond the amnesic eval

ch29/358

Keep dump capability.

Doubtless a great deal of the remaining design work is here.
But it's reasonable to assume that most of these functions work
as in Perl 5 unless we decide otherwise. Which, in many cases,
we already have. Or there's already a newer, more obvious way
to write the function in question.

ch30/186

Standard support for opening i/o handles on scalars and arrays-of-scalars

ch30/228

Add memoize into the standard library

ch30/260

More modules

ch30/287

Improve Perl Persistance

ch30/288

First-Class CGI Support

ch30/333

Add header and unheader funtions to core distribution

ch30/350

Advanced I/O (AIO)

Mostly oddities.

ch31/002.cf

Request For New Pragma: Implicit

ch31/041.rr

Request For New Pragma: Implicit

ch31/042

Request For New Pragma: Shell

ch31/066

Shell Style Redirection

ch31/140

One Should Not Get Away With Ignoring System Call Errors

ch31/153

New pragma 'autoload' to load functions and modules on-demand

ch31/275

New 'tristate' pragma to allow undef to take on NULL semantics

ch31/278

Additions to 'use strict' to fix syntactic ambiguities

ch31/302

Unrolling loops and tail recursion

ch31/303

Keep use less, but make it work.

ch31/304

sort algorithm to be selectable at compile time

ch31/329

use syntax

ch31/356

Dominant Value Expressions

Many pragma requests are bandaids on a deficient language design.
It's usually better to fix the language in those cases, except
where we want a certain default behavior, and use a pragma to
select a different default behavior. In particular, now that we
have named arguments, a lot of these options can just be applied
adverbially, such as forcing sort to use a particular algorithm.

ch33/003.bf

messages.rfc - An RFC to discussing the wisdom of allowing run time error

I could reasonably delegate the design of exception classes.
And I18N will certainly be an I11l effort. I think Parrot has
pretty much ignored the issue till now because all the Parrot
Mongers speak English, and since everyone else retrofits I18N,
why not us too? :-)

As Larry said in that mail: "I hope this all paints a rosier bike-shed, er,
picture for you."

I know this is something I already should know already, meaning the answer has been given as "When It's Done", but I have to ask anyway. I think you know the question. Ballpark, about when is Perl6 going to be released? There are many cool toys here, and .. well .. I'm just wondering.

Seriously. Jokes about the Apocalypse Aside. Most software projects set schedules, and while this is open-source and free, schedules seem to be a very good thing to have. Else, you end up with feature-itis and a stable product is never established.

Ok, I'll jump. How *do* I get involved? I'm currently jumping around with various ideas in my head, mostly all for personal fulfillment, and working on something more important to the community *is* what I am looking for. My previous involvement in open source projects is minimal, I've attempted to start something on sourceforge before, but nothing really came of it -- mainly because a lot of cool things can't happen while flying solo.

Perl6 is very important to Perl, of course, mainly because it straightens out the OO model enough to where it can start to really gain widespread acceptance in places Perl can't normally go. It's the third-stage rocket booster to Perl greatness, essentially.

Let me know what I can do, and I'm there. I have some fairly sharp design and development skills (IMHO), experience across a wide set of languages -- yet I'm not exactly sure how the process works. Helping would be awesome though.

Of note is that Perl6 the language and perl6 the interpreter are being developed separately. Right now, the language spec isn't anywhere near complete, and I don't think you can truely make any sort of schedule for that kind of thing. Also note that not even the Perl5 language spec is done. Given that the perl6 interpreter can and will be developed in parallel with the Perl6 langspec, I'd say schedules will be available once the langspec is considered sufficiently complete to attempt an actual implementation; and I'd also say that once we reach that point, the implementation will be with us much sooner than you probably imagine.