London Perl Workshop 2012

It’s been a few weeks since LPW 2012, so I thought I’d better write up my thoughts on it while I still retain the tiniest scintilla of memory. This year’s theme was “25 years of Perl”, as the workshop was held just a month shy of the 25th anniversary of the release of perl 1.0 on an unsuspecting world.

The start of the workshop was delayed somewhat, as the University was holding exams on the same day, and the foyer was filled with students registering. Naturally, the LPW organisers hadn’t been warned about this, so it took a while to find a space for the workshop’s registrations and goody-bags. I turned down the free mug from ByteMark, as I already have one from a previous year, but I’m now the proud owner of an antibody.mx boomerang and t-shirt (actually, I’m not sure those were both from antibody, but I’m 6000 miles away at the moment, so can’t check). The sponsors are one of the main reasons that it’s possible to hold this event and keep it free every year, so I have no qualms about promoting them here.

As in previous years, the theme might not have been obvious if you weren’t already aware of it. However, the first talk I attended, Richard Jelinek’s “My 16 of 25 – A Healthy(?) Schizophrenic View on Perl” at least had it in the title, even if it wasn’t excessively relevant to the talk. In fact this was one of a few talks concerned with steering and promoting Perl more effectively than is currently achieved. Richard has spent 16 years Perl programming, thinks Perl needs a good strategy (or any strategy, along with a goal), and provided a few ideas.

Next up was Piers Cawley’s “YARRR! Plundering’ Programmin’ Paradigms Fer Profit!” To my very slight disappointment (I was forewarned by the talk’s abstract, so I only have myself to blame) this wasn’t delivered in a Robert Newton accent. Instead, Piers pointed out various interesting and useful features of other programming languages and related research, and showed how some of them could be used in a Perl context. Some of the others merely suggest novel directions to think along (“Brainfuck teaches us to embrace constraints”) and Piers gave several good pointers for further reading.

The coffee break was again notable for the free drinks and over-frosted cupcakes, sponsored by Exonetric. At least this time the frosting didn’t exceed the cakes in volume, and the rhubarb-and-custard sweets adorning the peaks of one of the flavours evoked audible nostalgia from a few places around the room.

Back to the talks then, starting with Aaron Crane’s “Calamitous Context: Stop Breaking My Code!” Aaron has some quite reasonable issues with Perl’s treatment of subroutine return values in different contexts (scalar, list and void), and was essentially advising that they should be engineered out of your code wherever possible. He even dared to recommend against Saint Damian’s advice in Perl Best Practices, again for entirely sensible reasons. I asked a couple of questions, but didn’t mention that I’ve gone wildly against both sets of advice, for fear of being hounded out the the room (I wrote a method which always returns a scalar, albeit an integer in scalar context and an array ref in list context).

Every talk I’d seen so far was in the Bytemark theatre, and now it was time for the Bytemark talk. Matthew Bloch presented his paper, “How Bytemark built a cloud hosting system without buzzwords” (text here). The paper looks like quite an interesting read (dedicated networks for each type of data, independent migration of CPU and disk without downtime), with typical geek humour terminology (servers are called heads, tails and brains, and communicate using a spine protocol). Unfortunately, Matthew presented the paper by showing it on screen, and jumping backwards and forwards through it in a seemingly unrehearsed manner. A few slides with salient points picked from the paper might have been a better visual aid. So it wasn’t quite as informative as it could have been, but Matthew’s obvious enthusiasm for the subject and entertainingly haphazard presentation style made it all worthwhile.

The last talk before lunch was David Cantrell’s “Unit testing: you ain’t doing it and you should“. Everyone knows (or should know) that unit testing is essential, but David argued that what most people do isn’t actually unit testing. Now I’ve heard his case, I’m inclined to agree. The main issue is with only testing the subroutines or methods you call in your tests, without also testing all of the layers underneath (or to the side, or above, depending on how spaghetti-like your code is). I find this tricky enough to do right in Java, which has a whole bunch of different ways to do mocking of dependencies, but most Perl I’ve seen isn’t written in a way that makes such things easy. David showed an approach which did make this somewhat simpler, with the help of his Class::Mockable module. Personally, I’m not completely sold on the “one set of expectations per test file” behaviour of Class::Mockable, and the intrusive (compared to Java’s mocking) way that classes have to expect to be mocked. At least from looking at the documentation, I think that Test::MockObject works more like what I’m now used to in Java. Still, mocking is good, and either of these modules will make it much easier.

There was no sponsored lunch this year, but there were still quite a few of the cupcakes left, which meant I got to try a second flavour. After lunch, I made my first visit to the Booking.com theatre, and Pedro Figueiredo’s “The problem with Perl“. This was another talk about Perl’s relative failure of promotion and marketing to managers and developers. Pedro thinks that Perl found some good niches to inhabit 10-15 years ago, but hasn’t really struck a chord since then to anyone outside the monoculture. On the other hand, he does think that Dist::Zilla is a better tool than Java’s Maven. I haven’t used Dist::Zilla enough to judge, but Maven is pretty good when it cooperates, so I hope he’s right.

