Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
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
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
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
modules on CPAN (all currently non-core, believe it or not there are
no core modules for cloning except Storable). I'd recommend
Data::Clone. But it's nice to have a pure-Perl implementation, e.g.
for creating a dependency-free script using App::FatPacker.
IPC::System::Simple
Author: JKEENAN <https://metacpan.org/author/JKEENAN>
This is a well-designed module with a good interface. The core
system()'s behavior of whether to invoke shell or not depending on
the number of arguments is ... unfortunate. This module fixes that.
<br><br>However, the previous review's comparing of
IPC::System::Simple with IPC::Run or IPC::Simple is rather
misguided. They focus on different things: IPC::System::Simple
focuses on providing shell/no-shell versions of invoking commands
and making a command's result easier to parse. It does not support
feeding text to STDIN, handlers for STDOUT/STDERR, timeouts, or the
other features that IPC::{Run,Cmd} support.
IPC::Cmd
Author: BINGOS <https://metacpan.org/author/BINGOS>
IPC::Cmd does its job, but the interface is inconsistent, probably
because a different author wrote run_forked() (and didn't follow the
same convention). run() accepts a hash of arguments, but
run_forked() accepts a scalar + hashref. run() returns a list, but
run_forked() returns a hashref. Command in run_forked() cannot be an
arrayref, but in run() it can be.
Umask::Local
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>
Last time I checked, still can't parse system magic database, e.g.
/usr/share/file/magic (bug first filed in RT 4 years ago).
<br><br>The currently recommended module in this area seems to be
File::LibMagic. Other alternatives include File::MMagic (slow and
buggy, no longer maintained), Media::Type::Simple (only maps MIME
type from/to file extension).
Rating: 4/10
File::MMagic
Author: KNOK <https://metacpan.org/author/KNOK>
Works for basic usage, but has quite a few problems. Plus it is not
very performant. Doesn't seem to be maintained anymore. <br><br>The
currently recommended module in this area seems to be
File::LibMagic. Other alternatives include File::Type (gives less
useful results), File::MMagic::XS (also not actively maintained?
long standing bugs like failure to parse system magic file still
persists), Media::Type::Simple (only maps MIME type from/to file
extension). <br>
Rating: 4/10
File::Type
(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
to fix our application, so this is not really something meant for
public use. Will be purging this from PAUSE. <br>
SQL::Easy
Author: BESSARABV <https://metacpan.org/author/BESSARABV>
IIRC, there has also previous similar attempt like this. Modules
like these are not necessary, as DBI already has something
equivalent (and even better): selectrow_{array,hashref,arrayref} and
selectall_{array,hash}ref. <br>
Rating: 2/10
CGI::Struct
Author: FULLERMD <https://metacpan.org/author/FULLERMD>
Cool, will definitely try this out the next time I write another
form processing CGI script. Although the module is named CGI::,
there's nothing CGI-specific about it, and that's good. So this
module is basically a "path-expander" for hash values.
<br><br>Btw, one thing I use rather often in PHP is naming parameter
as "foo[]" which will automatically add elements to the
$_REQUEST['foo'] array. Perhaps this feature can be considered too.
DateTime::BusinessHours
Author: BRICAS <https://metacpan.org/author/BRICAS>
Just tried it. It works, but the module/dist is not in the best
shape: <br><br>* Test fails (pod-coverage, error in POD) <br><br>*
dependency on Class::MethodMaker not yet specified <br><br>*
Documentation: Synopsis contains mistake (class name is
DateTime::BusinessHours not BusinessHours), the name '$testing' is
not very suitable, there are typos. <br><br>* Style-wise, method
naming is "joinedwords", while in DateTime families it's
"separated_words" (not a big deal though). <br><br>
Rating: 6/10
Bundle::Dpchrist
Every once in a while everyone of us encounters a programmer that
disregards existing reusable code and creates his/her own
"standard library" for everything, from trimming string to
creating random number to cleaning the kitchen sink. We all might
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>
( run in 1.103 second using v1.01-cache-2.11-cpan-995e09ba956 )