perltodo - Perl TO-DO List

- NAME
- DESCRIPTION
- Infrastructure

- Mailing list archives
- Bug tracking system
- Regression Tests

- Configure

- Install HTML

- Perl Language

- 64-bit Perl
- Prototypes

- Perl Internals

- magic_setisa
- Garbage Collection
- Reliable signals
- Interpolated regex performance bugs
- Memory leaks from failed eval/regcomp
- Make XS easier to use
- Make embedded Perl easier to use
- Namespace cleanup
- MULTIPLICITY
- MacPerl

- Documentation

- A clear division into tutorial and reference
- Remove the artificial distinction between operators and functions
- More tutorials
- Include a search tool
- Include a locate tool
- Separate function manpages by default
- Users can't find the manpages
- Install ALL Documentation
- Outstanding issues to be documented
- Adapt www.linuxhq.com for Perl
- Replace man with a perl program
- Unicode tutorial

- Modules

- Update the POSIX extension to conform with the POSIX 1003.1 Edition 2
- Module versions
- New modules
- Profiler
- Tie Modules
- Procedural options
- RPC
- y2k localtime/gmtime
- Export File::Find variables
- Ioctl
- Debugger attach/detach
- Regular Expression debugger
- Alternative RE Syntax
- Bundled modules
- Expect
- GUI::Native
- Update semibroken auxiliary tools; h2ph, a2p, etc.
- pod2html
- Podchecker

- Tom's Wishes

- Webperl
- Mobile agents
- POSIX on non-POSIX
- Portable installations

- Win32 Stuff

- Rename new headers to be consistent with the rest
- Work out DLL versioning
- Style-check

- Would be nice to have
- Possible pragmas

- 'less'

- Optimizations

- constant function cache
- `foreach(reverse...)`
- Cache eval tree
- rcatmaybe
- Shrink opcode tables
- Cache hash value
- Optimize away @_ where possible
- Optimize sort by { $a <=> $b }
- Rewrite regexp parser for better integrated optimization

- Vague possibilities
- To Do Or Not To Do

- Making `my()` work on ``package'' variables
- ``or'' testing defined not truth
- ``dynamic'' lexicals
- ``class''-based, rather than package-based ``lexicals''

- Threading

- Modules
- Testing
- $AUTOLOAD
- exit/die
- External threads
- Thread::Pool
- thread-safety
- Per-thread GVs

- Compiler

- Optimization
- Byteperl
- Precompiled modules
- Executables
- Typed lexicals
- Win32
- END blocks
- _AUTOLOAD
- comppadlist
- Cached compilation

- Recently Finished Tasks

- Figure a way out of $^(capital letter)
- Filenames
- Foreign lines
- Namespace cleanup
- ISA.pm
- gettimeofday
- autocroak?

# NAME

perltodo - Perl TO-DO List

# DESCRIPTION

This is a list of wishes for Perl. It is maintained by Nathan Torkington for the Perl porters. Send updates to perl5-porters@perl.org. If you want to work on any of these projects, be sure to check the perl5-porters archives for past ideas, flames, and propaganda. This will save you time and also prevent you from implementing something that Larry has already vetoed. One set of archives may be found at:

        http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/

# Infrastructure

## Mailing list archives

Chaim suggests contacting egroup and asking them to archive the other perl.org mailing lists. Probably not advocacy, but definitely perl6-porters, etc.

## Bug tracking system

Richard Foley richard@perl.org is writing one. We looked at several, like gnats and the Debian system, but at the time we investigated them, none met our needs. Since then, Jitterbug has matured, and may be worth reinvestigation.

The system we've developed is the recipient of perlbug mail, and any followups it generates from perl5-porters. New bugs are entered into a mysql database, and sent on to perl5-porters with the subject line rewritten to include a ``ticket number'' (unique ID for the new bug). If the incoming message already had a ticket number in the subject line, then the message is logged against that bug. There is a separate email interface (not forwarding to p5p) that permits porters to claim, categorize, and close tickets.

