Ranguard's Friends' Journals

Finally, some Test::Builder2 examples!

schwern — 2010-09-09T08:33:42+00:00

For my PDX.pm presentation tonight on Test::Builder2 I threw together some quick examples of some of its killer features, in particular demonstrating changing how Test::Builder2 behaves using method modifiers and applying object roles.

First, demonstrating end-of-assert actions, there's die on fail but even cooler is DEBUG on fail! That's right, run your test in the debugger and have it automatically set a breakpoint on a failure. How cool is that?

I'm sure somebody with better debugger foo than I can make it even cooler and stop at the top of the assert stack rather than inside DebugOnFail.

The second is reimplementing Test::NoWarnings safely. TB2::NoWarnings demonstrates hooking into the start and end of the test as well as safely altering the number of tests planned by trapping the call to set_plan.

You can safely use them all together, though its a crap shoot if DebugOnFail or DieOnFail will trigger first.

While roles and method modifiers are relatively new to the Perl community, using them in lieu of designing my own event system for TB2 has two great advantages. First, I didn't have to design and debug my own event system. :) Second, rather than having to learn the quirks of a one-off system, you learn the quirks of Mo[uo]se and then can apply that knowledge all over the place.

There's a pile of stuff to be done in TB2, a lot of them are fairly small and self contained. Have a look. Patches welcome.

Test::Builder2 at 10k Feet

schwern — 2010-09-09T08:15:22+00:00

Here's a diagram of the "flow" of assert results through Test::Builder version 1.

.-------. | foo.t | '-------' | | .-------------. | .----------------. | Test::More |<--------->| Test::Whatever | '-------------' '----------------' | | | | | | | .---------------. | '---->| Test::Builder |<----' '---------------' | v .-----. | TAP | '-----' | v .---------------. | Test::Harness | '---------------'

You write foo.t using Test::More and Test::Whatever. These both
use the same Test::Builder object. It spits out TAP which
Test::Harness converts into something human readable.

The big problem there is Test::Builder is monolithic. There's no
further breakdown of responsibilities. It only spits out TAP, and
only one version of TAP.

Here's what Test::Builder2 looks like:

.-------. .----------------| foo.t |-------------------. | '-------' | | | | | | | v v v .------------. .----------------. .------------------. | Test::More | | Test::Whatever | | Test::NotUpdated | '------------' '----------------' '------------------' | | | | v v | .----------------. .---------------. '---------->| Test::Builder2 |<------| Test::Builder | '----------------' '---------------' | v .--------------. .-------------. | TB2::History |<---| TB2::Result | '--------------' '-------------' | | .--------------------------. | .---------------------. | TB2::Formatter::TAP::v13 |<-----'------>| TB2::Formatter::GUI | '--------------------------' '---------------------' | | v | .-------------------------------. | | TB2::Formatter::Streamer::TAP | | '-------------------------------' | | | v | .-----. | | TAP | | '-----' | | | v v .---------------. .-----------------. | Test::Harness | | Pretty Pictures | '---------------' '-----------------'

It starts out the same, foo.t uses a bunch of test modules
including Test::More and Test::Whatever using the same Test::Builder2
object, but it also uses Test::NotUpdated which is still using
Test::Builder. That's ok because Test::Builder has been rewritten in
terms of Test::Builder2 (more on that below).

Test::Builder2, rather than being a monolith, produces a
Test::Builder2::Result object for each assert run. This gets stored
in a Test::Builder2::History object for possible later use. It also
gets handed to a Test::Builder2::Formatter object, the default is
Test::Builder2::TAP::v13 which produces TAP version 13. This is fed
to a Streamer that prints it to STDOUT and STDERR which is read by
Test::Harness and made human readable.

Because Test::Builder2 is not monolithic, you can swap out parts. For
example, instead of outputting TAP it could instead hand results to a
formatter that produced a simple GUI representation, maybe a green
bar, or something that hooks into a larger GUI. Or maybe one that
produces JUnit XML.

Here's how Test::Builder and Test::Builder2 Relate.

.-----. .-----. | TB2 | | TB1 | '-----' '-----' | | | | | | | | v v .-------------. .--------------. .-------------. | TB2::Result |------->| TB2::History |<--------| TB2::Result | '-------------' '--------------' '-------------' | | | | | | | .----------------. | '------------->| TB2::Formatter |<--------------' '----------------' | v .--------. | Output | '--------'

Test::Builder and Test::Builder2 coordinate their actions by sharing
the same History and Formatter objects. If you call TB1->ok() it
produces a Result object which it hands to the History singleton and
the Formatter singleton. If you call TB2->ok() it produces a Result
object which it hands to the same History and Formatter objects.

This allows most of the Test::Builder code to remain the same while
still coordinating with Test::Builder2. It also allows radically
different builders to be made without Test::Builder2 dictating how
they're to work.

The downside is that roles applied to Test::Builder2 will not effect
Test::Builder. Because of this, Test::Builder may become more closely
coupled with Test::Builder2 in the future.

