view release on metacpan or  search on metacpan

README  view on Meta::CPAN

    App::whatthecommit
        Author: MUDLER <https://metacpan.org/author/MUDLER>

        From the description: &quot;App::whatthecommit is just another
        lazy-to-lazy line command utility.&quot; 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>

    Opt::Imistic
        Author: 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 &quot;proper&quot; 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 flag options,
        the ability to configure permute/no_permute (mix mashing options
        with arguments), some data validation, and of course:
        autoabbreviation of long option names, which requires a spec after
        all.

    Devel::STrace
        Author: DARNOLD <https://metacpan.org/author/DARNOLD>

        The doc looks promising, it really looks like it could be the
        &quot;strace for Perl functions&quot;, 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). And I'm
        probably an idiot, but I can't get this module to work for me.
        <br><br>One alternative if you're looking for a similar module is
        Debug::LTrace. <br><br>

    Devel::TraceSubs
        Author: 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>

    Devel::TraceCalls
        Author: 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 &quot;strace
        for Perl function&quot;). <br>

    Debug::LTrace
        Author: 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 &quot;strace for Perl
        functions&quot;, try this. <br>

    Debug::Trace
        Author: 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 &quot;off-by-1&quot; (see
        Hook::LexWrap). Plus, Debug::LTrace gives more information like
        timing. <br><br>

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

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

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

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

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

        At first I thought, hey, cute trick. But then Perl already has:
        <br><br>print &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