Bretheren of Perl,

When I first learned Perl, it was Perl 4. Perl 5 was available, but it was new, and the company I was working for didn't trust it yet. That was many years ago, at the first job I had after college. In the time since, I've used Perl to varying degrees at every job I've ever had. I still work with Perl 5 today, and I expect this will be how I continue to make my living for years to come.

Some months ago, I shifted my free time expenditures from the Monastery to contributing to Perl 6. At the time, I'd heard there were some Perl 5 folks none too happy with Perl 6, but I was really only dimly aware of this and even further oblivious to the reasons involved.

I found the Perl 6 community to be friendly, welcoming, helpful, and all the other wonderful things I'd come to expect from my experience here at the Monastery. I basically forgot about any rift between the Perl 5 and Perl 6 communities. As I had experienced them, I saw no reason for them not to get along.

My eyes have been opened by masak and mst, who had a long private conversation on this topic and revealed the results of it in two articles.

• F-ck Perl 6 by mst
• How Perl 6 could kill us all! by masak

I think the Perl community would benefit from taking these to heart. If you find yourself lacking the time to read the illuminations within them, mst has prepared a very brief summary, which I will summarize further.

Perl 5 and Perl 6 are two separate languages in the same family. I can tell you from my own experience that the fine folks working on Perl 6 do not plot the demise of Perl 5. I can also tell you that Perl 6 is clearly a different language from Perl 5 and just as clearly came from the same place. They were made with the same ideas in mind. Long may they live with our love and dedication.

Peace to you, Perl users everywhere.

Hi,

i was trying http://gearman.org and i've therefor got from cpan Gearman::Client and Gearman::Client::Async but, for what i need, i felt like they weren't designed as i need, and i've tried to write another which suits best my needs.

Having not wrote any documentation, i'll just show you the usage:

use Gearman::OO::Client;

my $client = Gearman::OO::Client->new(
        servers => ['127.0.0.1:4730'],
        max_queue => 4,
);

logit("connected");
foreach my $id (1..8) {
        $client->submit(
                func=>'test',
                req=>"Data for $id",
                complete => sub { logit("completed #$id: @_"); },
                error => sub { logit("ERROR #$id! @_"); },
        );
        logit("added #$id");
}

logit("sync...");
$client->sync();
logit("done.");
[download]

and here the output with 2 workers which just sleep for 1 second and respond with an empty string¹:

00:00:00 connected
00:00:00 added #1
00:00:00 added #2
00:00:00 added #3
00:00:00 added #4
00:00:01 completed #1:
00:00:01 completed #2:
00:00:01 added #5
00:00:01 added #6
00:00:02 completed #3:
00:00:02 completed #4:
00:00:02 added #7
00:00:02 added #8
00:00:02 sync...
00:00:03 completed #5:
00:00:03 completed #6:
00:00:04 completed #7:
00:00:04 completed #8:
00:00:04 done.
[download]

As you can see, some jobs are added early up to the max_queue limit, then it will block until any of the previous job complete to continue.

Also you can use a completely OO Job object:

package MyJob;
use base 'Gearman::OO::Job';

sub new { my ($class, %args) = @_; bless \%args, $class; }
sub function { 'test'; }
sub complete { my ($self, $data) = @_; logit("$self completed($data)")
+; }
sub req_data { my ($self) = @_; return $self->{req}; }

use Gearman::OO::Client;

my $client = Gearman::OO::Client->new(
        servers => ['127.0.0.1:4730'],
        max_queue => 4,
);

logit("connected");
foreach my $id (1..8) {
        $client->submit_job(MyJob->new(req => "OO #$id"));
        logit("added #$id");
}

logit("sync...");
$client->sync();
logit("done.");
[download]

and now the meditation: anyone think this could be usefull? and if so, which name should i use? does it merit to be on CPAN?

package DataTable;

sub new {
    my $class = shift;
    my $self = {};
    $self->{tablename} = undef;
    $self->{columns} = [];
    $self->{indices} = {};
    bless($self, $class);
    return $self;
}