Diagrams by App::Asciio.

A month of Test::Builder2

schwern — 2010-08-28T04:08:39+00:00

I've had a grant open for Test::Builder2 for, oh god over two years now. Since I started it, Perl 6 has had a release! I think its the second oldest running dev grant.

I've cleared the decks of other responsibilities and can dedicate September to, if not finishing, then at least releasing something people can poke at. First alpha release was supposed to be "two weeks after the start" ha ha ha! oh god. The design has evolved and simplified greatly in the intervening two years, but its time to get something the hell out the door. At least a Test::Builder2 Star if you will.

There's critical components missing. There's no diagnostics, YAML or otherwise. The issues with nested asserts are still congealing. Plans are not enforced. Result objects are in the middle of being remodeled... again. But Test::Builder is using what parts of Test::Builder2 are usable. Multiple output formats and streams work. Asserts can be nested in the common, simple cases without having to fiddle with $Level. And you can hook into various events.

Step one is I'm going to seal up what's there, write docs where they're missing, and release something.

A release before October or the grant dies.

Alien::SVN - new release, new management

schwern — 2010-08-18T22:33:29+00:00

Those of you still stuck using Subversion will be happy to find a new release of Alien::SVN. It drags it forward to 1.6.12, doesn't do much else.

Also, Alien::SVN has finally found a new manager! From out of the blue comes Matthew Lanier with a patch and the will and a PAUSE ID. He'll be taking care of things from now on. Its his first CPAN module, be gentle. Godspeed, Matthew.

Eek! I wrote some Perl!

Kake — 2010-08-16T09:54:56+00:00

I haven't written any Perl in a long time, but some fell out yesterday so I thought I'd mention it here. It's to do with Chinese text, specifically ways to grep in a traditional-simplified-insensitive way. More details on my regular blog. (Comments are enabled here, but preferred there — you can use OpenID or just sign your name so I know who you are.)

Test::Builder2::Design

schwern — 2010-08-10T02:31:05+00:00

In an effort to shed some light on what Test::Builder2 is about, I took a few hours and performed a brain dump about its goals and design. You can see the result in the new Test::Builder2::Design document.

The key design goals are 1) that it has to work, 2) that it has to work everywhere and 3) that it has to test everything. This throws out a lot of 98% solutions.

Method::Signatures returns! 5.12, func() and fast!

schwern — 2010-07-31T00:49:55+00:00

Chip submitted a minor performance patch to Method::Signatures today. That drove me to push out a new release making it friendly to 5.12 and adding func() for non methods!

func hello(:$greeting = "Hello", :$place = "World") {
print "$greeting, $place!\n";
}

hello( place => "Earth" );

For those who don't know, one of the neato features of Method::Signatures is that it can alias references to make working with references less of a trial:

func popn(\@array, $howmany) {
return splice @array, -$howmany;
}

my @stuff = (1,2,3,4,5);
my @last_three = popn(\@stuff, 3); # 3,4,5
print @last_three;

It does this with the amazing Data::Alias module. Unfortunately, 5.12 broke its black magic and its non-trivial to fix. Method::Signatures now makes Devel::Alias an optional dependency. If its available, it'll use it. Otherwise, no aliasing for you.

But that's ok, because perl5i makes working with references enjoyable. And while perl5i is adding its own simple signatures, they're forward compatible with Method::Signatures! They play together, so if you want perl5i and the full power of Method::Signatures you can have them.

use perl5i::2;
use Method::Signatures;

func echo($message is ro) {
say $message;
}

Just make sure you load MS after perl5i. The last one loaded wins.

Finally, I was comparing Method::Signatures with MooseX::Method::Signatures and made a disturbing discovery. I always new MooseX::Method::Signatures would have a performance penalty, it does more checks than Method::Signatures, I just didn't realize how bad it was.

Here's comparing an empty signature: method foo() {}.

Rate MMS MS Std MMS 3207/s -- -100% -100% MS 1498875/s 46644% -- -1% Std 1508351/s 46940% 1% --

That's showing MooseX::Method::Signatures is 450x slower than either Method::Signatures or a normal method call creaking out a mere 3500 method calls per second as compared to the 1.5 million it should be doing. And that's for a method with an empty signature!

To be clear, that's the speed of calling a method, not compiling them.

Here's one comparing a simple signature that requires a check, so MS can't optimize it away: method foo($arg!) { return $arg + 1 } That's a required positional argument.

Rate MMS MS Std MMS 2928/s -- -100% -100% MS 983127/s 33481% -- -2% Std 1005357/s 34240% 2% --

3000 method calls instead of a million.

Now I'm the first to counter arguments bemoaning method call overhead. Usually it doesn't matter. Usually the extra cost of calling a method and checking arguments is insignificant compared to what that method actually does. And MooseX::Method::Signatures has features Method::Signatures does not, most significantly type checking. But my god! Three orders of magnitude of performance lost! And its not even using the extra MMS features. That's just too much.

Perl 6 Is The Language Your Language Could Smell Like

schwern — 2010-07-29T19:24:09+00:00

Hello programmers. Look at your code, now at Perl 6, now back at your code, now back at Perl 6! Sadly, your code is not written in Perl 6. But if you use Rakudo Star then Perl 6 is the language your code could be written in!

Now Microsoft scented!

"def" or "func"?

schwern — 2010-07-13T00:06:57+00:00

perl5i 2.3.0_01 now has basic methods and subroutine signatures with code basically lifted straight from Method::Signatures::Simple. MooseX::Declare got me addicted, now I want them everywhere.

use perl5i::2; def add($this, $that) { return $this + $that; } method new($class: %args) { return bless \%args, $class; } my $echo = def($arg) { return $arg };

Its alpha for two reasons. First, I don't have time right now to really thoroughly test it, but I really want it.

Second, overriding "sub" is hard. Its been done but its a bit twitchy. Defining a new keyword is easy(er). So what should that keyword be? I've come up with two that have good arguments. "def" and "func". Both are short. "def" has the benefit of being used by other programming languages a Perl programmer is likely to encounter and not hate (Python, Ruby, Scala, Groovy). "func" is nice because it pretty clearly means "function" whereas "define" is a bit ambiguous.

perl5i currently does both. Only one will survive in version 3 (the other will be deprecated). Before you comment on which is your favorite, try it for a little bit. I found a difference between what I thought I like and what I actually use.

Announcing CPAN Testers 2.0

barbie — 2010-07-05T09:50:22+00:00

After 6 months of development work, following 2 years worth of design and preparation, CPAN Testers 2.0 is finally live.

With the rapid growth in CPAN Testers environments and testers over the past few years, the previous method of posting reports to a mailing list had reached a point where the scalability was no longer viable. This was recognised several years ago and discussions for a new system had already begun, with the view that reports should be submitted via HTTP.

At the Oslo QA Hackathon in 2008, David Golden and Ricardo Signes devised the Metabase, with the design work continuing at the Birmingham QA Hackathon in 2009, where David and Ricardo were able to bring others into the thought process to work through potential issues and begin initial coding. A number of releases to CPAN and Github followed, with more people taking an interest in the project.

The Metabase itself is a database framework and web API to store and search opinions from anyone about anything. In the terminology of Metabase, Users store Facts about Resources. In the Metabase world, each CPAN tester is a User. The Resource is a CPAN distribution. The Fact is the test report. Today that’s just the text of the email message, but in the future it will be structured data. The Metabase specifies data storage capabilities, but the actual database storage is pluggable, from flat files to relational databases to cloud services, which gives CPAN Testers more flexibility to evolve or scale over time.

Meanwhile the CPAN Testers community was also attracting more and more interest from people wanting to be testers themselves. As a consequence the volume of reports submitted increased each month, to the point that the perl.org mail server was struggling to deal with all the mailing lists it hosted. The cpan-testers mailing list was submitting more posts in one day than any other list submitted in a month (in a year in some cases). Robert and Ask, very reasonably, asked if the testers could throttle their submissions down to 5k report posts a day, and set a deadline of 1st March 2010 to switch off the mailing list.

David Golden quickly took on the task to envisage a project plan, and work began in earnest in December 2009. With less than 3 months to the cut-off date, there was a lot of work to do. David concentrated on the Metabase, with Barbie working on ensuring that the current cpanstats database and related websites could move to the Metabase style of reports. Despite a lot of hard work from a lot of people, we unfortunately missed the 1st March deadline. Having throttled report submissions to a more manageable level, and although not complete, the target for HTTP submissions was in sight, Robert and Ask were very understanding and agreed to keep us going a little while longer.

Throughout March and April a small group of beta testers were asked to fire their submissions at the new system. It ironed out many wrinkles and resulted in a better understanding of what we wanted to achieve. The first attempts at retrieving the reports from the Metabase into the cpanstats database began in April, and again highlighted further wrinkles that needed to be addressed. After a month of hard testing and refinement, we finally had working code that went from report submission by a tester, storage into the Metabase, retrieval into the cpanstats database and finally presentation on the CPAN Testers family of websites.

During June the process was silently switched from testing to live, allowing reports to be fed through into the live websites. Due to the ease with which the new style reporting fit into the existing system, the switch largely went unnoticed by the CPAN testers community as well as the Perl community. A considerable success.

The CPAN Testers eco-system is now considerably larger than those early days of simply submitting handwritten reports by email to a mailing list, and the work to get here has featured a cast of thousands. Specifically for CPAN Testers 2.0, the following people have contributed code, ideas and effort to the project over the past six months:

