until ($odometer[$wheel] < 9 || $wheel < 0)

[download]

use strict;
use warnings;

my @odometer = qw(0 0);
for (1..$ARGV[0]) {
    print "was: @odometer\t";
    @odometer = increment_odometer(@odometer);
    @odometer ? (print join ' ', @odometer) : (print "No more Wheels t
+o turn! $!" and exit) ;
    print "\n";

}

sub increment_odometer {
          my @odometer = @_;
          my $wheel = $#odometer; # start at rightmost wheel

    until ($odometer[$wheel] < 9 || $wheel < 0)
    {
                          $odometer[$wheel] = 0;
                          $wheel--; # next wheel to the left
    }
    if ($wheel < 0) {
                    return; # fell off the left end; no more sequences
    } else {
                    $odometer[$wheel]++; # this wheel now turns one no
+tch
                    return @odometer;
    }
}

[download]

The semantic translated

Inverting the condition

until ($odometer[$wheel] < 9 || $wheel < 0) #ok original

#negated direct form also ok
while  ( !($odometer[$wheel] < 9 || $wheel < 0) )

while ($odometer[$wheel] > 9 || $wheel < 0) # NO

while ($odometer[$wheel] > 8 || $wheel < 0) # OK but NOT for greter th
+an limit of the odometer!
          #Use of uninitialized value in numeric eq (==) at C:\SCRIPTS
+\odometer.pl line 27.
          #Modification of non-creatable array value attempted, subscr
+ipt -3 at C:\SCRIPTS\odometer.pl line 26.
          #getting: 9 9->

while ($odometer[$wheel] == 9 || $wheel < 0) # OK  but NOT for greter 
+than limit of the odometer!
          #Use of uninitialized value in numeric eq (==) at C:\SCRIPTS
+\odometer.pl line 27.
          #Modification of non-creatable array value attempted, subscr
+ipt -3 at C:\SCRIPTS\odometer.pl line 26.
          #getting: 9 9->

while ($odometer[$wheel] == 9 && $wheel >= 0)  # OK


[download]

Hi,

Not sure where this should go, so kindly move to the appropriate section.

Whoever came up with the Named Captures in Perl, Thank you. You are a Godsend. It's made things a hell a lot simpler and more clear. I just finished writing a small script and while I went from trying the basic capture to the named capture, I could not help but thank the people who came up with this.

Another note of thanks to the authors of Learning Perl 6th Edition for explaining it so nicely!! Guess one of the authors would be surely involved in the implementation of the Named Capture.

Now, time to go back to the script and add some more improvements...Perl is addictive. Very addictive...

use Learning::Perl;
use Beginning::Perl::Ovid;
print "Awesome Books";
[download]

Python

class OurClass(object):
   """Class docstring."""

   def __init__(self, arg1, arg2):
       """Method docstring."""
       self.arg1 = arg1
       self.arg2 = arg2

   def printargs(self):
       """Method docstring."""
       print self.arg1
       print self.arg2
[download]

Perl

package OurClass;
use Moose;
has ‘arg1’ => (
    is     => ‘rw’
);
has ‘arg2’ => (
    is     => ‘rw’
);
sub printargs {
    my $self = shift;
    say $self->arg1;
    say $self->arg2;
}
no Moose;
[download]

First some context: This is the format of an /etc/passwd file (rough example)...

root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin
rpc:x:32:32:Portmapper RPC user:/:/sbin/nologin
ntp:x:38:38::/etc/ntp:/sbin/nologin
haldaemon:x:68:68:HAL daemon:/:/sbin/nologin
dbus:x:81:81:System message bus:/:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin

Now then, can you sort that (numerically, descending) by UID (3rd field) and do it with less code? Show me how! I bet there's a way to optimize-out that split below...

cat /etc/passwd | perl -e 'print join ":", @$_ for sort { $b->[2] <=> 
+$a->[2] } map { [ split /:/, $_ ] } <>'
[download]

Granted, you can use the code below also, but it doesn't port to a certain flavor of Unix I have to work with more than I'd like... The Perl code works on all the platforms without changes...

