As a response to our post on QR Codes at YAPC::NA 2012, oylenshpeegul came up with a way to read QR Codes with Perl.

[From the YAPC::NA Blog.]

A question recently appeared on Stack Overflow about using namespace::autoclean in conjunction with operator overloading.

It turns out that you can't, because namespace::autoclean, in addition to cleaning up symbols for imported subs, also cleans up the operator magic installed by overload.pm.

This had been noticed before, but the suggested fix was rejected in favor of implementing the logic to support overload methods in Class::MOP, which namespace::autoclean uses under the hood to figure out the list of allowed methods for a class, and it doesn't look like anyone is interested in doing that right now.

As it happens, I'm working on a distribution right now which uses Moose and does some operator overloading, so namespace::autoclean would be a problem. I decided that there's really no reason a symbol-cleaning pragma should depend on Moose (or the MOP) so I wrote namespace::sweep as a replacement. More on the advantages and disadvantages below.

I'm writing about the Standard Perl Library for the Camel book (it still feels really strange to say something like that, like "Yeah, I'm helping ol' Mike paint the ceiling in this church, boy does my back hurt"). I'm going through the various installation directories and the limitations of @INC.

As you know, Perl searches @INC for a matching file. When it finds it, it stops. It won't keep looking for a later version

The ambitious can get around this. You could write a code reference that you stick in the front and completely reimplement the whole process. You can pre-scan the entire @INC and create links in a directory that you put at the front of @INC.

Does anyone actually do that for anything that matters (and not just for giggles)?

I could say a lot more about this, but it's back to the salt mines, ceiling, whatever.

We're still in the middle of Day 2, but we have photos available for Day 0 and Day 1. Day 2 photos will be available from the same URL.

For those would-be organizers: Since two years ago, we're hiring a professional photographer to capture the essence of the event. It's an extra cost, but very well worth it. You should consider it too!

I hope you’re enjoying your New Year so far. Did you make a resolution to come to YAPC::NA 2012? 

The dates are June 13-15. The place is Madison, WI. 

And don’t forget to invite your spouse to attend our Spouses Program.

[From the YAPC::NA Blog.]

TPF just opened a call for grant proposals. See details here: http://news.perlfoundation.org/2011/10/2011q4-call-for-grant-proposal.html.

The field of computation has many many metaphors. Objects is one of them.

To be honest, I don't really understand object oriented programming. I understand procedural programming aka C.

Procedural programming is like treating your computer as a dumb assistant. You tell it _what to do_ in the exact order(program/script).

Recently I began thinking about OOP in terms of how it can expand the dumb assistant metaphor. So this post is an exercise of trying to articulate it albeit, poorly.

In the real world, objects are dumb things. They sit around and do nothing. It is always a person who finds use for them.

Classically speaking, things have properties and things can be arranged into classes. It is the properties of the *thing* that differentiate it from other things of it's class and things of other classes.

I released Marpa::XS 0.016000 a week ago and the cpantesters results look excellent. With this release, my conversion of Marpa from Perl to C is finished. A lot of Perl code remains, to be sure, but all of it is code that arguably belongs in some kind of higher-level language.

This release was checked for leaks and other memory issues. The couple of issues that turned up were fixed.

What is Marpa?

Marpa is an advance over recursive descent and yacc. I hope the Marpa algorithm will become the standard parser for problems too big for regular expressions.

As you know we’ve started the open call for presentations for YAPC::NA 2012. This year, we’re going to be approving talks using a new process.

We’ll start approving talks next week, rather than waiting until we have a large array of talks. We’ll give priority to talks that fit with the Beginner Track or Perl in the Wild Track. We’ll be approving a handful of talks every week. This doesn’t mean that if your talk isn’t approved right away, it won’t be. However, the sooner you get your talk proposals in, the better chance you have of getting a talk approved and placed on the schedule.

Our deadline for proposals is March 15, 2012. So get those proposals in now. This year, there’s no time for procrastination, because the slots will be getting filled up in real-time.

[From the YAPC::NA Blog.]

When designing a Perl application that needs to run on many different versions I end up using 'corelist' a good deal. Most of the time I just needed a list of the additions or removals of core modules from different stable series of Perl releases. I kept all this information in a text file for reference. While searching for something Perl related it dawned on me that I should post this as it could be useful for other Perl developers as well.

I used 'corelist -r' and 'corelist -v ' to gather this data together. The release data is from 'perldoc perlhist'.

2008-12-14 Perl v5.8.9 released Pumpking: Nicholas Clark
2007-12-18 Perl v5.10.0 released Pumpking: Rafael Garcia-Suarez
2010-04-12 Perl v5.12.0 released Pumpking: Jesse Vincent
2011-05-14 Perl v5.14.0 released Pumpking: Jesse Vincent

You might have stumbled across Dist::Zilla's --trial command line option in the past, and maybe even used it for a developer CPAN release. Its effect is (as I understand it) two-fold:

• adds -TRIAL to the name of the distribution archive being produced
• sets release: testing in the META.json file which is parsed by CPAN services

It came to my attention that using -TRIAL is actually pretty bad for you and your system, and other users, even though it's one of the two naming conventions CPAN services use to identify developer releases.

The problem is that the actual $VERSION of your code is unaffected. This means once installed, you can't ask your computer the version of an installed distribution and work out from that whether it's a developer release, or not. A secondary issue is that in sites such as metacpan.org there's nothing really obvious about the release which highlights its status as "development", in the list of available versions.

feeling:
		NULL;

my @arrays_hurt;

calling'all &{*pointers};

print "out loud";
"he is dead";

segfault::the::airplanes;
void_the_system;
&mourn;

"entropy sucks";

At YAPC::NA 2012 we’re thinking about stealing a feature from PyCon they call Startup Row. In their exhibit hall they give away booth space to feature some up and coming new companies. 

There are a lot of new companies using Perl these days, like Parking Mobility, Social Flow, and Bluer.  I even have a few of my own. I’m willing to bet there are a lot out there we just don’t know about.

Depending on the interest level and number of submissions, we’ll either add some booths to our Job Fair for this, or we’ll open a completely separate exhibit space for it. 

If you’re interested in getting a free booth and some other exposure at YAPC::NA 2012, please fill out our Startup Row Application. Submission deadline is March 1, 2012.

[From the YAPC::NA Blog.]

Day #0, the Eve, is traditionally either a RejectConf or some other smaller event - and either way, we provide a room where you can drink and socialize. We also provide beer and some condiments. You can listen to the talks, or opt to only socialize:

We had a little problem with the check-in tonight (yours truly forgot to ALTER TABLE the production database and subsequently the webapp kept failing), but otherwise we had a GREAT turn out.

We met old friends, exchanged new ideas... Anyway, the REAL fun starts tomorrow!

Oh, and here are a few shots from the preparation earlier today. Total of about 40 people have signed up to help, so things went on very smoothly

And I'm already sore from the work. Going to be now.

As many of you have read in the news Dennis MacAlistair Ritchie has passed away at age 70. Given numerous awards for creating the C programming language and developing UNIX Dr. Ritchie is not just a giant among men, he is a titan in the computer industry. Here is a video of Ritchie and Thompson receiving an award from then President Bill Clinton.

One thing I've learned over the last few months is that nothing happens quickly or easily in a company of over 125.000 people.

My rewrite effort has been bogged down in security certifications and other time-consuming stuff, so I've been unable to sit down and do much actual code.
In stead, I've been reading Modern Perl again, and trying to wrap my head around PCI security standards compliance, and reading a whole stack of blogs and books about Perl (thanks, guys!).

Submit a talk for YAPC::NA 2012. We’re especially interested in talks on real-world Perl apps and quintessential Perl 101 talks, but we’re open to any ideas you have. 

[From the YAPC::NA Blog.]

Today, I was looking for a simple module that fetches my DB schema. Played around with DBIx::Class::Schema::Loader and Rose::DB::Object::Metadata, with no success.

Have already given up, but finally decided to make a Github search for DBIx, which provided exactly what I needed. Just curious why it was so hard to find this module?

DBIx::Inspector

Just thinking out aloud, for the sake of clarity.

Consider music improvisation. Should a musician stop and restart because one tune was a bit off ?

(I am not talking about reproducing mozart here but improvisation i.e, coming up with new tunes, maybe even a mozart remix)

I think not.

Programming languages without type systems don't complain much. This makes it easier to program despite the obvious errors. This makes it easy to _improvise_ algorithms.

Most improvised music can sound pretty _dirty_. This is why, after an improvisation session , what follows is an editing session which adds *structure* and *corrections* to make it sound _clean_

- unit tests --> music idea
- programming without a type system --> improvisation
- functional testing / benchmarks --> editing the music

Interestingly classical music with all of its "harmony" formulae and chord sequences analogically maps to type system and design patterns

So what do you prefer ?

Stingy mozart

or

Smooth jazz ?

I'm looking for references to Sharon Hopkins's Perl poetry in The Economist and The Guardian for my update of the Camel Book. The Economist website is down right now, and my search in The Guardian turned up nothing.

Does anyone have these references? She didn't list them in "Camel and Needles".