The OpenNET Project / Index page

[ новости /+++ | форум | теги | ]

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

perltodo (1)
  • >> perltodo (1) ( Solaris man: Команды и прикладные программы пользовательского уровня )
  • perltodo (1) ( Разные man: Команды и прикладные программы пользовательского уровня )
  • 
    
    

    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 ([email protected]) 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 extensability 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

         our ($var)
    
         Declare global variables (lexically or otherwise).
    
         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 accomodate 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 ([email protected]) has
             volunteered.
    
         I/O Mark-Jason Dominus ([email protected]) 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 ([email protected]) 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 ([email protected]) 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.
    
         POD Converters
    
         Brad's PodParser code needs to become part of the core, and
         the Pod::*  and pod2* programs rewritten to use this
         standard parser.  Currently the converters take different
         options, some behave in different fashions, and some are
         more picky than others in terms of the POD files they
         accept.
    
         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
    
         Sort out the spawnvp() mess
    
         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

    
    
    
         (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 that does
         not return success automatically die()s.  If you're feeling
         brave, tie this in with the unified exceptions scheme.
    
    
    
    


    Поиск по тексту MAN-ов: 




    Партнёры:
    PostgresPro
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2024 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру