An interesting post by Ovid about 100% test coverage, what it means, and what it does not mean. The first comment by David Golden is also worth a read.

I like the idea of 100% test coverage and I generally make every effort to get there. Using devel::cover is a great tool for finding code that will never be triggered, and the closer you get to 100% the easier it is to spot such code.

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.

Yes he is. Granted I woudn't go quite so far as to say, "Benchmarking is pointless", but his point about the comparative usefulness of benchmarking versus profiling is right on the money.

I think the reason for this is not an inherent problem with benchmarking. The problem is that people (developers) tend to benchmark the wrong things and then they optimize the wrong things. Profiling on the other hand takes the entire system into account in its results. This is much more useful than optimizing based on a benchmark of a small part of a complex system.

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

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.

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().

Devel::CheckLib: check for the existence of C libraries and their headers. I could have used this at my previous job.

File::Map: one of the better shared memory modules I have seen.

parent: a fork of the base module. Appears to come with standard Perl. Drops support for fields.

IPC::System::Simple: a drop-in replacement for Perl's builtin system() command. The difference being this version takes a lot of the complexity out of interpreting system()'s return code(s).