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>
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
<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.
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
=item L<DateTime::Format::Flexible>
Author: L<THINC|https://metacpan.org/author/THINC>
While it doesn't cover as much phrases as DateTime::Format::Natural, at least it's simpler to translate (and the dist already includes a couple of translations). BTW, I think like in the POD of DateTime::Format::Natural, it needs to list which phrase...
<br><br>
Rating: 8/10
=item L<DateTime::Format::Natural>
Author: L<SCHUBIGER|https://metacpan.org/author/SCHUBIGER>
I'm giving DateTime::Format::Natural 3 stars because while it's great for English (it covers more phrases than DateTime::Format::Flexible), it's also hard to translate. Look at the source code for DateTime::Format::Natural::Lang::EN: lots of Englishi...
<br>
Rating: 6/10
=item L<App::sourcepan>
Author: L<PEVANS|https://metacpan.org/author/PEVANS>
Thanks, just what I needed. (I was hoping cpanm would accept my --download patch, but this is just as well).
<br><br>It still uses CPAN.pm and thus downloads the relatively big 01mailrc.txt.gz and 02packages.details.txt.gz file, thus slowing the first use. If you use cpanm exclusively, this is rather annoying especially if you're on a slow link.
Rating: 8/10
=item L<Text::ASCIITable::TW>
The method of determining visual width of Chinese characters is rather hackish. Text::ASCIITable should perhaps use Text::CharWidth (which can be used to determine visual width of text in other languages e.g. Japanese, etc) thus rendering this module...
<br>
=item L<Text::VisualWidth>
Author: L<NANZOU|https://metacpan.org/author/NANZOU>
Also look at Text::CharWidth for an alternative that can be used with text in other languages (Chinese, etc).
<br>
=item L<Text::VisualWidth::PP>
Author: L<TOKUHIROM|https://metacpan.org/author/TOKUHIROM>
Also look at Text::CharWidth for an alternative that can be used with text in other languages (Chinese, etc).
<br>
=item L<Taint::Runtime>
Author: L<RHANDOM|https://metacpan.org/author/RHANDOM>
Nice idea. Perl should really have included something like this (analogous to warnings.pm for -w).
<br><br>However, for something as security-related as tainting, I personally think the interface is a bit too complex and not robust enough. There are too many pitfalls where one can fail to turn on tainting properly.
<br><br>* First, user must remember to import $TAINT, or doing '$TAINT = 1' has no effect. There's no error/warning for this mistake.
<br><br>* Then, if one also forgets to import taint_start or taint_start, then doing 'taint_start' or 'taint_env' (without parentheses) will do nothing. Also does not produce an error/warning except under strict mode.
<br><br>* One must remember to 'taint_env' I<after> 'taint_start'. There's no warning/error if one does the opposite.
<br><br>I'd rather have something like this:
<br><br>{
<br><br>use tainting;
<br><br>... code is running in taint mode ...
<br>
}
<br><br>use tainting;
<br>
{
<br><br>no tainting;
<br><br>... code is running without taint mode ...
<br>
}
<br><br>No functions, no variables to set, no exports. Tainting of %ENV etc should be done automatically just like -T.
<br><br>EDIT: I wrote tainting and uploaded it to CPAN as proof of concept.
Rating: 8/10
=item L<L>
Author: L<SONGMU|https://metacpan.org/author/SONGMU>
Reinvents Class::Autouse (written 12 years ago). But at least L is much simpler and shorter to type (the equivalent of -ML is -MClass::Autouse=:superloader).
<br><br>BTW, there's also Module::AutoLoad, Module::AutoINC, and lib::xi which can automatically install modules from CPAN and load them upon first use.
=item L<UNIVERSAL::moniker>
Author: L<KASEI|https://metacpan.org/author/KASEI>
Perl is not Ruby != everything Ruby does is horrible. This module has its uses.
=item L<Time::Out>
Author: L<PATL|https://metacpan.org/author/PATL>
A wrapper around Perl's alarm()/$SIG{ALRM}, so it has the same limitations, e.g. you cannot use this to properly timeout external programs started by system()/backtick. For the latter, you might want to try IPC::Cmd (run() or run_forked()), or some s...
<br><br>
=item L<Util::Timeout>
Author: L<NOTBENH|https://metacpan.org/author/NOTBENH>
A wrapper around Perl's alarm()/$SIG{ALRM}, so it has the same limitations, e.g. you cannot use this to properly timeout external programs started by system()/backtick. For the latter, you might want to try IPC::Cmd (run() or run_forked()), or some s...
<br><br>
=item L<System::Timeout>
Author: L<CHENGANG|https://metacpan.org/author/CHENGANG>
This is a thin wrapper over IPC::Cmd's run(). I'd personally use run() directly, it's not much harder or longer to type. Plus, IPC::Cmd is a core module.
<br><br>
=item L<Module::Quote>
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
Rating: 8/10
=item L<Data::Rmap>
Author: L<BOWMANBS|https://metacpan.org/author/BOWMANBS>
A very handy utility, sort of like s/// on your nested data structure instead of just strings. One nitpick: no coderef support. I needed to replace all coderefs inside a data structure into a string, since I want to pass it to JSON encoder. None of t...
<br><br>UPDATE 2011-12-30: The author (Brad) quickly responded to my RT ticket and added rmap_code. Upgrading from 4- to 5-star :) Regexp support is not there yet though, and I have suggested the ability to get all kinds of Perl-specific and weird ob...
<br>
=item L<Data::Properties::JSON>
Author: L<JOHND|https://metacpan.org/author/JOHND>
The abstract for this module is a bit strange. What does this have to do with 'test fixtures'? Also the documentation doesn't say much, e.g. What will happen if a hash key contains funny characters (or arrays, etc)?
<br><br>A similar module in spirit is Data::Hive. I think "providing convenient chained method access to hierarchical data" should be refactored out. So perhaps Data::Properties::{JSON,YAML,...} should just be a convenient shortcut for {JSO...
=item L<Exporter::Auto>
Author: L<NEILB|https://metacpan.org/author/NEILB>
I discourage module authors from exporting like this because it's simply too impolite/intrusive for module users. If the module author is lazy, there is already Exporter::NoWork which offers a few options for module users. This module, on the other h...
<br><br>Let me remind all again by quoting from Exporter's POD: "Do I<not> export anything else by default without a good reason! Exports pollute the namespace of the module user."
=item L<Net::Douban>
Interface to web services should be put under WWW::I<, not Net::>
=item L<HTML::Form::XSS>
Author: L<DUMB|https://metacpan.org/author/DUMB>
Should probably be put under Test::*?
=item L<Thread::IID>
Author: L<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>
=item L<Test::Lite>
Author: L<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 rei...
=item L<Sub::Mage>
Author: L<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 v...
<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>
=item L<relative_lib>
Documentation is placed in README.md, so it's inaccessible from perldoc et al. Why? This is not a Python library.
=item L<CPAN::Mini::Webserver>
Author: L<MITHALDU|https://metacpan.org/author/MITHALDU>
Just found out about it, despite having used CPAN::Mini for over a year. Helps I<a lot>. More people should know this (e.g. mention from CPAN::Mini POD).
=item L<Win32::App::which>
Author: L<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.
=item L<Devel::Platform::Info>
Author: L<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>
=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).
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
<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>
( run in 2.580 seconds using v1.01-cache-2.11-cpan-364913b4093 )