Andreas König
Apocalypse
Ask Bjørn Hansen
Barbie
Chris Williams
Dan Collins
David Cantrell
David Golden
Florian Ragwitz
H.Merijn Brand
Jon Allen
Lars Dɪᴇᴄᴋᴏᴡ 迪拉斯
Léon Brocard
MW487
Nigel Horne
Ricardo Signes
Richard Dawe
Robert Spier
Serguei Trouchelle
Shlomi Fish
Slaven Rezić

Barbie and David would like to thank everyone for their involvement. Without these guys CPAN Testers 2.0 would not have been possible. Thanks to everyone, we can now look forward to another 10 years and more of CPAN Testers.

CPAN Testers now holds over 7.5 million test reports covering nearly 11 years worth of testing Perl distributions. There have been over 1,000 testers in that time, and every single one has helped the CPAN Testers project to be the largest single community supported testing system of any programming language. For a full list of everyone who has contributed, visit the CPAN Testers Leaderboard. A huge thank you to everyone.

With the Metabase now online and live, we can now announce an absolute deadline to close the mailing list. This is currently set as 31st August 2010. After this date all submissions via email will be rejected, and testers will be encouraged to upgrade their testing tools to take advantage of the new HTTP submission system. Many of the high volume testers have already moved to the new system, and we expect nearly everyone else to move in the next month. We will be tailing the SMTP submissions to catch those who haven't switched, such as some of the more infrequent testers, and warn them of the deadline.

More work is planned for CPAN Testers, from further validation and administration of reports, to providing more functionality for alternative analysis and search capabilities. Please check the CPAN Testers Blog for our regular updates.

If you'd like to become a CPAN Tester, please check the CPAN Testers Wiki for details about setting up a smoke testing environment, and join the cpan-testers-discuss mailing list where many of the key members of the project can offer help and advice.

You can find out more about CPAN Testers at two forthcoming conferences. David Golden will be presenting "Free QA! What FOSS can Learn from CPAN Testers" at OSCON and Barbie will be presenting "CPAN Testers 2.0 : I love it when a plan comes together" at YAPC::Europe.

CPAN Testers is sponsored by Birmingham Perl Mongers, and supported by the Perl community.

You can now download the full and complete Press Release from the CPAN Testers Blog. If you have access to further IT news reporting services, please feel free to submit the Press Release to them. Please let us know if you are successful it getting it published.

Cross-posted from the CPAN Testers Blog

Where The Hell Is Test::Builder2?

schwern — 2010-06-27T19:16:09+00:00

My progress and communication about the Test::Builder2 grant has been nothing short of appalling. There is a sort of herky-jerky progress where I figure out a design problem, push the code forward, then remember a use-case that throws a wrench in the whole design and the whole thing comes to a screeching halt again.

At the QA hackathon we elegantly solved the problem of things like die-on-fail and Test::NoWarnings but then ran afoul of things like Test::Warn and Test::Exception which runs tests inside of tests but those aren't actually part of the test stack.

Confused? I'll post more about it another time. Point is, TB2 continues to move forward, its just that there's long periods of rumination between sprints of development. And I get distracted by other projects. At this rate I'll be collecting Social Security before I collect the second half of the grant. I really want TB2 to happen, but something decisive has to be done. I work best with hard deadlines, so the plan is to clear a month for working mostly on TB2. A lot of the wibbling is trying to come up with the most elegant solution, but I usually have a less than elegant way to solve it and move forward. If its between an elegant TB2 that doesn't exist and a less elegant TB2 that does, well, go with the one that exists. With the way my schedule is looking, that will probably be mid-August to mid-September. If that doesn't produce an alpha, then I'll kill the grant.

That doesn't mean TPF gets nothing for your money. Chunks of TB2 can be harvested to improve TB1. Specifically, the TB2 formatting and history objects. The TB2 formatter makes the guts of TB1 cleaner, and it also allows it to produce something other than TAP. Used together, history and formatter allows non-Test::Builder based test frameworks to work together with Test::Builder providing even more flexibility. This is already done in the TB2 branch.

Looking at the grant deliverables, most of it is done:

* Split up global shared Test resources into individual objects * The test counter * The output filehandles * The plan * Allow hooks for global beginning and end of test functions. * Ensure multiple hooks "stack" * die on fail * debug on fail * Hooks for global beginning and end of test actions * Example: A safer Test::NoWarnings * Example: Don't cleanup temp files on failure so they can be debugged * Allow for test output other than TAP * Allow another Test::Builder-like module to work in the same process as Test::Builder (for example, sharing the counter). * Rewrite Test::Builder in terms of Test::Builder2.

Here's what's not complete:

* Split up localizable behaviors into objects * Allow individual test modules to locally override Test::Builder2 behaviors * Allow test modules to globally override Test::Builder2 behaviors * How the plan works

Since I'm not writing to the letter of the law, there's more than that to be done before release, but the project does move.

The Post-YAPC Plan

schwern — 2010-06-27T18:34:30+00:00

