Very good at what it does (pronouce time in English).
Very simple to use.
Can be a nice touch.
Edit: I just came back to this module after a number of years.
Why did I only give it a four back then? It's clearly an overall five! It installs, it just works, the interface isn't overcomplicated.
If you need human readable durations, this is the one to get. Kudos.
This module rates high on most counts.
Except it has a three years old outstanding bug report (with attached fix) that it doesn't install on Windows.
So on average: 2
Just a note: The need to manually install elisp files is long gone.
It's all dealt with by installing the Perl module, and there are setup/config instructions in the manual.
Nice, easy to use module.
Enable it, run your program and it will list classes and object counts for live objects (i.e. not garbage collected ones) on exit.
I used it to find a memory leak in Devel::Cover. While it was simple to see wich objects were still alive, this module won't help you find out the root cause, i.e. where the circular dependencies are. But you can always just Dump one of the objects. Given the classes, you can probably figure out what a proper root object would be.
* list ref count of each class or even object, maybe limited per class, so you can see where the leak is.
The best kind of interface -- i.e. no interface.
The only thing the docs could use is a mention whether "use bigint" is lexical or global, but it seems lexical from the examples.
(The reason I'm even anxious about this is I recall other similar modules that affected global behaviour.)
Solves the problem well, in a very usable manner.
The documentation is slightly code-oriented and could do with a little bit better introduction to the problem domain.
A real lifesaver the few occations when you have two large pieces of text that don't match and you need to find out exactly how.
I especially like the way newlines is indicated as \n in the diff. That, and other convenient touches, makes this module stand out.
Simply the easiest-to-use front end to DBI.
If you're planning on write SQL yourself instead of using one of the ORM modules (CDBI, DBIx::Class, Rose::DB etc.), this is the interface you want to use.
Does one thing and does it well.
The only bad thing about the docs are the negative numbers in the example in the SYNOPSIS, that's just distracting.
Pragmatic automation. No, wait, that's a book. Ok, it's also what this module is about.
Create a graphical representation of the inheritance tree of a module.
Very easy to use, but I miss a simple command line script to point to a directory of modules.
No tests. Um... no makefile? Did install but then didn't work because of missing dependencies.
Instead I ended up using... Acme::JavaTrace :)
The only gripe I have with this module is the name, since I know this design pattern under the name "Null object" rather than "Null class". Maybe the docs could at least mention that.
Other than that: well done!
One of those bread-and-butter modules that are simply there for you when you realize you need Perl to reach into yet another domain.
It does what it says. In a good way.
The sub names could have been more in line with e.g. Test::Exception, but it works.
Devel::Profile dumps per-subroutine execution statistics during or after the program run.
One of the profilers that actually works.
One of the preferred modules for creating standard getter/setter methods, among other things. There are a number of modules for doing that, this one works well.
Useful when some module with a poor API needs a file handle and all you've got is a string.
Strong points of DBI:
* it's the de facto standard in Perl, focusing database development.
* a unified interface for connectivity, basic activities (and somewhat for capabilities), making it almost-not-a-nightmare to switch between database backends (but then there's always the specific syntax, semantics and concepts of different databases for anything non-trivial... *sigh*)
* it's stable and mature with countless hours in production.
* nice API.
* huge amounts of additions and utilities in the DBIx namespace, built on top of DBI. Not to mention Class::DBI.
Interface: simple and powerful.
Database abstraction at an extremely productive level.
Lots of declarative logic and lots of under-the-cover smarts, hiding the boring and repetitive parts from you.
Some of the croak error messages could be a bit more helpful, and possibly not croak at the level _above_ where you are coding.
Plot values over time. Add one or more series of time + value datapoints and this module will make a pretty chart with most things automatically the way you want it; Axis comments, grids, time etc.
Excellent module! If you need some kind of "tail -f" in your program, this is what you want. Being able to use non-blocking selects on many files (or in my case, building a tailing server) is extra nice.
The documentation could use a little more work for the methods, which parameters they take, examples etc.
The module appears to work just fine under Win32 despite the failing tests (I suspect DOS/Unix line feed problems).
For when the options on the command line just become too many or too long to keep on the command line. Put them in a file and include them. Recursively if need be. Excellent extension to @ARGV parsing modules.
Manage ZIP files easily. It took me fifteen minutes from "I need to put that directory tree into a zip file" and I had a working solution.
Good synopsis, good FAQ.
Excellent functionality for when you want to pass around specific information in a die(). The $@ is still stringified in a useful way.
Easy-to-use API for defining your own exceptions.
Very, very useful for testing database contents.
I found the various ways to specify the SQL query to be overly complex for my taste. I pass in simple SQL strings instead.