Skip to content

First reported bug for one of my CPAN modules

February 21, 2010
tags: , ,

It should invoke some trepidation when seeing the first ever reported bug hitting your inbox. However it was the complete opposite because I got a nice warm feeling about the fact that something I’ve written is being used in the wild.

Still the bug(s) needs fixing and its understandable that prolific CPAN / opensource authors may get bogged down having to find time to fix bugs in heavily used projects.

Fortunate for me I only have a few CPAN modules at this time and I doubt they’re heavily used! Even more lucky that in this case the bug was only related to testing on Windows.

So if you’ve written software then you have bugs! Thus you need a good issue tracking system to keep a handle on things. Luckily CPAN comes with its own Request Tracker (RT) from Best Practical. My first reported bug came via this last week.

You can change your CPAN module page to point to any other issue tracker should you wish this (see part about amending your meta tag and also my old post on repo link). But I’m more than happy to go with RT and there maybe good reasons for doing this because it maybe better integrated into the CPAN toolchain (my PAUSE login worked with RT).

BTW, my testing with Windows issue is the usual pathname and EOL delimiter differences. Just because it leaves your box with 100% passes it would be silly to expect it arrives at someone else’s box the same :)

/I3az/

PS. Related references:

Nearly famous on Github!

February 13, 2010
tags: ,

After reading about Tatsuhiko Miyagawa well deserved accolade for being famous on github, I thought I better check my own vanity score :)

I was a little shocked to see i am listed in San Francisco list? Though no surprises to see I’m in the bottom bunch with score of 0.0 on that list!

But i am relieved to see i do appear in the London list and indeed pretty chuffed to see i reached a respectable position of 155 with a github “social score” of 688.949686387002

Well done to Miyagawa and all those other Perl mongers who continue keep the Perl flag flying high on Github.

/I3az/

refs:

Perl and Mac OS X versions

February 3, 2010
tags: ,

Apple website has an opensource page: http://www.opensource.apple.com/, which lists all its products and components which have and use opensource technology.

If you go here: http://www.apple.com/opensource/, it provides a complete list of opensource projects that Apple uses.

In this list is of course Perl. From this we can see which version of Perl was compiled on Mac OS X. We can also see what options, patches, fixes & extra modules were included.

So I’ve been able to glean these Perl versions that Apple have used with Mac OS X:

  • 5.10.0 & 5.8.9 (perl-63)
  • 5.8.8 (perl-51 patches: perl-51.1.1, perl-51.1.4)
  • 5.8.6 (perl-38 patch: perl-38.1)
  • 5.8.6 (perl-35 patch: perl-35.1.1)
  • 5.8.4 (perl-28.2)
  • 5.8.1-RC3 (perl-25.2)
  • 5.8.1 (perl-24.1) “Maintenance release working toward v5.8.1″
  • 5.6.0 (perl-21)
  • 5.6.0 (perl-17)

Now which one(s) are tied to which Mac OS X is still in the air a bit! This is my best stab at it:

  10.6    5.10.0 & 5.8.9      perl-63
  10.5    5.8.8               perl-51
  10.4    5.8.6               perl-38 or perl-35
  10.3    5.8.4 or 5.8.1 ?
  10.2    5.8.1 ?
  10.1    5.6.0               ? perl-21 and/or perl-17
  10.0    5.6.0 ?

Hopefully this information is useful to someone

/I3az/

refs:

Mac OS X “Snow Leopard” (10.6) and Perl

January 24, 2010

Snow Leopard ships with multiple versions of Perl:

  • 5.10.0 (64 bit)
  • 5.10.0 (32 bit)
  • 5.8.9 (32 bit)

The default Perl is 5.10.0 (64 bit). However you can change this to 32-bit Perl by setting the following ENV shell variable:

export VERSIONER_PERL_PREFER_32_BIT=yes

And to switch to 5.8.9 all you need is this ENV variable set:

export VERSIONER_PERL_VERSION=5.8.9

Instead of setting these ENV variables in your Terminal sessions you can also make the change to the systems defaults:

  • defaults write com.apple.versioner.perl Prefer-32-Bit -bool yes
  • defaults write com.apple.versioner.perl Version 5.8.9

This is a interesting move by Apple and something which may come in very handy in the future.

As it stands at this moment though you probably want 5.10.1 (and beyond) because of issues with 5.10.0. So you will probably be looking down the compiling route anyway. Still it does give the future option of a local::lib possibility with the pre-installed Perl provided by Apple.