cat /etc/passwd | sort -t : -k3 -nr
# the above method works great with GNU /bin/sort!
[download]

In summary, for the chosen benchmarks, in June 2012 the Rakudo compiler was about 10x to 100x faster than it was 18 months prior, but still about 100x slower than mainstream languages/compilers like Perl 5's perl.

It's gotten faster since, but in late 2012 Larry Wall said on #perl6 "performance is still the main blocker to widespread adoption of Perl 6".

I agree with Larry. (There are other issues of course. Carl Mäsak immediately added "and CPAN/Perl 5 integration". But, as Larry went on to say, "if Perl 6 were fast enough, we couldn't stop people from translating Perl 5 CPAN into Perl 6 CPAN in droves".)

One strategy tactic to speed up Rakudo would be to speed up the VM on which it runs. Currently Rakudo Perl 6 runs on the Parrot VM. There's been effort to speed up Parrot for years. Another approach would be to target a different VM. And there's been effort in preparing for that for years.

Rakudo is written in a mix of languages. For Rakudo to target a different VM than Parrot, a key chunk of the work involved is to port a small language called NQP that until very recently only ran on Parrot.

Jonathan Worthington began preparing a port of NQP to the JVM late last year. Jonathan has been making rapid progress on the port of NQP to JVM. Today he posted an outstanding blog post about the JVM port.

Then later today on #perl6 Nicholas Clark said "not exactly comparing like-with-like, but for various fibonachi example scripts, NQP on the JVM is 8 times faster than on Parrot and runs in about 60% of the time of Perl 5".

Early results often obscure all the work that is to come. Jonathan clearly thinks it'll take another few months to port Rakudo to the JVM. So don't expect a much faster Perl 6 this month. But it's clear that Perl 6 is going to get a lot faster in 2013.

I've been watching Perl 6 since the start. I recall the excitement and fun on #perl6 when Audrey was pushing Pugs forward very rapidly. I see the same signs this year, with Jonathan the genius at the center of a whirlwind of progress. If you love Perl and want to have a lot of fun, consider dropping in on #perl6, the freenode IRC channel.

What's Up

File::Util has undergone some major changes in v4.x, some of which have been discussed here since late December. I've preserved complete backward compatibility while performing the overhaul.

The 4.x series is a both a response to community complaints/requests, and a big push to bring it into step with "modern" best practices and interface styles.

I'm looking for people to kindly let me know what they think...good/bad/otherwise. Why? I'd like to get as much community feedback as possible in the way of "social review" of the new interface before publishing this distribution of major changes, features, bug fixes. I value what you have to say.

The git repository is here: https://github.com/tommybutler/file-util

A packaged dist is available here: http://www.atrixnet.com/File-Util-4.130300.tar.gz

What's New

Other than a slew of bug fixes and feature additions, a quick look at some key differences in the interface is succinctly presented here. See also the NEWS file in the dist.

What's Left

Things left before actual 4.x release would be to correct any grammar/spelling issues in the docs that I haven't already caught, to add more to the cookbook (and revisit recipes in the cookbook that are old and could be improved), and to add even more to the test suite (which currently runs over 500 tests in developer release test mode). See also the TODO file in the dist.

My gratitude goes out to those who provide feedback, even if all you do is read over the Manual on github and point out anything you find good/bad/otherwise. For those who try out the dist itself (maybe with perlbrew?) and play with File::Util a bit, I thank you in the most emphatic terms possible. It's so important to me to put forth the best code I can for the community, for those who use the module commercially, for the CPAN, and for Perl.

My thanks already goes out to MST and RJBS who have provided valuable help via IRC and CPAN RT. Also to SirSpammenot and Nick Perez who helped via email and Google+, and to anyone who ever filed a bug report or smoked File::Util.

No code here,,,just a crazy rant :

I am starting to re-learn perl and entered the monastery so I could say this...I am over whelmed. I used perl before and got paid for it, and walked away, actually more like slipped away, and now I've decided I don't want to do anything but perl, but, it's like I can't fit it all into my skull, and I feel like my plane is crashing.

