view release on metacpan or  search on metacpan

README  view on Meta::CPAN

    App::Trace
        Author: SPADKINS <https://metacpan.org/author/SPADKINS>

        The name and abstract is slightly inaccurate/misleading. This module
        is supposed to be a general logging framework instead of just
        subroutine entry/exit tracer. For alternative subroutine tracer, I'd
        recommend Devel::TraceSubs or Devel::TraceCalls (or even
        Devel::Trace + variants). <br><br>Not very convenient to use. It
        still requires you to put 'if $App::Trace' clause everytime. For
        general logging that can be switched on/off upon runtime, I'd
        recommend using Log::Any instead. <br><br>Lastly, this module is
        tied to App::Options and thus only really usable if you use both.

    Tie::Hash::Identity
        Author: CINDY <https://metacpan.org/author/CINDY>

        Hash::Identity has a use case of convenience when embedding
        expression in double-quote strings. I fail to see the point of
        Tie::Hash::Identity though. Can't you just say: <br><br>'abc' eq
        'abc'; # true <br><br>(1+2+3) eq '6'; # true <br>

    Hash::Identity
        Author: CINDY <https://metacpan.org/author/CINDY>

        At first I thought, hey, cute trick. But then Perl already has:
        <br><br>print &quot;You could use expr like this:
        ${(2**3)}.\n&quot;; <br><br>print &quot;Or you could use ident ${(
        'a' . 'b' )} as well.\n&quot;; <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 = &quot;perl${(6-1)}-style
        interpolation&quot;; <br> { <br><br>use v6str; <br><br>$s =
        &quot;perl{ 5+1 }-style interpolation&quot;; <br> } <br>

    Data::Structure::Util
        Author: ANDYA <https://metacpan.org/author/ANDYA>

        @Tom Browder: If you just need unblessing, there's also another
        module Acme::Damn which is more minimalist. You can also create a
        shallow copy to unbless a reference, if you want to do it without
        the help of any module (Both Acme::Damn and Data::Structure::Util
        are XS modules, JFYI). <br><br>Re Data::Structure::Util: nifty
        module that provides speedy alternative for several things like
        checking for circular references, weaken them, unblessing a
        reference, etc. You can do many of the routines in pure Perl. This
        module lets you do them in C. <br>

    Fsdb
        Author: JOHNH <https://metacpan.org/author/JOHNH>

        An interesting tool that has been developed since 1991 (which is
        roughly around the time the WWW and Linux was born, whew). Kudos to
        the author for the dedication and consistency. <br><br>Since
        nowadays SQL is pretty much ubiquitous, users might also want to
        check out an alternative tool, App::fsql. For example (taking a
        similar example from the module's doc), to select entries in
        /etc/passwd where UID is between 1000 and 2000: <br><br>$ ( echo -e
        &quot;login\tpassword\tuid\tgid\tgecos\thome\tshell&quot;; sed
        's/:/\t/g' /etc/passwd ) | fsql --add-tsv - 'SELECT * FROM stdin
        WHERE uid &gt;= 1000 AND uid &lt;= 2000' --format text --aoh

    Date::Tie
        Author: FGLOCK <https://metacpan.org/author/FGLOCK>

        Cool, but personally I'd rather have something like JavaScript's
        properties (since Perl does have lvalue subroutine support):
        <br><br>$date-&gt;year = 2014; <br>

    File::Slurp::Tiny
        Author: LEONT <https://metacpan.org/author/LEONT>

        More effort needs to be made with regards to documentation,
        especially for File::Slurp users looking for alternatives. Why is
        this module needed? What are the differences with File::Slurp? How
        do the functions behave on I/O errors (since err_mode option is not
        supported)? <br>

    Clone::PP
        Author: NEILB <https://metacpan.org/author/NEILB>

        Thanks for providing a pure-Perl alternative for deep cloning.
        Otherwise we are stuck with core module Storable's dclone, which
        cannot handle Regexp objects out of the box, must use deparse to
        handle coderefs, and not to mention is not as fast as it should be
        because it's a marshall+unmarshall algrorithm (ab)used for deep
        cloning. <br><br>Of course, there are faster XS-based cloning
        modules on CPAN (all currently non-core, believe it or not there are
        no core modules for cloning except Storable). I'd recommend
        Data::Clone. But it's nice to have a pure-Perl implementation, e.g.
        for creating a dependency-free script using App::FatPacker.

    IPC::System::Simple
        Author: JKEENAN <https://metacpan.org/author/JKEENAN>

        This is a well-designed module with a good interface. The core
        system()'s behavior of whether to invoke shell or not depending on
        the number of arguments is ... unfortunate. This module fixes that.
        <br><br>However, the previous review's comparing of
        IPC::System::Simple with IPC::Run or IPC::Simple is rather
        misguided. They focus on different things: IPC::System::Simple
        focuses on providing shell/no-shell versions of invoking commands
        and making a command's result easier to parse. It does not support
        feeding text to STDIN, handlers for STDOUT/STDERR, timeouts, or the
        other features that IPC::{Run,Cmd} support.

    IPC::Cmd
        Author: BINGOS <https://metacpan.org/author/BINGOS>

        IPC::Cmd does its job, but the interface is inconsistent, probably
        because a different author wrote run_forked() (and didn't follow the
        same convention). run() accepts a hash of arguments, but
        run_forked() accepts a scalar + hashref. run() returns a list, but
        run_forked() returns a hashref. Command in run_forked() cannot be an
        arrayref, but in run() it can be.

    Umask::Local
        Author: ROUZIER <https://metacpan.org/author/ROUZIER>