I spent most of YAPC::NA mildly sick, sleep deprived and writing talks. Each of those things alone isn't so bad, but put all together meant I had time and energy enough to do my talks, discuss with people after, and that's about it. As a result, I was kind of dead in the head most of the time and didn't do a whole lot of interaction with people. I didn't feel like I got the most out of the one opportunity a year I get to hang out with huge gobs of Perl folk.

One of the things which I wanted to do at YAPC was get gitpan restarted. It can run right now, but the code is a mess and needs to be babied. It needs a rewrite. That rewrite was supposed to happen at YAPC but see above. I'm doing that now, using MooseX::Declare, perl5i and Path::Class just to mess around with them seriously. Also log4perl, which I'm finally learning a decade late. Its fun, far more pleasant than knocking it together without, once you learn to cope with Moose's idiosyncrasies. Better to learn the quirks of one complete system than nine incomplete ones.

That's what's absorbing my time right now. After that I want to add subroutine signatures to perl5i and the über file and directory objects. They were supposed to be in, at least as a prototype, by YAPC but that didn't work out. Using MooseX::Declare, Path::Class and perl5i together has me drooling for them.

Will Coleda, representing the TPF, found me at YAPC and mercifully did not break my legs. We hashed out a plan to make a last stab at Test::Builder2 before calling the grant done. That's not going to happen until August, I'll post about that later.

Oh, and I have a talk to do at OSCON about how the world is going to end in 2038 assuming 2012 doesn't claim the prize first. And a two part Git tutorial for Drupal programmers that I'm developing into a commercial class. And two paid clients to keep happy.

One thing I *don't* have to worry about is MakeMaker. Gird your loins, MakeMaker has provisionally been handed off to Matt Trout. Maybe I need to worry about it more...

Birmingham.pm Technical Meeting - Wednesday 26th May 2010

barbie — 2010-05-24T19:26:06+00:00


Event:   Birmingham.pm Technical Meeting

Date:    Wednesday 26th May 2010

Times:   from 7pm onwards (see below)

Venue:   The Victoria, 48 John Bright Street, Birmingham, B1 1BN.

Details: http://birmingham.pm.org/tech/next

Talks:

Accelerated web development with Catalyst [Richard Wallman]
CPAN Testers 2.0 - "I love it when a plan comes together" [Barbie]

Details

This month we welcome a returning guest speaker, Richard Wallman, who will be taking a look at how Catalyst has eased the development lifcycle of websites, from his own experiences. In addition I'll be looking at the progress of the CPAN Testers 2.0, and looking at some of the near future plans for CPAN Testers.

As per usual, this month's technical meeting will be upstairs at The Victoria. The pub is on the corner of John Bright Street and Beak Street, between the old entrance to the Alexandra Theatre and the backstage entrance. If in doubt, the main entrance to the Theatre is on the inner ring road, near the Pagoda roundabout. The pub is on the road immediately behind the main entrance. See the map link on the website if you're stuck.

As always entry is free, with no knowledge of Perl required. We'd be delighted to have you along, so feel free to invite family, friends and colleagues ;)

Some of us should be at the venue from about 7.00pm, usually in the backroom downstairs. Order food as you get there, and we'll aim to begin talks at about 8pm. I expect talks to finish by 9.30pm, with plenty of time for discussion in the bar downstairs.

Venue & Directions:

The Victoria, 48 John Bright Street, Birmingham, B1 1BN
- Pub Details
- Picture
- Google Map

The venue is approximately 5-10 minutes walk from New Street station, and about the same from the city centre. On street car parking is available see full details and directions on the website.

Times:

These are the rough times for the evening:

food available until 9.00pm
talks: 8.00-10.00pm
pub closes: 11.00pm

Please note that beer will be consumed during all the above sessions ;)

Object::ID - A unique object identifier for any object

schwern — 2010-05-02T17:17:01+00:00

Something Perl's OO has been missing has been a reliable way to identify an object. Is $this the same as $that? Not asking if it contains the same information, but is it a referent to the same object? Have we seen it before? When I alter $this will I also be changing $that?

package Foo; use Object::ID; ...write the class however you want...

Really, HOWEVER YOU WANT! Inside out, outside in, code refs, regexes, globs, Moose, Mouse... Call the constructor whatever you like, add in a DESTROY method. Doesn't matter, it'll work.

my $id = $obj->object_id; my $uuid = $obj->object_uuid;

object_id() is a cheap, process-specific identifier. object_uuid() is a bit more expensive on first call (it has to generate the UUID, about 30% slower) but it should be universally unique across machines and processes.

That's great for YOUR objects, but what about everyone else? You can either inject the Object::ID role one class at a time...

package DateTime; use Object::ID; my $date = DateTime->now; say $date->object_id;

or you can load UNIVERSAL::Object::ID and every object has it. EVERY OBJECT! Even things you don't realize are objects.

use UNIVERSAL::Object::ID; # Regexes are objects say qr/foo/->object_id; # Loading IO::Handle turns all filehandles into objects use IO::Handle; open my $fh, "foo/bar"; say $fh->object_id;

