Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
Devel::Confess
Author: HAARG <https://metacpan.org/author/HAARG>
Very nifty, it's like Carp::Always but with much more
options/features (so you don't need a separate Carp::Always::Color,
Carp::Always::Dump, and so on).
SQL::Statement
Author: REHSACK <https://metacpan.org/author/REHSACK>
The concept is truly cool, unfortunately the parser is currently
flaky/buggy: one SQL query might work but another valid and
seemingly simple SQL would fail with weird error message. See
distribution's RT queue. <br>
Rating: 6/10
PerlMongers::Hannover
Author: PTC <https://metacpan.org/author/PTC>
Instead of just printing some info, why not make it an Acme::PM or
Acme::PerlMongers like Acme::CPANAuthors? Various stats can then be
produced about the various Perl Mongers. <br>
App::multiwhich
Note that File::Which can also search for all matches too if you use
it in a list context, e.g. @paths = which('foo'). File::Which also
comes with a pwhich CLI utility which also accepts multiple
arguments and has the -a switch to print all matches. The output
format is slightly different than 'multiwhich' though. <br><br>In
fact, the Unix 'which' command (or at least its Debian variant) also
sports the -a switch.
Object::Anon
Author: ROBN <https://metacpan.org/author/ROBN>
Nice idea. Some notes: 1) to be widely used, it really needs to be
very efficient; 2) if the goal is simply to objectify a hash,
perhaps Hash::Objectify or Object::From::Hash or Hash::To::Object
(or Data::Objectify and so on) is a more descriptive name. <br>
Data::Seek
The "extremely fast and efficient" claim currently doesn't
hold, as this module creates a *whole* flattened tree for *every*
search operation. <br><br>A simple benchmark: <br><br>### <br> use
Benchmark qw(timethese); <br> use Data::Seek; <br> use Data::DPath
qw(dpath); <br> use JSON::Path; <br><br>my $data = { map { $_ =>
{map {$*=>[1..4]} 1..20} } "a".."z" };
<br><br>timethese(-0.25, { <br><br>dseek => sub { $ds =
Data::Seek->new(data=>$data);
$ds->search("j.1.\@")->data },
<br><br>dseek*cacheobj=>sub{ state
$ds=Data::Seek->new(data=>$data);
$ds->search("j.1.\@")->data },
<br><br>dpath=>sub{ dpath("/j/1/*")->match($data) },
<br><br>jpath=>sub{
JSON::Path->new(q[$.j.1.[*]])->values($data) }, <br> }); <br>
=head2 #
<br><br>### <br> Benchmark: running dpath, dseek, dseek_cacheobj,
jpath for at least 0.25 CPU seconds... <br><br>dpath: 1 wallclock
secs ( 0.27 usr + 0.00 sys = 0.27 CPU) @ 8292.59/s (n=2239)
<br><br>(warning: too few iterations for a reliable count)
<br><br>dseek: 1 wallclock secs ( 0.29 usr + 0.00 sys = 0.29 CPU) @
37.93/s (n=11) <br><br>(warning: too few iterations for a reliable
count) <br> dseek_cacheobj: 0 wallclock secs ( 0.33 usr + 0.00 sys =
0.33 CPU) @ 42.42/s (n=14) <br><br>(warning: too few iterations for
a reliable count) <br><br>jpath: 0 wallclock secs ( 0.27 usr + 0.00
sys = 0.27 CPU) @ 11711.11/s (n=3162) <br><br>(warning: too few
iterations for a reliable count) <br> =head2 #
<br><br>Also: 1) the syntax is rather inconsistent: ':n' for array
index access, but '.@' (instead of ':@') for grabbing all elements.
2) currently cannot select subtree (must always select leaf node).
<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
le Sereal!
Test::Tester
Author: EXODIST <https://metacpan.org/author/EXODIST>
If you write test functions, you need this. It's like the
"Test::More" for "Test::More". However, it
currently does not work out of the box with subtests (submitted as
wishlist to RT). <br><br>PS: Thanks to Toby Inkster for pointing
this module out. <br><br>
Text::CharWidth
Author: KUBOTA <https://metacpan.org/author/KUBOTA>
It's faster than Unicode::GCString->new($str)->columns, but it
gives wrong answers to lots of characters, e.g. control characters
like "\n", "\t", etc are currently assumed to
have width of -1 character. You're better off with
Unicode::GCString.
Rating: 2/10
App::Options
Author: SPADKINS <https://metacpan.org/author/SPADKINS>
2010-10-13: <br><br>I admit, this is not the most flexible
configuration framework out there as it enforces some convention.
And I don't/can't use it on every project. But it's certainly one of
the easiest. You can slap a few lines of options declaration in your
code and voila, your script suddenly can accept command line
arguments, has --help message et al, read from config files (in
several preset locations). <br><br>There are still a few annoyances
(I submitted them in the RT), but in general, this is a very handy
module to use for lazy coders who just want to accept
configuration/options from outside the code. <br><br><shameless
plug>I'm trying to do somewhat the same with Config::Tree, but as
of now the module is not really done yet.</shameless plug>
<br><br>UPDATE 2013-08-15: <br><br>I'm reducing the ratings from 5
to 2. I've now avoided using this module due to two lingering issue
since 2010: 1) App::Options does not accept '--opt val', only
'--opt=val' which is incompatible with how most command-line
programs work, causing confusion for some of my users. 2) 'perl -c'
doesn't work under this module, it will still trigger command-line
processing. <br><br>I'm now using Perinci::CmdLine as replacement,
but I cannot recommend it in general, as the two modules are not
equivalent.
Rating: 4/10
Filesys::Notify::Simple
Author: MIYAGAWA <https://metacpan.org/author/MIYAGAWA>
It's rather unfortunate that currently the choice for general
purpose cross-platform filesystem notification modules on CPAN falls
between this module (FNS) or File::ChangeNotify (F::CN). The other
CPAN modules are either OS-/framework-specific. <br><br>FNS has a
simple API but is perhaps too simple for some uses, while F::CN uses
Moose and has a big startup overhead. <br><br>If you simply want to
check from time to time whether a change has occured, you need to
wrap the wait() method with alarm(). And I found on my Linux PC that
I need a timeout of at least 3 seconds for this to work reliably.
Rating: 8/10
experimental
Author: LEONT <https://metacpan.org/author/LEONT>
Vote +1 to add this to core. Please make coding in Perl 5 relatively
painless.
MIME::Lite::HTML
Author: ALIAN <https://metacpan.org/author/ALIAN>
Very straightforward to use (I needed to send a URL/webpage as HTML
email with embedded images/objects). With this module I can finish
my job with only a few lines of Perl in 3-5 minutes (searching for
this module in CPAN takes more than that! searching using "mail
web" or "email url" at first didn't get results).
<br><br>Blackberry is having trouble displaying the resulting email
though. No problem with Gmail or Thunderbird/Icedove.
Term::Size
Author: FERREIRA <https://metacpan.org/author/FERREIRA>
5-year old bug like RT#38594 still present. Use one of the alternate
implementations like Term::Size::{Unix,Win32,ReadKey}. <br>
Rating: 2/10
DateTime::Format::Flexible
Author: THINC <https://metacpan.org/author/THINC>
While it doesn't cover as much phrases as DateTime::Format::Natural,
at least it's simpler to translate (and the dist already includes a
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: SYP <https://metacpan.org/author/SYP>
Shows great promise. I personally need this for HTTPS proxy support.
After testing, the module still doesn't work to login to my internet
banking sites. But I'll still check in from time to time. <br>
Devel::SizeMe
Author: TIMB <https://metacpan.org/author/TIMB>
Wow, just wow. Hopefully now that we can use this tool to know how
big things are, we are encouraged to create leaner, faster, more
efficient Perl modules.
Oktest
Author: KWATCH <https://metacpan.org/author/KWATCH>
A reinvention of Perl testing modules (it even comes with an
equivalent for 'prove' command), with probably no added features and
some added quirks. (Nested) topic can already be done using
Test::More's subtests. Filtering and setup/teardown can be done with
Test::Class. And I am supposed to replace specific assertion
functions (with specific, helpful error messages) like is(), isnt(),
like(), is_deeply(), etc with just OK()? <br>
Rating: 4/10
HTML::Escape
Author: TOKUHIROM <https://metacpan.org/author/TOKUHIROM>
Still a bit slower than PHP's htmlspecialchars(), but in the same
ballpark. An order of magnitude faster than HTML::Entities. Does not
provide unescaping, but it's okay since escaping is the majority of
use cases.
Clone::Fast
Casual benchmarking on my PC shows that Data::Clone is up to twice
faster than this.
Rating: 6/10
Perl::Strip
Author: MLEHMANN <https://metacpan.org/author/MLEHMANN>
Balancing previous unhelpful review. Slowish (can't complain,
PPI-based) but works and comes with a command-line utility.
<br><br>Beware though that the command-line utility modifies file in
place without backup, without warning, and without option to create
backup. <br>
Rating: 8/10
Perl::Squish
Author: ADAMK <https://metacpan.org/author/ADAMK>
Have failed to build for 1.5 years (reported bug RT#66958 left
untouched, users need to install Module::Install first). No usage
documentation. <br><br>
Rating: 2/10
perlsecret
Author: BOOK <https://metacpan.org/author/BOOK>
Nice collection of perl shortcuts. Today I forgot about the name for
"x!!" and nicely found it in this module.
PerlX::ArraySkip
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
Cute idea as always, though I'd rather use comments rather than
taking multiple sub calls hit.
App::perlfind
Author: MARCEL <https://metacpan.org/author/MARCEL>
A timesaver. Using it on a daily basis (aliased to "pod").
Thanks, Marcel!
PerlX::Maybe
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
A nice syntax addition for avoiding passing or writing a bunch of
undefs. More convenient to write than using ternary operator or
grep. I'm beginning to adore syntax modules like this (as long as it
adds negligible overhead). <br><br>
File::Path::Tiny
Author: DMUEY <https://metacpan.org/author/DMUEY>
I like the concept, but do not like the overly short names mk() and
rm(). Instead of mk(), how about mkdir_p() or mkpath() like in
File::Path. Instead of rm(), how about rm_r() or rmtree() like in
File::Path. <br>
Rating: 6/10
Exporter::Lite
Author: NEILB <https://metacpan.org/author/NEILB>
2011-10-04: I am now using Exporter::Lite exclusively instead of
Exporter. Got bit once by Exporter when using for an OO module due
to clash of assigning to @ISA vs 'use base'. +1 for putting it into
core. <br><br>EDIT 2012-08-08: Nowadays I revert back to Exporter
most of the time because Exporter is core. To avoid @ISA issue, one
simply needs to import import() instead setting @ISA: <br><br>use
Exporter qw(import); <br>
YAML::Syck
Author: TODDR <https://metacpan.org/author/TODDR>
To be fair, in my experience YAML::Syck is not "much more
buggy" than ::XS. It even sometimes works with my YAML data
while ::XS crashes. Go figure.
Devel::FindPerl
Author: LEONT <https://metacpan.org/author/LEONT>
IMO the module should explain in the POD, in what cases using $^X is
not enough or how it is different from Probe::Perl. <br><br>Anyway,
quoting CPAN Testers' CPAN Authors FAQ, $^X is not enough when: <br>
1) perl was executed with a relative path and the script has
I prefer YAML::Syck, in others YAML::XS, this depends on the data
that I'm handling. <br>
PerlX::Perform
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
I personally don't see much value of this syntactic sugar since Perl
already allows us to express clearly. Pick one: <br><br>for ($foo) {
say $_ if defined } <br><br>for (grep {defined} $foo) { say $_ }
<br><br>do { say $_ if defined } for $foo <br><br>say $_ for grep
{defined} $foo <br><br>And save yourself from having to remember
whether we should add a comma or not before "wherever".
<br>
TOBYINK::PerlX::A
I have nothing against bundles like this, but beware that adding
'use TOBYINK::PerlX::A' will cause Perl to load 460 files and
compile +- 160k lines (takes 1s on my Core i5 machine and 8s on my
Atom netbook).
WWW::Google::Images
Just adding a note that this module is unmaintained (as expressed by
the author) and has stopped working for some time. If you are
looking for alternatives, try REST::Google (which includes
REST::Google::Search::Images). The latter has been working OK for
me.
Acme::Damn
Author: IBB <https://metacpan.org/author/IBB>
5 stars for cute metaphor (there's also Acme::Holy by the same
author, but that is just another implementation of Scalar::Util's
blessed()) and for prompt support from the author. <br><br>I'm sure
there exists a real use case to move this out of Acme::, however
obscure that might be. Can't come up with any right now, all I can
think of is reblessing, which can be handled with bless() from the
start. <br><br>UPDATE 2013-09-11: I found a real use-case for it!
Cleaning up data to be sent to JSON. BTW, Data::Structure::Util also
has an unbless() function, but Acme::Damn is smaller and faster.
Data::Structure::Util also currently doesn't build on Windows. <br>
WWW::Parallels::Agent
@Justin Case: The name is unfortunate, but it's already proper
(WWW:: followed by website or company name). HTTP client libraries
are in LWP::. But VM:: is also an apt choice. <br>
Underscore
I don't know why Sawyer X's review is marked as unhelpful (2 out of
8), but I agree with him. This is *not* an Acme module, it's a port
of a JavaScript library of the same name. <br>
Locale::Geocode
Author: DIZ <https://metacpan.org/author/DIZ>
Sorry to have to rate with 1 star. I don't have problem with the
interface/documentation. The 1-star rating is just to warn people
that the data used by this module is not up to date. And that
YEARS-old bugs are not being fixed. <br><br>At the time of this
writing, this module still uses ISO 3166-2:1998 (first edition) +
the newsletters (minor updates) up to 2006. When it should be
updated to ISO 3166-2:2007 (second edition) + all the newsletters.
For example, this module does not report 3 newer provinces in
Indonesia. <br><br>Sadly we live in a world where countries and
subcountries change all the time.
Rating: 2/10
Locale::SubCountry
Author: KIMRYAN <https://metacpan.org/author/KIMRYAN>
UPDATE 2012-08-30: I am not sure if the module is now fully
compliant to the new ISO 2007, but bug reports are certainly being
responded and resolved now. Updating rating from 1-star to 4-star.
Thanks, Kim. <br><br>2012-02-17: Review to version 1.47:
<br><br>Sorry to have to rate with 1 star. I don't have problem with
the interface/documentation. The 1-star rating is just to warn
people that the data used by this module is not up to date. And that
months-old bugs are not being fixed. <br><br>At the time of this
writing, this module still uses ISO 3166-2:1998 (first edition) when
it should be updated to ISO 3166-2:2007 (second edition) + all the
newsletters (minor updates). For example, this module does not
report 3 newer provinces in Indonesia. <br><br>Sadly we live in a
world where countries and subcountries change all the time.
<br><br>EDIT: Ok, so I was not being clear that I was not talking
about my own bug report (posted at about the same time of this
review). And bugs were certainly being resolved up to about 7 months
ago. <br>
Rating: 8/10
Data::Rmap
Author: BOWMANBS <https://metacpan.org/author/BOWMANBS>
A very handy utility, sort of like s/// on your nested data
structure instead of just strings. One nitpick: no coderef support.
I needed to replace all coderefs inside a data structure into a
string, since I want to pass it to JSON encoder. None of the
rmap_*() functions seem to let me get to the coderefs. (RT wishlist
ticket added.) <br><br>UPDATE 2011-12-30: The author (Brad) quickly
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>
Rating: 2/10
Unix::ConfigFile
Author: SSNODGRA <https://metacpan.org/author/SSNODGRA>
Outdated module that doesn't handle /etc/shadow and /etc/gshadow.
Rating: 2/10
lib::xi
Author: GFUJI <https://metacpan.org/author/GFUJI>
Handy module for installing dependencies. There are previous
efforts, but the arrival of cpanm makes autoinstall process less
tedious, so hats off also to the creator of cpanm. <br>
Capture::Tiny::Extended
Author: MITHALDU <https://metacpan.org/author/MITHALDU>
Indispensable. Provides nice enhancement to Capture::Tiny
(particularly the real-time teeing). <br>
google_talk_bot
Improperly packaged, improper POD formatting, bot messages hardcoded
in script, and yes... idiotic license. Basically a "trial"
script to bait users into consultation gig. CPAN is not a place for
this kind of thing. Please try again. <br>
Rating: 2/10
Clone::Any
Author: EVO <https://metacpan.org/author/EVO>
Using Clone::Any nowadays is more trouble than it's worth.
<br><br>First, there are annoying incompatibilities between cloning
modules. Most notably Storable, which is the default cloning module
if Clone is not available, *still* doesn't support storing Regexp
objects out-of-the-box after all these years. <br><br>Second, this
module has not been updated for a long time and newer alternatives
like the fast Data::Clone is not recognized. <br><br>Right now I'm
replacing all code from using Clone::Any code to Data::Clone.
<br><br>
Rating: 4/10
Array::OrdHash
Author: WOWASURIN <https://metacpan.org/author/WOWASURIN>
Fun module to play with, especially for those among us infected with
a bit of PHP envy (me, never!). <br>
Bash::Completion
Author: MELO <https://metacpan.org/author/MELO>
Clean code, plugin interface simple to use, but implementation needs
to be improved. For example, parsing $ENV{COMP_LINE} &
$ENV{COMP_POINT} into @argv is done simplistically using
split(/\h+/), without regard to shell's quotes/escapes.
(Getopt::Complete's way is somewhat better by invoking shell, but it
also has its problems. I guess in this regard external programs are
second-class citizens to shell functions because they don't get the
equivalents of COMP_WORDS/COMP_CWORD). <br>
Rating: 6/10
Bash::Completion::Plugins::cpanm
Author: PERLER <https://metacpan.org/author/PERLER>
Cool, except that with cpanm I often install local distribution
(cpanm Foo-Bar-1.23.tar.gz). Perhaps the completion can look in the
filesystem first before firing API request. Also, might be nice if
there is some caching because it seems to be slow (at least from
where I am). <br>
Rating: 8/10
Switch
Author: CHORNY <https://metacpan.org/author/CHORNY>
With all due respect to the author, Switch is no longer necessary in
5.10+ as 5.10+ already introduced smart matching and given().
given() is superior because it doesn't introduce compile-time
overhead, doesn't mess line numbers, and should be faster (simply
because smart match is fast, and Switch is not utilizing it).
<br><br>You have been using 5.10+, right? (Since 5.8 is no longer
officially supported) <br>
Moo Author: HAARG <https://metacpan.org/author/HAARG>
Last week I ported an application from Mouse (Any::Moose) to Moo.
Went without a hitch (well I did replace "with 'X', 'Y',
'Z';" to "with 'X'; with 'Y'; with 'Z';" as
instructed in the Moo documentation). Startup time decreased
significantly. Planning to move every Moose apps to Moo. Splendid!
<br>
Sub::StopCalls
Author: RUZ <https://metacpan.org/author/RUZ>
Cool idea, if a bit extreme. <br><br>If computing a value is
expensive, there's Memoize for the caller. On the callee side, you
can cache the result (there's state variable in 5.10+ so it's dead
simple to use). <br><br>So I believe Sub::StopCalls is only
necessary if you find the overhead of the sub call itself to be a
bottleneck. And if that is the case, perhaps you should refactor the
calling code anyway.
Rating: 8/10
Log::Log4perl::Tiny
Author: POLETTIX <https://metacpan.org/author/POLETTIX>
5 stars solely for the idea (I'm beginning to love the ::Tiny
movement more and more these days). Haven't actually tried it
though, but I bet many Log4perl users, me included, mostly only use
easy_init. As much as Log4perl is mature and fairly optimized, it's
still a relatively "huge" library. Nice to know there's a
drop-in ::Tiny replacement.
SHARYANTO::YAML::Any
Re: Blue. I guess I shouldn't release this. I need something quick
have been one too, at one time or another. I'm not saying that this
bundle is a case of the above, but it's giving me a similar feeling.
:-) <br><br>A commendable effort, David. But there really are a lot
of wheels being reinvented here.
Net::BitTorrent::File
Author: ORCLEV <https://metacpan.org/author/ORCLEV>
I mass download stuffs by putting a bunch of torrent files in a
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
Author: SHLOMIF <https://metacpan.org/author/SHLOMIF>
This module has been developed for more than a decade and seen
different maintainers over the years. The codebase is indeed showing
these, with different capitalization and indentation styles, among
other things. <br><br>However, among more than a dozen or so of INI
modules in CPAN, ironically there seems to be few other choices if
you go beyond the most basic feature set. Some INI modules can only
simplistically rewrite/dump the whole INI structure and thus lose
comments/orders, while others can't even write INI files.
<br><br>Config::IniFiles by far offers the most options and
features, like dealing with line continuation, case sensitivity,
default section, multiline/array, deltas, etc. So for now, despite
all of its quirks, this module is still hard to beat.
<br><br>There's another nice little INI module that can do
read/set/delete/unset (instead of just read/dump): Prima::IniFile,
but it is included in a totally unrelated distribution.
Rating: 8/10
DateTime
Author: DROLSKY <https://metacpan.org/author/DROLSKY>
Amidst all the glowing reviews may I add a reminder that, as with
everything, there's a catch: runtime performance. On my PC, the
speed of creating a DateTime object is just around 6000/sec. If you
use DateTime intensively, it can quickly add up. <br><br>Imagine
serving a web page that fetches 50 rows from database, where for
convenience you convert each date column to a DateTime object, and
you have 120 requests/sec coming in... That's already 6000 objects
(an extra second!). <br><br>Which is unfortunate because DateTime is
so wonderful, convenient, correct, complete and all that. So one
approach you can use might be to delay converting to DateTime object
until necessary.
Date::Manip
Author: SBECK <https://metacpan.org/author/SBECK>
Wow, there are surely a lot of negative reviews ... <br><br>First of
all, Date::Manip has a long history. I used this module back in
2001-2002, IIRC. Back then it was *the* swiss army of date/time
manipulation, something you use when you want the most
flexible/complete thing in Perl. True, it's slow, but it works.
<br><br>But then things change. DateTime project was started, and
now it is somewhat the de facto standard. It's more modern and far
more modular than the monolithic Date::Manip (every timezone and
language support and parsing/formatting modules shipped in one
single distribution). <br><br>And then there's the 5.x -> 6.x
debacle. As someone who also sprinkle Perl 5.10 requirements to his
CPAN modules, I can feel for the author. But the difference is, most
of my modules are not that widely used/known, and also many start
its life already requiring 5.10 right from its first released
version. While in Date::Manip's case, this happens to a very widely
used module. Surely backwards compatibility should be considered
more. <br><br>All in all, you are free to use or not use
Date::Manip. There are other alternatives. Pick wisely. <br>
Rating: 6/10
App::pmuninstall
Author: XAICRON <https://metacpan.org/author/XAICRON>
One would wonder why CPAN clients still don't have this crucial
feature Though you see Miyagawa listed in the Credits so maybe
cpanminus or its sister will end up having this functionality? One
can only hope. At 0.06, some things are not working flawlessly
(submitted in RT). Keep up the good work! <br><br>
App::lntree
Author: ROKR <https://metacpan.org/author/ROKR>
I guess this app is still useful, since "cp -sR" still
doesn't work as many would expect, and there are Windows users out
there (yes, newer NTFS does support symlinks; though I don't know
whether this module supports creating symlinks on NTFS). <br><br>A
minor comment would be on the name, maybe lnstree can be considered
instead (since "ln" indicates hardlink, at least for me).
Btw, there's also a free software called "lns" to do the
exact same thing. <br><br>
Data::Clone
Author: GFUJI <https://metacpan.org/author/GFUJI>
I've never encountered difficulty in cloning data structures in
Perl, usually I just use Clone or sometimes Storable's freeze + thaw
(the later does not yet support cloning Regexp objects out of the
box). <br><br>However, I like Data::Clone for its speed! It's
several times faster than Clone or freeze+thaw. So hats up. Planning
to use Data::Clone in future projects. <br><br>Now if we can
convince Goro to write a fast serializer/deserializer with compact
output (essentially, a faster version of Storable), that would be
( run in 3.386 seconds using v1.01-cache-2.11-cpan-63c85eba8c4 )