There is also a web interface to the system at http://bugs.perl.org.

The current delay in implementation is caused by perl.org lockups. One suspect is the mail handling system, possibly going into loops.

We still desperately need a bugmaster, someone who will look at every new ``bug'' and kill those that we already know about, those that are not bugs at all, etc.

## Regression Tests

The test suite for Perl serves two needs: ensuring features work, and ensuring old bugs have not been reintroduced. Both need work.

Brent LaVelle (lavelle@metronet.com) has stepped forward to work on performance tests and improving the size of the test suite.

Coverage
  Do the tests that come with Perl exercise every line (or every block, or ...) of the Perl interpreter, and if not then how can we make them do so?

Regression
  No bug fixes should be made without a corresponding testsuite addition. This needs a dedicated enforcer, as the current pumpking is either too lazy or too stupid or both and lets enforcement wander all over the map. :-)

__DIE__
  Tests that fail need to be of a form that can be readily mailed to perlbug and diagnosed with minimal back-and-forth's to determine which test failed, due to what cause, etc.

suidperl
  We need regression/sanity tests for suidperl

The 25% slowdown from perl4 to perl5
  This value may or may not be accurate, but it certainly is eye-catching. For some things perl5 is faster than perl4, but often the reliability and extensibility have come at a cost of speed. The benchmark suite that Gisle released earlier has been hailed as both a fantastic solution and as a source of entirely meaningless figures. Do we need to test ``real applications''? Can you do so? Anyone have machines to dedicate to the task? Identify the things that have grown slower, and see if there's a way to make them faster.

# Configure

Andy Dougherty `maintain(ed|s)` a list of ``todo'' items for the configure that comes with Perl. See Porting/pumpkin.pod in the latest source release.

## Install HTML

Have ``make install'' give you the option to install HTML as well. This would be part of Configure. Andy Wardley (certified Perl studmuffin) will look into the current problems of HTML installation--is 'installhtml' preventing this from happening cleanly, or is pod2html the problem? If the latter, Brad Appleton's pod work may fix the problem for free.

# Perl Language

## 64-bit Perl

Verify complete 64 bit support so that the value of sysseek, or `-s`, or stat(), or tell can fit into a perl number without losing precision. Work with the perl-64bit mailing list on perl.org.

## Prototypes

Named prototypes
  Add proper named prototypes that actually work usefully.

Indirect objects
  Fix prototype bug that forgets indirect objects.

Method calls
  Prototypes for method calls.

Context
  Return context prototype declarations.

Scoped subs
  lexically-scoped subs, e.g. my sub

# Perl Internals

## magic_setisa

`magic_setisa` should be made to update %FIELDS [???]

## Garbage Collection

There was talk of a mark-and-sweep garbage collector at TPC2, but the (to users) unpredictable nature of its behaviour put some off. Sarathy, I believe, did the work. Here's what he has to say:

Yeah, I hope to implement it someday too. The points that were raised in TPC2 were all to do with calling `DESTROY()` methods, but I think we can accommodate that by extending `bless()` to stash extra information for objects so we track their lifetime accurately for those that want their `DESTROY()` to be predictable (this will be a speed hit, naturally, and will therefore be optional, naturally. :)

[N.B. Don't even ask me about this now! When I have the time to write a cogent summary, I'll post it.]

## Reliable signals

Sarathy and Dan Sugalski are working on this. Chip posted a patch earlier, but it was not accepted into 5.005. The issue is tricky, because it has the potential to greatly slow down the core.

There are at least three things to consider:

Alternate `runops()` for signal despatch
  Sarathy and Dan are discussed this on perl5-porters.

Figure out how to `die()` in delayed sighandler
Add tests for Thread::Signal
Automatic tests against CPAN
  Is there some way to automatically build all/most of CPAN with the new Perl and check that the modules there pass all the tests?

## Interpolated regex performance bugs

      while (<>) {
        $found = 0;
        foreach $pat (@patterns) {
          $found++ if /$pat/o;
        }
        print if $found;
      }

