view release on metacpan or  search on metacpan

README  view on Meta::CPAN

        in Unix command-line. <br>

    Text::Table::Tiny
        Author: 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
        joining cells together with join(). <br><br>I did a comparison in:
        <a
        href="http://blogs.perl.org/users/steven_haryanto/2014/07/benchmarki
        ng-several-ascii-table-generator-modules.html"
        rel="nofollow">blogs.perl.org/users/steven_haryanto/...</a>

    Mo  Author: 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 single line of
        +-500 characters, and it's inlinable. It loads in under 1ms. If a
        script must be executed thousands of times a day, that 9ms
        difference will matter more. <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>

    App::ChangeShebang
        Author: SKAJI <https://metacpan.org/author/SKAJI>

        Given that the name of this module/app is &quot;change shebang&quot;
        (instead of &quot;change shebang to samedir perl&quot;) perhaps this
        app can be made more generic? For example, I've had to change all
        shebangs from &quot;#!/usr/bin/env perl&quot; to &quot;#!perl&quot;
        and vice versa. Perhaps this module/app can become a tool to easily
        switch between shebangs. <br>

    Hash::Ordered
        Author: 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>

    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