sub tablename {
   my $self = shift;
   if (@_) { $self->{tablename} = shift; }
   return $self->{tablename};
}

sub columns {
   my $self = shift;
   if (@_) { @{$self->{columns}} = @_; }
   return @{$self->{columns}};
}

sub indices {
   my $self = shift;
   if (@_) { %{$self->{indices}} = @_; }
   return %{$self->{indices}};
}

1;
[download]

package DataTable;

sub new {
    my $class = shift;
    my $self = {};
    $self->{tablename} = undef;
    $self->{columns} = [];
    $self->{indices} = {};
    $self->{datatypes} = [];
    $self->{lengths} = [];
    $self->{decimals} = [];
    $self->{signed} = [];
    $self->{allownull} = [];
    $self->{default} = [];
    $self->{usequote} = [];
    }
    bless($self, $class);
    return $self;
}

# Accessor methods
sub ArrayAccessor {
   my $arrayname = shift;
   my $self = shift;
   if (@_) { @{$self->{$arrayname}} = @_; }
   return @{$self->{$arrayname}};
}

sub HashAccessor {
   my $hashname = shift;
   my $self = shift;
   if (@_) { %{$self->{$hashname}} = @_; }
   return %{$self->{$hashname}};
}

sub ScalarAccessor {
   my $scalarname = shift;
   my $self = shift;
   if (@_) { $self->{$scalarname} = shift; }
   return $self->{$scalarname};
}

sub tablename { return ScalarAccessor("tablename", @_); }
sub columns { return ArrayAccessor("columns", @_); }
sub indices { return HashAccessor("indices", @_); }
sub datatypes { return ArrayAccessor("datatypes", @_); }
sub lengths { return ArrayAccessor("lengths", @_); }
sub decimals { return ArrayAccessor("decimals", @_); }
sub signed { return ArrayAccessor("signed", @_); }
sub allownull { return ArrayAccessor("allownull", @_); }
sub default { return ArrayAccessor("default", @_); }
sub usequote { return ArrayAccessor("usequote", @_); }
1;
[download]

package DataTable;