I've been on this site quite a bit, and it helped me to learn XRC for wxperl , which I quite like, but --- I'm trying now to figure the best way to distribute that, and that's causing me some distress, and I've drifted into Perl 6,,,,which may be like a snow bank at the end of a rough ski hill...crashing. Is it hard, is it soft? I can't seem to fit 5 into my head...so where does 6 go?

Actually, I also had the exact same experience with pde's - partial differential equations. I wonder if there's a connection there? Total blind panic.

I don't know, just lot's of questions, and I don't feel like I'm sufficiently fluent to trust I'll go in the right direction. In practical terms that means I can read it fine, but writing it is difficult. Too many pointers pointing in too many different directions.

Originally, when I thought about getting onto this site, I thought I would ask if there are any Minnesota perl'ers that want to help create a Minnesota perl-mongers --- so at least that some kind of a question - that might make sense.

Sorry, crazy rant --- I feel like a could use some guidance or maybe a hug? -- Couldn't help it. Does anybody else feel this way? Or is everyone too busy for that?

I will try to avoid these kinds of emotional outbursts in the future.

#!/usr/bin/perl -w

use strict;

BEGIN {
use Guard;
use Carp;
{
  my $guard = guard { Carp::cluck "Function replaced!" };
  my $code = \&time;
  *time = sub { return $code->(@_); undef $guard; };
};
};

BEGIN { print time(), "\n"; };

use Time::HiRes qw(time);

print time, "\n";

Not long ago I was hunting a memory leak in a long-running AnyEvent-based application. I thought it would be a great idea to put a special guard object into every closure, so that I could see them created and destroyed.

The interface was very simple:

    # in initial section
    use My::Stat::Guard;
    my $stat = My::Stat::Guard->new;

    # when running
    my $guard = $stat->guard;
    my $callback = sub { 
        $guard->finish("taken route 1"); 
        # now do useful stuff
    };
    # ... do whatever I need and call $callback eventually

    # in diagnostic procedures started via external event
    my $data = $stat->get_stat;
    # now I have some useful numbers in %$data
    # total: 100
    # alive: 19
    # dead: 81
    # etc.

get_stat also shows data for finished callbacks that still float around, and unfinished ones that left scope (typically both mean something went wrong).

The module also allows (when used with want_time => 1 parameter to new) to display (very rough) statistical distribution of guard lifetimes (== total time to process request).

I have searched CPAN for such a module before rolling out my own, but haven't found anything except several Guard-like modules.

So my question is: does such a module exist, and if not, is there a demand for one?

Introduction

Hungarian notation (and any derivation thereof) has its cons and pros. I understand that there are people who like it, and that there are people opposed to it. Some would argue that Perl code doesn't need any kind of Hungarian notation, because we already have our sigils that mark $variable as a scalar, @variable as an array, and %variable as a hash.

However, a scalar is a flexible thing. I don't have to tell you it doesn't just hold strings and numbers, it can also hold a multitude of different kind of references. In my experience, in can be helpful to make it obvious what sort of data you expect to be in a scalar, so that you can see at all times what you're dealing with. I usually do that by adding a short two or three letter suffix to a variable name (and in rare occasions, just one or even four letters).

Conclusion

I find sticking to such suffixes greatly improve readability of my code. When I come back to a piece of code because I discovered a bug or want to improve the way something works, I can dive straight into some relevant subroutine and see what each variable is supposed to be. Note that none of these suffixes tell me whether a scalar is a string or an int or what-have-you: those details should be clear by the main name of the variable, if they're not obvious by the suffix (for example, a $..._idx will hardly ever be a string ;) ).

Another thing, which is only tangentially relevant, is that I always use underscores_to_separate words and suffixes in a variable name, and never camelCasing. That saves me from wondering, "what was it again? $myAwesomeScalar, $MyAwesomeScalar, or $my_awesome_scalar?" It will always be the latter.

The module Net::XMPP::Client::GTalk is aimed at providing an easy to use wrapper around NET::XMPP class of modules for specific use with GTalk.

