Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
package Acme::CPANModules::Import::CPANRatings::User::stevenharyanto;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-29'; # DATE
our $DIST = 'Acme-CPANModules-Import-CPANRatings-User-stevenharyanto'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {description=>"This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.",entries=>[{description=>"\n(REMOVED)\n",module=>"Log::Any",rating=>undef},{description=>"\nProvides a thin/lightweight OO interface for \$?, ...
1;
# ABSTRACT: List of modules mentioned by CPANRatings user stevenharyanto
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::Import::CPANRatings::User::stevenharyanto - List of modules mentioned by CPANRatings user stevenharyanto
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::Import::CPANRatings::User::stevenharyanto (from Perl distribution Acme-CPANModules-Import-CPANRatings-User-stevenharyanto), released on 2023-10-29.
=head1 DESCRIPTION
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<Log::Any>
Author: L<PREACTION|https://metacpan.org/author/PREACTION>
(REMOVED)
=item L<Process::Status>
Author: L<RJBS|https://metacpan.org/author/RJBS>
Provides a thin/lightweight OO interface for $?, much like what Time::Piece does for localtime()/gmtime() or File::Stat for stat(). Of course, Real(TM) programmers shift and fiddle bits by themselves, but for the rest of us this module is a nice conv...
=item L<Archive::Any>
Author: L<OALDERS|https://metacpan.org/author/OALDERS>
Nice idea, but the API needs to richer to be more useful (otherwise one will still need to go to individual Archive::Tar, Archive::Zip, etc). Currently the API provided are: listing files and extracting all files. We can't: create archive, add more f...
Rating: 8/10
=item L<Devel::Confess>
Author: L<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).
=item L<SQL::Statement>
Author: L<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
=item L<PerlMongers::Hannover>
Author: L<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>
=item L<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. ...
<br><br>In fact, the Unix 'which' command (or at least its Debian variant) also sports the -a switch.
=item L<Object::Anon>
Author: L<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 na...
<br>
=item L<Data::Seek>
The "extremely fast and efficient" claim currently doesn't hold, as this module creates a I<whole> flattened tree for I<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 {$I<< =>[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/I<< ")->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>
=item L<Games::2048>
Author: L<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.
=item L<App::D>
Author: L<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>
=item L<Getopt::Long>
Author: L<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...
<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, ...
<br>
=item L<Text::Table::Tiny>
Author: L<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 joi...
<br><br>I did a comparison in: <a href="http://blogs.perl.org/users/steven_haryanto/2014/07/benchmarking-several-ascii-table-generator-modules.html" rel="nofollow">blogs.perl.org/users/steven_haryanto/...</a>
=item L<Mo>
Author: L<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 ...
<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>
=item L<App::ChangeShebang>
Author: L<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" ...
<br>
=item L<Hash::Ordered>
Author: L<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>
=item L<App::whatthecommit>
Author: L<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>
=item L<Opt::Imistic>
Author: L<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 fla...
=item L<Devel::STrace>
Author: L<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). ...
<br><br>One alternative if you're looking for a similar module is Debug::LTrace.
<br><br>
=item L<Devel::TraceSubs>
Author: L<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>
=item L<Devel::TraceCalls>
Author: L<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>
=item L<Debug::LTrace>
Author: L<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>
=item L<Debug::Trace>
Author: L<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 ti...
<br><br>
=item L<App::Trace>
Author: L<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 (o...
<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.
=item L<Tie::Hash::Identity>
Author: L<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>
=item L<Hash::Identity>
Author: L<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>
=item L<Data::Structure::Util>
Author: L<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::Stru...
<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 ...
<br>
=item L<Fsdb>
Author: L<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
=item L<Date::Tie>
Author: L<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>
=item L<File::Slurp::Tiny>
Author: L<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 opt...
<br>
=item L<Clone::PP>
Author: L<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 ...
<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. ...
=item L<IPC::System::Simple>
Author: L<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...
=item L<IPC::Cmd>
Author: L<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 ...
=item L<Umask::Local>
Author: L<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>
=item L<Proc::PidUtil>
Author: L<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>
=item L<Data::Dumper::Sorted>
Author: L<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>
=item L<Archive::Probe>
Author: L<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>
=item L<App::DBBrowser>
Author: L<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 I<much> more useful if usernames/passwords, queries, and other settings can be saved in a config/session file.
<br>
=item L<Locale::Maketext>
Author: L<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>
=item L<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>
=item L<Moo::Lax>
Author: L<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>
=item L<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...
<br>
=item L<Data::CompactDump>
Author: L<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.
=item L<P>
Author: L<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 (...
<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).
=item L<Xporter>
Author: L<LAWALSH|https://metacpan.org/author/LAWALSH>
A couple of comments. First, if you want to import the default exports I<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.
=item L<Dist::Zilla::Shell>
Author: L<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 :-)
=item L<CPANPLUS::Shell::Curses>
Author: L<MARCUS|https://metacpan.org/author/MARCUS>
Unmaintained. Installs but no longer runs.
Rating: 2/10
=item L<Task::Mechanistic>
If you peek into its Makefile.PL, you'll see a seemingly random/heterogenous collection of modules to install (instead of just WWW::Mechanize). This is probably a Task::BeLike::$AUTHOR in disguise.
<br><br>
=item L<Sereal>
Author: L<YVES|https://metacpan.org/author/YVES>
So far the best of the bunch.
<br><br>FAST: much faster than Storable, roughly the same speed as (sometimes slightly faster than) Data::Clone for cloning.
<br><br>FEATUREFUL: Can handle circular references, Regexp objects (trips out-of-the-box Storable), JSON::{PP,XS}::Boolean objects (trips Data::Clone).
<br><br>COMPACT: definitely more compact (up to several times) than Storable.
<br><br>I'm sold. What more do you want? Le Storable est mort, vive le Sereal!
=item L<Test::Tester>
Author: L<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>
=item L<Text::CharWidth>
Author: L<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 wi...
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
Rating: 8/10
=item L<Data::Compare>
Author: L<DCANTRELL|https://metacpan.org/author/DCANTRELL>
Pros: handle hashes as well as arrays, handle nested and cyclic structure, plugins.
<br><br>Cons: No cmp-like functionality (returning -1, 0, 1), slow (even slower than Array::Compare).
<br><br>See also: Array::Compare, JSON/YAML/Storable.
<br>
Rating: 6/10
=item L<Array::Compare>
Author: L<DAVECROSS|https://metacpan.org/author/DAVECROSS>
Pros: has a perm() function to check whether the two arrays contain the same things but in different order (although you can simply just run sort() over the arrays first). Allow skipping some elements from comparison.
<br><br>Cons: no cmp-like functionality (returning -1, 0, 1), slow (for equality test, you might as well compare the json_encode() result of the arrays, which is way faster), no nested comparison. No procedural interface.
<br><br>See also: Data::Compare, JSON/YAML/Storable.
Rating: 4/10
=item L<Mozilla::Mechanize>
Author: L<SLANNING|https://metacpan.org/author/SLANNING>
No longer builds (tested on a current Debian). A pity, since drop-in replacements for WWW::Mechanize (using different backend like curl, IE, Mozilla, Chrome, etc) might be handy.
<br><br>
=item L<LWP::Curl>
Author: L<LORN|https://metacpan.org/author/LORN>
Those looking for LWP drop-in replacement might want to take a look at the recently released LWP::Protocol::Net::Curl instead, which supports WWW::Mechanize.
<br><br>
=item L<LWP::Protocol::Net::Curl>
Author: L<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>
=item L<Devel::SizeMe>
Author: L<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.
=item L<Oktest>
Author: L<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 d...
<br>
Rating: 4/10
=item L<HTML::Escape>
Author: L<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.
=item L<Clone::Fast>
Casual benchmarking on my PC shows that Data::Clone is up to twice faster than this.
Rating: 6/10
=item L<Perl::Strip>
Author: L<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
=item L<Perl::Squish>
Author: L<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
=item L<perlsecret>
Author: L<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.
=item L<PerlX::ArraySkip>
Author: L<TOBYINK|https://metacpan.org/author/TOBYINK>
Cute idea as always, though I'd rather use comments rather than taking multiple sub calls hit.
=item L<App::perlfind>
Author: L<MARCEL|https://metacpan.org/author/MARCEL>
A timesaver. Using it on a daily basis (aliased to "pod"). Thanks, Marcel!
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
Author: L<KEEDI|https://metacpan.org/author/KEEDI>
I use Markdown::Pod for my module Perinci::To::POD.
<br><br>This module does not output proper POD for many (not so) edge cases, like:
<br><br>C<>> and the likes are not yet escaped, producing C<>> when it should have been C<< > >> or C<E<gt>>.
<br><br>Ordered list numbering does not yet work, e.g. "2. ...\n3. ...\n" produces "=item 1. ... =item 1. ..."
<br><br>Ordered list with item numbered other than 1 does not work (see above). This should be supported in POD because POD allows us to write the bullets/numbers for each item.
<br><br>Inline markup is not smart enough to differentiate word_with_underscore. So "foo_bar and foo_baz" becomes "fooI<bar and foo>baz".
<br><br>Plus it segfaults sometimes (might be my perl though).
Rating: 4/10
=item L<Lingua::Metadata>
Author: L<MAJLIS|https://metacpan.org/author/MAJLIS>
As previous reviewer noted, this module is actually just a front-end to the author's web service. Plus license is specifically BSD (which allows this module to be included in closed source projects), this is rather ironic to me.
<br>
=item L<Finance::Currency::Convert::WebserviceX>
Author: L<CLACO|https://metacpan.org/author/CLACO>
Simple, no-fuss interface, recommended. As mentioned in the doc, the alternatives have some downsides: Finance::Currency::Convert::Yahoo is based on web scraping while ::XE has usage limits.
<br>
=item L<Carp::Always::Color>
Author: L<DOY|https://metacpan.org/author/DOY>
Like Carp::Always? Want something better? Here it is.
<br>
=item L<CHI>
Author: L<ASB|https://metacpan.org/author/ASB>
The DBI of caching. Stop reinventing your caching framework and just use this.
<br><br>UPDATE 2013-01-16: unfortunately, the use of Moose reduces the usefulness of CHI for command-line scripts (0.2s/146 files/53k lines startup overhead just to initialize a File cache). So 4 stars instead of 5. Let's hope the author migrates to ...
<br>
Rating: 8/10
=item L<Monkey::Patch>
Author: L<FRODWITH|https://metacpan.org/author/FRODWITH>
Compared to several other monkey-patching modules (like Sub::Monkey or Class::Monkey) I prefer this one because the interface is simplest and the documentation is the most straightforward. Plus it can do stacked patching and unordered restore, which ...
<br><br>
=item L<Log::AutoDump>
Author: L<CAGAO|https://metacpan.org/author/CAGAO>
This module is simple and to the point. Unfortunately, if you're a user of Log4perl or other logging framework, you'll have to switch just for a single feature (autodumping).
<br><br>An alternative is to use Log::Any, which also features autodumping (via $log->debugf("%s", $complex), $log->warnf(), and friends), while still allowing you to use Log4perl and other frameworks supported by Log::Any.
<br><br>
=item L<List::Pairwise>
Author: L<TDRUGEON|https://metacpan.org/author/TDRUGEON>
Two nice and possibly very useful functions. But IMO the names 'mapp' and 'grepp' are two similar to 'map' and 'grep', making it prone to typos and misreading. Perhaps consider 'map2' and 'grep2'?
=item L<Log::Log4perl::Appender::File::FixedSize>
Author: L<HOREA|https://metacpan.org/author/HOREA>
Module name should perhaps be Log::Log4perl::Appender::File::RoundRobin to make it clearer that the backend is File::RoundRobin.
<br>
=item L<Any::Mo>
Why exclude Moo?
<br><br>Also the issue with any Any::* (or Any::*) modules is that there should be a mechanism (preferably a common one) to adjust the ordering. Sometimes I prefer Moose first, for full capability or compatibility or whatever. Sometimes I prefer Mous...
<br>
=item L<PerlX::Perform>
Author: L<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>
=item L<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).
=item L<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 O...
=item L<Acme::Damn>
Author: L<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 Win...
<br>
=item L<WWW::Parallels::Agent>
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
<br><br>This module is so new though (started in 2010) so I wonder whether this need has never come up before.
<br>
=item L<Package::Builder>
Author: L<DRAUONER|https://metacpan.org/author/DRAUONER>
Less boilerplate please!
Rating: 2/10
=item L<File::LibMagic>
Author: L<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
=item L<File::MMagic::XS>
Author: L<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
=item L<File::MMagic>
Author: L<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...
<br>
Rating: 4/10
=item L<File::Type>
Author: L<PMISON|https://metacpan.org/author/PMISON>
As another reviewer has said, this module tends to conclude "application/octet-stream" for many kinds of files, making it not very useful.
<br><br>The currently recommended module in this area seems to be File::LibMagic. Other alternatives include File::MMagic (slow, has quite a few bugs, no longer maintained), File::MMagic::XS (also not actively maintained? long standing bug like failu...
<br>
Rating: 2/10
=item L<Time::Mock>
Author: L<EWILHELM|https://metacpan.org/author/EWILHELM>
Balancing previous 1 rating by @Ingo.
<br><br>To Ingo: You said module's documentation is okay, one feature you use works okay, and other features you don't use. Why only 1 star then?
<br><br>This module is a worthy alternative to Test::MockTime. It offers extra features such as working across forks, mocking Time::HiRes (eventually), and speeding/slowing down time.
=item L<Sakai::Stats>
Release early, release often indeed. First you release nothing but boilerplate :)
Rating: 2/10
=item L<Spreadsheet::Perl>
Author: L<NKH|https://metacpan.org/author/NKH>
Good documentation. All modules' documentation should similarly strive to contain at least: rationale for existence, pointer to alternatives, and task-oriented organization.
=item L<Unix::PasswdFileOps>
Author: L<BMAYNARD|https://metacpan.org/author/BMAYNARD>
Less-than-descriptive name (module's main function seems to be sorting entries, can't be guessed from the name). No unit tests. Doesn't handle /etc/shadow. Also, it might be useful to explain why one needs to sort entries in passwd file.
<br>
Rating: 4/10
=item L<Array::Diff>
Author: L<NEILB|https://metacpan.org/author/NEILB>
Yes, simple and gets the job done. Though I'm a bit curious with the implementation. If the interface is only to get number of deleted and added items (instead of positions of deletion/insertion), why depend on Algorithm::Diff (or use the name 'diff'...
<br>
=item L<DZ1>
Why do we need this uploaded to CPAN?
Rating: 2/10
=item L<Passwd::Unix>
Author: L<STRZELEC|https://metacpan.org/author/STRZELEC>
No tests. No detailed error status, only true/false (yes, there is a 'warnings' parameter on constructor, but this doesn't give out warnings on all operations, only some). No locking (although there is backup, but still).
<br><br>Also, some weird choices, why use bzip2 when creating backup? Or, why still require running as root (checking $() if we are allowing custom database file location?
<br><br>Between this and Unix::ConfigFile, I'm seriously considering using Unix commands instead (useradd, userdel, gpasswd, et al).
<br><br>UPDATE 2011-04-21: I created a fork of Passwd::Unix 0.52 called Passwd::Unix::Alt instead, which add some tests and modifications. Try it out if your needs are also not met by Passwd::Unix.
<br><br>UPDATE 2012-08-30: I created a new module called Unix::Passwd::File. Try it out if your needs are also not met by Passwd::Unix.
Rating: 2/10
=item L<Unix::ConfigFile>
Author: L<SSNODGRA|https://metacpan.org/author/SSNODGRA>
Outdated module that doesn't handle /etc/shadow and /etc/gshadow.
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
Rating: 8/10
=item L<Switch>
Author: L<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...
<br><br>You have been using 5.10+, right? (Since 5.8 is no longer officially supported)
<br>
=item L<Moo>
Author: L<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 si...
<br>
=item L<Sub::StopCalls>
Author: L<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
=item L<Log::Log4perl::Tiny>
Author: L<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 optimi...
=item L<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>
=item L<SQL::Easy>
Author: L<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
=item L<CGI::Struct>
Author: L<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 ...
<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.
=item L<DateTime::BusinessHours>
Author: L<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
=item L<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 a...
<br><br>A commendable effort, David. But there really are a lot of wheels being reinvented here.
=item L<Net::BitTorrent::File>
Author: L<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 prett...
<br>
=item L<Module::CoreList>
Author: L<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-s...
<br>
=item L<WWW::Mechanize>
Author: L<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 d...
<br>
=item L<Mail::Sendmail>
Author: L<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::Sendma...
Rating: 6/10
=item L<autodie>
Author: L<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>
=item L<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
=item L<Script::State>
Author: L<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...
=item L<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), &quo...
<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 ...
Rating: 8/10
=item L<File::Slurp>
Author: L<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 rel...
Rating: 2/10
=item L<Log::Log4perl>
Author: L<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...
<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>
=item L<Log::Handler>
Author: L<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 ...
Rating: 8/10
=item L<Log::Fast>
Author: L<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...
<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 log...
=item L<Log::Minimal>
Author: L<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 leve...
<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/FAT...
<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
=item L<Log::Fine>
Author: L<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 c...
<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 ...
Rating: 6/10
=item L<Config::IniFiles>
Author: L<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 ...
<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
=item L<DateTime>
Author: L<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.
=item L<Date::Manip>
Author: L<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 I<the> swiss army of date/time manipulation, something you use when you want the most flexible/complete thing in Perl. True, it's slow,...
<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 ship...
<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 ...
<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
=item L<App::pmuninstall>
Author: L<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 flaw...
<br><br>
=item L<App::lntree>
Author: L<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 NT...
<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>
=item L<Data::Clone>
Author: L<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>
=item L<Data::Pond>
Author: L<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 few...
<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
=item L<File::Which>
Author: L<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 tha...
<br><br>Btw, there's also File::Which::Cached.
=item L<String::ShellQuote>
Author: L<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 fe...
<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>
=item L<Capture::Tiny>
Author: L<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 I<ONLY> or stderr I<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 ra...
Rating: 8/10
=item L<File::chdir>
Author: L<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 ...
=back
=head1 FAQ
=head2 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 L<Acme::CPANModules> for more details.
=head2 What are ways to use this Acme::CPANModules module?
Aside from reading this Acme::CPANModules module's POD documentation, you can
install all the listed modules (entries) using L<cpanm-cpanmodules> script (from
L<App::cpanm::cpanmodules> distribution):
% cpanm-cpanmodules -n Import::CPANRatings::User::stevenharyanto
Alternatively you can use the L<cpanmodules> CLI (from L<App::cpanmodules>
distribution):
% cpanmodules ls-entries Import::CPANRatings::User::stevenharyanto | cpanm -n
or L<Acme::CM::Get>:
% perl -MAcme::CM::Get=Import::CPANRatings::User::stevenharyanto -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::Import::CPANRatings::User::stevenharyanto -E'say $_->{module} for @{ $Acme::CPANModules::Import::CPANRatings::User::stevenharyanto::LIST->{entries} }' | cpanm -n
This Acme::CPANModules module also helps L<lcpan> produce a more meaningful
result for C<lcpan related-mods> command when it comes to finding related
modules for the modules listed in this Acme::CPANModules module.
See L<App::lcpan::Cmd::related_mods> for more details on how "related modules"
are found.
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANModules-Import-CPANRatings-User-stevenharyanto>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANModules-Import-CPANRatings-User-stevenharyanto>.
=head1 SEE ALSO
L<Acme::CPANModules> - about the Acme::CPANModules namespace
L<cpanmodules> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 CONTRIBUTING
To contribute, you can send patches by email/via RT, or send pull requests on
GitHub.
Most of the time, you don't need to build the distribution yourself. You can
simply modify the code, then test via:
% prove -l
If you want to build the distribution (e.g. to try to install it locally on your
system), you can install L<Dist::Zilla>,
L<Dist::Zilla::PluginBundle::Author::PERLANCAR>,
L<Pod::Weaver::PluginBundle::Author::PERLANCAR>, and sometimes one or two other
Dist::Zilla- and/or Pod::Weaver plugins. Any additional steps required beyond
that are considered a bug and can be reported to me.
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2023, 2018 by perlancar <perlancar@cpan.org>.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANModules-Import-CPANRatings-User-stevenharyanto>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=cut
( run in 2.426 seconds using v1.01-cache-2.11-cpan-302cb4679cc )