Beefy Boxes and Bandwidth Generously Provided by pair Networks
The stupid question is the question not asked

Re: Why should I use perl 5.10?

by grinder (Bishop)
on Nov 30, 2007 at 11:35 UTC ( #654086=note: print w/replies, xml ) Need Help??

in reply to Why should I use perl 5.10?

Here are some things of the top of my head that I think are pretty cool:

  • state variables No more scoping variables with an outer curly block, or the naughty my $f if 0 trick (the latter is now a syntax error).
  • defined-or No more $x = defined $y ? $y : $z, you may write $x = $y // $z instead.
  • regexp improvements Lots of work done by dave_the_m to clean up the internals, which paved the way for demerphq to add all sorts of new cool stuff.
  • smaller variable footprints Nicholas Clark worked on the implementations of SVs, AVs, HVs and other data structures to reduce their size to a point that happens to hit a sweet spot on 32-bit architectures
  • smaller constant sub footprints Nicholas Clark reduced the size of constant subs (like use constant FOO => 2). The result when loading a module like POSIX is significant.
  • stacked filetests you can now say if  (-e -f -x $file). Perl 6 was supposed to allow this, but they moved in a different direction. Oh well.
  • lexical $_ allows you to nest $_ (without using local).
  • _ prototype you can now declare a sub with prototype _. If called with no arguments, gets fed with $_ (allows you to replace builtins more cleanly).
  • x operator on a list you can now say my @arr = qw(x y z) x 4. (Update: this feature was backported to the 5.8 codebase after having been implemented in blead, which is how Somni notices that it is available in 5.8.8).
  • switch a true switch/given construct, inspired by Perl 6
  • smart match operator (~~) to go with the switch
  • closure improvements dave_the_m thoroughly revamped the closure handling code to fix a number of buggy behaviours and memory leaks.
  • faster Unicode lc, uc and /i are faster on Unicode strings. Improvements to the UTF-8 cache.
  • improved sorts inplace sorts performed when possible, rather than using a temporary. Sort functions can be called recursively: you can sort a tree
  • map in void context is no longer evil. Only morally.
  • less opcodes used in the creation of anonymous lists and hashes. Faster pussycat!
  • tainting improvements More things that could be tainted are marked as such (such as sprintf formats)
  • $# and $* removed Less action at a distance
  • perlcc and JPL removed These things were just bug magnets, and no-one cared enough about them.

update: ok, in some ways that's just a rehash of perldelta, here's the executive summary:

There has been an awful lot of refactoring done under the hood. Andy "petdance" Lester added const to just about everything that it was possible to do, and in the process uncovered lots of questionable practices in the code. Similarly, Nicholas Clark and Dave Mitchell nailed down many, many, many memory leaks.

Much of the work done to the internals results in a much more robust engine. Far likelier err, less likely, to leak, or, heavens forbid, dump core. If you have long running processes that chew through datasets and/or use closures heavily, that is a good reason to upgrade.

For new developments, there are a number of additions at the syntax level that make writing Perlish code even better. Things like Mark-Jason Dominus's book on Higher Order Perl makes heavy use of constructs such as closures that tend to leak in 5.8. If this style of programming becomes more widespread (and I hope it does, because it allows one to leverage the power of the language in extraordinary ways) then 5.10 will be a better fit.

Years ago, having been bitten by nasty things in 5.6, I asked Does 5.8.0 suck?. As it turns out, it didn't. I think that 5.10 won't suck, either. One big thing that has changed then is that far more people are smoking all sorts of weird combinations of build configurations on a number of different platforms, and many corrections are being made as a result of that. Things that otherwise would have forced a 5.10.1 to be pushed out in short order.

update: clarified the "no more foo" additions, as per dmorgo's comment.

• another intruder with the mooring in the heart of the Perl

Replies are listed 'Best First'.
Re^2: Why should I use perl 5.10?
by doom (Deacon) on Nov 30, 2007 at 23:34 UTC
    Really, that's an excellent summary, much more readable than the perl5 delta.

    I hadn't realized that unicode handling had been sped up a bit: that sounds like one of the more practical advantages. I know at least one place that's still running on 5.6 perl because they saw a 30% slowdown in their attempt at upgrading to perl 5.8 (they didn't know about "use bytes", but cut them some slack, that's an easy thing to miss).

    My personal favorite new feature would be the improvements to the regular expressions: it's now possible to do recursive regexps in a much neater way than the experimental features in 5.8 (no, I don't actually have a use for this, but I still think it's really neat...).

Re^2: Why should I use perl 5.10?
by shotgunefx (Parson) on Nov 30, 2007 at 23:51 UTC
    Finally a real switch statement! BTW, that is the best summary I've seen so far.

    My understanding is that most of these new features need to be enabled with use, if so, I'm assuming it will be easier to add new syntax features in the future?

    "To be civilized is to deny one's nature."
Re^2: Why should I use perl 5.10?
by Jenda (Abbot) on Dec 01, 2007 at 03:24 UTC
    x operator on a list you can now say my @arr = qw(x y z) x 4

    THAT ONE IS DANGEROUS! The current x operator provides scalar context to both its operands (@a = (1,2,3,3,3,3); print @a x 3; ==> 666), the new one will not. While this may seem unimportant since it's unlikely that you'd want to repeat several times the lenght of an array it may easily cause problems with things like foo(...) x 8. Suddenly the foo() will be evaluated in a different context! That might easily lead to hard to find bugs!

    Update: Looks like the change is more restricted than I thought so it should not be a problem. Thanks Somni!

      This change applies specifically to qw(...). The code:

      @x = qw(a b c); print @x x 3;
      still prints "333". qw(a b c) x 3 used to be a syntax error.

      What I find confusing is why this is mentioned for 5.10. This was added in 5.8.8 according to my perl588delta.

      The qw() operator provides list context already. So
      print ( qw(a b c) x 3 );

      yields the same result as

      @l = qw(a b c); print ( (@l) x 3);

      which makes sense imho. An array isn't a list, but a qw() expression is.

      update: as a reminder, this is from perlop:

      Binary "x" is the repetition operator. In scalar context or if the left operand is not enclosed in parentheses, it returns a string consisting of the left operand repeated the number of times specified by the right operand. In list context, if the left operand is enclosed in parentheses or is a list formed by "qw/STRING/", it repeats the list. If the right operand is zero or negative, it returns an empty string or an empty list, depending on the context.


      _($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                                    /\_¯/(q    /
      ----------------------------  \__(m.====·.(_("always off the crowd"))."·
      ");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}
Re^2: Why should I use perl 5.10?
by John M. Dlugosz (Monsignor) on Apr 29, 2008 at 15:34 UTC
    Thanks for the catalog. I've been focused on Perl 6, and had no idea that 5.10 back-ported so many important features. I also noticed 'say' as a built-in.

    Re stacked filetests: The syntax is different, but you can indeed stack them. And define your own operators on your own types that work the same way.

      The article says: "defined-or No more $x = defined $y ? $y : $z, you may write $x = $y // $z instead." Does "no more" in this case mean you are no longer *allowed* to do it, or you no longer *need* to do it, because there is an easier way? I must assume the latter!

        Your assumption is correct. The old syntax still works, but the new syntax is easier.

Re^2: Why should I use perl 5.10?
by dmorgo (Pilgrim) on Dec 04, 2007 at 17:57 UTC
    When you say "no more <insert foo syntax here>" do you mean these things are no longer supported, as in, existing code will break?

    That's kind of what it sounds like you're saying. However, I think it's not what you mean.

    While the intended meaning may be obvious to me and to most of us, there are a lot of redditors here today reading this, some of whom are going to think "holy crap, Perl sure breaks a lot of stuff when it moves forward in a dot release." Maybe a bit of clarification would be nice on what breaks and what doesn't.

    Thanks for the great post! I'm looking forward to using these features.

Re^2: Why should I use perl 5.10?
by bart (Canon) on Dec 05, 2007 at 12:40 UTC
    • state variables No more scoping variables with an outer curly block, or the naughty my $f if 0 trick (the latter is now a syntax error).
    I think you mean "static variables". A state variable is, generally, just a global variable, typically those used by the system, for example all those variables (with a special name) in perlvar.

      I think the OP means "state variables" as that's what they are called in Perl 6. The declarator is the word state too.

      sub foo { state $x = 0; # $x will retain it's state through # successive invocations of foo() # ... }
      (Yes, other languages use the keyword static, but this is Perl!)

Log In?

What's my password?
Create A New User
Domain Nodelet?
Node Status?
node history
Node Type: note [id://654086]
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others wandering the Monastery: (4)
As of 2022-01-27 23:43 GMT
Find Nodes?
    Voting Booth?
    In 2022, my preferred method to securely store passwords is:

    Results (72 votes). Check out past polls.