NB. I always recommend that you avoid installing modules with CPAN (shell) on OS provided Perl. Always stick to the OS provided package installer to update Perl & modules (which unfortunately for Mac’s means “zilch” :( Apple “Software Updater” may update Perl itself but no extra modules are provided above what Apple provides on top of core Perl)

/I3az/

References:

Anyone for Perl 6 metaprogramming?

January 14, 2010

My last post about the Metaprogramming: Ruby vs. Javascript blog post stirred a little thought in my head:

How would it look in Perl 6?

Well here goes, the complete example written in Perl 6 which runs on Rakudo, an implementation of the Perl 6 spec on the Parrot VM:

use v6;

class Ninja {
    has Str $.name is rw;
}

my Ninja $drew .= new( name => 'Drew' );
my Ninja $adam .= new( name => 'Adam' );


###########################################################
# Reopen Ninja class ("is also" does the biz) 
# and add 'battle_cry' method

class Ninja is also {    
    method battle_cry {
        say $.name ~ ' says zing!!!'; 
    }
}

$drew.battle_cry;   # => Drew says zing!!!
$adam.battle_cry;   # => Adam says zing!!!


###########################################################
# add 'throw_star' method to $drew object by creating
# and applying ("does") role to it (Singleton method)

role ThrowStar {
    method throw_star { say "throwing star" }
}

$drew does ThrowStar;
$drew.throw_star;     # => throwing a star


###########################################################
# call method dynamically: $obj.'method_name' or $obj.$method

$drew.'battle_cry';     # => Drew says zing!!!


###########################################################
# add "colour" method closing over $colour_name (ie. closure):

my $colour_name = 'black';

class Ninja is also {
    method colour { say "{$.name}'s colour is {$colour_name} " }
}

$drew.colour;    # => Drew's colour is black
$adam.colour;    # => Adam's colour is black


###########################################################

# "defining a method dynamically on an instance that closes 
# over local scope and accesses the instance’s state"

my $sword_symbol = '********';

$drew.^add_method( 'swing', method ( Str $sound_effect ) { 
    say "{$.name}: {$sword_symbol} {$sound_effect}";
});

$drew.swing( 'slash!!' );    # => Drew: ********* slash!!

Of all the examples (in Perl 5 / Moose, Ruby, Javascript & Python) I think this one is the most clean and intuitive. Perl 6 has a good future if it keeps this up!

And it all went surprising smoothly. There were a couple of bumps in my Perl 6 road but these are all connected to the flux between the Perl 6 spec, Rakudo and knowing what info you find on the web is still accurate (or not).

First bump was how to re-open a class. Most Perl 6 documentation implied that classes were always open (unless is final was used). This no longer seemed to be the case and it gave examples of class A is augmented { ... }. However this didn’t work in Rakudo but eventually I came across is also which did.

I like the look of class A is also { ... }. However Moritz on IRC #perl6 mentioned that the Perl 6 spec had changed so my example would need to be:

augment class Ninja {    
    method battle_cry {
        say $.name ~ ' says zing!!!'; 
    }
}

Rakudo is currently a bit behind Perl 6 spec here but above will replace is also shortly. The change to augment makes sense because it avoids any confusion with roles in the class declaration.

The second bump was how to create a method dynamically. Now being familiar with Moose I had expected the following to work:

Ninja.meta.add_method( 'swing', method ( Str $sound_effect ) { 
    say "{$.name}: {$sword_symbol} {$sound_effect}";
});

And according to most Perl 6 docs .meta was the method to access the metaclass (MOP). However meta produced a method not defined error :(

Trawling the web further I did find that you could do:

Ninja.swing = method { say "Changed to zing" };

But this only allowed you to redefine a method, not create a new one.

Luckily IRC #perl6 came to the rescue again! jnthn & Moritz pointed me to $object.^add_method( ... ) and the docs on the ng branch of Rakudo on Github.

Perl6 does have some beautiful syntax. I love the $drew does Throwstar line. Soon Rakudo will be able to do:

$drew does role {
    method throw_star { say "throwing star" }
};

So this, augment and probably lots more will be part of the ng branch which will be merged with the Rakudo master in the not too distant future.

/I3az/

Anyone for metaprogramming?

January 13, 2010

What is metaprogramming? Well this question caused a heated discussion on Hacker News yesterday.

I personally would describe that metaprogramming provides the ability to:

transform programs with programs

and leave it at that!

The article that stirred the metaprogramming pot was Metaprogramming: Ruby vs. Javascript. This actually is a good post and it helped fill in a few holes in my “fragile” Javascript knowledge.

Luckily I believe my Perl is a bit less fragile!, so I thought I would convert the metaprogramming examples into Perl & Moose.

So following the blogs examples, below defines the Ninja class in Moose. MooseX::SingletonMethod loads Moose with a bit of singleton method sugar.

use Modern::Perl;

{
    package Ninja;
    use MooseX::SingletonMethod;
    use namespace::clean -except => 'meta';
    
    has name => ( is => 'rw', isa => 'Str' );
}

my $drew = Ninja->new( name => 'Drew' );
my $adam = Ninja->new( name => 'Adam' );

NB. namespace::clean stops the Moose sugar percolating into Ninja class (except meta… which is the Meta Object Protocol method… which handy for metaprogramming!).

Now we re-open the Ninja class and add battle_cry method like so:

{
    package Ninja;
    
    sub battle_cry {
        my $self = shift;
        say $self->name . ' says zing!!!'; 
    }
}

$drew->battle_cry;   # => Drew says zing!!!
$adam->battle_cry;   # => Adam says zing!!!

Now using MooseX::SingletonMethod we add throw_star singleton method into $drew object:

$drew->add_singleton_method( throw_star => sub {
    say "throwing star";
});

$drew->throw_star;   # => throwing a star

To call method dynamically we do this:

$drew->${ \'battle_cry' };   # => Drew says zing!!!

Create colour method closing over $colour_name (ie. closure):

my $colour_name = 'black';

Ninja->meta->add_method( colour => sub {
    my $self = shift;
    say "${ \$self->name }'s colour is $colour_name";
});

$drew->colour;    # => Drew's colour is black
$adam->colour;    # => Adam's colour is black

Finally… “defining a method dynamically on an instance that closes over local scope and accesses the instance’s state”

my $sword_symbol = '********';

$drew->add_singleton_method( swing => sub {
    my ($self, $sound_effect) = @_;
    say "${ \$self->name }: $sword_symbol $sound_effect";
});

$drew->swing( 'slash!!' );   # => Drew: ********* slash!!

Everything nicely works the same as the Ruby & Javascript blog examples.

To round things off, below is the complete example but with MooseX::Declare sugar stirred into the pot.

use Modern::Perl;
use MooseX::Declare;

class Ninja with MooseX::SingletonMethod::Role is mutable {
    has name => ( is => 'rw', isa => 'Str' );
}

my $drew = Ninja->new( name => 'Drew' );
my $adam = Ninja->new( name => 'Adam' );

###########################################################

class Ninja is mutable {    
    method battle_cry {
        say $self->name . ' says zing!!!'; 
    }
}

$drew->battle_cry;   # => Drew says zing!!!
$adam->battle_cry;   # => Adam says zing!!!

###########################################################

$drew->add_singleton_method( throw_star => sub {
    say "throwing star";
});

$drew->throw_star;   # => throwing a star

###########################################################

$drew->${ \'battle_cry' };   # => Drew says zing!!!

###########################################################

my $colour_name = 'black';

Ninja->meta->add_method( colour => sub {
    my $self = shift;
    say "${ \$self->name }'s colour is $colour_name";
});

$drew->colour;    # => Drew's colour is black
$adam->colour;    # => Adam's colour is black

###########################################################

my $sword_symbol = '********';

$drew->add_singleton_method( swing => sub {
    my ($self, $sound_effect) = @_;
    say "${ \$self->name }: $sword_symbol $sound_effect";
});

$drew->swing( 'slash!!' );   # => Drew: ********* slash!!

/I3az/

PS. If you want Moose in Javascript then have a look at Joose

Receiving contributions to your Github project

January 4, 2010
tags: , ,

Received my first ever contribution to one of my Github projects today. A pull request from a cpanservice? And I wasn’t the only one or was wondering who this cpanservice is or was?

I suspect that this as something to do with the recent gitPAN upload to Github and therefore is probably some automated service that is going through related projects making sure that Github CPAN projects do have the meta repository tag populated in the build process.

NB. I blogged about this repository link back in May but forgot to put my changes live. *blush*

This contribution was the necessary nudge I needed to find out how to use git to merge in external changes. Github itself did seem to provide a web option to apply this change directly under “Fork Queue”. However I wanted to do it all via git so first place I looked is the Github documention on pull requests.

My local directory was up-to-date so I just needed to do the following to pull & merge into my code:

  • git pull git://github.com/cpanservice/builder.git master

All merged and committed (see PS). Quick check of diffs & logs and then just needed to populate it back to Github:

  • git push origin master

You will see cpanservice changes immediately in the commits. However the Github graphs and fork queue take a little while to be updated to show the merge.

/I3az/

 

PS. The merged cpanservice changes showed up under me in the network graph (see red line below) despite showing up correctly under commits.

github-builder-graph

I think this is because I merge changes locally and then pushed back to Github? Its not an issue for these cpanservice changes but I would like to get it right for “proper” contributors.

So I think the alternate merge example documented by Github might be the better approach?

git remote add defunkt git://github.com/defunkt/grit.git
git fetch defunkt
git merge defunkt/master

Follow

Get every new post delivered to your Inbox.