But OH GOD UNIVERSAL! Well, use at your own risk. Its handy to use in your own programs and private libraries. Or you can use Method::Lexical and apply it lexically.

Why not just use the object's reference address? Well, as people implementing inside-out objects discovered, they're not unique. They're not thread safe, and worse they're not even unique for the life of the process. Perl will reuse the reference of a destroyed object. Observe:

{ package Foo; sub new { my $class = shift; return bless {}, $class; } } for(1..3) { my $obj = Foo->new; print "Object's reference is $obj\n"; }

Run that and you should get the same reference, three times, for three different objects.

And then there's the problem of string overloaded objects. You have to be careful to always use Scalar::Util::refaddr or overload::StrVal.

It turns out inside-out objects have nearly the same problem, and 5.10.0 introduced field hashes to solve that. rjbs explains the pain of all this at slide 120 in his excellent 5.10 For People Who Aren't Totally Insane. You can read the gory details of field hashes but it comes down to this: in 5.10 you can A) get a process unique, thread safe identifier for an object and B) you can store it in hash such that it gets destroyed when the object is destroyed. Perfect!

Because of this, if you look inside Object::ID you'll see there's not a lot to it. It makes a field hash to store the IDs in, a state variable to hold an ID counter, and then just accesses the field hash.

use Hash::Util::FieldHash qw(fieldhash); fieldhash(my %IDs); sub object_id { my $self = shift; state $last_id = "a"; return $IDs{$self} //= ++$last_id; }

No scary black magic (beyond what's inside fieldhash). Its so simple, which is why it works with everything.

Now, I didn't come up with this implementation. I just laid out the requirements and Vincent Pit filled in the blanks. I was only vaguely aware of field hashes, Vincent made the connection. Thank you VPIT!

Practical applications? Honestly, I'm not sure. I needed it as a shortcut for expensive object equality checks in perl5i. Maybe some of the OO theorists out there can fill this part in. Let me know what you might use it for.

Possible extensions? Well... with some tweaking Object::ID can be used as a universal object registry. Not only can you ask "does the object associated with this ID still exist" but field hashes provide the ability to get the object associated with an ID. It would only work on objects that have had their ID asked of them, and thus registered with the field hash, but how else would you have the ID? Is this useful? Is this a security hole? I dunno, but it would be easy.

OMG UNICORNIFY::URL!!! <3

schwern — 2010-04-01T22:51:34+00:00

OMG! A UNICORN PONY FOR MEEEE!!!

You can get 1 2 wth Unicornify::URL!! Here's a program to do it at the command line.

use Acme::Pony; bUf Fybuf FyBuFFYbU FfyBUFfYbUff YBuffybuFfyBuF fYbUffYBUfFYbUff YbUFfYBuffYBuFFYBu FFybUffYBUffYBUfFYb UffYbUFfyBUffYBuFfyB UFFybUfFYBuffYbUFF ybUfFyBuFfyBufFy BuffYBufFyBUfFYB uffY bUffybuffyBUFfyBuf FYBuFfy BuFFybUFFyBUffyBuFFYbuffybUf fYbUfFYBu fFYB uFFyBufFyBUfFYbufFYbUFFYbUFfyBufFYBufFYBu FFyBufFyBUffYBufFYbUffYBUFfYBUFFyBuFfYbUFFybUffYBU ffyBU fFYbuffYbUffybuffYbuFfYbuFFyBuFFyBUfFybufFYbUf fYbUF fybUFfYBuffybuFfyBuFFYBuffYBUFFybuffybUffYBu fFYBuf fyBuFFyBufFyBUffYBufFYbufFyBUFfybUFfYbuffyb uFfyB UffYBUfFybUfFYbuFfYBUFfYbUffYBuffybuFf yBuFFY BuffYBUFFybuffybUffYbufFYb ufFyb UFfybufFYBuffybufFyb UffYb UffybUFfY buffybuF fybUf fyBuffy BUFfYbuF FYbUF fyBuffYbuFFyBUFf ybUf Fybu ffYb UffybuF fYbu ffYB UFFy BuFFYB UfFy BuF fybU ffYB Uff Ybu fFyb uFf YBUF F yBuFFYBUfFy

<3 k thx bye!!1!11!!!

Some Facts About Schwern

schwern — 2010-03-26T03:45:05+00:00

Open Source Bridge requested that I improve my bio, so I decided to share some facts about myself...

Schwern has a copy of Perl 6, he lets Larry Wall borrow it and take notes.
Schwern once sneezed into a microphone and the text-to-speech conversion was a regex that turns crap into gold.
Damian Conway and Schwern once had an arm wrestling contest. The superposition still hasn’t collapsed.
Schwern was the keynote speaker at the first YAPC::Mars.
When Schwern runs a smoke test, the fire department is notified.
Dan Brown analyzed a JAPH Schwern wrote and discovered it contained the Bible.
Schwern writes Perl code that writes Makefiles that write shell scripts on VMS.
Schwern does not commit to master, master commits to Schwern.
SETI broadcast some of Schwern’s Perl code into space. 8 years later they got a reply thanking them for the improved hyper drive plans.
Schwern once accidentally typed “git pull —hard” and dragged Github’s server room 10 miles.
There are no free namespaces on CPAN, there are just modules Schwern has not written yet.
Perl's threads are implemented with a single strand of Schwern's hair.
"Schwern" cmp "Chuck Norris" will cause Perl to segfault rather than try to compare them.
Schwern’s tears are said to cure cancer, unfortunately his Perl code gives it right back.

The Basic Unit of Bug Report Frustration

schwern — 2010-03-22T23:57:26+00:00

I submitted a proposal to OSCON called "How To Report A Bug" about the social issues involved in reporting and accepting bug reports. Its still pending, but its caused me to do a little writing for it. I came up with this introduction which I feel sums up the problem well. I'm also tickled that one measures bug report frustration in bags of shit.

Developers often treat bug reports like someone dumping a bag of shit on your doorstep, ringing the bell and telling you to clean it up. That's not what they are. A bug report is someone pointing out that there's some shit on your doorstep, they stepped in it, and maybe it should be cleaned up.
Either way, nobody likes stepping in shit. And nobody likes cleaning up shit. So the whole interaction starts off on the wrong foot, perhaps the one covered in shit. Your job, as developer or as reporter, is to deliberately steer it back to being a positive one where the developer wants to fix shit and the reporter wants to continue to report shit.

Gone

Ovid — 2010-03-14T08:02:43+00:00

Like many others, I'm no longer posting here very much. You'll find my new technical journal at blogs.perl.org. It's much shinier.

As you can see, use.perl visits have been dropping for a while (blogs.perl.org is too new to show up on that search) and the front page of use.perl has been sadly neglected. As for blogs.perl.org, after an initial rough start, plenty of people are switching over and are very happy with the shiny.

I have fond memories of use.perl.org, but it's just too old and out-of-date. Come on over to our new platform and look around. Plus, tell us what you want changed about it. (To be fair, while I was involved in the project to get it launched (mostly kibitzing and asking why things were stalled -- I'm such a marketroid :), the hands-on work was Dave Cross, Aaron Crane and the wonderful folks at SixApart.)

