=head1 NAME
perltodo - Perl TO-DO List
=head1 DESCRIPTION
This is a list of wishes for Perl. The tasks we think are smaller or
easier are listed first. Anyone is welcome to work on any of these,
but it's a good idea to first contact I to
avoid duplication of effort, and to learn from any previous attempts.
By all means contact a pumpking privately first if you prefer.
Whilst patches to make the list shorter are most welcome, ideas to add to
the list are also encouraged. Check the perl5-porters archives for past
ideas, and any discussion about them. One set of archives may be found at:
http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/
What can we offer you in return? Fame, fortune, and everlasting glory? Maybe
not, but if your patch is incorporated, then we'll add your name to the
F file, which ships in the official distribution. How many other
programming languages offer you 1 line of immortality?
=head1 Tasks that only need Perl knowledge
=head2 Remove duplication of test setup.
Schwern notes, that there's duplication of code - lots and lots of tests have
some variation on the big block of C<$Is_Foo> checks. We can safely put this
into a file, change it to build an C<%Is> hash and require it. Maybe just put
it into F. Throw in the handy tainting subroutines.
=head2 merge common code in installperl and installman
There are some common subroutines and a common C block in F
and F. These should probably be merged. It would also be good to
check for duplication in all the utility scripts supplied in the source
tarball. It might be good to move them all to a subdirectory, but this would
require careful checking to find all places that call them, and change those
correctly.
=head2 common test code for timed bail out
Write portable self destruct code for tests to stop them burning CPU in
infinite loops. This needs to avoid using alarm, as some of the tests are
testing alarm/sleep or timers.
=head2 POD -E HTML conversion in the core still sucks
Which is crazy given just how simple POD purports to be, and how simple HTML
can be. It's not actually I simple as it sounds, particularly with the
flexibility POD allows for C<=item>, but it would be good to improve the
visual appeal of the HTML generated, and to avoid it having any validation
errors. See also L, as the layout of installation tree
is needed to improve the cross-linking.
The addition of C and its related modules may make this task
easier to complete.
=head2 merge checkpods and podchecker
F (and C in the F subdirectory)
implements a very basic check for pod files, but the errors it discovers
aren't found by podchecker. Add this check to podchecker, get rid of
checkpods and have C use podchecker.
=head2 perlmodlib.PL rewrite
Currently perlmodlib.PL needs to be run from a source directory where perl
has been built, or some modules won't be found, and others will be
skipped. Make it run from a clean perl source tree (so it's reproducible).
=head2 Parallel testing
(This probably impacts much more than the core: also the Test::Harness
and TAP::* modules on CPAN.)
The core regression test suite is getting ever more comprehensive, which has
the side effect that it takes longer to run. This isn't so good. Investigate
whether it would be feasible to give the harness script the B
would be roughly equivalent to:
do { local $"='|'; /\b(?:P)\b/ }
See L
for the discussion.
=head2 optional optimizer
Make the peephole optimizer optional. Currently it performs two tasks as
it walks the optree - genuine peephole optimisations, and necessary fixups of
ops. It would be good to find an efficient way to switch out the
optimisations whilst keeping the fixups.
=head2 You WANT *how* many
Currently contexts are void, scalar and list. split has a special mechanism in
place to pass in the number of return values wanted. It would be useful to
have a general mechanism for this, backwards compatible and little speed hit.
This would allow proposals such as short circuiting sort to be implemented
as a module on CPAN.
=head2 lexical aliases
Allow lexical aliases (maybe via the syntax C.
=head2 entersub XS vs Perl
At the moment pp_entersub is huge, and has code to deal with entering both
perl and XS subroutines. Subroutine implementations rarely change between
perl and XS at run time, so investigate using 2 ops to enter subs (one for
XS, one for perl) and swap between if a sub is redefined.
=head2 Self-ties
Self-ties are currently illegal because they caused too many segfaults. Maybe
the causes of these could be tracked down and self-ties on all types
reinstated.
=head2 Optimize away @_
The old perltodo notes "Look at the "reification" code in C".
=head2 The yada yada yada operators
Perl 6's Synopsis 3 says:
I
Those would be nice to add to Perl 5. That could be done without new ops.
=head2 Virtualize operating system access
Implement a set of "vtables" that virtualizes operating system access
(open(), mkdir(), unlink(), readdir(), getenv(), etc.) At the very
least these interfaces should take SVs as "name" arguments instead of
bare char pointers; probably the most flexible and extensible way
would be for the Perl-facing interfaces to accept HVs. The system
needs to be per-operating-system and per-file-system
hookable/filterable, preferably both from XS and Perl level
(L is good reading at this point,
in fact, all of L is.)
This has actually already been implemented (but only for Win32),
take a look at F and F. While all Win32
variants go through a set of "vtables" for operating system access,
non-Win32 systems currently go straight for the POSIX/UNIX-style
system/library call. Similar system as for Win32 should be
implemented for all platforms. The existing Win32 implementation
probably does not need to survive alongside this proposed new
implementation, the approaches could be merged.
What would this give us? One often-asked-for feature this would
enable is using Unicode for filenames, and other "names" like %ENV,
usernames, hostnames, and so forth.
(See L.)
But this kind of virtualization would also allow for things like
virtual filesystems, virtual networks, and "sandboxes" (though as long
as dynamic loading of random object code is allowed, not very safe
sandboxes since external code of course know not of Perl's vtables).
An example of a smaller "sandbox" is that this feature can be used to
implement per-thread working directories: Win32 already does this.
See also L"Extend PerlIO and PerlIO::Scalar">.
=head2 Investigate PADTMP hash pessimisation
The peephole optimier converts constants used for hash key lookups to shared
hash key scalars. Under ithreads, something is undoing this work. See
See http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2007-09/msg00793.html
=head2 repack the optree
Repacking the optree after execution order is determined could allow
removal of NULL ops, and optimal ordering of OPs wrt cache-line
filling. The slab allocator could be reused for this purpose.
http://www.nntp.perl.org/group/perl.perl5.porters/2007/12/msg131975.html
=head2 optimize tail-calls
Tail-calls present an opportunity for broadly applicable optimization;
anywhere that C<< return foo(...) >> is called, the outer return can
be replaced by a goto, and foo will return directly to the outer
caller, saving (conservatively) 25% of perl's call&return cost, which
is relatively higher than in C. The scheme language is known to do
this heavily. B::Concise provides good insight into where this
optimization is possible, ie anywhere entersub,leavesub op-sequence
occurs.
perl -MO=Concise,-exec,a,b,-main -e 'sub a{ 1 }; sub b {a()}; b(2)'
Bottom line on this is probably a new pp_tailcall function which
combines the code in pp_entersub, pp_leavesub. This should probably
be done 1st in XS, and using B::Generate to patch the new OP into the
optrees.
=head1 Big projects
Tasks that will get your name mentioned in the description of the "Highlights
of 5.12"
=head2 make ithreads more robust
Generally make ithreads more robust. See also L
This task is incremental - even a little bit of work on it will help, and
will be greatly appreciated.
One bit would be to write the missing code in sv.c:Perl_dirp_dup.
Fix Perl_sv_dup, et al so that threads can return objects.
=head2 iCOW
Sarathy and Arthur have a proposal for an improved Copy On Write which
specifically will be able to COW new ithreads. If this can be implemented
it would be a good thing.
=head2 (?{...}) closures in regexps
Fix (or rewrite) the implementation of the C(?{...})/> closures.
=head2 A re-entrant regexp engine
This will allow the use of a regex from inside (?{ }), (??{ }) and
(?(?{ })|) constructs.
=head2 Add class set operations to regexp engine
Apparently these are quite useful. Anyway, Jeffery Friedl wants them.
demerphq has this on his todo list, but right at the bottom.