April 2000 Archives

This Week on p5p 2000/04/30


You can subscribe to an email version of this summary by sending an empty message to p5p-digest-subscribe@plover.com.

Please send corrections and additions to mjd-perl-thisweek-YYYYMM@plover.com where YYYYMM is the current year and month.

Line Disciplines Continue

The discussion of Simon's trial implementation of line disciplines continued, with Sarathy, Ilya, Nick Ing-Simmons, and Larry participating. Some topics of discussion: How do disciplines interact with end-of-line location? Will a discipline request data character-by-character from the discipline below it, or can it request lines or larger chunks? Does a filter transform a file object into another file object, or does it transform an SV into another SV? In either case, what to do with the current sv_gets function that reads a line from a file and passes the resulting line upwards as an SV? What is the real meaning of :raw? Is it a filter, or an indication that filters should not be used? What happens to $/ in the presence of disciplines? What does sysread do when buffering is being provided by some line discipline? (Larry's answer to this last: It calls the low-level read() function, bypassing the disciplines, as usual.)

Paul Moore asked what the benefit of line disciplines is that is not shared by tied filehandles. The answer was 'speed'. Tied filehandles have all the overhead of objects and method calls.

Ben Tilly Fixes map

Last week, I reported on all the interesting topics raised by Ben Tilly, including an opservation that the grep code is optimized for the assumption that the output will be smaller than (or the same size as) the input, which is a good assumption. However, the map code, which is derived from grep, is optimized the same way, but in this case the assumption is totally wrong. Ben pointed out that you can rewrite a version of map in Perl that is faster than the builtin map for many common cases. He even suggested how this might be fixed, and I regretfully observed that he did not provide a patch.

Apparently spurred by this, Ben submitted a patch! Woo-hoo!

Gack! Big Bug in 5.6

Larry Rosler pointed out that

        perl -e "my $x = 10; $x = '2' . $x; print $x + 0"

prints 10 instead of 210. Whoops. Simon Cozens provided a patch. 5.6.1 anybody?

More pack Options

John Holdsworth added more features to pack] to better support Sun's XDR (external data representation) formats, which is something I haven't looked at since about 1990. His change also supports ? as a length specifier, saying that the length can be found in the data. Ilya found fault with this; he thinks it is not general enough.

Interested parties might like to read more

For me this discussion is reminiscent of a long discussion from last year in which Ilya wanted to introduce a feature that would make data self-unpacking; it would carry its own template with it.

Similar discussion from last year


Barrie Slaymaker posted a really interesting module that combines open3, select and , waitpid. This is something we've needed for a long time. Everyone should check out this thread.

Full details, including man page

Discussion about the user interface followed for about 25 messages.

perldiag Re-alphabetized

I submitted a little patch to add a new diagnostic message, and Ron Kimball pointed out that I had put the message into the wrong part of perldiag. The messages in perldiag are supposed to be in alphabetical order, but in 5.6 there are a bunch that are just tacked onto the end in their own miniature alphabetical order, and I had added mine there by mistake.

I re-alphabetized the whole thing with a different (and more consistent) alphabetic scheme.

Novus Ordo Seclorum

Poor Diagnosis of sort Errors

If you try to use a sort comparator function when either of the magical variables $a or $b has been declared to have lexical scope, the comparator won't work, because it is looking at the lexical variables, and sort is leaving the values to be compared in the global variables. There's a diagnostic for this:

        Can't use "my $a" in sort comparison

Here's what perldiag says about it:

     (F) The global variables $a and $b are reserved for sort comparisons.
     You mentioned $a or $b in the same line as the <=> or cmp operator,
     and the variable had earlier been declared as a lexical variable.
     Either qualify the sort variable with the package name, or rename the
     lexical variable.

Peter Scott points out that this is not very nice---it only detects uses of $a that appear in comparisons; in particular, the following code does not produce the diagnostic, although it should:

        my $a;
        my @sorted_list = sort { sortfunc($a, $b) } @list;

I know there are many people out there looking for a not-too-difficult core hacking project to get started on. Fixing this might be such a project.

glob() function not documented

Randal pointed out that the File::Glob man page, which is the default globber for the 5.6.0 glob() function, does not say what the function actually does. For example, does this globber support the csh-style {foo,bar,baz} notation? Perhaps someone would like to rectify this?

Overloading Assignment