Test::Class::Most

Ovid — 2010-01-31T19:25:10+00:00

Test::Class::Most.

Testing with PostgreSQL

Ovid — 2010-01-30T16:22:57+00:00

My new personal project has a PostgreSQL database. Here's how I'm handling testing.

Roles without Moose?

Ovid — 2010-01-25T14:04:31+00:00

Milliseconds are important.

The return of perl5i!

schwern — 2010-01-24T02:00:43+00:00

After an extended period in hibernation, perl5i returns to CPAN with a rack of new changes since the last CPAN release. Thanks to Bruno Vecchi, Chas Owens, Darian Patrick, Jeff Lavallee, Michael Greb, rjbs, benh and chromatic for contributing!

Why was it deleted from CPAN? Version numbers. I'd used my usual ISO date integer style versioning but realized pretty quick that I need full X.Y.Z versioning to indicate incompatible changes. Yes, perl5i is planning to be incompatible but without breaking your code!

How? By allowing you to declare what major version of perl5i you rely on. At this point its most likely going to be "use perl5i::2" which has the nice benefit of also allowing you to declare a dependency on perl5i::2. Easy peasy.

The question remains, what should "use perl5i" do? Should it A) load the currently installed version of perl5i? Or B) die with instructions on what to do? A is convenient, but means you'll get (probably unknowingly) walloped by an incompatibility later. B is a little inconvenient, but it makes the planned incompatibilities explicit and visible. The existence of a perl5i command line program (which also works on the #! line) makes A less of a concern if you want to go that route. So likely in short order "use perl5i" won't work any more. But I'd still like your thoughts on the matter.

Unless what?

Ovid — 2010-01-15T11:47:53+00:00

Unless what?

Dear Recruiters

Ovid — 2010-01-13T13:06:11+00:00

Dear Recruiters

note to self

TeeJay — 2010-01-13T12:20:00+00:00

note to self.. if puzzled why changes to a function/sub/method seem to have no effect make sure you don't have *any* warnings disabled, but especially the redefined sub one.. otherwise you'll never spot the accidentally pasted duplicate of the sub you want to change

Next QA Hackathon -- What Do You Need?

Ovid — 2010-01-12T11:37:14+00:00

Read about the next QA Hackathon.

Great Perl Code

schwern — 2010-01-11T22:59:39+00:00

I was in a bar the other day talking with somebody about Perl. He asked, "what is some great Perl code I could read?" He was looking for a non-trivial amount of production Perl 5 code that elegantly solves a problem, and is beautiful to read.

