=head1 DESCRIPTION
-This is a list of wishes for Perl. Send updates to
-I<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:
+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<perl5-porters@perl.org> to avoid duplication of
+effort. By all means contact a pumpking privately first if you prefer.
- http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/
-
-=head1 To do during 5.6.x
+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:
-=head2 Support for I/O disciplines
+ http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/
-C<perlio> provides this, but the interface could be a lot more
-straightforward.
+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<AUTHORS> file, which ships in the official distribution. How many other
+programming languages offer you 1 line of immortality?
-=head2 Autoload bytes.pm
+=head1 Tasks that only need Perl knowledge
-When the lexer sees, for instance, C<bytes::length>, it should
-automatically load the C<bytes> pragma.
+=head2 Remove duplication of test setup.
-=head2 Make "\u{XXXX}" et al work
+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<test.pl>. Throw in the handy tainting subroutines.
-Danger, Will Robinson! Discussing the semantics of C<"\x{F00}">,
-C<"\xF00"> and C<"\U{F00}"> on P5P I<will> lead to a long and boring
-flamewar.
+=head2 merge common code in installperl and installman
-=head2 Create a char *sv_pvprintify(sv, STRLEN *lenp, UV flags)
+There are some common subroutines and a common C<BEGIN> block in F<installperl>
+and F<installman>. 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.
-For displaying PVs with control characters, embedded nulls, and Unicode.
-This would be useful for printing warnings, or data and regex dumping,
-not_a_number(), and so on.
+=head2 common test code for timed bail out
-Requirements: should handle both byte and UTF8 strings. isPRINT()
-characters printed as-is, character less than 256 as \xHH, Unicode
-characters as \x{HHH}. Don't assume ASCII-like, either, get somebody
-on EBCDIC to test the output.
+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.
-Possible options, controlled by the flags:
-- whitespace (other than ' ' of isPRINT()) printed as-is
-- use isPRINT_LC() instead of isPRINT()
-- print control characters like this: "\cA"
-- print control characters like this: "^A"
-- non-PRINTables printed as '.' instead of \xHH
-- use \OOO instead of \xHH
-- use the C/Perl-metacharacters like \n, \t
-- have a maximum length for the produced string (read it from *lenp)
-- append a "..." to the produced string if the maximum length is exceeded
-- really fancy: print unicode characters as \N{...}
+=head2 POD -E<gt> HTML conversion in the core still sucks
-NOTE: pv_display(), pv_uni_display(), sv_uni_display() are already
-doing something like the above.
+Which is crazy given just how simple POD purports to be, and how simple HTML
+can be. It's not actually I<as> 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</make HTML install work>, as the layout of installation tree
+is needed to improve the cross-linking.
-=head2 Overloadable regex assertions
+The addition of C<Pod::Simple> and its related modules may make this task
+easier to complete.
-This may or may not be possible with the current regular expression
-engine. The idea is that, for instance, C<\b> needs to be
-algorithmically computed if you're dealing with Thai text. Hence, the
-B<\b> assertion wants to be overloaded by a function.
+=head2 merge checkpods and podchecker
-=head2 Unicode
+F<pod/checkpods.PL> (and C<make check> in the F<pod/> 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<make check> use podchecker.
-=over 4
+=head2 perlmodlib.PL rewrite
-=item *
+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).
-Allow for long form of the General Category Properties, e.g
-C<\p{IsOpenPunctuation}>, not just the abbreviated form, e.g.
-C<\p{IsPs}>.
+=head2 Parallel testing
-=item *
+(This probably impacts much more than the core: also the Test::Harness
+and TAP::* modules on CPAN.)
-Allow for the metaproperties: C<XID Start>, C<XID Continue>,
-C<NF*_NO>, C<NF*_MAYBE> (require the DerivedCoreProperties and
-DerviceNormalizationProperties files).
+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<option> of
+running sets of tests in parallel. This would be useful for tests in
+F<t/op/*.t> and F<t/uni/*.t> and maybe some sets of tests in F<lib/>.
-There are also multiple value properties still unimplemented:
-C<Numeric Type>, C<East Asian Width>.
+Questions to answer
-=item *
+=over 4
- Case Mappings? http://www.unicode.org/unicode/reports/tr21/
+=item 1
-lc(), uc(), lcfirst(), and ucfirst() work only for some of the
-simplest cases, where the mapping goes from a single Unicode character
-to another single Unicode character. See lib/unicore/SpecCase.txt
-(and CaseFold.txt).
+How does screen layout work when you're running more than one test?
-=item *
+=item 2
-UTF-8 identifier names should probably be canonicalized: NFC?
+How does the caller of test specify how many tests to run in parallel?
-=item *
+=item 3
-UTF-8 in package names and sub names? The first is problematic
-because of the mapping to pathnames, ditto for the second one if
-one does autosplitting, for example.
+How do setup/teardown tests identify themselves?
=back
-See L<perlunicode/UNICODE REGULAR EXPRESSION SUPPORT LEVEL> for what's
-there and what's missing. Almost all of Levels 2 and 3 is missing,
-and as of 5.8.0 not even all of Level 1 is there.
-They have some tricks Perl doesn't yet implement, such as character
-class subtraction.
-
- http://www.unicode.org/unicode/reports/tr18/
-
-=head2 use Thread for iThreads
-
-Artur Bergman's C<iThreads> module is a start on this, but needs to
-be more mature.
-
-=head2 make perl_clone optionally clone ops
-
-So that pseudoforking, mod_perl, iThreads and nvi will work properly
-(but not as efficiently) until the regex engine is fixed to be threadsafe.
-
-=head2 Work out exit/die semantics for threads
-
-=head2 Typed lexicals for compiler
-
-=head2 Compiler workarounds for Win32
-
-=head2 AUTOLOADing in the compiler
-
-=head2 Fixing comppadlist when compiling
-
-=head2 Cleaning up exported namespace
-
-=head2 Complete signal handling
-
-Add C<PERL_ASYNC_CHECK> to opcodes which loop; replace C<sigsetjmp> with
-C<sigjmp>; check C<wait> for signal safety.
-
-=head2 Out-of-source builds
-
-This was done for 5.6.0, but needs reworking for 5.7.x
-
-=head2 POSIX realtime support
-
-POSIX 1003.1 1996 Edition support--realtime stuff: POSIX semaphores,
-message queues, shared memory, realtime clocks, timers, signals (the
-metaconfig units mostly already exist for these)
-
-=head2 UNIX98 support
-
-Reader-writer locks, realtime/asynchronous IO
-
-=head2 IPv6 Support
-
-There are non-core modules, such as C<Socket6>, but these will need
-integrating when IPv6 actually starts to really happen. See RFC 2292
-and RFC 2553.
-
-=head2 Long double conversion
-
-Floating point formatting is still causing some weird test failures.
-
-=head2 Locales
-
-Locales and Unicode interact with each other in unpleasant ways.
-One possible solution would be to adopt/support ICU:
-
- http://oss.software.ibm.com/developerworks/opensource/icu/project/
-
-=head2 Thread-safe regexes
-
-The regular expression engine is currently non-threadsafe.
-
-=head2 Arithmetic on non-Arabic numerals
-
-C<[1234567890]> aren't the only numerals any more.
-
-=head2 POSIX Unicode character classes
-
-(C<[=a=]> for equivalance classes, C<[.ch.]> for collation.)
-These are dependent on Unicode normalization and collation.
-
-=head2 Factoring out common suffices/prefices in regexps (trie optimization)
-
-Currently, the user has to optimize C<foo|far> and C<foo|goo> into
-C<f(?:oo|ar)> and C<[fg]oo> by hand; this could be done automatically.
-
-=head2 Security audit shipped utilities
-
-All the code we ship with Perl needs to be sensible about temporary file
-handling, locking, input validation, and so on.
-
-=head2 Sort out the uid-setting mess
-
-Currently there are several problems with the setting of uids ($<, $>
-for the real and effective uids). Firstly, what exactly setuid() call
-gets invoked in which platform is simply a big mess that needs to be
-untangled. Secondly, the effects are apparently not standard across
-platforms, (if you first set $< and then $>, or vice versa, being
-uid == euid == zero, or just euid == zero, or as a normal user, what are
-the results?). The test suite not (usually) being run as root means
-that these things do not get much testing. Thirdly, there's quite
-often a third uid called saved uid, and Perl has no knowledge of that
-feature in any way. (If one has the saved uid of zero, one can get
-back any real and effective uids.) As an example, to change also the
-saved uid, one needs to set the real and effective uids B<twice>-- in
-most systems, that is: in HP-UX that doesn't seem to work.
-
-=head2 Custom opcodes
-
-Have a way to introduce user-defined opcodes without the subroutine call
-overhead of an XSUB; the user should be able to create PP code. Simon
-Cozens has some ideas on this.
-
-=head2 DLL Versioning
-
-Windows needs a way to know what version of an XS or C<libperl> DLL it's
-loading.
-
-=head2 Introduce @( and @)
-
-C<$(> may return "foo bar baz". Unfortunately, since groups can
-theoretically have spaces in their names, this could be one, two or
-three groups.
-
-=head2 Floating point handling
-
-C<NaN> and C<inf> support is particularly troublesome.
-(fp_classify(), fp_class(), fp_class_d(), class(), isinf(),
-isfinite(), finite(), isnormal(), unordered(), <ieeefp.h>,
-<fp_class.h> (there are metaconfig units for all these) (I think),
-fp_setmask(), fp_getmask(), fp_setround(), fp_getround()
-(no metaconfig units yet for these). Don't forget finitel(), fp_classl(),
-fp_class_l(), (yes, both do, unfortunately, exist), and unorderedl().)
-
-As of Perl 5.6.1, there is a Perl macro, Perl_isnan().
-
-=head2 IV/UV preservation
-
-Nicholas Clark has done a lot of work on this, but work is continuing.
-C<+>, C<-> and C<*> work, but guards need to be in place for C<%>, C</>,
-C<&>, C<oct>, C<hex> and C<pack>.
-
-=head2 Replace pod2html with something using Pod::Parser
-
-The CPAN module C<Marek::Pod::Html> may be a more suitable basis for a
-C<pod2html> convertor; the current one duplicates the functionality
-abstracted in C<Pod::Parser>, which makes updating the POD language
-difficult.
+Pugs already does parallel testing - can their approach be re-used?
-=head2 Automate module testing on CPAN
+=head2 Make Schwern poorer
-When a new Perl is being beta tested, porters have to manually grab
-their favourite CPAN modules and test them - this should be done
-automatically.
-
-=head2 sendmsg and recvmsg
-
-We have all the other BSD socket functions but these. There are
-metaconfig units for these functions which can be added. To avoid these
-being new opcodes, a solution similar to the way C<sockatmark> was added
-would be preferable. (Autoload the C<IO::whatever> module.)
-
-=head2 Rewrite perlre documentation
-
-The new-style patterns need full documentation, and the whole document
-needs to be a lot clearer.
-
-=head2 Convert example code to IO::Handle filehandles
-
-=head2 Document Win32 choices
-
-=head2 Check new modules
-
-=head2 Make roffitall find pods and libs itself
-
-Simon Cozens has done some work on this but it needs a rethink.
-
-=head1 To do at some point
-
-These are ideas that have been regularly tossed around, that most
-people believe should be done maybe during 5.8.x
-
-=head2 Remove regular expression recursion
-
-Because the regular expression engine is recursive, badly designed
-expressions can lead to lots of recursion filling up the stack. Ilya
-claims that it is easy to convert the engine to being iterative, but
-this has still not yet been done. There may be a regular expression
-engine hit squad meeting at TPC5.
-
-=head2 Memory leaks after failed eval
-
-Perl will leak memory if you C<eval "hlagh hlagh hlagh hlagh">. This is
-partially because it attempts to build up an op tree for that code and
-doesn't properly free it. The same goes for non-syntactically-correct
-regular expressions. Hugo looked into this, but decided it needed a
-mark-and-sweep GC implementation.
+We should have tests for everything. When all the core's modules are tested,
+Schwern has promised to donate to $500 to TPF. We may need volunteers to
+hold him upside down and shake vigorously in order to actually extract the
+cash.
-Alan notes that: The basic idea was to extend the parser token stack
-(C<YYSTYPE>) to include a type field so we knew what sort of thing each
-element of the stack was. The F<perly.c> code would then have to be
-postprocessed to record the type of each entry on the stack as it was
-created, and the parser patched so that it could unroll the stack
-properly on error.
+=head2 Improve the coverage of the core tests
-This is possible to do, but would be pretty messy to implement, as it
-would rely on even more sed hackery in F<perly.fixer>.
+Use Devel::Cover to ascertain the core modules's test coverage, then add
+tests that are currently missing.
-=head2 bitfields in pack
+=head2 test B
-=head2 Cross compilation
+A full test suite for the B module would be nice.
-Make Perl buildable with a cross-compiler. This will play havoc with
-Configure, which needs to know how the target system will respond to
-its tests; maybe C<microperl> will be a good starting point here.
-(Indeed, Bart Schuller reports that he compiled up C<microperl> for
-the Agenda PDA and it works fine.) A really big spanner in the works
-is the bootstrapping build process of Perl: if the filesystem the
-target systems sees is not the same what the build host sees, various
-input, output, and (Perl) library files need to be copied back and forth.
+=head2 Deparse inlined constants
-As of 5.8.0 Configure mostly works for cross-compilation
-(used successfully for iPAQ Linux), miniperl gets built,
-but then building DynaLoader (and other extensions) fails
-since MakeMaker knows nothing of cross-compilation.
-(See INSTALL/Cross-compilation for the state of things.)
+Code such as this
-=head2 Perl preprocessor / macros
+ use constant PI => 4;
+ warn PI
-Source filters help with this, but do not get us all the way. For
-instance, it should be possible to implement the C<??> operator somehow;
-source filters don't (quite) cut it.
+will currently deparse as
-=head2 Perl lexer in Perl
+ use constant ('PI', 4);
+ warn 4;
-Damian Conway is planning to work on this, but it hasn't happened yet.
+because the tokenizer inlines the value of the constant subroutine C<PI>.
+This allows various compile time optimisations, such as constant folding
+and dead code elimination. Where these haven't happened (such as the example
+above) it ought be possible to make B::Deparse work out the name of the
+original constant, because just enough information survives in the symbol
+table to do this. Specifically, the same scalar is used for the constant in
+the optree as is used for the constant subroutine, so by iterating over all
+symbol tables and generating a mapping of SV address to constant name, it
+would be possible to provide B::Deparse with this functionality.
-=head2 Using POSIX calls internally
+=head2 A decent benchmark
-When faced with a BSD vs. SysV -style interface to some library or
-system function, perl's roots show in that it typically prefers the BSD
-interface (but falls back to the SysV one). One example is getpgrp().
-Other examples include C<memcpy> vs. C<bcopy>. There are others, mostly in
-F<pp_sys.c>.
+C<perlbench> seems impervious to any recent changes made to the perl core. It
+would be useful to have a reasonable general benchmarking suite that roughly
+represented what current perl programs do, and measurably reported whether
+tweaks to the core improve, degrade or don't really affect performance, to
+guide people attempting to optimise the guts of perl. Gisle would welcome
+new tests for perlbench.
-Mostly, this item is a suggestion for which way to start a journey into
-an C<#ifdef> forest. It is not primarily a suggestion to eliminate any of
-the C<#ifdef> forests.
+=head2 fix tainting bugs
-POSIX calls are perhaps more likely to be portable to unexpected
-architectures. They are also perhaps more likely to be actively
-maintained by a current vendor. They are also perhaps more likely to be
-available in thread-safe versions, if appropriate.
+Fix the bugs revealed by running the test suite with the C<-t> switch (via
+C<make test.taintwarn>).
-=head2 -i rename file when changed
+=head2 Dual life everything
-It's only necessary to rename a file when inplace editing when the file
-has changed. Detecting a change is perhaps the difficult bit.
+As part of the "dists" plan, anything that doesn't belong in the smallest perl
+distribution needs to be dual lifed. Anything else can be too. Figure out what
+changes would be needed to package that module and its tests up for CPAN, and
+do so. Test it with older perl releases, and fix the problems you find.
-=head2 All ARGV input should act like E<lt>E<gt>
+To make a minimal perl distribution, it's useful to look at
+F<t/lib/commonsense.t>.
-eg C<read(ARGV, ...)> doesn't currently read across multiple files.
+=head2 Improving C<threads::shared>
-=head2 Support for rerunning debugger
+Investigate whether C<threads::shared> could share aggregates properly with
+only Perl level changes to shared.pm
-There should be a way of restarting the debugger on demand.
+=head2 POSIX memory footprint
-=head2 Test Suite for the Debugger
+Ilya observed that use POSIX; eats memory like there's no tomorrow, and at
+various times worked to cut it down. There is probably still fat to cut out -
+for example POSIX passes Exporter some very memory hungry data structures.
-The debugger is a complex piece of software and fixing something
-here may inadvertently break something else over there. To tame
-this chaotic behaviour, a test suite is necessary.
+=head2 embed.pl/makedef.pl
-=head2 my sub foo { }
+There is a script F<embed.pl> that generates several header files to prefix
+all of Perl's symbols in a consistent way, to provide some semblance of
+namespace support in C<C>. Functions are declared in F<embed.fnc>, variables
+in F<interpvar.h>. Quite a few of the functions and variables
+are conditionally declared there, using C<#ifdef>. However, F<embed.pl>
+doesn't understand the C macros, so the rules about which symbols are present
+when is duplicated in F<makedef.pl>. Writing things twice is bad, m'kay.
+It would be good to teach C<embed.pl> to understand the conditional
+compilation, and hence remove the duplication, and the mistakes it has caused.
-The basic principle is sound, but there are problems with the semantics
-of self-referential and mutually referential lexical subs: how to
-declare the subs?
+=head2 use strict; and AutoLoad
-=head2 One-pass global destruction
+Currently if you write
-Sweeping away all the allocated memory in one go is a laudable goal, but
-it's difficult and in most cases, it's easier to let the memory get
-freed by exiting.
-
-=head2 Rewrite regexp parser
-
-There has been talk recently of rewriting the regular expression parser
-to produce an optree instead of a chain of opcodes; it's unclear whether
-or not this would be a win.
-
-=head2 Cache recently used regexps
-
-This is to speed up
-
- for my $re (@regexps) {
- $matched++ if /$re/
+ package Whack;
+ use AutoLoader 'AUTOLOAD';
+ use strict;
+ 1;
+ __END__
+ sub bloop {
+ print join (' ', No, strict, here), "!\n";
}
-C<qr//> already gives us a way of saving compiled regexps, but it should
-be done automatically.
-
-=head2 Re-entrant functions
-
-Add configure probes for C<_r> forms of system calls and fit them to the
-core. Unfortunately, calling conventions for these functions and not
-standardised.
-
-=head2 Cross-compilation support
-
-Bart Schuller reports that using C<microperl> and a cross-compiler, he
-got Perl working on the Agenda PDA. However, one cannot build a full
-Perl because Configure needs to get the results for the target platform,
-for the host.
-
-=head2 Bit-shifting bitvectors
-
-Given:
-
- vec($v, 1000, 1) = 1;
-
-One should be able to do
-
- $v <<= 1;
-
-and have the 999'th bit set.
+then C<use strict;> isn't in force within the autoloaded subroutines. It would
+be more consistent (and less surprising) to arrange for all lexical pragmas
+in force at the __END__ block to be in force within each autoloaded subroutine.
-Currently if you try with shift bitvectors you shift the NV/UV, instead
-of the bits in the PV. Not very logical.
+There's a similar problem with SelfLoader.
-=head2 debugger pragma
+=head1 Tasks that need a little sysadmin-type knowledge
-The debugger is implemented in Perl in F<perl5db.pl>; turning it into a
-pragma should be easy, but making it work lexically might be more
-difficult. Fiddling with C<$^P> would be necessary.
+Or if you prefer, tasks that you would learn from, and broaden your skills
+base...
-=head2 use less pragma
+=head2 make HTML install work
-Identify areas where speed/memory tradeoffs can be made and have a hint
-to switch between them.
+There is an C<installhtml> target in the Makefile. It's marked as
+"experimental". It would be good to get this tested, make it work reliably, and
+remove the "experimental" tag. This would include
-=head2 switch structures
-
-Although we have C<Switch.pm> in core, Larry points to the dormant
-C<nswitch> and C<cswitch> ops in F<pp.c>; using these opcodes would be
-much faster.
-
-=head2 Cache eval tree
-
-=head2 rcatmaybe
-
-=head2 Shrink opcode tables
-
-=head2 Optimize away @_
-
-Look at the "reification" code in C<av.c>
+=over 4
-=head2 Prototypes versus indirect objects
+=item 1
-Currently, indirect object syntax bypasses prototype checks.
+Checking that cross linking between various parts of the documentation works.
+In particular that links work between the modules (files with POD in F<lib/>)
+and the core documentation (files in F<pod/>)
-=head2 Install HTML
+=item 2
-HTML versions of the documentation need to be installed by default; a
-call to C<installhtml> from C<installperl> may be all that's necessary.
+Work out how to split C<perlfunc> into chunks, preferably one per function
+group, preferably with general case code that could be used elsewhere.
+Challenges here are correctly identifying the groups of functions that go
+together, and making the right named external cross-links point to the right
+page. Things to be aware of are C<-X>, groups such as C<getpwnam> to
+C<endservent>, two or more C<=items> giving the different parameter lists, such
+as
-=head2 Prototype method calls
+ =item substr EXPR,OFFSET,LENGTH,REPLACEMENT
+ =item substr EXPR,OFFSET,LENGTH
+ =item substr EXPR,OFFSET
-=head2 Return context prototype declarations
+and different parameter lists having different meanings. (eg C<select>)
-=head2 magic_setisa
+=back
-=head2 Garbage collection
+=head2 compressed man pages
-There have been persistent mumblings about putting a mark-and-sweep
-garbage detector into Perl; Alan Burlison has some ideas about this.
+Be able to install them. This would probably need a configure test to see how
+the system does compressed man pages (same directory/different directory?
+same filename/different filename), as well as tweaking the F<installman> script
+to compress as necessary.
-=head2 IO tutorial
+=head2 Add a code coverage target to the Makefile
-Mark-Jason Dominus has the beginnings of one of these.
+Make it easy for anyone to run Devel::Cover on the core's tests. The steps
+to do this manually are roughly
-=head2 Rewrite perldoc
+=over 4
-There are a few suggestions for what to do with C<perldoc>: maybe a
-full-text search, an index function, locating pages on a particular
-high-level subject, and so on.
+=item *
-=head2 Install .3p manpages
+do a normal C<Configure>, but include Devel::Cover as a module to install
+(see F<INSTALL> for how to do this)
-This is a bone of contention; we can create C<.3p> manpages for each
-built-in function, but should we install them by default? Tcl does this,
-and it clutters up C<apropos>.
+=item *
-=head2 Unicode tutorial
+ make perl
-Simon Cozens promises to do this before he gets old.
+=item *
-=head2 Update POSIX.pm for 1003.1-2
+ cd t; HARNESS_PERL_SWITCHES=-MDevel::Cover ./perl -I../lib harness
-=head2 Retargetable installation
+=item *
-Allow C<@INC> to be changed after Perl is built.
+Process the resulting Devel::Cover database
-=head2 POSIX emulation on non-POSIX systems
+=back
-Make C<POSIX.pm> behave as POSIXly as possible everywhere, meaning we
-have to implement POSIX equivalents for some functions if necessary.
+This just give you the coverage of the F<.pm>s. To also get the C level
+coverage you need to
-=head2 Rename Win32 headers
+=over 4
-=head2 Finish off lvalue functions
+=item *
-They don't work in the debugger, and they don't work for list or hash
-slices.
+Additionally tell C<Configure> to use the appropriate C compiler flags for
+C<gcov>
-=head2 Update sprintf documentation
+=item *
-Hugo van der Sanden plans to look at this.
+ make perl.gcov
-=head2 Use fchown/fchmod internally
+(instead of C<make perl>)
-This has been done in places, but needs a thorough code review.
-Also fchdir is available in some platforms.
+=item *
-=head2 Make v-strings overloaded objects
+After running the tests run C<gcov> to generate all the F<.gcov> files.
+(Including down in the subdirectories of F<ext/>
-Instead of having to guess whether a string is a v-string and thus
-needs to be displayed with %vd, make v-strings (readonly) objects
-(class "vstring"?) with a stringify overload.
+=item *
-=head2 Allow restricted hash assignment
+(From the top level perl directory) run C<gcov2perl> on all the C<.gcov> files
+to get their stats into the cover_db directory.
-Currently you're not allowed to assign to a restricted hash at all,
-even with the same keys.
+=item *
- %restricted = (foo => 42); # error
+Then process the Devel::Cover database
-This should be allowed if the new keyset is a subset of the old
-keyset. May require more extra code than we'd like in pp_aassign.
+=back
-=head2 Should overload be inheritable?
+It would be good to add a single switch to C<Configure> to specify that you
+wanted to perform perl level coverage, and another to specify C level
+coverage, and have C<Configure> and the F<Makefile> do all the right things
+automatically.
-Should overload be 'contagious' through @ISA so that derived classes
-would inherit their base classes' overload definitions? What to do
-in case of overload conflicts?
+=head2 Make Config.pm cope with differences between built and installed perl
+
+Quite often vendors ship a perl binary compiled with their (pay-for)
+compilers. People install a free compiler, such as gcc. To work out how to
+build extensions, Perl interrogates C<%Config>, so in this situation
+C<%Config> describes compilers that aren't there, and extension building
+fails. This forces people into choosing between re-compiling perl themselves
+using the compiler they have, or only using modules that the vendor ships.
+
+It would be good to find a way teach C<Config.pm> about the installation setup,
+possibly involving probing at install time or later, so that the C<%Config> in
+a binary distribution better describes the installed machine, when the
+installed machine differs from the build machine in some significant way.
+
+=head2 linker specification files
+
+Some platforms mandate that you provide a list of a shared library's external
+symbols to the linker, so the core already has the infrastructure in place to
+do this for generating shared perl libraries. My understanding is that the
+GNU toolchain can accept an optional linker specification file, and restrict
+visibility just to symbols declared in that file. It would be good to extend
+F<makedef.pl> to support this format, and to provide a means within
+C<Configure> to enable it. This would allow Unix users to test that the
+export list is correct, and to build a perl that does not pollute the global
+namespace with private symbols.
+
+=head2 Cross-compile support
+
+Currently C<Configure> understands C<-Dusecrosscompile> option. This option
+arranges for building C<miniperl> for TARGET machine, so this C<miniperl> is
+assumed then to be copied to TARGET machine and used as a replacement of full
+C<perl> executable.
+
+This could be done little differently. Namely C<miniperl> should be built for
+HOST and then full C<perl> with extensions should be compiled for TARGET.
+This, however, might require extra trickery for %Config: we have one config
+first for HOST and then another for TARGET. Tools like MakeMaker will be
+mightily confused. Having around two different types of executables and
+libraries (HOST and TARGET) makes life interesting for Makefiles and
+shell (and Perl) scripts. There is $Config{run}, normally empty, which
+can be used as an execution wrapper. Also note that in some
+cross-compilation/execution environments the HOST and the TARGET do
+not see the same filesystem(s), the $Config{run} may need to do some
+file/directory copying back and forth.
-=head2 Taint rethink
+=head2 roffitall
-Should taint be stopped from affecting control flow, if ($tainted)?
-Should tainted symbolic method calls and subref calls be stopped?
-(Look at Ruby's $SAFE levels for inspiration?)
+Make F<pod/roffitall> be updated by F<pod/buildtoc>.
-=head1 Vague ideas
+=head1 Tasks that need a little C knowledge
-Ideas which have been discussed, and which may or may not happen.
+These tasks would need a little C knowledge, but don't need any specific
+background or experience with XS, or how the Perl interpreter works
-=head2 ref() in list context
+=head2 Exterminate PL_na!
+
+C<PL_na> festers still in the darkest corners of various typemap files.
+It needs to be exterminated, replaced by a local variable of type C<STRLEN>.
-It's unclear what this should do or how to do it without breaking old
-code.
+=head2 Modernize the order of directories in @INC
-=head2 Make tr/// return histogram of characters in list context
+The way @INC is laid out by default, one cannot upgrade core (dual-life)
+modules without overwriting files. This causes problems for binary
+package builders. One possible proposal is laid out in this
+message:
+L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2002-04/msg02380.html>.
-There is a patch for this, but it may require Unicodification.
+=head2 -Duse32bit*
-=head2 Compile to real threaded code
+Natively 64-bit systems need neither -Duse64bitint nor -Duse64bitall.
+On these systems, it might be the default compilation mode, and there
+is currently no guarantee that passing no use64bitall option to the
+Configure process will build a 32bit perl. Implementing -Duse32bit*
+options would be nice for perl 5.12.
-=head2 Structured types
+=head2 Make it clear from -v if this is the exact official release
-=head2 Modifiable $1 et al.
+Currently perl from C<p4>/C<rsync> ships with a F<patchlevel.h> file that
+usually defines one local patch, of the form "MAINT12345" or "RC1". The output
+of perl -v doesn't report that a perl isn't an official release, and this
+information can get lost in bugs reports. Because of this, the minor version
+isn't bumped up until RC time, to minimise the possibility of versions of perl
+escaping that believe themselves to be newer than they actually are.
- ($x = "elephant") =~ /e(ph)/;
- $1 = "g"; # $x = "elegant"
+It would be useful to find an elegant way to have the "this is an interim
+maintenance release" or "this is a release candidate" in the terse -v output,
+and have it so that it's easy for the pumpking to remove this just as the
+release tarball is rolled up. This way the version pulled out of rsync would
+always say "I'm a development release" and it would be safe to bump the
+reported minor version as soon as a release ships, which would aid perl
+developers.
-What happens if there are multiple (nested?) brackets? What if the
-string changes between the match and the assignment?
+This task is really about thinking of an elegant way to arrange the C source
+such that it's trivial for the Pumpking to flag "this is an official release"
+when making a tarball, yet leave the default source saying "I'm not the
+official release".
-=head2 Procedural interfaces for IO::*, etc.
+=head2 Profile Perl - am I hot or not?
-Some core modules have been accused of being overly-OO. Adding
-procedural interfaces could demystify them.
+The Perl source code is stable enough that it makes sense to profile it,
+identify and optimise the hotspots. It would be good to measure the
+performance of the Perl interpreter using free tools such as cachegrind,
+gprof, and dtrace, and work to reduce the bottlenecks they reveal.
-=head2 RPC modules
+As part of this, the idea of F<pp_hot.c> is that it contains the I<hot> ops,
+the ops that are most commonly used. The idea is that by grouping them, their
+object code will be adjacent in the executable, so they have a greater chance
+of already being in the CPU cache (or swapped in) due to being near another op
+already in use.
-=head2 Attach/detach debugger from running program
+Except that it's not clear if these really are the most commonly used ops. So
+as part of exercising your skills with coverage and profiling tools you might
+want to determine what ops I<really> are the most commonly used. And in turn
+suggest evictions and promotions to achieve a better F<pp_hot.c>.
-With C<gdb>, you can attach the debugger to a running program if you
-pass the process ID. It would be good to do this with the Perl debugger
-on a running Perl program, although I'm not sure how it would be done.
+=head2 Allocate OPs from arenas
-=head2 GUI::Native
+Currently all new OP structures are individually malloc()ed and free()d.
+All C<malloc> implementations have space overheads, and are now as fast as
+custom allocates so it would both use less memory and less CPU to allocate
+the various OP structures from arenas. The SV arena code can probably be
+re-used for this.
-A non-core module that would use "native" GUI to create graphical
-applications.
+Note that Configuring perl with C<-Accflags=-DPL_OP_SLAB_ALLOC> will use
+Perl_Slab_alloc() to pack optrees into a contiguous block, which is
+probably superior to the use of OP arenas, esp. from a cache locality
+standpoint. See L<Profile Perl - am I hot or not?>.
-=head2 foreach(reverse ...)
+=head2 Improve win32/wince.c
-Currently
+Currently, numerous functions look virtually, if not completely,
+identical in both C<win32/wince.c> and C<win32/win32.c> files, which can't
+be good.
- foreach (reverse @_) { ... }
+=head2 Use secure CRT functions when building with VC8 on Win32
-puts C<@_> on the stack, reverses it putting the reversed version on the
-stack, then iterates forwards. Instead, it could be special-cased to put
-C<@_> on the stack then iterate backwards.
+Visual C++ 2005 (VC++ 8.x) deprecated a number of CRT functions on the basis
+that they were "unsafe" and introduced differently named secure versions of
+them as replacements, e.g. instead of writing
-=head2 Constant function cache
+ FILE* f = fopen(__FILE__, "r");
-=head2 Approximate regular expression matching
+one should now write
-=head1 Ongoing
+ FILE* f;
+ errno_t err = fopen_s(&f, __FILE__, "r");
-These items B<always> need doing:
+Currently, the warnings about these deprecations have been disabled by adding
+-D_CRT_SECURE_NO_DEPRECATE to the CFLAGS. It would be nice to remove that
+warning suppressant and actually make use of the new secure CRT functions.
-=head2 Update guts documentation
+There is also a similar issue with POSIX CRT function names like fileno having
+been deprecated in favour of ISO C++ conformant names like _fileno. These
+warnings are also currently suppressed by adding -D_CRT_NONSTDC_NO_DEPRECATE. It
+might be nice to do as Microsoft suggest here too, although, unlike the secure
+functions issue, there is presumably little or no benefit in this case.
-Simon Cozens tries to do this when possible, and contributions to the
-C<perlapi> documentation is welcome.
+=head2 __FUNCTION__ for MSVC-pre-7.0
-=head2 Add more tests
+Jarkko notes that one can things morally equivalent to C<__FUNCTION__>
+(or C<__func__>) even in MSVC-pre-7.0, contrary to popular belief.
+See L<http://www.codeproject.com/debug/extendedtrace.asp> if you feel like
+making C<PERL_MEM_LOG> more useful on Win32.
-Michael Schwern will donate $500 to Yet Another Society when all core
-modules have tests.
+=head2 strcat(), strcpy(), strncat(), strncpy(), sprintf(), vsprintf()
-=head2 Update auxiliary tools
+Maybe create a utility that checks after each libperl.a creation that
+none of the above (nor sprintf(), vsprintf(), or *SHUDDER* gets())
+ever creep back to libperl.a.
-The code we ship with Perl should look like good Perl 5.
+ nm libperl.a | ./miniperl -alne '$o = $F[0] if /:$/; print "$o $F[1]" if $F[0] eq "U" && $F[1] =~ /^(?:strn?c(?:at|py)|v?sprintf|gets)$/'
-=head2 Create debugging macros
+Note, of course, that this will only tell whether B<your> platform
+is using those naughty interfaces.
-Debugging macros (like printsv, dump) can make debugging perl inside a
-C debugger much easier. A good set for gdb comes with mod_perl.
-Something similar should be distributed with perl.
-The proper way to do this is to use and extend Devel::DebugInit.
-Devel::DebugInit also needs to be extended to support threads.
+=head1 Tasks that need a knowledge of XS
-See p5p archives for late May/early June 2001 for a recent discussion
-on this topic.
+These tasks would need C knowledge, and roughly the level of knowledge of
+the perl API that comes from writing modules that use XS to interface to
+C.
-=head2 truncate to the people
+=head2 autovivification
-One can emulate ftruncate() using F_FREESP and F_CHSIZ fcntls
-(see the UNIX FAQ for details). This needs to go somewhere near
-pp_sys.c:pp_truncate().
+Make all autovivification consistent w.r.t LVALUE/RVALUE and strict/no strict;
-One can emulate truncate() easily if one has ftruncate().
-This emulation should also go near pp_sys.pp_truncate().
+This task is incremental - even a little bit of work on it will help.
=head2 Unicode in Filenames
-chdir, chmod, chown, chroot, exec, glob, link, lstat, mkdir, open, qx,
-readdir, readlink, rename, rmdir, stat, symlink, sysopen, system,
-truncate, unlink, utime. All these could potentially accept Unicode
-filenames either as input or output (and in the case of system and qx
-Unicode in general, as input or output to/from the shell). Whether a
-filesystem - an operating system pair understands Unicode in filenames
-varies.
+chdir, chmod, chown, chroot, exec, glob, link, lstat, mkdir, open,
+opendir, qx, readdir, readlink, rename, rmdir, stat, symlink, sysopen,
+system, truncate, unlink, utime, -X. All these could potentially accept
+Unicode filenames either as input or output (and in the case of system
+and qx Unicode in general, as input or output to/from the shell).
+Whether a filesystem - an operating system pair understands Unicode in
+filenames varies.
Known combinations that have some level of understanding include
Microsoft NTFS, Apple HFS+ (In Mac OS 9 and X) and Apple UFS (in Mac
requires some thought. Remember that an OS does not implicate a
filesystem.
-Note that in Windows the -C command line flag already does quite
-a bit of the above (but even there the support is not complete:
-for example the exec/spawn are not Unicode-aware) by turning on
-the so-called "wide API support".
-
-=head1 Recently done things
-
-These are things which have been on the todo lists in previous releases
-but have recently been completed.
-
-=head2 Alternative RE syntax module
+(The Windows -C command flag "wide API support" has been at least
+temporarily retired in 5.8.1, and the -C has been repurposed, see
+L<perlrun>.)
-The C<Regexp::English> module, available from the CPAN, provides this:
+Most probably the right way to do this would be this:
+L</"Virtualize operating system access">.
- my $re = Regexp::English
- -> start_of_line
- -> literal('Flippers')
- -> literal(':')
- -> optional
- -> whitespace_char
- -> end
- -> remember
- -> multiple
- -> digit;
+=head2 Unicode in %ENV
- /$re/;
+Currently the %ENV entries are always byte strings.
+See L</"Virtualize operating system access">.
-=head2 Safe signal handling
+=head2 Unicode and glob()
-A new signal model went into 5.7.1 without much fanfare. Operations and
-C<malloc>s are no longer interrupted by signals, which are handled
-between opcodes. This means that C<PERL_ASYNC_CHECK> now actually does
-something. However, there are still a few things that need to be done.
+Currently glob patterns and filenames returned from File::Glob::glob()
+are always byte strings. See L</"Virtualize operating system access">.
-=head2 Tie Modules
+=head2 Unicode and lc/uc operators
-Modules which implement arrays in terms of strings, substrings or files
-can be found on the CPAN.
+Some built-in operators (C<lc>, C<uc>, etc.) behave differently, based on
+what the internal encoding of their argument is. That should not be the
+case. Maybe add a pragma to switch behaviour.
-=head2 gettimeofday
+=head2 use less 'memory'
-C<Time::HiRes> has been integrated into the core.
+Investigate trade offs to switch out perl's choices on memory usage.
+Particularly perl should be able to give memory back.
-=head2 setitimer and getimiter
+This task is incremental - even a little bit of work on it will help.
-Adding C<Time::HiRes> got us this too.
+=head2 Re-implement C<:unique> in a way that is actually thread-safe
-=head2 Testing __DIE__ hook
+The old implementation made bad assumptions on several levels. A good 90%
+solution might be just to make C<:unique> work to share the string buffer
+of SvPVs. That way large constant strings can be shared between ithreads,
+such as the configuration information in F<Config>.
-Tests have been added.
+=head2 Make tainting consistent
-=head2 CPP equivalent in Perl
+Tainting would be easier to use if it didn't take documented shortcuts and
+allow taint to "leak" everywhere within an expression.
-A C Yardley will probably have done this by the time you can read this.
-This allows for a generalization of the C constant detection used in
-building C<Errno.pm>.
+=head2 readpipe(LIST)
-=head2 Explicit switch statements
+system() accepts a LIST syntax (and a PROGRAM LIST syntax) to avoid
+running a shell. readpipe() (the function behind qx//) could be similarly
+extended.
-C<Switch.pm> has been integrated into the core to give you all manner of
-C<switch...case> semantics.
+=head2 Audit the code for destruction ordering assumptions
-=head2 autocroak
+Change 25773 notes
-This is C<Fatal.pm>.
+ /* Need to check SvMAGICAL, as during global destruction it may be that
+ AvARYLEN(av) has been freed before av, and hence the SvANY() pointer
+ is now part of the linked list of SV heads, rather than pointing to
+ the original body. */
+ /* FIXME - audit the code for other bugs like this one. */
-=head2 UTF/EBCDIC
+adding the C<SvMAGICAL> check to
-Nick Ing-Simmons has made UTF-EBCDIC (UTR13) work with Perl.
+ if (AvARYLEN(av) && SvMAGICAL(AvARYLEN(av))) {
+ MAGIC *mg = mg_find (AvARYLEN(av), PERL_MAGIC_arylen);
- EBCDIC? http://www.unicode.org/unicode/reports/tr16/
+Go through the core and look for similar assumptions that SVs have particular
+types, as all bets are off during global destruction.
-=head2 UTF Regexes
+=head2 Extend PerlIO and PerlIO::Scalar
-Although there are probably some small bugs to be rooted out, Jarkko
-Hietaniemi has made regular expressions polymorphic between bytes and
-characters.
+PerlIO::Scalar doesn't know how to truncate(). Implementing this
+would require extending the PerlIO vtable.
-=head2 perlcc to produce executable
+Similarly the PerlIO vtable doesn't know about formats (write()), or
+about stat(), or chmod()/chown(), utime(), or flock().
-C<perlcc> was recently rewritten, and can now produce standalone
-executables.
+(For PerlIO::Scalar it's hard to see what e.g. mode bits or ownership
+would mean.)
-=head2 END blocks saved in compiled output
+PerlIO doesn't do directories or symlinks, either: mkdir(), rmdir(),
+opendir(), closedir(), seekdir(), rewinddir(), glob(); symlink(),
+readlink().
-=head2 Secure temporary file module
+See also L</"Virtualize operating system access">.
-Tim Jenness' C<File::Temp> is now in core.
+=head2 -C on the #! line
-=head2 Integrate Time::HiRes
+It should be possible to make -C work correctly if found on the #! line,
+given that all perl command line options are strict ASCII, and -C changes
+only the interpretation of non-ASCII characters, and not for the script file
+handle. To make it work needs some investigation of the ordering of function
+calls during startup, and (by implication) a bit of tweaking of that order.
-This module is now part of core.
+=head2 Propagate const outwards from Perl_moreswitches()
-=head2 Turn Cwd into XS
+Change 32057 changed the parameter and return value of C<Perl_moreswitches()>
+from <char *> to <const char *>. It should now be possible to propagate
+const-correctness outwards to C<S_parse_body()>, C<Perl_moreswitches()>
+and C<Perl_yylex()>.
-Benjamin Sugars has done this.
+=head2 Duplicate logic in S_method_common() and Perl_gv_fetchmethod_autoload()
-=head2 Mmap for input
+A comment in C<S_method_common> notes
-Nick Ing-Simmons' C<perlio> supports an C<mmap> IO method.
+ /* This code tries to figure out just what went wrong with
+ gv_fetchmethod. It therefore needs to duplicate a lot of
+ the internals of that function. We can't move it inside
+ Perl_gv_fetchmethod_autoload(), however, since that would
+ cause UNIVERSAL->can("NoSuchPackage::foo") to croak, and we
+ don't want that.
+ */
-=head2 Byte to/from UTF8 and UTF8 to/from local conversion
+If C<Perl_gv_fetchmethod_autoload> gets rewritten to take (more) flag bits,
+then it ought to be possible to move the logic from C<S_method_common> to
+the "right" place. When making this change it would probably be good to also
+pass in at least the method name length, if not also pre-computed hash values
+when known. (I'm contemplating a plan to pre-compute hash values for common
+fixed strings such as C<ISA> and pass them in to functions.)
-C<Encode> provides this.
+=head2 Organize error messages
-=head2 Add sockatmark support
+Perl's diagnostics (error messages, see L<perldiag>) could use
+reorganizing so that each error message has its
+stable-for-all-eternity unique id, categorized by severity, type, and
+subsystem. (The error messages would be listed in a datafile outside
+of the Perl source code, and the source code would only refer the
+messages by the is.) This clean-up and regularizing should apply
+for all croak() messages.
-Added in 5.7.1
+This would enable all sorts of things: easier translation/localization
+of the messages (though please do keep in mind the caveats of
+L<Locale::Maketext> about too straightforward approaches to
+translation), filtering by severity, and instead of grepping for a
+particular error message one could look for a stable error id. (Of
+course, changing the error messages by default would break all the
+existing software depending on some particular error message...)
-=head2 Mailing list archives
+This kind of functionality is known as I<message catalogs>. Look for
+inspiration for example in the catgets() system, possibly even use it
+if available-- but B<only> if available, all platforms will B<not>
+catgets().
-http://lists.perl.org/ , http://archive.develooper.com/
+For the really pure at heart, consider extending this item to cover
+also the warning messages (see L<perllexwarn>, C<warnings.pl>).
-=head2 Bug tracking
+=head1 Tasks that need a knowledge of the interpreter
-Richard Foley has written the bug tracking system at http://bugs.perl.org/
+These tasks would need C knowledge, and knowledge of how the interpreter works,
+or a willingness to learn.
-=head2 Integrate MacPerl
+=head2 state variable initialization in list context
-Chris Nandor and Matthias Neeracher have integrated the MacPerl changes
-into 5.6.0.
+Currently this is illegal:
-=head2 Web "nerve center" for Perl
+ state ($a, $b) = foo();
-http://use.perl.org/ is what you're looking for.
+The current Perl 6 design is that C<state ($a) = foo();> and
+C<(state $a) = foo();> have different semantics, which is tricky to implement
+in Perl 5 as currently the produce the same opcode trees. It would be useful
+to clarify that the Perl 6 design is firm, and then implement the necessary
+code in Perl 5. There are comments in C<Perl_newASSIGNOP()> that show the
+code paths taken by various assignment constructions involving state variables.
-=head2 Regular expression tutorial
+=head2 Implement $value ~~ 0 .. $range
-C<perlretut>, provided by Mark Kvale.
+It would be nice to extend the syntax of the C<~~> operator to also
+understand numeric (and maybe alphanumeric) ranges.
-=head2 Debugging Tutorial
+=head2 A does() built-in
-C<perldebtut>, written by Richard Foley.
+Like ref(), only useful. It would call the C<DOES> method on objects; it
+would also tell whether something can be dereferenced as an
+array/hash/etc., or used as a regexp, etc.
+L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2007-03/msg00481.html>
-=head2 Integrate new modules
+=head2 Tied filehandles and write() don't mix
-Jarkko has been integrating madly into 5.7.x
+There is no method on tied filehandles to allow them to be called back by
+formats.
-=head2 Integrate profiler
-
-C<Devel::DProf> is now a core module.
+=head2 Attach/detach debugger from running program
-=head2 Y2K error detection
+The old perltodo notes "With C<gdb>, you can attach the debugger to a running
+program if you pass the process ID. It would be good to do this with the Perl
+debugger on a running Perl program, although I'm not sure how it would be
+done." ssh and screen do this with named pipes in /tmp. Maybe we can too.
-There's a configure option to detect unsafe concatenation with "19", and
-a CPAN module. (C<D'oh::Year>)
+=head2 Optimize away empty destructors
-=head2 Regular expression debugger
+Defining an empty DESTROY method might be useful (notably in
+AUTOLOAD-enabled classes), but it's still a bit expensive to call. That
+could probably be optimized.
-While not part of core, Mark-Jason Dominus has written C<Rx> and has
-also come up with a generalised strategy for regular expression
-debugging.
+=head2 LVALUE functions for lists
-=head2 POD checker
+The old perltodo notes that lvalue functions don't work for list or hash
+slices. This would be good to fix.
-That's, uh, F<podchecker>
+=head2 LVALUE functions in the debugger
-=head2 "Dynamic" lexicals
+The old perltodo notes that lvalue functions don't work in the debugger. This
+would be good to fix.
-=head2 Cache precompiled modules
+=head2 regexp optimiser optional
-=head1 Deprecated Wishes
+The regexp optimiser is not optional. It should configurable to be, to allow
+its performance to be measured, and its bugs to be easily demonstrated.
-These are items which used to be in the todo file, but have been
-deprecated for some reason.
+=head2 delete &function
-=head2 Loop control on do{}
+Allow to delete functions. One can already undef them, but they're still
+in the stash.
-This would break old code; use C<do{{ }}> instead.
+=head2 C</w> regex modifier
-=head2 Lexically scoped typeglobs
+That flag would enable to match whole words, and also to interpolate
+arrays as alternations. With it, C</P/w> would be roughly equivalent to:
-Not needed now we have lexical IO handles.
+ do { local $"='|'; /\b(?:P)\b/ }
-=head2 format BOTTOM
+See L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2007-01/msg00400.html>
+for the discussion.
-=head2 report HANDLE
+=head2 optional optimizer
-Damian Conway's text formatting modules seem to be the Way To Go.
+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 Generalised want()/caller())
+=head2 You WANT *how* many
-Robin Houston's C<Want> module does this.
+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 Named prototypes
+=head2 lexical aliases
-This seems to be delayed until Perl 6.
+Allow lexical aliases (maybe via the syntax C<my \$alias = \$foo>.
-=head2 Built-in globbing
+=head2 entersub XS vs Perl
-The C<File::Glob> module has been used to replace the C<glob> function.
+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 Regression tests for suidperl
+=head2 Self ties
-C<suidperl> is deprecated in favour of common sense.
+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 re-
+instated.
-=head2 Cached hash values
+=head2 Optimize away @_
-We have shared hash keys, which perform the same job.
+The old perltodo notes "Look at the "reification" code in C<av.c>".
-=head2 Add compression modules
+=head2 Properly Unicode safe tokeniser and pads.
-The compression modules are a little heavy; meanwhile, Nick Clark is
-working on experimental pragmata to do transparent decompression on
-input.
+The tokeniser isn't actually very UTF-8 clean. C<use utf8;> is a hack -
+variable names are stored in stashes as raw bytes, without the utf-8 flag
+set. The pad API only takes a C<char *> pointer, so that's all bytes too. The
+tokeniser ignores the UTF-8-ness of C<PL_rsfp>, or any SVs returned from
+source filters. All this could be fixed.
-=head2 Reorganise documentation into tutorials/references
+=head2 The yada yada yada operators
-Could not get consensus on P5P about this.
+Perl 6's Synopsis 3 says:
-=head2 Remove distinction between functions and operators
+I<The ... operator is the "yada, yada, yada" list operator, which is used as
+the body in function prototypes. It complains bitterly (by calling fail)
+if it is ever executed. Variant ??? calls warn, and !!! calls die.>
-Caution: highly flammable.
+Those would be nice to add to Perl 5. That could be done without new ops.
-=head2 Make XS easier to use
+=head2 Virtualize operating system access
-Use C<Inline> instead, or SWIG.
+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<perlport/"Files and Filesystems"> is good reading at this point,
+in fact, all of L<perlport> is.)
-=head2 Make embedding easier to use
+This has actually already been implemented (but only for Win32),
+take a look at F<iperlsys.h> and F<win32/perlhost.h>. 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.
-Use C<Inline::CPR>.
+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<perlunicode/"When Unicode Does Not Happen">.)
-=head2 man for perl
+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 the Perl Power Tools. ( http://language.perl.com/ppt/ )
+See also L</"Extend PerlIO and PerlIO::Scalar">.
-=head2 my $Package::variable
+=head2 Investigate PADTMP hash pessimisation
-Use C<our> instead.
+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 "or" tests defined, not truth
+=head1 Big projects
-Suggesting this on P5P B<will> cause a boring and interminable flamewar.
+Tasks that will get your name mentioned in the description of the "Highlights
+of 5.12"
-=head2 "class"-based lexicals
+=head2 make ithreads more robust
-Use flyweight objects, secure hashes or, dare I say it, pseudo-hashes instead.
-(Or whatever will replace pseudohashes in 5.10.)
+Generally make ithreads more robust. See also L</iCOW>
-=head2 byteperl
+This task is incremental - even a little bit of work on it will help, and
+will be greatly appreciated.
-C<ByteLoader> covers this.
+One bit would be to write the missing code in sv.c:Perl_dirp_dup.
-=head2 Lazy evaluation / tail recursion removal
+Fix Perl_sv_dup, et al so that threads can return objects.
-C<List::Util> gives first() (a short-circuiting grep); tail recursion
-removal is done manually, with C<goto &whoami;>. (However, MJD has
-found that C<goto &whoami> introduces a performance penalty, so maybe
-there should be a way to do this after all: C<sub foo {START: ... goto
-START;> is better.)
+=head2 iCOW
-=head2 Make "use utf8" the default
+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.
-Because of backward compatibility this is difficult: scripts could not
-contain B<any legacy eight-bit data> (like Latin-1) anymore, even in
-string literals or pod. Also would introduce a measurable slowdown of
-at least few percentages since all regular expression operations would
-be done in full UTF-8. But if you want to try this, add
--DUSE_UTF8_SCRIPTS to your compilation flags.
+=head2 (?{...}) closures in regexps
-=head2 Unicode collation and normalization
+Fix (or rewrite) the implementation of the C</(?{...})/> closures.
-The Unicode::Collate and Unicode::Normalize modules
-by SADAHIRO Tomoyuki have been included since 5.8.0.
+=head2 A re-entrant regexp engine
- Collation? http://www.unicode.org/unicode/reports/tr10/
- Normalization? http://www.unicode.org/unicode/reports/tr15/
+This will allow the use of a regex from inside (?{ }), (??{ }) and
+(?(?{ })|) constructs.
-=head2 pack/unpack tutorial
+=head2 Add class set operations to regexp engine
-Wolfgang Laun finished what Simon Cozens started.
+Apparently these are quite useful. Anyway, Jeffery Friedl wants them.
-=cut
+demerphq has this on his todo list, but right at the bottom.
https://perl5.git.perl.org / perl5.git / blobdiff