Although the majority of this can be achieved through Net::XMPP::Client there are several parameters that need to be fixed and it took me a good hour and half just to get the basics to work, which IMHO is too long.

Additionally Net::XMPP::Client provides call back functions which ( again IMHO ) is confusing/counter-intuitive/unnecessary in synchronous programs - And these are not just additional provisions but requirements.

There are also sections ( such as checking if a buddy is online ) that do not work and this module provides for a workaround.

Additionally Net::XMPP::Client::GTalk provides direct access to the NET::XMPP connection object, so all functions of the NET::XMPP class of modules.

This example connects to GTalk and waits for a chat message from someone. It replies to that person with the chat message that it received. Additionally it will dump online buddies at regular intervals along with the contents of the message it receives.

You can quit this program by sending it the chat message 'exit'.

    use Net::XMPP::Client::GTalk    ;
    use Data::Dump qw( dump )       ;

    my $username ; # = '' ; Set GTalk username here [ WITHOUT '@gmail.
+com' ]. 
    my $password ; # = '' ; Set GTalk password here.


    unless( defined( $username ) and defined( $password ) ) { 
    die( "SET YOUR GTALK USERNAME AND PASSWORD ABOVE!\n" ) ;
    }

    my $ob = new Net::XMPP::Client::GTalk( 
    USERNAME   =>  $username         ,
    PASSWORD   =>  $password         ,
    );


    my $require_run = 1 ;
    my $iteration   = 1 ;
    while( $require_run ) { 

    my $message = $ob->wait_for_message( 60 ) ;

    unless( $message ) { 
        print "GOT NO MESSAGE - waiting longer\n" ;
    }

    if( $message->{ error } ) { 
        print "ERROR \n" ;
        next             ;
    } else { 
        dump( $message ) ;
    }

    if( $message->{ message } eq 'exit' ) { 
        print "Asked to exit by " . $message->{ from } . "\n" ;
        $message->{ message } = 'Exiting ... ' ;
        $require_run = 0 ;
    }

    $ob->send_message( $message->{ from }, $message->{ message } ) ;

    if( int( $iteration / 3 ) == ( $iteration / 3 ) ) { 
        my @online_buddies = @{ $ob->get_online_buddies() } ;
        dump( \@online_buddies ) ;
    }

    $iteration++ ;

    }


    exit() ;

[download]

Would greatly appreciate any kind of feedback!

Update: This module is now on CPAN here

What do you read, when you’re on the plane or waiting for a backup to finish or whatever the else you do?   I mean, besides “The Camel Book?”   Stuff that really gets you thinking, either about the business we are in, or the businesses we work for?

May I suggest a few, to start?