You can't use the overload mechanism to overload assignment, but you can use the tie mechanism. Jeff Pinyan posted an example module that wraps up overloaded assignment semantics for a module. Damian replied that he has a paper about that. Discussion went offlist.

Jeff's Idea

POSIX Character Classes

POSIX Character Classes (new in 5.6) do not work in the tr operator. Since \d and \w, and character classes generally also do not work there, it is not a big surprise. Summary: tr[a-z][A-Z] looks like it has character classes, but it doesn't.

First Cite for 'Perl'?

The Oxford English Dictionary folks contacted Larry and asked for the earliest possible print citation for the word 'Perl'. (The OED is the premier dictionary of the English languagem, and seeks to provide contemporary quotations for every word; that way you can see from examples how the meaning and usage of each word has changed over its lifetime. The Third Edition of the OED is due out in 2007.)

The earliest cite located seems to be around 1989; it would be good to get an earlier cite, which the OED folks call an 'antedating'. If you know of an English source that mentions Perl that was printed prior to 1989, please contact Larry. If you can't reach Larry, contact me.

People guess that the best bet for antedatings is probably old ;login: magazines. If you have a pile of these, please take a look.


A large collection of bug reports, bug fixes, an unusual number of non-bug reports (split deletes trailing null fields! int rounds down! $object->$field = $value is a snytax error!), questions, answers, and a small amaount of spam. There were no flames this week.

Until next week I remain, your humble and obedient servant,

Mark-Jason Dominus

This Week on p5p 2000/04/23



The most recent report will always be available at http://www.perl.com/p5pdigest.cgi .

You can subscribe to an email version of this summary by sending an empty message to p5p-digest-subscribe@plover.com.

Please send corrections and additions to mjd-perl-thisweek-YYYYMM@plover.com where YYYYMM is the current year and month.

Brief Update

Since last time, Perl 5.6.0 has been released. As you can see, the version-numbering scheme has been changed. If it had not been changed, this would have been 5.006, or maybe 5.006_00.

Announcement for version 5.6.0

In the wake of this, list traffic was very high with various small bug reports and configuration problems. It has since quieted down.

Another major contributor to the high volume in late March and early April was a huge amount of whining and recrimination about whether or not 5.6.0 wasn't any good. Gosh, p5p at its worst. Sarathy works like a dog to get 5.6.0 ready, and then after the release everyone started whining.

On the one hand were people complaining about bugs and how it was unstable and saying that nobody was going to switch, and there were some accusations that Sarathy was part of a Microsoft conspiracy to sabotage Perl. Blah blah blah. Then on the other hand were a lot of people saying that the changes were not significant enough to warrant a new version number.

