Reviews by educated_foo



List-Objects-WithUtils (1.000001) *

Modules like this, which let you replace Perl's built-in operators with a bunch of object-y arrow-infested junk, belong in Acme::.

Statistics-Basic (0.42) **

What a horrible interface: why call a function to take the mean of your data when, instead, you can simply create a new "mean object" with the data, then "query" it to get the result? </sarcasm> Plus there's not much functionality. If you want statistics, use Statistics::Descriptive.

bioperl (1.4) ***

Good news: bioperl is fairly complete and correct, as far as I can tell.

Bad news: it's absolute agony to use, making easy things hard, and hard things slow. A few points:
* The interface is a twisty little maze of objects, all alike.
* Many methods are unnecessarily slow.
* Some formats (e.g. BLAST) are incompletely supported.
* The documentation "follows standards", which means that many of the less-used bits are documented with a pile of uninformative but mandatory boilerplate.
* For simple tasks, it's usually easier to roll your own than to wade through the docs.

Other modules are a better bet if they meet your needs -- see e.g. Chemistry::* and Boulder::* .

Mac-PropertyList (0.9) ***

Easy to use, but really quite slow compared to raw XML::Parser. Parsing a moderate-size iTunes library file, for example, is far too slow to be useful.

DP-Perl (0.101) *

Some of the subtlest CPAN comedy I've seen in years. For full effect, take a look at the source, not just the web documentation.

Unfortunately, his later work in DP::Date doesn't compare.

Data-Dumper (2.101) ****

I used to think Data::Dumper was the bee's knees for data inspection, but I've recently found that YAML is often more readable. Data::Denter is supposed to be useful for data structure debugging as well, but I haven't had a chance to use it.

Oh, and for serialization, Storable is probably a better option.

Still, probably a "must-have" module.


Emacs-EPL (0.7) ****

Two great things that (could) go great together -- Emacs and Perl talking to each other through a pipe. There's good support for calling in both directions, and the code seems well-thought-out (e.g. circular data structures are properly serialized). I say "could" because the support is incomplete, e.g. hashes can only be passed as opaque references. However, this module's still fun, useful, and fun to use.
Check it out.


Heap (0.50) **

Well-documented, with a complete interface, but I can't recommend it because:

1 - At least to me, it's too awkward to use. From the doc:

use Heap::Elem::Num(NumElem);

foreach $i ( 1..100 ) {

$elem = NumElem( $i );

$heap->add( $elem );

2 - Its implicit performance claims are misleading -- while Fibonacci heaps
are fast asymptotically, they are so complex that even in C, you are better
off with a normal heap for moderate amounts of data. A pure Perl
implementation of a Fibonacci heap isn't all that useful -- it's likely to be
slower than using Perl's pure-C sort builtin.

If I needed a Heap module off CPAN, I'd use Ton Hospel's Heap::Simple.