The Long Tail, by Chis Anderson (http://www.amazon.com/Long-Tail-Future-Business-Selling/dp/B001Q9E9F6).   The tag line of this book is “Why the future of business is selling less of more.”   Extending this idea, say, to websites, this might explain why, even though there are bigger and bigger “brand-name” sites, there are also more sites out there than ever before.   I’m starting on my third re-reading of this one ...

Managing the Mechanism, by Vince North (http://www.amazon.com/Managing-Mechanism-Software-Successfully-ebook/dp/B00ANYTJZA), an interesting apparently Kindle-only take that basically says that the reason why software is so hard to manage, is that software’s so different.   Pleasantly little methodology-bashing.   He takes the position that software is a mechanism, always doing whatever it does under its own pre-programmed direction, and that most software projects fail due to project management approaches which do not take the implications of this into account.   (A thought-provoking idea ...)

How to Build Your Own Website for Free, by Charlie Morelli (http://www.amazon.com/Build-Your-Mobile-Site-Less/dp/1479262781).   Okay, so I like “Kindle freebies,” but lately I have gathered quite a few books that make this point in various ways, – and frankly, they all are beginning to scare me a little.   I mean, you really can do a lot of the stuff that businesses actually want, including mobile-app stuff, for free now.   Even though there will always be a demand for heavy-hitting back-end coding, like we are all used to doing, I perceive a sharp reduction in the notion that a web-site and the programming that used to go into it is still worth tens of thousands of dollars.   I openly fear that there is developing in our business an over-supply of workers that coincides with a sharp reduction(!) in demand.

Anyway, there’s three.   Any good ones from you that you think we programmer-types all should be reading on these cold winter nights?   What do you think of what they said?

I'm really lucky: I get to use Perl every day, and make a living doing it. It's awesome.

However without going into unecessary detail, I'll just say that the Perl that I use at $work is old. Very old. It is considered stable and secure, and is therefore blessed by the powers that be for use in our %ENV.

It's no fun to read learning materials like the Modern Perl book and look at all the things that newer Perls have to offer, while not being able to use them. I'd like to get a chance to use operators like //= (a favorite of mine), or things like sub { state $counter = 0; return $counter++ }, or even builtins like say $foo

I'm guessing there are other monks in similar situations. But I'm curious if this is more common than not. So here's sub the_question {

Do you get to use Modern::Perl at your $job?

UPDATE:

I can't make a poll out of this since I'm not a pollster (pollsters), but I will submit this as a poll "idea" in a little while. In the mean time, I want to keep enjoying the discussion as it unfolds. The replies are both informational and entertaining. It is very amusing to see how other monks are using Perl versions/features at $work. So...err... goto \&the_question

UPDATE 2:

By (high?) demand, a Poll has been submitted for review to the pollsters. Happy Voting!

my @list= qw(first_string second_string);
@list = map(s/_string$//,@list);
print @list;
[download]

Returns a bunch of ones, in this case "11"

What should be done instead:

my @list= qw(first_string second_string);
@list = map((s/_string$// and $_), @list);
print @list;
[download]

Another similar reference can be found at: id:20505

Ready the flame retardant! I know there are monks who don't like Dist::Zilla...or my modules... or me... But in the past such criticisms have only served to make me a better Perl hacker than before I was criticized, and (more importantly) guided me to improve my code. I fear the day when people stop offering me negative feedback (because that will probably be when I'm dead HAR HAR). So:

A couple of days ago I moved File::Util to git+Dist::Zilla, and added Perl::Critic into the mix. This was on my list of resolutions, but not just for the new year. It's more because I think I owe it to the community to keep offering better things and generally never cease trying to improve.

Euphoric Observations and Kvetches:

1. git is so frikkin easy; you're over-thinking it-- just type "git" and you'll "get" it (how anyone manages to write a whole book on something so simple is a real puzzler)
2. Dist::Zilla was a pain in the *censored* to get working, but it really was worth it, especially with the many plugins that make being a CPAN author waaaay more easy and fun
3. Perl::Critic is mean (wah ;_;). I like to eval 'expressions'; Perl::Critic does not.
4. Perl::Critic cites the Perl Best Practices book for everything it complains about. The book is not free, and the references to page numbers are USELESS when you decide to shell out the money, but buy the more budget-conscious kindle version instead. Kindle doesn't have real page numbers! Hello McFly!
5. Dist::Zilla fosters and facilitates "kwalitee" (as in CPANTS) by generating/maintaining certain "meta" files that you might forget to add or update before packing up your dist. (version control and the MANIFEST admittedly help with the "add" part, but Dist::Zilla still has your back in this regard, should you mistakenly un-add something that should be there)
6. My CPAN modules will from now on have much better kwalitee, pass Perl::Critic tests, include git repo info, build more easily on platforms that don't have a "make" utility, add a Module::Signature to all builds, and other lofty devel snobbery that I haven't yet added to the mental list
7. The next Perl Mongers meeting will be more fun now that I'll know what I'm talking about as I cover the scheduled topic (collaborative development with git) :-D I'll also be supplementing the curriculum by showing merlyn's presentation video on git which he shared very recently on google+!

That is all.

UPDATE:

And with the new year, these resolutions begin to unfold. Over at a new github repo, items are getting checked off the TODO file while I pour another glass of non-alcoholic sparkling white grape Martinelli's