Then Oleg Komarov presented “Reliable cron jobs in a distributed environment“, in which he described the problems he’s encountered with managing a large set of automated processes running on a collection of heterogeneous servers. I must admit to not making enough notes to remember much of the talk, except that Oleg uses Net::ZooKeeper::Lock and his own switchman to make his life easier.

I’d had trouble picking which talk to go to next, as Dave Cross and Matt S Trout are both usually worth hearing, though for very different reasons. In the end, I decided to do both; Dave’s talk was scheduled for a shorter time than Matt’s, so I thought I could at least catch the tail end of the latter. As it turned out though, Dave’s title, “25 years of Perl in Twenty Five(ish) minutes” proved prescient. Even though the slot was officially only 20 minutes long, the following talk had been cancelled, so (apart from the low battery warning on Dave’s laptop) there was no need to rush. Dave picked out notable, significant and silly facts and events from each of Perl’s 25 years, backed by a flashy swooping slide show. His battery did run out part way through the penultimate year, which though sad, did give those of us rushing off an extra minute or so of Matt’s talk.

Matt S Trout’s “Fat, furious, fatpacked and fun” was another chance for him to show off some of his latest work while simultaneously alarming and inspiring the audience. At the point I came in, Matt was in the middle of describing how he’s made <p>, "foo", </p> parse as "<p>foo</p>", as part of his Web::Simple framework. This also includes URL dispatching based on matching rules coded into subroutine prototypes, so that the matched parts of the URL are available in the argument list. I wish I could have seen the whole thing, but at least it’s available on YouTube, along with several of the other talks from the workshop.

James Laver’s “What I learned from other technologies” was similar to Piers Cawley’s earlier talk, but with a different collection of languages to steal ideas from, and not even a mention of pirates. The real difference was that James included more of the downsides of those other technologies, such as Node.js and Scala. Clojure was singled out as a favourite, as although there’s little documentation, it’s a super-Lisp which feels like writing in Perl.

That was another talk side-by-side with a longer one, so I only caught the end of Mike Whitaker chairing “The state of the Perl jobs market II“. I’m the fortunate position of not needing to look for work, but I do occasionally have to conduct technical interview candidates for positions in my office, and it always makes me feel uncomfortable. I was therefore quite glad to arrive at the point where the question was raised of what makes for a good interview. “What’s wrong with this code?” rated highly, and I have used that myself. It’s always good to see whether other people are as critical of your own code as you are, and assuming that the code is reasonably understandable, it can be more effective than getting candidates to code a solution from a blank slate.

After a quick break, it was time for the lightning talks, with Leon Brocard as MC, enlisting the audience to supply “one minute!” warnings and the “bong!” sound to his non-existent gong when the time was up. Neil Bowers’s “PAUSE::Permissions” was about the model used by the Perl Authors Upload SErver, including how ownership is determined, transferred and shared, and how to reserve namespaces before you write the modules. Dave Cross presented “Matt’s PSGI Archive“, an attempt to further modernise the “not matt’s scripts” idea by not operating under the same punitive restrictions as the original, much despised, Matt’s Script Archive. Mark Norman Francis talked about “Keeping direct.gov.uk on the internet“, which in large part seemed to depend on maintaining a multi-thousand line config file. Lots of the code is available on github. Ulrich Habel’s “Given, when for business critical applications” used the new Perl syntax to show why managers often find it hard to accept Perl. Tom Hukins introduced “London.pm” to the audience.

At this point, with five talks still to go, we were informed that we had to leave the building imminently. Even though the workshop had been arranged to go on until six thirty, the University had forgotten to mention that the doors would all automatically lock at six o’clock, so there was only time left for Mark Keating’s closing remarks. Next year’s workshop will be the tenth, and we should expect new stuff which we’re sure to hear about in due course.

In the meantime, there was still the social event at the nearby pub, sponsored by Net-a-Porter, antibodyMX, Evozon, Nestoria and Shadowcat Systems. Thanks to their generosity, there was plenty of free food and drink for rather more people than could comfortably fit into the function room upstairs and overflow into the main bar downstairs. As usual, the conversations in the pub were just as interesting, amusing and informative as those on the official schedule. I didn’t take any notes however, so I’m afraid that I don’t remember who any of the people were that I talked to, nor what we talked about.

So, that’s a fantastic Perl workshop, lots of interesting people, food and drink laid on, and it cost less than £1.50 per hour for a 20 hour day, or without the train travel, nothing at all for 14 hours. Thank you very much Mark Keating, all of the speakers, sponsors and volunteers. If anyone has read this far and isn’t planning to go next year, I want to know why; they’re missing out on a great deal.

Advertisements
This entry was posted in lpw, perl. Bookmark the permalink.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s