(To this last point, I think Tom's reply answers the point most effectively. The tone is characteristic of most of the entire discussion.)

You would think that at most one set of these assertions could be plausible; either Microsoft is trying to sabotage Perl by forcing a premature, unstable release, or the changes are too small to be worth releasing. You might think this, but you would be mistaken.

Now let's close the book on this particularly disgraceful chapter.

p5p to become Refereed?

Partly as a result of the long, tedious, and irrelevant flamefest that took up so much time and energy in March and April, Sarathy proposed that the list be `refereed'. This is a little different from moderation: Most people's messages go through normally, but if the referees agree, then messages in a certain thread or from a certain subscriber have to pass a moderator before they are sent to the list. Read the actual proposal before you make up your mind.

The following discussion was gratifyingly free of manifestoes, ultimatums, accusations, soapboxing, etc.

Sarathy: Many good people are not here anymore. Chip left, but has been brave enough to run a new list in an attempt to rediscover the old perl5-porters as we knew it. Jarkko disappeared, disgusted by all the name-calling and lurid behavior. Andy is gone too, thanks to useless arguments, personality clashes, and FUD-mongering. We simply cannot afford this.

A sideline here was that Jarkko expressed a desire that someone else pick up the Configure pumpkin. If you want to pick up the Configure pumpkin, contact Jarkko.

Jarkko: We need to educate more pumpkin holders.

perlretut and perlrequick

While I wasn't doing reports, Mark Kvale submitted a draft of a perlretut man page which would be a tutorial for regular expression beginners. (Maybe you haven't noticed that the existing perlre man page is incomprehensible unless you've been using sed for three years already.) I complained that perlretut was much too long, and Mark obligingly produced a cut-down version, perlrequick.



Threading Hilarity

Dan Sugalski discovered that the lock() function is not thread safe. I nominate this for Funniest Unintentional Perl Source Joke of 2000.

This started off another debate between Dan and Sarathy about the best appraoch for Perl threads. Dan's patch added a mutex to every SV; Sarathy objected to this.

The thread starts here.

Dan Sugalski: Whenever there's any sharing you have to deal with this.
Sarathy: Sorry, I don't have a VISA to enter the Land of Conclusions just now. :-)
Dan: And apparently nobody's granted a visa to enter the Land Of Even Partially Working Alternatives in the past two years either.

Sarathy's reply

Discussion continued later in a second thread.

The discussion was really interesting, and I didn't understand all of it. If someone wants to contribute a more detailed discussion of the issues for my next report, I'd be grateful to get it.

Line Disciplines

Simon Cozens did some work on the promised 'line disciplines' feature that didn't quite materialize in 5.6.0. It's a proof-of-concept, and it's not quite finished. The idea is that you could associate a Perl (or XS) function with a filehandle, and then any time you read from the filehandle, the function is called to transform the input somehow. Typical transformations: Turn CRLF into LF for Windows machines; turn some national character set like ISO-2022 into Unicode or vice versa.

The rudiments of this are in Perl 5.6.0; see for example the documentation for binmode() in 5.6.0.

Simon's message.

Older Discussion of Disciplines

Previous discussion part I

Previous discussion part II

Previous discussion part III

Big Line Numbers

James Jurach reported that when your program is more than 65,535 lines long, Perl reports the wrong line numbers for errors. It turns out that the line numbers are stored in the op node, and are only 16 bits long, to save space. (In a 64Kline program, 32-bit line numbers would consume and extra 128Kb space.) James submitted a patch that makes 32-bit line numbers a compile-time option.

Pseudohash Field Names, Hash Performance, and map Performance

Benjamin Tilly brought up a number of interesting points. First, the error message that says No such array field for a pseudohash does not say what the problem field name is. And second, that hash performance could degrade more gracefully than it does at present if, when the linked list in a bucket got too long, it was replaced with a binary search tree.

However, he did not provide patches for either of these things.

Benjamin's article

Later, Benjamin reported that map is quite slow in some cases, even slower than an all-Perl function to do the same thing. It appears that the grep function, which map is based on, is optimized to be fast in cases where the result list is no longer than the argmuent list. For grep, this is all cases. But is it not always true for map, the typical example being

        %hash = map {($_ => 1)} @array;

Benjamin suggested how this might be fixed, but unfortunately did not provide a patch.

Benjamin's other article

Benjamin also reported a bug in Math::BigInt; it crashes with Out of memory! when it shouldn't. Hugo van der Sanden confirmed, and found a smaller test case:

        perl -we 'use Math::BigInt ":constant"; for ($n = 1; $n < 10; $n++) { 1 }'

C with Embedded Perl

Vadim Konovalov came up with a very simple and convenient way to embed Perl code into a C program. It's a simple preprocessor that works alongside the regular C preprocessor. Read about it.

`Unreachable' code.

Someone named Zefram took issue with the part of the manual that says

        [goto] also can't be used to go into a construct that is
        optimized away.

His example:

	if(0) {
	print "1\n";
	goto FOO;

Here the if block is optimized away, so the program prints 1 and then aborts with Can't find label FOO. Zefram rightly points out that he is not supposed to know what might or might not be optimized away, and that there should at least be a compile-time warning in this case. He also says:

Unreachable code elimination is a good thing. But if code has a label in front of it then there's a fair chance that it's not unreachable.

Hard to argue with that. However, there were no followups.

The original message.

sprintf Precision

Someone wrote in (again) asking why sprintf("%.0f", 0.5) yielded 0 and not 1. I wouldn't mention this, except that it attracted a followup from John Peacock, who said he was writing a Math::FixedPrecision module that might help with this sort of problem. It sounds interesting, and might be worth a look. Read about it.

SDF Replacement

Some time ago, Ian Clatworthy developed a document format called SDF, the Simple Document Format. It's a markup language that's easy to read, like POD, but more powerful, but also convertible to many other formats. (In some cases it uses POD as an intermediate format.)

Ian announced to p5p that he was working on a successor to SDF, called ANEML. He did this because he thought we'd be interested (I'm certainly interested) and because he thought someone might volunteer to help him. Many details are here.


A large collection of bug reports, bug fixes, non-bug reports, questions, and answers. No spam this time.

Until next time I remain, your humble and obedient servant,

Mark-Jason Dominus

What's New in 5.6.0.

Table of Contents
  • Unicode - Perl goes
  • Better Building
  • Improved Compiler
  • Version Tuples
  • Lexical Warnings
  • Lvaluable Subroutines
  • Weak References
  • POSIX Character
  • Miscellaneous Bits

`Darn it, who spiked my coffee with water?!' - lwall

Well, it's been two years in the making. Everyone's favourite Swiss Army Chainsaw is coming up to thirteen years old now, and would be about to show the world a brand new face for the new millennium if that didn't start next year instead of this one. If, like me, you remember the day that the combined might of Malcolm and Sarathy produced the last major release of Perl, you might be wondering what's happened since then. Allow me, then, to present to you the wonderful world of 5.6.0!

Unicode - Perl goes international!

`It's kind of weird to read a standards document that has all these instance of "Oh, by the way, Perl does it this way instead."' - lwall

The largest change in Perl 5.6 has to be the introduction of UTF-8 Unicode support. By default, Perl now thinks in terms of Unicode characters instead of simple bytes; a character can, as the CJK people already know extremely well, span several bytes. All the relevant built-in functions (length, reverse, and so on) now work on a character-by-character basis instead of byte-by-byte, and strings are represented internally in Unicode.

Two new pragmata, byte and utf8, have been written to control the Unicode settings; use byte will go back to the old default of reading a byte at a time, whereas use utf8 turns on support for UTF8 characters in the source code of a program itself. The utf8 pragma also loads in the character tables, but this is done automatically by Perl on demand.

What does it actually mean, then? So things are encoded in Unicode internally, what does this enable me as a programmer to do? Well, if we turn on utf8, we can specify string literals in Unicode using the \x{} notation; just put your character codes in hexadecimal inside the brackets.

 $glis =

You can also reference Unicode characters by their name: the charnames pragma loads in the list of names, allowing you to then say something like "\N{WHITE SMILING FACE}".

Next, if you've got a Unicode editor, you can now, just like Java, use any Unicode for all your identifiers. This currently needs use utf8 to enable Unicode in your source, but is expected to become standard very soon; the utf8 pragma is attempting to make itself redundant.

Unicode support for regular expressions is now in, and supports matching characters based on Unicode properties - you can now match any upper-case character in any language with \p{IsUpper}. Characters, rather than bytes, are matched by \w, which is a superb thing for the Japanese and other multiple-byte worlds. Best of all, the new match \X will snatch any character plus all the attributes (markings, breathings, and so on) that apply to it.

Translation is fully supported: whether you mean translation from Unicode to ordinary 8-bit and back, or upper/lower case translation. For the former, the tr/// operator can be given the UC and CU modifiers to translate from Unicode to 8-bit characters (`chars') and back. As for casifying, uc, lc and friends Do The Right Thing for all upper and lower case characters specified in the Unicode translation tables.

Unfortunately, there is currently no way to tell Perl that incoming data from an external file is Unicode; while you can write Unicode data out to a file, you cannot read Unicode data back in again. While you can work around this with tr///CU, it's obviously a serious shortcoming, which we hope will be addressed soon.

In short, it should be a lot easier for us who have to deal regularly with multiple-byte alphabets to do so, to manipulate and process data. A new documentation page, perlunicode, fully documents all the new support.

Better Building

`I'd be slow to label Configure as "bilge". that's unnecessarily insulting to all the maintainers of Configure (and metaconfig). Configure is lovingly crafted, highly knowledgable bilge.' - lwall

As usual, Perl now supports more computers than ever before, with the addition of six new supported platforms; notably, the GNU/Hurd is now supported, as is the Psion 5.

Configure finally allows you to look in directories used in old versions of Perl to search for modules; the split between core modules, architecture-specific modules and locally added modules is now more clear-cut. This makes it a lot cleaner and easier to upgrade your Perl distribution, without having to worry about the modules you've installed for older versions.

Perl can now also take advantage of those architectures which use 64 bit integers (quads) if you use the -Duse64bits flag to Configure, and so you can now do your integer arithmetic with values up to 9,223,372,036,854,775,808 instead of a measly 2,147,483,648.

Similarly, Perl can now process files larger than 2 gigabytes on computers that support them. Just add -Duselargefiles to your Configure, and off you go.

Finally, floating point support is enhanced on those computers which support the `long double' variable type, and we're also starting to see the beginnings of cross-compiling options appear in Configure.


`Here be dragons' - thread.h

Perl's threading has been drastically reworked. It's still experimental, and there's still every expectation that the current implementation may be thrown out and started again, but Perl now supports two different types of threads.

Firstly, we've got the threads that existed in Perl 5.005 - your program can thread, and each thread can have its own variables and stashes, controlled with the Thread module as before, and these threads have become slightly more stable - but we also now have interpreter-based threads.

In this model, the entire Perl interpreter gets cloned and runs in a separate thread. At the moment, however, there's no way to create a new thread from Perl space, so it's not what you want if you're trying to play with threaded programs, but what it does mean is that platforms such as Windows that don't support the fork() system call can have an emulated fork by cloning the entire perl interpreter; each `pseudo-process' then emulates the properties on an independent process. It's a huge hack, but it works.

As well as enhanced threading support, we now have support for `multiplicity'. What this means is that not only can you have two interpreters in separate threads that have a common ancestry, you can have completely separate and independent interpreters inside the same process. Again, there is no interface to this from Perl space; if you want to use threads in your program, you'll need to turn on the old 5.005 threads; they're still an experimental feature, so caveat programmor.

Improved Compiler

`Perl has a long tradition of working around compilers' - lwall

Full kudos is due to Vishal Bhatia and Nick Ing-Simmons for their work on the Perl compiler; it's come on in leaps and bounds since the last release. While it's still not ready for prime time, the Perl-to-C compiler now passes a fair amount of the standard Perl test suite, and can even be used to compile (some) Tk programs. The `optimised C' compiler is also slightly more stable, but some problems have been reported.

The usual provisos apply: your program may not be any faster or smaller than an uncompiled version. (Quick tests show that a simple program - op/recurse.t in the test suite - is a few milliseconds faster when compiled; it's also a quarter of a megabyte on this computer and took 70 seconds to compile.) Compiling a program still means embedding the Perl interpreter inside it - we're not even dreaming of producing native assembler or C code translations of a Perl program yet.

The new perlcompile documentation explains what's going on.

Version Tuples

`That is a known bug in 5.00550. Either an upgrade or a downgrade will fix it.' - lwall

Perl's version numbers have always been a little bizarre; this version marks a move away from the x.yyy_zz format towards the more standard major-minor-patchlevel format. Even-numbered minor versions, such as 5.6.0, will be the stable versions, with the odd-numbered minor versions making up the development stream; now 5.6.0 is released, work will begin on 5.7.0 - this follows the format of many other open source projects.

Together with this, a new method of specifying strings has been created - a literal such as v5.6.0, for example, will be interpreted as a Unicode string made up of three characters: character 5, character 6 and character 0. This allows one to compare version numbers using the string comparison operators, and provides a more readable way of writing long Unicode literals; the string above can also be specified as

     $glis = v917.973.945.947.947.949.955.970.947;

printf and sprintf have now had the v flag added to their format specifications, which allows you to go the other way: to turn a string into a series of numbers separated by periods - it's effectively join ".", map {ord} split //, $_

  print  "Perl version: $^V\n";    # This gives you a messy string!
  printf "Perl version: %vd\n", $^V;  # Perl version 5.6.0

This is ideal for any number of things which are specified in such a format, such as IP addresses:

     use Socket;
     printf "%vd", (gethostbyname("www.perl.com"))[4];

The new syntax takes a bit of getting used to, it has to be said; most people won't be using it, but it's a neat trick if you can get your head around it.

Lexical Warnings

'Death is not good. I reject death. I will stay away from trucks today.' - lwall

The way Perl generates warnings has also been completely revised: as a replacement for the -w flag and the $^W special variable, the warnings pragma gives you more flexibility about what warnings you receive and when.

In terms of what, you can now specify warnings by category: there are a bunch of standard categories, such as 'syntax', 'io', 'void', and modules will be able to define their own categories. You can also choose to escalate any categories of warning into a fatal error.

As for when, the pragma is lexically scoped, so you can switch it on and off as you wish:

     use warnings;

     $a = @a[1];      # This generates a warning.

          no warnings;
          $a = @a[1];  # This does not.

See perllexwarn for how to use this from programs and modules.

Lvaluable Subroutines

'I surely do hope that's a syntax error.' - lwall

From the department of bizarre syntax, subroutines can now be legal lvalues; that means they can be assigned to. Of course, this only works if they return something assignable, and if they're marked as an lvalue subroutine. For example, normally, you'd have something like this:

     my $a = 10;
     my $b = 20;

     sub mysub {
          if ($_[0] > 0) { return $a } else { return $b }

     print mysub( 2); # Returns 10
     print mysub(-1); # Returns 20

What you can now do is this:

     sub mysub : lvalue {
          if ($_[0] > 0) { return $a } else { return $b }

     mysub(2)  = 15; # Set $a to 15
     mysub(-1) =  9; # Set $b to 9

That is, the function returns not a value, but the variable itself.

This is still an experimental feature, and may go away in the future; it's also not possible to return array or hash variables yet.

Weak References

'I might be able to shoehorn a reference count in on top of the numeric value by disallowing multiple references on scalars with a numeric value, but it wouldn't be as clean. I do occasionally worry about that.' --lwall

Perl keeps track of when values are in use and when they can be taken out of commission by counting the number of references that remain to them. The problem with this was that if you had a variable that was a reference to itself, like this:

     $a = \$a;

the memory would never be freed even if nothing else referred to it, since it had a valid existing reference.

What you can now do is weaken a reference; this means that while it is still a valid reference, it does not add to the reference count. In the example above, you could weaken $a and it would be freed once it went out of scope. This also means you can keep a spare copy of a variable or an object but not interfere with its lifespan.

To take advantage of this, you need to install the WeakRef package from CPAN, and read the further documentation there.

POSIX Character Classes

'How do Crays and Alphas handle the POSIX problem?' - lwall

The Portable Operating Systems Extension (POSIX) standards documents define a set of named character classes: the class [:upper:], for example, matches an upper-case character. Of course, Perl supports a wide range of character classes and can now support matching Unicode properties too, but it seemed odd that the POSIX standard had not been implemented, especially since it's familiar to C programmers and used in standard utilities such as tr. So we implemented it.

These classes, [:upper:], [:lower:], [:digit:] and a bunch of others, actually sit inside ordinary Perl character classes; as RD Laing said, `now put the brackets in brackets' - to match a whitespace character, use [[:space:]]. This is equivalent to the Unicode \p{IsSpace} and the ordinary Perl \s.

This being Perl, we allow things that POSIX can't do, and you can negate a POSIX character class with a ^ before the name. A non-space character can be matched either with [[:^space:]], \P{IsSpace} or \S.

Miscellaneous Bits

'Perl will never turn into APL, despite our best efforts.' - lwall

Aside from the changes I've just mentioned, there are a myriad of little things that have been added, improved, and corrected. New documentation has been written, and older documentation revised; code has been tweaked, extended, rearranged, and rethought; some small pieces of syntax have been added or changed; experimental features have been tried, judged and sentenced.

While we can't go into all of the less major modifications in the new version, I'll just pick out some points which may be useful. For the whole story, you can see the perldelta documentation - for even more of the whole story, read the Changes file in the Perl distribution.

Binary Numbers

As well as being able to specify numbers in decimal (1234), octal (02322) and hexadecimal, (0x4D2) we now have the 0b prefix for binary numbers - 0b10011010010

While there isn't a bin() function to match hex() and oct(), you can actually make one from the oct() function; oct("0b1001") returns 9.

our Variables

Whereas my declares lexical variables, our declares global variables - it's a cleaner and hopefully more intuitive replacement for use vars.

File Globbing

The glob operator (<*> and glob) used to be processed by spawning a shell; that was problematic for operating systems that didn't have a standard shell, and anyway had the overhead of creating a new process. It's now implemented by calling the standard File::Glob|File::Glob module on demand.

Bug Fixes

Most of the bugs, surprises and unpleasantries from 5.005 have been cleared up; recently there's been quite a blitz on the security of the utilities that come with Perl, safer handling of temporary files, and tons of work on debugger, but most of the work of the past year has been clearing up the issues that you've reported to perl5-porters in the interim. Keep them coming - it's only by reporting them that they get fixed.

     Q: How many programmers does it take to change a Sarathy?
     A: None needed, Sarathys never burn out.' - lwall

I'd like to close by commending the great labour of hundreds of porters in the past year who've worked to bring Perl 5.6 to you, fearlessly led by the tireless Gurusamy Sarathy, and overseen by the guiding hand of Larry Wall, and by hoping that this new version will maximise the ease, power, and above all, enjoyment of your programming.

May you do Good Magic with Perl... 5.6!

Visit the home of the Perl programming language: Perl.org

Sponsored by

Monthly Archives

Powered by Movable Type 5.13-en