November Lightning Talks

In the run up to the meeting, 9 people volunteered to present. For one reason or another, 2 of those had to bow out before the meeting started. One of the original list of presenters gave a second lightning talk off the cuff, and another attendee volunteered to give a lightning talk with no prep. This gave us 9 talks in the end.

Of those 9 talks, 7 finished in less than their alloted 5 minutes. One problem that came out was the lead did not do a good job of letting the speaker know how much time was remaining. He got his act together after a couple of presentations, but since he was off to one side of the room, the speaker did not always see him.

The presentations were as follows:

Robert Stone - $# sigil

Robert covered both the $# global variable and the $# sigil when applied to an array. Resources included:

Todd Rinaldo - Mocking subs with Test::MockModule

Todd described problems with unit tests that run too long because of expensive internal dependencies. He showed how to use Test::MockModule to decouple these dependencies in the code under test. This can help tests become fast enough that they will be run consistently.

The code for Todd's talk is available on github.

Julian Brown - PostgreSQL Unit Testing

Julian showed how he uses temporary tables in PostgreSQL to make unit tests that are useful and don't leave test data in any production databases.

Chris Mevissen - Tail recursion using Clojure

Chris gave an introduction to the concept of tail recursion and explained how some languages can optimize it. He showed how tail recursion works using the Clojure programming language.

Brett Estrade - Text Mining in Perl

Brett introduced the book Practical Text Mining with Perl and showed a technique for determining the simularity between documents by counting words and applying vector math. While this sounds crazily advanced, Brett's explanation was clear and pretty easy to understand.

Brett has provided a more advanced example of the document simularity concept on github.

Zaki Mughal - Embedding R in Perl through the C API

Zaki briefly introduced the problem of doing statistical analysis in Perl. There do not appear to be many modules supporting serious statistical analysis. The R language does support serious statistics, but it's not Perl.

Zaki showed how he embedded R in Perl to test the idea of using R from Perl form real statistical analysis.

He says that everything is a bit experimental at this point and the APIs are likely to change.

G. Wade Johnson - Use map

Wade spent a short time talking about the virtues of Perl's map operator, before getting down to the business of showing how it should be used. He finished with an example of using map in a way that most people would not expect. He did stress that he would never do this in production code.

The slides are available on-line.

Jim Bacon - When to Delegate Instead of Inherit

Jim gave a quick unprepared talk on an OO design decision that many people find difficult: when do you inherit from a class and when do you aggregate and delegate.

His advice is if you will not pass the other class's unit tests, you cannot inherit and must delegate. This is a concrete test for the advice that you often find on-line for only inheriting if the subclass ISA base class.

Jim went further to talk about how Moo and Moose support easy delegation. He also suggested checking out the Throwable module.

Brett Estrade - Try::Tiny and nested try/catch blocks

Brett got up again to give one more talk. He described a piece of code he had found that seemed particularly offensive. To show what he meant, Brett has provided code to explain his position.


We had 17 people attending this month. As always, we'd like to thank cPanel, Inc. for providing the meeting space and food for the group.