The qr// syntax added in 5.005 has solved this problem, but it needs more thorough documentation.

## Memory leaks from failed eval/regcomp

The only known memory leaks in Perl are in failed code or regexp compilation. Fix this. Hugo Van Der Sanden will attempt this but won't have tuits until January 1999.

## Make XS easier to use

There was interest in SWIG from porters, but nothing has happened lately.

## Make embedded Perl easier to use

This is probably difficult for the same reasons that ``XS For Dummies'' will be difficult.

## Namespace cleanup

        CPP-space:    restrict CPP symbols exported from headers
        header-space: move into CORE/perl/
        API-space:    begin list of things that constitute public api
        env-space:    Configure should use PERL_CONFIG instead of CONFIG etc.

## MULTIPLICITY

Complete work on safe recursive interpreters `Perl->new()`. Sarathy says that a reference implementation exists.

## MacPerl

Chris Nandor and Matthias Neeracher are working on better integrating MacPerl into the Perl distribution.

# Documentation

There's a lot of documentation that comes with Perl. The quantity of documentation makes it difficult for users to know which section of which manpage to read in order to solve their problem. Tom Christiansen has done much of the documentation work in the past.

## A clear division into tutorial and reference

Some manpages (e.g., perltoot and perlreftut) clearly set out to educate the reader about a subject. Other manpages (e.g., perlsub) are references for which there is no tutorial, or are references with a slight tutorial bent. If things are either tutorial or reference, then the reader knows which manpage to read to learn about a subject, and which manpage to read to learn all about an aspect of that subject. Part of the solution to this is:

## Remove the artificial distinction between operators and functions

History shows us that users, and often porters, aren't clear on the operator-function distinction. The present split in reference material between perlfunc and perlop hinders user navigation. Given that perlfunc is by far the larger of the two, move operator reference into perlfunc.

## More tutorials

More documents of a tutorial nature could help. Here are some candidates:

Regular expressions
  Robin Berjon (r.berjon@ltconsulting.net) has volunteered.

I/O
  Mark-Jason Dominus (mjd@plover.com) has an outline for perliotut.

pack/unpack
  This is badly needed. There has been some discussion on the subject on perl5-porters.

Debugging
  Ronald Kimball (rjk@linguist.dartmouth.edu) has volunteered.

## Include a search tool

perldoc should be able to 'grep' fulltext indices of installed POD files. This would let people say:

      perldoc -find printing numbers with commas

and get back the perlfaq entry on 'commify'.

This solution, however, requires documentation to contain the keywords the user is searching for. Even when the users know what they're looking for, often they can't spell it.

## Include a locate tool

perldoc should be able to help people find the manpages on a particular high-level subject:

      perldoc -find web

would tell them manpages, web pages, and books with material on web programming. Similarly `perldoc -find databases`, `perldoc -find references` and so on.

