Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
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
Author: ROUZIER <https://metacpan.org/author/ROUZIER>
Please consider a simpler non-OO interface instead, a la
File::chdir: <br><br>use File::Umask; # or whatever, the
"Local" thing is redundant <br> { <br><br>local $UMASK =
0077; <br><br>open(...); <br><br>copy(...); <br> } <br> =head1
previous umask is restored
<br><br>which is arguably better (to me at least) than the current:
<br><br>use Umask::Local; <br> { <br><br>my $umask_local =
Umask::Local->new(0077); <br><br>open(...); <br><br>copy(...);
<br> } <br> =head1 previous umask is restored
<br>
Proc::PidUtil
Author: MIKER <https://metacpan.org/author/MIKER>
No file locking is currently done to the PID file to avoid race
condition. Look at Proc::PID::File for a more proper implementation.
<br><br>
Data::Dumper::Sorted
Author: MIKER <https://metacpan.org/author/MIKER>
Unnecessary. Data::Dumper does have the option to sort hash keys
($Sortkeys, look for 'sort' in 'perldoc Data::Dumper'). <br><br>This
module also does not handle circular refs yet (and probably lacks
other features of Data::Dumper too). <br><br>Also the choice of
returning error ("$Var00 = not a reference" when given
Dumper(1) for example) as result is arguably unwise. <br>
Archive::Probe
Author: FGZ <https://metacpan.org/author/FGZ>
I would personally pick a non-OO, no-nonsense interface based on
File::Find, like: <br><br>use File::Find::Archive qw(find); # or
find_archive <br> find(sub { ... }, "some.tar.gz");
<br><br>instead of the multiline, tedious setup just to search a
file. <br>
App::DBBrowser
Author: KUERBIS <https://metacpan.org/author/KUERBIS>
A nice, minimalistic, terminal-based user interface for browsing
your database and tables. Might be useful for simple cases.
<br><br>It would be *much* more useful if usernames/passwords,
queries, and other settings can be saved in a config/session file.
<br>
Locale::Maketext
Author: TODDR <https://metacpan.org/author/TODDR>
Users might want to check out this article on why one should perhaps
use Locale::TextDomain instead of Locale::Maketext: <a
href="http://www.perladvent.org/2013/2013-12-09.html"
rel="nofollow">www.perladvent.org/2013/2013-12-09.html</a>
Curses::Toolkit
Nice effort, but one might also want to look at Tickit, which is not
curses-based and looks more promising. Being based on Curses, this
module still suffers from the many bugs and limitations of curses.
The lack of Shift-Tab support, for one. <br><br>See also: <a
href="http://www.perlmonks.org/?node_id=1059926"
rel="nofollow">www.perlmonks.org/?node_id=1059926</a> <br><br>As I
explore doing TUI more, I will update the reviews. <br>
Moo::Lax
Author: DAMS <https://metacpan.org/author/DAMS>
Great idea! I've been bitten and annoyed by strictures on more than
one occasion. It has its uses, but users should have a choice on how
to react to warnings. <br>
App::YTDL
This module is based on WWW::YouTube::Download but its documentation
does not yet explain how it differs from WWW::YouTube::Download.
From what I see at a glance, App::YTDL supports downloading a video
from a playlist and setting download speed limit, but perhaps the
author should do the mode detailed explaining to help users when to
choose between the two. <br>
Data::CompactDump
Author: MILSO <https://metacpan.org/author/MILSO>
At the current form, simply too simplistic to be an alternative to
Data::Dump or Data::Dumper. No support for blessed refs,
filehandle/globs, circular references, and so on. Changes numbers to
stringy numbers or vice versa. <br><br>Currently also contains some
bugs like for -1 (changes it to string), "\" (produces
invalid dump, does not handle backslash yet currently), <br><br>And
Data::Dump's dump of {} and [] are currently more compact ;-)
<br><br>Need to be improved significantly first. But keep up the
effort.
P Author: LAWALSH <https://metacpan.org/author/LAWALSH>
I personally don't mind the namespace choice. There are other
single-letter CPAN modules too like B, L, U, V. If you have a beef
with regard to namespace, don't single out P and perhaps downvote
the other modules too. <br><br>Having said that, I would like to
comment on the design and implementation of this module. <br><br>1)
The choice of Unicode character U+2204 as representation of undef.
Unless one does something like 'binmode STDOUT, ":utf8"',
with 'say P undef' I am just trading one warning ("Use of
uninitialized value") with another ("Wide character in
say/print"). The wide character warning is avoided if you do 'P
"%s", undef' though, which means... <br><br>2) P loads
utf8 by default. For ultra-lightweight cases, this is sometimes not
desirable. There is currently no way to turn this off. <br><br>3)
The arbitrary choice of three levels deep when printing references.
This can be customized but with an unusual syntax. But again, the
arbitrary choice of three. <br><br>4) The "complex" rules
of newline printing. p() is like puts, it can optionally add a
newline. But unlike puts, the doc says it can also remove newlines.
The behavior can also change if the string to be printed ends with
0x83. <br><br>I might use P for a sprintf/printf replacement, but
for debugging values, I'd prefer something "dumber" like
Data::Dump::Color (or Data::Printer, if that's your thing).
Xporter
Author: LAWALSH <https://metacpan.org/author/LAWALSH>
A couple of comments. First, if you want to import the default
exports *as well as* some additional others, you can use Exporter's
feature (the :DEFAULT tag): <br><br>use SomeModule qw(:DEFAULT a b
c); <br><br>or you can also "use" twice: <br><br>use
SomeModule; # imports default exports <br><br>use SomeModule qw(a b
c); # import a, b, c <br><br>Second, if you use Xporter, your module
will behave unlike most CPAN modules out there, because a majority
of modules use Exporter. When people see this Perl code: <br><br>use
SomeModule qw(a b c); <br><br>normally they will expect only a, b,
and c are exported. If SomeModule uses Xporter, it will also by
default export the default exports. <br><br>Basically Xporter is
just Exporter with a different default (not arguably better or more
user-friendly). For the sake of minimizing surprise to my users, I
would avoid the use of Xporter. <br><br>UPDATE 2014-01-24: some
edits. I appreciate the effort of the author to defend her module,
though I am not convinced by her arguments.
Dist::Zilla::Shell
Author: DOLMEN <https://metacpan.org/author/DOLMEN>
Nice tool that lets you type dzil commands like 'build', 'test', etc
while sending all the other unknown commands like 'ls -l', 'man Foo'
to the underlying shell. Also lets you avoid multiple startup
overhead of dzil :-)
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
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
even nicer :-) <br><br>
Data::Pond
Author: ZEFRAM <https://metacpan.org/author/ZEFRAM>
With due respect to the author, I fail to see the practical point of
Pond. Pond (Perl-based open notation for data) is the Perl
counterpart of JSON, except that implementation is currently only
available in Perl (CMIIW), and "Pond represents fewer data
types directly". <br><br>Pond is pitched against Data::Dumper +
eval, which is dangerous, but Data::Dumper + eval is by far not the
only method available for serialization. Perl can do Storable, JSON,
YAML, even PHP serialization format. <br><br>The documentation does
not show what Pond looks like. <br><br>One cute thing about Pond is
that you can check Pond syntax using a single regex. But apart from
that, there's nothing compelling in using Pond to serialize data.
Rating: 4/10
File::Which
Author: PLICEASE <https://metacpan.org/author/PLICEASE>
You can always count on CPAN to have prewritten modules for various
things, including this one. I've never bothered before about
portability and just rely on the "which" command, but for
one reason there's a time when I just couldn't do that. <br><br>Btw,
there's also File::Which::Cached.
String::ShellQuote
Author: ROSCH <https://metacpan.org/author/ROSCH>
I admit it. Ever since I know about escapeshellarg() and
escapeshellcmd() in PHP, I've been reimplementing this function in
Perl literally a million of times (mostly because of laziness and
because it only takes a couple of lines in Perl). Only a few months
ago after the millionth time I said enough is enough and started to
look around in CPAN, and found this module. <br><br>The only problem
for this module is lack of visibility. Before I've never read
articles or blog posts mentioning this module, ever. Yes, we have
system() that can bypass the shell, but qx() can't. So yes, this
module needs to be marketed more! <br>
Capture::Tiny
Author: DAGOLDEN <https://metacpan.org/author/DAGOLDEN>
Another very handy little module that takes the hassle out of
figuring the various mechanisms of capturing output. <br><br>Nice
interface, great documentation, very easy to use. But....
<br><br>Currently it cannot just capture stdout *ONLY* or stderr
*ONLY* (while leaving the other alone). I believe this is one of the
most commonly requested feature (already in RT). If that feature is
implemented, this module deservers a 7-star rating.
Rating: 8/10
File::chdir
Author: DAGOLDEN <https://metacpan.org/author/DAGOLDEN>
This is a handy little module, with a simple and nice interface. One
of the more common bugs encountered in my scripts is forgetting to
track the current working directory after doing chdir() in
subroutines. By localizing $CWD, I don't have to worry that
subroutines mess up current working directory anymore.
FAQ
What is an Acme::CPANModules::* module?
An Acme::CPANModules::* module, like this module, contains just a list
of module names that share a common characteristics. It is a way to
categorize modules and document CPAN. See Acme::CPANModules for more
details.
( run in 2.091 seconds using v1.01-cache-2.11-cpan-0fb53d1c279 )