sub new {
    my $class = shift;
    my $self = {};
    $self->{tablename} = undef;
    $self->{columns} = [];
    $self->{indices} = {};
    $self->{datatypes} = [];
    $self->{lengths} = [];
    $self->{decimals} = [];
    $self->{signed} = [];
    $self->{allownull} = [];
    $self->{default} = [];
    $self->{usequote} = [];
    # Automatically create Accessor methods
    foreach (keys(%{$self})) {
        my ($type, $prefix, $suffix) = (ref($self->{$_}), "", "");
        if ($type eq "ARRAY") {
            $prefix = '@{';
            $suffix = '}';
        }
        if ($type eq "HASH") {
            $prefix = '%{';
            $suffix = '}';
        }
        eval("sub $_ { " .
            'my $self = shift;
            if (@_) { ' . $prefix . '$self->{' . $_ . '}' . $suffix . 
+' = @_; }
            return ' . $prefix . '$self->{' . $_ . '}' . $suffix . ';
        }');
    }
    bless($self, $class);
    return $self;
}
1;
[download]

It is described as "expressive, concurrent, garbage-collected," which, to me, not only doesn't say much, but whatever it does say, sounds like a language that you and I already know.

Since languages are cultural, and are always evolving (and those that are not busy evolving are busy dying, to paraphrase our national bard), I seek your comments, musings, rants on this new language. Maybe we will even see an Inline::Go sooner or later.

Let's go.

Update: Names behind "Go" -- Robert Griesemer, Rob Pike, Ken Thompson, Ian Taylor, Russ Cox, Jini Kim and Adam Langley (see http://google-opensource.blogspot.com/2009/11/hey-ho-lets-go.html. Very impressive.

Today I thought I'd implement a way to compute pi using continued fractions

I was trying to get 1000 decimals for codegolf.com , but I was only able to get 10 correct decimals(yes, I know..pathetic) in 6 seconds(codegolf limits this to 4 seconds).

I used the formula here(the one in the middle),and wrote code that weighs at about 140 bytes , but the 1st entry in codegolf.com for this problem has 54 bytes or so.

Anyone care to divulge their (partial) solution to this ?

Maybe they treat the problem as one of compressing those 1000 digits rather than computing them? And if so, I think there were some theoretical bounds to compressing data, I do not remember what those were ... I'm pretty sure codegolf doesn't allow use of modules and implementing your own compression algo would jump over 54bytes for sure , or not ?

use bignum qw/p -20/;
my ($pi,$n) = ('3+1/(X)',1500);
$pi =~ s{X}{
    '6'.
    (
        $_!=$n
        ?'+'.((2*$_+1)**2).'/(X)'
        :''
    ) 
}e for(1..$n);
print eval $pi;
[download]

• Huge Amount of Data
• Large Processing Time
• Different versions of Perl/OS
• Non-centralized data
• Unknown hardware failure
• Segmentation fault (out of memory)
• Lost code :-)
• Lack of code maintenance due to a left developer
• Unmaintainable code due to spaghetti nature

$ perl -le'$x=0.05;$y=sqrt($x+$x+$x);$g="$y";print "Is $y equal to $g?
+";print $y==$g?"Yes":"No"'
Is 0.387298334620742 equal to 0.387298334620742?
No
[download]

So, dear monks, how do you see yourself in reference to the race I mentioned, now and in forthcoming years? I am somewhat exhausted, but my enthusiasm continues. I am worrying about the confidence level, because when I am looking for job, I need higher confidence.

#!/usr/bin/perl -w
use UI::Dialog; # sudo apt-get install libui-dialog-perl

my $statement = "My name is $0...\n";

my $d1 = new UI::Dialog(title => 'I know my name');
$d1->msgbox(text => $statement);

print $statement;

exit;
[download]

1. The first time you open a terminal and type "perl knowthyself". You get this output: "My name is knowthyself..."
2. Then you use the terminal and type "./knowthyself". You get this output: "My name is ./knowthyself..."
3. Finally you go to your file manager (Nautilus) and click on the file. You are asked what to do: Do you want to run it in a terminal, do you want to show its contents, do you want to cancel the action, or do you want to just run it? Of course you choose this last action (run the program without opening a terminal). You get this output (in a window): My name is /home/user/Desktop/knowthyself...

In looking at it, the one thing I notice about the XML File Syntax is that there is no way for parameters to have default values if not specified.

Another thing is that XML File Syntax makes it difficult for a SQL mode in emacs to highlight and indent the code unless you do something with mixed mode so that it handles the XML and SQL gracefully.

The final thing is that the session management features of this module appear to be a violation of orthogonal integration of concerns.

This post answers a few common questions and misconceptions about Perl's memory management.

Lexical variables don't get freed at end of scope

Lexical variables don't get freed at end of scope. They are cleared on scope exit to give you the apperance of a fresh variable. This is an optimisation that should be transparent to you.

On scope exit, if anything prevents the variable from being resused (e.g. if there are remaining references to the variable), the existing variable becomes anonymous and a new variable is allocated.

Clearing a variable does not free the memory it uses

It was previously mentioned that variables on cleared on scope exit. Variables can also be cleared as follows:

$s = undef;
@a = ();
%h = ();
[download]

Clearing a variable frees no memory directly. The buffer of a string is marked as being unused, but it remains allocated for later use. The underlying array of pointers in arrays and hashes is cleared, but it remains allocated for later use. This is an optimisation that should be transparent to you.

As a result of a variable being cleared, referenced variables (incl array elements) have their refcount lowered, and that may free those variables. But not the variable being cleared.

undef does not free a variable

undef can be used to clear a variable.

undef $s;
undef @a;
undef %h;
[download]

undef does do more than clear the variable. It also frees any buffers the variable has.

$ perl -MDevel::Peek -e'
    $s = "abc"; Dump $s;
    $s = undef; Dump $s;
    undef $s;   Dump $s;
'
SV = PV(0x814fb00) at 0x814f69c
  REFCNT = 1
  FLAGS = (POK,pPOK)         <-- Var contains a string
  PV = 0x81651b8 "abc"\0
  CUR = 3
  LEN = 4
SV = PV(0x814fb00) at 0x814f69c
  REFCNT = 1
  FLAGS = ()                 <-- Var is undefined
  PV = 0x81651b8 "abc"\0     <-- String buffer still
  CUR = 3                         allocated after clearing
  LEN = 4
SV = PV(0x814fb00) at 0x814f69c
  REFCNT = 1
  FLAGS = ()                 <-- Var is undefined
  PV = 0                     <-- undef freed the buffer
[download]

This function is rarely useful.

However, undef will never free a variable. Clearing the variable may result in the reduction of the ref counts of other variables, which may free those variables. But not the variable that was passed to undef.

Freeing variables may result in no change in available system memory

You can't rely on memory being returned to the system, but it can happen.

If and when memory is returned to the OS is dependant on the memory allocation mechanism perl was compiled to use. You may also see differences between system using the same memory allocation mechanism. It's also possible that a mechanism will only ever release the large blocks it allocated.

The default memory allocation mechanism varies by OS. You are more likely to see memory being released to the OS on Windows.

This particularly involves the monks among you who use more than one programming languages in their work. I was introduced to SAS sometime before Perl, I reached a nice level of understanding its different language structures and concepts and used to work my way through the many procedures it had to achieve something purposeful, it was nice and fun. Today I don't know if it is mastery anymore that I thought I possessed, I haven't used SAS, however, for ~4 months. Back to yesterday again, I heard of a new SAS community that holds the sort of interactions the likes of StackOverFlow, I happily joined in, and then tried to answer a simple post, to my consternation, my fingers just couldn't type and my mind stayed blank,and dude(tte) I wasn't caught in the moment and it seems like I forgot the syntax!.

What betook me then was enormous to describe, and in the inside of my mind I have been thinking about this; All the love I have for Perl, every time I check a Monk's node and find that that Monk hasn't been around here for 2 or 5 or 7 years and I'd sadly wonder, where they are and what has become of their Perl programming skills and if I would get to walk down that path ever would I forget the syntax, would it rust with length of unuse, and I feel while I am in the middle of such thoughts that it would be a darn world outside the confines of the Monastery, so I stop thinking and haste back to try to reply to a freshly submitted post or get to contemplate the Monastery.

It is a frustration to not be able to retain information after all the dedication and enthusiasm spent picking it, I don't wanna say I forgot SAS (Retrograde Forgetfulness), but I would wanna know how do you manage to transit between two disparate programming languages and how do you strive to keep abreast without sacrificing one for the other.

Would ye revered monks be caught in such a situation at times?, how would you cope to retain and compartmentalize your programming tools and how would you push the refresh button on a programming language you haven't probably used in a while in response to an immediate stimulus like the one I had yesterday and not fail like I did?

I decided to post this question here since this section is for discussions of non-programming related issues. But to tell you the truth, I really dont know if this is the right place to post this question but here it goes.

I was tasked by my superior to check the knowledge level of our developers on Perl. Previously, the developers were asked to learn Perl by self-study. Time was the only thing provided (no training). After 3 months, the developers are saying that they have learned a lot and have used it on their work. But we dont have any idea on how to gauge their knowledge gained.

Will you guys suggest on how to do this? how to gauge/check their knowledge so that we can have an idea which of our developers has potential or whom needs more training or time to learn.

We noticed that they are using perl on their work and most of their scripts are working. But how are we going to know if what they did is the best practice or the best way to do that. Note that we dont have a senior level or an experience developer to check their code.

Any suggestion, comments are welcome. And if you think that this question is not for this section, you can remove it but please tell me the section where I should post this.

Thanks in advance!