I've had co-workers that never wrote POD, and that was probably the worst. But the next worst are the people that inline their POD. I really cannot stand inline POD. Apparently I am not alone. Mike Friedman expresses it at least as well as I can so I'll leave it at that.

Well, almost. He says one odd thing:

  If someone's looking at your code, it's because they need more information 
  than the documentation or interface itself can provide.

I don't think this is even half true. I often look at Perl code that has perfectly good (and non-inline) POD. Almost always because I'm less interested in the public interface than I am interested in how that interface was written. What fun is software development if all you do is work with the public interface of blackbox libraries? It's much more interesting to see what's going on behind the scenes and actually learn something new, right?

NEXT: I don't know that I will ever use this module, but it is interesting. Provides for interesting method dispatching scenarios such as calling all DESTROY's in the inheritance tree.

Net::Amazon::EC2: Perl interface to the Elastic Compute Cloud (EC2) environment. I'm not certain if this is a competitor to the Amazon Perl API or if it somehow complements it.

XML::Compile::SOAP: A real replacement for SOAP::Lite.

Matt S. Trout has an interesting blog post about Perl call semantics. There are a number of things in there I was unaware of. Of particular interest to me is that this works:

  my $undef = undef;
  my $code = sub { "foo" };
  $undef->$code; # returns "foo"

Apparently when the right hand side of the '->' is a coderef there is no method lookup. Very interesting.

POE::Filter::HTTPD::Chunked: As a big proponent of POE I thought this looked interesting. A drop-in replacement for POE::Filter::HTTPD that can deal properly with chunked encoding.

Template::ShowStartStop: Inserts comments in the generated output to show where one template ended and a new one begins. It overrides Template Toolkit's Template::Context to do this.

UNIVERSAL::require: A module that gets around the silly bareword requirements for the builtin require() sub.

IPC::Cmd: An API to run external commands. A wrapper around system() I would guess, but very nice looking.

A good introductory article about Perl namespaces and how they can become dirty. Not surprisingly it mostly talks about how to properly use namespace::clean.

SQL::Translator: Translate the DDL from one schema type (say, Oracle) to another (say, PostgreSQL). It can also be used to translate a schema to something completely different, such as a YAML file. One particularly nice feature is the ability to translate a schema to code. An example of this would be translating a MySQL schema to Class::DBI code. Introductory documentation is available.

Sub::Override: Instead of writing this:

  undef (local *Some::sub);
  local *Some::sub = sub { ... };

You would write:

  Sub::Override->new('Some::sub', sub { ... });

The scoping rules are (mostly) the same and it is more readable. Very useful for tests.

Data::Random: Generate random words, characters, numbers, date, time, .... Seems like this would be very useful for testing.

Fey::ORM::Mock: An attempt at a replacement for DBD::Mock. The author suggests it is better but does not eliminate all the problems with DBD::Mock. Likely requires that you use Fey::ORM as your object to relational mapper.

Yet another good blog post today. This one covers the trials of writing good unit tests for an application that interacts with a database. The comments are definitely worth a read too.

Apparently using exceptions as flow control can be very bad. That blog post has some concrete numbers on the performance hit of die()/eval() versus return() and versus eval{return()}.

I've often wondered about this but had never followed up by performing some simple tests. The absolute worst case of this I have ever seen was when I was benchmarking the protobuf-perl library. At that time Moose was capturing a confess() by Class::MOP. It was doing this thousands of times for even simple tasks. As you can see if you read this thread getting rid of the confess() was a big win (although protobuf-perl was still slow). I wonder if getting rid of the eval would have proven to be even more beneficial? As I wrote about here I will likely never know.

autodie: Replace functions with ones that succeed or die with lexical scope. Very useful if you are dealing with a large script or you don't want to do all the die() code yourself in a new script.

indirect: Lexically warn about using the indirect object syntax. This module seems very useful for catching difficult to find bugs. This blog post gives a compelling case for its use.

namespace::autoclean: Keep imports and functions out of your namespace.

namespace::clean: Keep imports and functions out of your namespace. Allows a bit more control as compared to namespace::autoclean.

Carp::POE: Carp adapted for use with POE. May be interesting.

Module::CoreList: Generate lists of core modules shipped with Perl. This module is maintained by the Perl 5 Porters. I can see this being useful for package dependency generation.

Cache::FastMmap: Yet another very good IPC module.

Forks::Super: Never used this module but it does appear to do some handy things. If you are familiar with POE it is probably better to just use that.

Devel::Caller: a more powerful caller().