I'm couldn't answer that. The code I see is either beautiful to read but fairly boring in what it does OR is an elegant solution but is terrifying to read (for example, autodie). I'm a biased observer, I work mostly with the plumbing so I see mostly the scary stuff that implements the elegant solutions.

What code would you show a non-Perl programmer read that is both beautiful and interesting?

Most Popular Testing Modules - January 2010

Ovid — 2010-01-07T21:46:46+00:00

CPAN Testers Summary - December 2009 - The Wall

barbie — 2010-01-07T13:54:38+00:00

Cross-posted from the CPAN Testers Blog.

Last month CPAN Testers was finally given a deadline to complete the move away from SMTP to HTTP submissions for reports. Or perhaps more accurately to move away from the perl.org servers, as the amount of report submissions has been affecting support of other services to the Perl eco-system. The deadline is 1st March 2010, which leaves just under 2 months for us to move to the CPAN Testers 2.0 infrastructure. Not very long.

David Golden has now put together a plan of action, which is being rapidly consumed and worked on. The first fruits of which has been an update to the CPAN Testers Reports site. The ID previously visible on the site, refering to a specific report, is now being hidden away. The reason for this is that the current ID refers to the NNTP ID that is used on the perl.org NNTP archive for the cpan-testers mailing list. This ID is specific to the SMTP submissions and includes many posts which are not valid reports. As such we will be moving to a GUID as supplied by the Metabase framework, with existing valid SMTP submitted reports being imported into the Metabase. The NNTP ID will eventually be completely replaced by the Metabase GUID across all parts of the CPAN Testers eco-system, including all the databases and websites. As such you will start to see a transition over the next few weeks.

The second change which has now been implemented, is to present the reports via the CPAN Testers Report site and not the NNTP arcive on the perl.org servers. Currently the presentation of a report (e.g. this report for App-Maisha) is accessed via the reports pages for a distribution or an author, but will also be accessible in a similar manner across all the CPAN Testers websites. There are a large batch of early reports that are currently missing from the database, but these are being updated now, and will hopefully be complete within the next few days. If you have any issues with the way the reports are presented, including any broken or missing links from other parts of the site, please let me know.

In all this change, there is one aspect that may worry a few people, and that is the "Find A Tester" application. For the next few months it will still exist, but the plan is to make the Reports site more able to provide tester contact information. In addition to this the testers themselves will soon have the ability to update their own profiles. Initially this will be used to link email addresses to reports and then map those email addresses to a profile held wihtin the Metabase, but in the longer term will be used to help us manage the report submissions better.

David Golden is concentrating on the Client and Metabase parts of the action plan, and I am working on porting the websites and 'cpanstats' database. If you have any free time and would like to help out, please review the action plan, join the cpan-testers-discuss mailing list, and please let us know where you'd like to help. There is a lot of work to be done and the more people involved, the better the spread of knowledge in the longer term.

After David announced the deadline last month, all the testers have throttled back their smoke bots. This saw a dramatic reduction in the number of reports and page being processed, and enabled the Reports Page Builder to catchup with itself, to the point it was frequently having less than a 1000 request waiting. That changed yesterday with the changes to the website, as every page now needs to be updated. It typically takes about 5 days to build the complete site, so this quiet period will help allow the Builder to rebuild the site, without adversely affecting the currently level of report submissions. Expect the site to reach a more managable level of processing some time next week. To help monitor the progress of the builder, a new part of the Reports site, The Status Page, now checks the status of all outstanding request every 15 minutes, providing a 24 hour persepctive and a week long perspective.

A new addition to the family was also launched recently, the CPAN Testers Analysis site, which Andreas König has been working on, to help authors identify failure trends from reports for their distributions. Read more on Andreas' blog.

Last month we had a total of 168 tester addresses submitting reports. The mappings this month included 22 total addresses mapped, of which 2 were for newly identified testers. Another low mapping month, due to work being done on CPAN Testers as a whole.

My thanks this month go to David Golden for finding the time to write an action plan, and his wife for allowing him the time to write it, as well as working on all the other areas involving the CPAN Testers and the Metabase :)

gitPAN now updating

schwern — 2010-01-07T03:05:02+00:00

After a month's break I've fixed up the gitPAN importer so it can update distributions in place fairly efficiently. This involved a major overhaul of Parse::BACKPAN::Packages into the new SQLite and DBIx::Class backed BackPAN::Index. Faster, leaner, far more flexible.

Its grinding through an update now, should be done before tomorrow morning. Still running off my laptop, hosting is in the works and then daily updates can happen.

UPDATE: The update is complete. Hit a few snags. 1) I wasn't always sorting releases by date, so I might have gotten some out of order in this update. Eventually there will be a full sweep and rebuild. 2) Some parts of github are case sensitive, some parts are not, and this caused some issues when distribution names subtly change case (like WebService vs Webservice). BackPAN::Index treats this as two different distributions, github treats it as one repository, hilarity ensues.

So that's the first 90% complete. Given that too about a month and the last 10% takes 90% of the time... see you in 2011.