We need something in the vicinity of:

      % perl -help random stuff
      No documentation for perl function `random stuff' found
      The following entry in perlfunc.pod matches /random/a:
        =item rand EXPR

        =item rand

        Returns a random fractional number greater than or equal to C<0> and less
        than the value of EXPR.  (EXPR should be positive.)  If EXPR is
        omitted, the value C<1> is used.  Automatically calls C<srand()> unless
        C<srand()> has already been called.  See also C<srand()>.

        (Note: If your rand function consistently returns numbers that are too
        large or too small, then your version of Perl was probably compiled
        with the wrong number of RANDBITS.)
      The following pod pages seem to have /stuff/a:
        perlfunc.pod        (7 hits)
        perlfaq7.pod        (6 hits)
        perlmod.pod         (4 hits)
        perlsyn.pod         (3 hits)
        perlfaq8.pod        (2 hits)
        perlipc.pod         (2 hits)
        perl5004delta.pod   (1 hit)
        perl5005delta.pod   (1 hit)
        perlcall.pod        (1 hit)
        perldelta.pod       (1 hit)
        perlfaq3.pod        (1 hit)
        perlfaq5.pod        (1 hit)
        perlhist.pod        (1 hit)
        perlref.pod         (1 hit)
        perltoc.pod         (1 hit)
        perltrap.pod        (1 hit)
      Proceed to open perlfunc.pod? [y] n
      Do you want to speak perl interactively? [y] n
      Should I dial 911? [y] n
      Do you need psychiatric help? [y] y
      <PELIZA> Hi, what bothers you today?
               A Python programmer in the next cubby is driving me nuts!
      <PELIZA> Hmm, thats fixable.  Just [rest censored]

## Separate function manpages by default

Perl should install 'manpages' for every function/operator into the 3pl or 3p manual section. By default. The splitman program in the Perl source distribution does the work of turning big perlfunc into little 3p pages.

## Users can't find the manpages

Make `perldoc` tell users what they need to add to their .login or .cshrc to set their MANPATH correctly.

## Install ALL Documentation

Make the standard documentation kit include the VMS, OS/2, Win32, Threads, etc information. installperl and pod/Makefile should know enough to copy README.foo to perlfoo.pod before building everything, when appropriate.

## Outstanding issues to be documented

Tom has a list of 5.005_5* features or changes that require documentation.

Create one document that coherently explains the delta between the last camel release and the current release. perldelta was supposed to be that, but no longer. The things in perldelta never seemed to get placed in the right places in the real manpages, either. This needs work.

## Adapt www.linuxhq.com for Perl

This should help glorify documentation and get more people involved in perl development.

## Replace man with a perl program

Can we reimplement man in Perl? Tom has a start. I believe some of the Linux systems distribute a manalike. Alternatively, build on perldoc to remove the unfeatures like ``is slow'' and ``has no apropos''.

## Unicode tutorial

We could use more work on helping people understand Perl's new Unicode support that Larry has created.

# Modules

## Update the POSIX extension to conform with the POSIX 1003.1 Edition 2

The current state of the POSIX extension is as of Edition 1, 1991, whereas the Edition 2 came out in 1996. ISO/IEC 9945:1-1996(E), ANSI/IEEE Std 1003.1, 1996 Edition. ISBN 1-55937-573-6. The updates were legion: threads, IPC, and real time extensions.

## Module versions

Automate the checking of versions in the standard distribution so it's easy for a pumpking to check whether CPAN has a newer version that we should be including?

## New modules

Which modules should be added to the standard distribution? This ties in with the SDK discussed on the perl-sdk list at perl.org.

## Profiler

Make the profiler (Devel::DProf) part of the standard release, and document it well.

## Tie Modules

VecArray
  Implement array using vec(). Nathan Torkington has working code to do this.

SubstrArray
  Implement array using `substr()`

VirtualArray
  Implement array using a file

ShiftSplice
  Defines shift et al in terms of splice method

## Procedural options

Support procedural interfaces for the common cases of Perl's gratuitously OOO modules. Tom objects to ``use IO::File'' reading many thousands of lines of code.

## RPC

Write a module for transparent, portable remote procedure calls. (Not core). This touches on the CORBA and ILU work.

## y2k localtime/gmtime

Write a module, Y2k::Catch, which overloads localtime and gmtime's returned year value and catches ``bad'' attempts to use it.

## Export File::Find variables

Make File::Find export `$name` etc manually, at least if asked to.

## Ioctl

Finish a proper Ioctl module.

## Debugger attach/detach

Permit a user to debug an already-running program.

## Regular Expression debugger

Create a visual profiler/debugger tool that stepped you through the execution of a regular expression point by point. Ilya has a module to color-code and display regular expression parses and executions. There's something at http://tkworld.org/ that might be a good start, it's a Tk/Tcl RE wizard, that builds regexen of many flavours.

## Alternative RE Syntax

Make an alternative regular expression syntax that is accessed through a module. For instance,

      use RE;
      $re = start_of_line()
          ->literal("1998/10/08")
          ->optional( whitespace() )
          ->literal("[")
          ->remember( many( or( "-", digit() ) ) );

      if (/$re/) {
        print "time is $1\n";
      }

Newbies to regular expressions typically only use a subset of the full language. Perhaps you wouldn't have to implement the full feature set.

## Bundled modules

Nicholas Clark (nick@flirble.org) had a patch for storing modules in zipped format. This needs exploring and concluding.

## Expect

Adopt IO::Tty, make it as portable as Don Libes' ``expect'' (can we link against expect code?), and perfect a Perl version of expect. IO::Tty and expect could then be distributed as part of the core distribution, replacing Comm.pl and other hacks.

## GUI::Native

A simple-to-use interface to native graphical abilities would be welcomed. Oh, Perl's access Tk is nice enough, and reasonably portable, but it's not particularly as fast as one would like. Simple access to the mouse's cut buffer or mouse-presses shouldn't required loading a few terabytes of Tk code.

## Update semibroken auxiliary tools; h2ph, a2p, etc.

Kurt Starsinic is working on h2ph. mjd has fixed bugs in a2p in the past. a2p apparently doesn't work on nawk and gawk extensions. Graham Barr has an Include module that does h2ph work at runtime.

## pod2html

A short-term fix: pod2html generates absolute HTML links. Make it generate relative links.

## Podchecker

Something like lint for Pod would be good. Something that catches common errors as well as gross ones. Brad Appleton is putting together something as part of his PodParser work.

# Tom's Wishes

## Webperl

Design a webperl environment that's as tightly integrated and as easy-to-use as Perl's current command-line environment.

## Mobile agents

More work on a safe and secure execution environment for mobile agents would be neat; the Safe.pm module is a start, but there's a still a lot to be done in that area. Adopt Penguin?

## POSIX on non-POSIX

Standard programming constructs for non-POSIX systems would help a lot of programmers stuck on primitive, legacy systems. For example, Microsoft still hasn't made a usable POSIX interface on their clunky systems, which means that standard operations such as `alarm()` and fork(), both critical for sophisticated client-server programming, must both be kludged around.

I'm unsure whether Tom means to emulate alarm( )and fork(), or merely to provide a document like perlport.pod to say which features are portable and which are not.

## Portable installations

Figure out a portable semi-gelled installation, that is, one without full paths. Larry has said that he's thinking about this. Ilya pointed out that `perllib_mangle()` is good for this.

# Win32 Stuff

## Rename new headers to be consistent with the rest

## Work out DLL versioning

## Style-check

# Would be nice to have

`pack "(stuff)*"`
Contiguous bitfields in pack/unpack
lexperl
Bundled perl preprocessor
Use posix calls internally where possible
format BOTTOM
-i rename file only when successfully changed
All ARGV input should act like <>
report HANDLE [formats].
support in perlmain to rerun debugger
lvalue functions
  Tuomas Lukka, on behalf of the PDL project, greatly desires this and Ilya has a patch for it (probably against an older version of Perl). Tuomas points out that what PDL really wants is lvalue methods, not just subs.

# Possible pragmas

## 'less'

(use less memory, CPU)

# Optimizations

## constant function cache

## `foreach(reverse...)`

## Cache eval tree

Unless lexical outer scope used (mark in &compiling?).

## rcatmaybe

## Shrink opcode tables

Via multiple implementations selected in peep.

## Cache hash value

Not a win, according to Guido.

## Optimize away @_ where possible

## Optimize sort by { $a <=> $b }

Greg Bacon added several more sort optimizations. These have made it into 5.005_55, thanks to Hans Mulder.

## Rewrite regexp parser for better integrated optimization

The regexp parser was rewritten for 5.005. Ilya's the regexp guru.

# Vague possibilities

ref function in list context
  This seems impossible to do without substantially breaking code.

make tr/// return histogram in list context?
Loop control on do{} et al
Explicit switch statements
  Nobody has yet managed to come up with a switch syntax that would allow for mixed hash, constant, regexp checks. Submit implementation with syntax, please.

compile to real threaded code
structured types
Modifiable $1 et al
  The intent is for this to be a means of editing the matched portions of the target string.

# To Do Or Not To Do

These are things that have been discussed in the past and roundly criticized for being of questionable value.

## Making `my()` work on ``package'' variables

Being able to say my($Foo::Bar), something that sounds ludicrous and the 5.6 pumpking has mocked.

## ``or'' testing defined not truth

We tell people that `||` can be used to give a default value to a variable:

        $children = shift || 5;             # default is 5 children

which is almost (but not):

        $children = shift;
        $children = 5 unless $children;

but if the first argument was given and is ``0'', then it will be considered false by `||` and `5` used instead. Really we want an `||`-like operator that behaves like:

        $children = shift;
        $children = 5 unless defined $children;

Namely, a `||` that tests defined-ness rather than truth. One was discussed, and a patch submitted, but the objections were many. While there were objections, many still feel the need. At least it was decided that `??` is the best name for the operator.

## ``dynamic'' lexicals

      my $x;
      sub foo {
        local $x;
      }

Localizing, as Tim Bunce points out, is a separate concept from whether the variable is global or lexical. Chip Salzenberg had an implementation once, but Larry thought it had potential to confuse.

## ``class''-based, rather than package-based ``lexicals''

This is like what the Alias module provides, but the variables would be lexicals reserved by perl at compile-time, which really are indices pointing into the pseudo-hash object visible inside every method so declared.

# Threading

## Modules

Which of the standard modules are thread-safe? Which CPAN modules? How easy is it to fix those non-safe modules?

## Testing

Threading is still experimental. Every reproducible bug identifies something else for us to fix. Find and submit more of these problems.

## $AUTOLOAD

## exit/die

Consistent semantics for exit/die in threads.

## External threads

Better support for externally created threads.

## Thread::Pool

## thread-safety

Spot-check globals like statcache and global GVs for thread-safety. ``Part done'', says Sarathy.

## Per-thread GVs

According to Sarathy, this would make @_ be the same in threaded and non-threaded, as well as helping solve problems like filehandles (the same filehandle currently cannot be used in two threads).

# Compiler

## Optimization

The compiler's back-end code-generators for creating bytecode or compilable C code could use optimization work.

## Byteperl

Figure out how and where byteperl will be built for the various platforms.

## Precompiled modules

Save byte-compiled modules on disk.

## Executables

Auto-produce executable.

## Typed lexicals

Typed lexicals should affect B::CC::load_pad.

## Win32

Workarounds to help Win32 dynamic loading.

## END blocks

END blocks need saving in compiled output, now that CHECK blocks are available.

## _AUTOLOAD

_AUTOLOAD prodding.

## comppadlist

Fix comppadlist (names in comppad_name can have fake SvCUR from where newASSIGNOP steals the field).

## Cached compilation

Can we install modules as bytecode?

# Recently Finished Tasks

## Figure a way out of $^(capital letter)

Figure out a clean way to extend $^(capital letter) beyond the 26 alphabets. (${^WORD} maybe?)

Mark-Jason Dominus sent a patch which went into 5.005_56.

## Filenames

Keep filenames in the distribution and in the standard module set be 8.3 friendly where feasible. Good luck changing the standard modules, though.

## Foreign lines

Perl should be more generous in accepting foreign line terminations. Mostly done in 5.005.

## Namespace cleanup

        symbol-space: "pl_" prefix for all global vars
                      "Perl_" prefix for all functions

        CPP-space:    stop malloc()/free() pollution unless asked

## ISA.pm

Rename and alter ISA.pm. Done. It is now base.pm.

## gettimeofday

See Time::HiRes.

## autocroak?

This is the Fatal.pm module, so any builtin that does not return success automatically die()s. If you're feeling brave, tie this in with the unified exceptions scheme.

perltodo - Perl TO-DO List