Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
<br><br>As alternatives, I recommend the much simpler JSON::Path, or
the more powerful Data::DPath. <br>
Games::2048
Author: BLAIZER <https://metacpan.org/author/BLAIZER>
My favorite 2048 implementation (it's text-mode, written in Perl,
uses my module Color::ANSI::Util, and what else... oh yeah, it's the
only implementation where I've reached 2048 :-) ). <br><br>One tip:
enlarge the fonts of your terminal emulator (e.g. Ctrl-+ on Konsole)
until it's big and convenient enough.
App::D
Author: BESSARABV <https://metacpan.org/author/BESSARABV>
As an alternative, one can also do: <br><br>alias d=' <br><br>TZ=UTC
date; # show date in UTC <br><br>date ; # show date in local
timezone <br><br>cal -3 ; # show monthly calendar for curmon-1,
curmon, curmon+1 <br> ' <br><br>
Getopt::Long
Author: JV <https://metacpan.org/author/JV>
Having worked for quite some time with option processing and several
other similar modules, I have to say that most of the time you
probably want to use Getopt::Long instead of the other alternatives.
Or at least pick the alternatives which are based on Getopt::Long,
instead of those that reinvent the wheel and do their own option
parsing. <br><br>Most other modules that reinvent option parsing
either don't bother to do short option bundling (-abc instead of -a
-b -c), or abbreviation (--long-o instead --long-option-name), or
the choice to (dis)allow mix-mashing options and arguments, or
support '--' to end option processing, or respect ordering, or
support multiple options (--verbose --verbose), or support
'--foo=val' *as well as* '--foo val', and so on. These are features
and conveniences that are taken for granted by people working daily
in Unix command-line. <br>
Text::Table::Tiny
Author: NEILB <https://metacpan.org/author/NEILB>
Very fast, several times faster than Text::TabularDisplay or
Text::Table (and many times faster than the other slower
table-generator modules). It uses sprintf() to format a whole row
instead of formatting each cell separately using sprintf() and
joining cells together with join(). <br><br>I did a comparison in:
<a
href="http://blogs.perl.org/users/steven_haryanto/2014/07/benchmarki
ng-several-ascii-table-generator-modules.html"
rel="nofollow">blogs.perl.org/users/steven_haryanto/...</a>
Mo Author: TINITA <https://metacpan.org/author/TINITA>
A great alternative when Moo is a bit too much for you. Useful for
scripts that must start really fast. Mind you, Moo loads about 5K
lines of code and more than a dozen files, all of which takes +-
10ms on my computer. Mo on the other hand is only a single line of
+-500 characters, and it's inlinable. It loads in under 1ms. If a
script must be executed thousands of times a day, that 9ms
difference will matter more. <br><br>I use this for a very
lightweight parent class. A richer subclass then uses Moo.
<br><br>Isn't it great that we have the choices and upgrade path
from the very minimal Mo, to Moo for normal cases, to Moos and Moose
for even richer (but heavier) alternatives. Truly TIMTOWTDI! <br>
App::ChangeShebang
Author: SKAJI <https://metacpan.org/author/SKAJI>
Given that the name of this module/app is "change shebang"
(instead of "change shebang to samedir perl") perhaps this
app can be made more generic? For example, I've had to change all
shebangs from "#!/usr/bin/env perl" to "#!perl"
and vice versa. Perhaps this module/app can become a tool to easily
switch between shebangs. <br>
Hash::Ordered
Author: DAGOLDEN <https://metacpan.org/author/DAGOLDEN>
Overall looks ok, with the exception that it does not look and feel
like a regular Perl hash at all. Now someone just needs to create a
tie interface on top of this :) <br>
App::whatthecommit
Author: MUDLER <https://metacpan.org/author/MUDLER>
From the description: "App::whatthecommit is just another
lazy-to-lazy line command utility." I'd thought the definition
of laziness would be something like 'alias gc=git commit
--allow-empty-message'. This is more like hubris. Or whatever. :)
<br>
Opt::Imistic
Author: ALTREUS <https://metacpan.org/author/ALTREUS>
Very nifty for short scripts and some clever design inside (all
options are stored as arrayref, but there is some overloading to
make getting boolean/flag and normal scalar value convenient).
<br><br>For more "proper" scripts though (anything above
say 20-30 lines) I'd recommend using something like Getopt::Long
with a real spec. Some of the features I like in G::L not in
Opt::Imistic: the ability to get --noOPT for free for flag options,
the ability to configure permute/no_permute (mix mashing options
with arguments), some data validation, and of course:
autoabbreviation of long option names, which requires a spec after
all.
Devel::STrace
Author: DARNOLD <https://metacpan.org/author/DARNOLD>
The doc looks promising, it really looks like it could be the
"strace for Perl functions", but the usage is awkward (you
have to open two terminals, one for running your program and
producing trace file, and another for reading this file). And I'm
probably an idiot, but I can't get this module to work for me.
<br><br>One alternative if you're looking for a similar module is
Debug::LTrace. <br><br>
Devel::TraceSubs
Author: PARTICLE <https://metacpan.org/author/PARTICLE>
For an alternative, try Debug::LTrace, which roughly provides the
same basic feature but is more convenient to use from the
command-line and give extra information like timing. <br><br>
Devel::TraceCalls
Author: COSIMO <https://metacpan.org/author/COSIMO>
Might be powerful and flexible, but not convenient to use especially
from command-line. (I was searching for something like "strace
for Perl function"). <br>
Debug::LTrace
Author: KOORCHIK <https://metacpan.org/author/KOORCHIK>
One of the more convenient and usable subroutine tracing modules on
CPAN. If you're looking for something like "strace for Perl
functions", try this. <br>
Debug::Trace
Author: JV <https://metacpan.org/author/JV>
Good module, but try its derivative Debug::LTrace instead.
Debug::Trace doesn't fake caller() yet so traced/wrapped subroutines
get caller() results that are "off-by-1" (see
Hook::LexWrap). Plus, Debug::LTrace gives more information like
timing. <br><br>
App::Trace
Author: SPADKINS <https://metacpan.org/author/SPADKINS>
The name and abstract is slightly inaccurate/misleading. This module
is supposed to be a general logging framework instead of just
subroutine entry/exit tracer. For alternative subroutine tracer, I'd
recommend Devel::TraceSubs or Devel::TraceCalls (or even
Devel::Trace + variants). <br><br>Not very convenient to use. It
still requires you to put 'if $App::Trace' clause everytime. For
general logging that can be switched on/off upon runtime, I'd
recommend using Log::Any instead. <br><br>Lastly, this module is
tied to App::Options and thus only really usable if you use both.
Tie::Hash::Identity
Author: CINDY <https://metacpan.org/author/CINDY>
Hash::Identity has a use case of convenience when embedding
expression in double-quote strings. I fail to see the point of
Tie::Hash::Identity though. Can't you just say: <br><br>'abc' eq
'abc'; # true <br><br>(1+2+3) eq '6'; # true <br>
Hash::Identity
Author: CINDY <https://metacpan.org/author/CINDY>
At first I thought, hey, cute trick. But then Perl already has:
<br><br>print "You could use expr like this:
${(2**3)}.\n"; <br><br>print "Or you could use ident ${(
'a' . 'b' )} as well.\n"; <br><br>So you're trading a backslash
and a couple of parentheses against having to depend on a non-core
module and making your code reader raise her eyebrow when she first
sees your code. Pick your poison :-) <br><br>I wonder if this
belongs in Acme:: <br><br>On the other hand and slightly off-topic,
a module that can do Perl6-style interpolation (lexically) would be
cool, I think: <br><br>$s = "perl${(6-1)}-style
interpolation"; <br> { <br><br>use v6str; <br><br>$s =
"perl{ 5+1 }-style interpolation"; <br> } <br>
Data::Structure::Util
Author: ANDYA <https://metacpan.org/author/ANDYA>
@Tom Browder: If you just need unblessing, there's also another
module Acme::Damn which is more minimalist. You can also create a
shallow copy to unbless a reference, if you want to do it without
the help of any module (Both Acme::Damn and Data::Structure::Util
are XS modules, JFYI). <br><br>Re Data::Structure::Util: nifty
module that provides speedy alternative for several things like
checking for circular references, weaken them, unblessing a
reference, etc. You can do many of the routines in pure Perl. This
module lets you do them in C. <br>
Fsdb
Author: JOHNH <https://metacpan.org/author/JOHNH>
An interesting tool that has been developed since 1991 (which is
roughly around the time the WWW and Linux was born, whew). Kudos to
the author for the dedication and consistency. <br><br>Since
nowadays SQL is pretty much ubiquitous, users might also want to
check out an alternative tool, App::fsql. For example (taking a
similar example from the module's doc), to select entries in
/etc/passwd where UID is between 1000 and 2000: <br><br>$ ( echo -e
"login\tpassword\tuid\tgid\tgecos\thome\tshell"; sed
's/:/\t/g' /etc/passwd ) | fsql --add-tsv - 'SELECT * FROM stdin
WHERE uid >= 1000 AND uid <= 2000' --format text --aoh
Date::Tie
Author: FGLOCK <https://metacpan.org/author/FGLOCK>
Cool, but personally I'd rather have something like JavaScript's
properties (since Perl does have lvalue subroutine support):
<br><br>$date->year = 2014; <br>
File::Slurp::Tiny
Author: LEONT <https://metacpan.org/author/LEONT>
More effort needs to be made with regards to documentation,
especially for File::Slurp users looking for alternatives. Why is
this module needed? What are the differences with File::Slurp? How
do the functions behave on I/O errors (since err_mode option is not
supported)? <br>
Clone::PP
Author: NEILB <https://metacpan.org/author/NEILB>
Thanks for providing a pure-Perl alternative for deep cloning.
Otherwise we are stuck with core module Storable's dclone, which
cannot handle Regexp objects out of the box, must use deparse to
handle coderefs, and not to mention is not as fast as it should be
because it's a marshall+unmarshall algrorithm (ab)used for deep
cloning. <br><br>Of course, there are faster XS-based cloning
couple of translations). BTW, I think like in the POD of
DateTime::Format::Natural, it needs to list which phrases it
supports. And probably add more :-) <br><br>
Rating: 8/10
DateTime::Format::Natural
Author: SCHUBIGER <https://metacpan.org/author/SCHUBIGER>
I'm giving DateTime::Format::Natural 3 stars because while it's
great for English (it covers more phrases than
DateTime::Format::Flexible), it's also hard to translate. Look at
the source code for DateTime::Format::Natural::Lang::EN: lots of
Englishisms and weird structures (%grammars). Wonder why so far
there has not been any translations to another language? <br>
Rating: 6/10
App::sourcepan
Author: PEVANS <https://metacpan.org/author/PEVANS>
Thanks, just what I needed. (I was hoping cpanm would accept my
--download patch, but this is just as well). <br><br>It still uses
CPAN.pm and thus downloads the relatively big 01mailrc.txt.gz and
02packages.details.txt.gz file, thus slowing the first use. If you
use cpanm exclusively, this is rather annoying especially if you're
on a slow link.
Rating: 8/10
Text::ASCIITable::TW
The method of determining visual width of Chinese characters is
rather hackish. Text::ASCIITable should perhaps use Text::CharWidth
(which can be used to determine visual width of text in other
languages e.g. Japanese, etc) thus rendering this module
unnecessary. <br>
Text::VisualWidth
Author: NANZOU <https://metacpan.org/author/NANZOU>
Also look at Text::CharWidth for an alternative that can be used
with text in other languages (Chinese, etc). <br>
Text::VisualWidth::PP
Author: TOKUHIROM <https://metacpan.org/author/TOKUHIROM>
Also look at Text::CharWidth for an alternative that can be used
with text in other languages (Chinese, etc). <br>
Taint::Runtime
Author: RHANDOM <https://metacpan.org/author/RHANDOM>
Nice idea. Perl should really have included something like this
(analogous to warnings.pm for -w). <br><br>However, for something as
security-related as tainting, I personally think the interface is a
bit too complex and not robust enough. There are too many pitfalls
where one can fail to turn on tainting properly. <br><br>* First,
user must remember to import $TAINT, or doing '$TAINT = 1' has no
effect. There's no error/warning for this mistake. <br><br>* Then,
if one also forgets to import taint_start or taint_start, then doing
'taint_start' or 'taint_env' (without parentheses) will do nothing.
Also does not produce an error/warning except under strict mode.
<br><br>* One must remember to 'taint_env' *after* 'taint_start'.
There's no warning/error if one does the opposite. <br><br>I'd
rather have something like this: <br><br>{ <br><br>use tainting;
<br><br>... code is running in taint mode ... <br> } <br><br>use
tainting; <br> { <br><br>no tainting; <br><br>... code is running
without taint mode ... <br> } <br><br>No functions, no variables to
set, no exports. Tainting of %ENV etc should be done automatically
just like -T. <br><br>EDIT: I wrote tainting and uploaded it to CPAN
as proof of concept.
Rating: 8/10
L Author: SONGMU <https://metacpan.org/author/SONGMU>
Reinvents Class::Autouse (written 12 years ago). But at least L is
much simpler and shorter to type (the equivalent of -ML is
-MClass::Autouse=:superloader). <br><br>BTW, there's also
Module::AutoLoad, Module::AutoINC, and lib::xi which can
automatically install modules from CPAN and load them upon first
use.
UNIVERSAL::moniker
Author: KASEI <https://metacpan.org/author/KASEI>
Perl is not Ruby != everything Ruby does is horrible. This module
has its uses.
Time::Out
Author: PATL <https://metacpan.org/author/PATL>
A wrapper around Perl's alarm()/$SIG{ALRM}, so it has the same
limitations, e.g. you cannot use this to properly timeout external
programs started by system()/backtick. For the latter, you might
want to try IPC::Cmd (run() or run_forked()), or some simpler
interface for it like System::Timeout. <br><br>
Util::Timeout
Author: NOTBENH <https://metacpan.org/author/NOTBENH>
A wrapper around Perl's alarm()/$SIG{ALRM}, so it has the same
limitations, e.g. you cannot use this to properly timeout external
programs started by system()/backtick. For the latter, you might
want to try IPC::Cmd (run() or run_forked()), or some simpler
interface for it like System::Timeout. <br><br>
System::Timeout
Author: CHENGANG <https://metacpan.org/author/CHENGANG>
This is a thin wrapper over IPC::Cmd's run(). I'd personally use
run() directly, it's not much harder or longer to type. Plus,
IPC::Cmd is a core module. <br><br>
Module::Quote
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
Wouldn't a function like
load_module("Math::Module")->new(42) be more obvious?
Is there a specific goal for using custom quote operator (which
requires Devel::Declare, and thus a C compiler to build)? <br>
responded to my RT ticket and added rmap_code. Upgrading from 4- to
5-star :) Regexp support is not there yet though, and I have
suggested the ability to get all kinds of Perl-specific and weird
objects, because one of the main uses of Data::Rmap for me is to
"clean" a data structure to pass to non-Perl systems. <br>
Data::Properties::JSON
Author: JOHND <https://metacpan.org/author/JOHND>
The abstract for this module is a bit strange. What does this have
to do with 'test fixtures'? Also the documentation doesn't say much,
e.g. What will happen if a hash key contains funny characters (or
arrays, etc)? <br><br>A similar module in spirit is Data::Hive. I
think "providing convenient chained method access to
hierarchical data" should be refactored out. So perhaps
Data::Properties::{JSON,YAML,...} should just be a convenient
shortcut for {JSON,YAML,...} parser + Data::Hive.
Exporter::Auto
Author: NEILB <https://metacpan.org/author/NEILB>
I discourage module authors from exporting like this because it's
simply too impolite/intrusive for module users. If the module author
is lazy, there is already Exporter::NoWork which offers a few
options for module users. This module, on the other hand, gives no
control at all for users (so they'll have to resort to 'use Module
();'). <br><br>Let me remind all again by quoting from Exporter's
POD: "Do *not* export anything else by default without a good
reason! Exports pollute the namespace of the module user."
Net::Douban
Interface to web services should be put under WWW::*, not Net::*
HTML::Form::XSS
Author: DUMB <https://metacpan.org/author/DUMB>
Should probably be put under Test::*?
Thread::IID
Author: WROG <https://metacpan.org/author/WROG>
When I saw the perlmonks thread yesterday, I thought "well,
someone should package it and put it on CPAN". And then someone
did :) Thanks. <br>
Test::Lite
Author: BRADH <https://metacpan.org/author/BRADH>
This is just a reimplementation of Test::More. But I thank the
author for writing a short description of why this module is
written, how it is different from others, and suggestion of what
modules users should use. There are a lot of wheels being reinvented
on CPAN, and that's okay, I just wish more people would document the
reason.
Sub::Mage
Author: BRADH <https://metacpan.org/author/BRADH>
Since the first release, there are 13 subsequent releases in total.
What are the changes between releases? No idea, the author doesn't
bother to update Changes (and no public repo is listed). Apparently
all his other modules are also like this. Not very user-friendly.
<br><br>UPDATE 2011-11-22: I see that this has been rectified by the
author, there is now Changes entry for each new release. Cool,
thanks. <br>
relative_lib
Documentation is placed in README.md, so it's inaccessible from
perldoc et al. Why? This is not a Python library.
CPAN::Mini::Webserver
Author: MITHALDU <https://metacpan.org/author/MITHALDU>
Just found out about it, despite having used CPAN::Mini for over a
year. Helps *a lot*. More people should know this (e.g. mention from
CPAN::Mini POD).
Win32::App::which
Author: DOLMEN <https://metacpan.org/author/DOLMEN>
I don't use this module since I'm not on Windows. But why another
module? File::Which also handles Win32 (probably not the "the
current directory is explored before PATH" thing, but you
should consider submitting a patch). <br><br>At least the
documentation should state why this module is necessary. It
complicates scripts by having to select between two 'which'
implementations.
Devel::Platform::Info
Author: BARBIE <https://metacpan.org/author/BARBIE>
I knew CPAN wouldn't let me down. Now I can discard my own
OS/platform detecting code (which probably is buggier and not nearly
as extensive) and rely on Devel::Platform::Info instead.
<br><br>Devel::Platform::Info gives information not only about the
OS but also architecture, kernel type & version, etc. In my case
I need to detect distro name, its version, and its codename. All of
those are provided. <br><br>This module is so new though (started in
2010) so I wonder whether this need has never come up before. <br>
Package::Builder
Author: DRAUONER <https://metacpan.org/author/DRAUONER>
Less boilerplate please!
Rating: 2/10
File::LibMagic
Author: DROLSKY <https://metacpan.org/author/DROLSKY>
After comparing against File::MMagic, File::MMagic::XS, File::Type,
I ended up choosing File::LibMagic because it has the least problems
and looks like being the most maintained (although it would be nice
if the author cleans up the RT queue). <br><br>For those stuck
without a C compiler, File::Type or File::Magic can be an
alternative.
Rating: 8/10
File::MMagic::XS
Author: DMAKI <https://metacpan.org/author/DMAKI>
directory on the server and let rtorrent takes care of them. With
this module I can quickly whip up a short script to calculate the
total size of the downloadable files so I can be pretty sure that
when I leave my server for days/weeks, I don't run out of disk space
because I put in too many torrent files. <br>
Module::CoreList
Author: BINGOS <https://metacpan.org/author/BINGOS>
Wow, I was thinking the same exact "godsend" too and turns
out some other reviewer already said so. Very very helpful to assist
deployment and pick modules to use. I personally made a couple of
command-line scripts like pm-in-core or core-since-when to save some
typing. <br>
WWW::Mechanize
Author: SIMBABQUE <https://metacpan.org/author/SIMBABQUE>
WWW::Mechanize is of course one of the indispensable tools for any
web programmer or admin. The current problem is the proliferation of
3rd party subclasses, the functionalities of which cannot be used
together. So you want a polite Mechanize which does
self-rate-limiting and uses the Firefox or IE engine? A subclass
exists for each feature, but how do you use them together?
WWW::Mechanize needs to be more role/plugin-oriented instead of
inheritance-oriented. <br>
Mail::Sendmail
Author: NEILB <https://metacpan.org/author/NEILB>
I used Mail::Sendmail and a few others "older" modules
back from the days when it didn't support setting envelope sender
different from RFC From, and when the test hung on some dead host.
<br><br>If it's still working for you, great. I personally have
moved on to other modules like Email::Sender::Simple, which
abstracts sending mechanism (transport) and support SMTP auth, for
two. Also, many of the guide/documentation for Mail::Sendmail are
not quite up to date in style (though they still might work), for
example the low level way of building HTML email. Also, the
Changelog file doesn't seem to be maintained?
Rating: 6/10
autodie
Author: TODDR <https://metacpan.org/author/TODDR>
I started using autodie in almost all of my applications a few
months ago. It's somewhat of a mixed blessing. For existing
applications, it can break things and making things less robust,
solely because old code are not built with autodie in mind.
<br><br>But the best thing about it is that it's lexically scoped,
so for sections of code that you're not sure about, just sprinkle
'no autodie' to get the old behaviour. <br><br>It should be used on
probably 95% of code out there. For the rest of the cases, where you
need to report the status of each I/O operation, it's obviously more
convenient to check $? instead of trapping exception everytime.
<br><br>+1 for getting it into core. <br>
App::FileTools::BulkRename
Disclaimer: I maintain a "competitor" module, App::perlmv.
Apparently a lot of people, like me, likes to rename files using
Perl. And the examples in the documentation are about renaming movie
files too, something which I do a lot :) <br><br>I applaud Stirling
Westrup for taking a legacy script and improving it. May we have a
lot of ideas to borrow from each other. <br><br>This is an early
release, there are quite a few things I find lacking. Most
importantly, I suggest adding a test suite as soon as possible. The
filesystem differences can be tricky, and CPAN Testers can help
providing feedback. <br><br>Keep up the good work.
Rating: 8/10
Script::State
Author: MOTEMEN <https://metacpan.org/author/MOTEMEN>
Nice idea, straight and simple interface. A better name could
perhaps be chosen? Documentation should be expanded, e.g. to warn
users about security, since Data::Dumper a.k.a. eval() is used to
load variable content. Also, the implementation does not yet
consider file locking.
PathTools
I guess File::Spec's API is sane enough, but I suspect not a lot of
people are using it because there's not enough incentive for it.
When 99% population of the world use Unix/Linux/Windows (even Macs
been technically Unix for a number of years), "/" works
everywhere and using File::Spec does not gain you anything except
lots of typing exercise. <br><br>That's why I think Path::Class
might have a better chance of succeeding. It gives niceties like a
few more convenience methods, a shortcut of getting dir & file
object from each other, etc. It gives users more incentive of using
a proper path manipulation library because it gives extra stuff
along with that. It should also be in core to accompany File::Spec.
Rating: 8/10
File::Slurp
Author: CAPOEIRAB <https://metacpan.org/author/CAPOEIRAB>
I've been using File::Slurp for years and is generally satisfied
with it. However reading the negative reviews today and looking at
its RT queue, I realize that this module is broken for many and is
effectively abandoned by the maintainer (no new releases for almost
3 years now despite several RT items labeled as critical). So I
suggest others checking out the alternatives.
Rating: 2/10
Log::Log4perl
Author: ETJ <https://metacpan.org/author/ETJ>
It's a very mature and an excellent logging framework. However, some
of the common minor complaints are: 1) It's too complex. I agree: it
should not be this hard to get started. 2) Configuration is too
verbose. Agreed: but well, what can you do, most things from Java is
a bit overengineered and verbose anyway. At least you can do almost
anything with the configuration. 3) It's not very Perlish. Also
agreed. 4) Performance. My note: speed is not an issue in majority
of the cases and Log4perl's performance is adequate for most of the
rest of the cases. For faster/leaner alternatives you might want to
take a look at Log::Fast, but a lot of Log4perl's features are
missing. <br><br>One of the main strengths of Log4perl is its
sublogger/subcategory feature, which few other frameworks seem to
have. <br><br>For other alternatives, also take a look at:
Log::Handler, Log::Any. And of course Log::Message too. <br>
Log::Handler
Author: BLOONIX <https://metacpan.org/author/BLOONIX>
This review mostly compares Log::Handler with Log4perl, which is a
mature and one of the most popular logging frameworks. <br><br>I
think Log::Handler's interface is much simpler, nicer, more Perlish
than Log4perl. It's a bit similar to Log::Any::App, which I created
just because I hate Log4perl configuration. <br><br>There is a
unique concept of maxlevel not normally found in other frameworks,
though it can be emulated in other frameworks using filters.
<br><br>At a quick glance, the speed is around twice that of
Log::Log4perl, so I'll say it's on the low-end side (there are other
much faster logging modules, but anyway speed is not an issue to
most people). <br><br>It currently lacks sublogger (hierarchical
categorization and adjustable/automatic appending of subcategory to
its parent), so it cannot be used to replace Log4perl in most cases
as that's one of the main feature of Log4perl. Which is a pity
because I would otherwise switch.
Rating: 8/10
Log::Fast
Author: POWERMAN <https://metacpan.org/author/POWERMAN>
This logging framework is also minimalistic: no
categories/hierarchiecal loggers, no custom levels, no config file,
or other whistles and bells. And the interface & default levels
are rather syslog-oriented. But it's fast alright. The POD doesn't
mention a comparison to Log::Log4perl, but a casual benchmark shows
that it's at least 10x faster. <br><br>So this module will certainly
come handy if you have a performance critical application.
<br><br>Btw, note that the benchmarks are done for actual logging to
output. For log statements that do not actually get logged (e.g.
because the level is below the desired output level), I don't find
that extreme differences in overhead between logging frameworks. For
example, on my Athlon64 X2 5600+ PC, Log::Fast's overhead is roughly
around 3mils/sec, while Log::Log4perl is around 1,5mils/sec.
Log::Minimal
Author: KAZEBURO <https://metacpan.org/author/KAZEBURO>
Log::Minimal's slogan is "minimal but customizable". It's
minimal alright, probably only suitable for simple scripts as the
moment you organize your application/library into separate modules,
you'll want/need categories instead of just level, which is not
provided by Log::Minimal. <br><br>Also, only formats is
customizable, there is currently no way to customize level. And the
levels are "not standard" (not that there is an official
authoritative standard, but the popular convention is
TRACE/DEBUG/INFO/WARN/ERROR/FATAL and NONE). Log::Minimal's levels
are <br> DEBUG/INFO/WARN/CRITICAL and NONE). Surely most people
would expect another level between WARN and CRITICAL, for
non-critical errors? But that is actually just a matter of taste.
<br>
Rating: 4/10
Log::Fine
Author: CFUHRMAN <https://metacpan.org/author/CFUHRMAN>
Log::Fine is touted as a framework for those who "need a
fine-grained logging mechanism in their program(s)". But apart
from the emphasis on custom levels, to me there is nothing extra
fine-grained about it. The other thing it provides is
categories/namespace, which is also supported by a lot of other
frameworks. So I fail to see the benefit/uniqueness of Log::Fine.
<br><br>Btw regarding custom levels, this practice is long
deprecated by log4j (and thus also by Log4perl, although Log4perl
can do custom levels). I can understand this decision as I sometimes
already have trouble managing the popular convention of 6 levels
(FATAL/ERROR/WARN/INFO/DEBUG/TRACE) as it is, much less with custom
levels!
Rating: 6/10
Config::IniFiles
( run in 2.755 seconds using v1.01-cache-2.11-cpan-364913b4093 )