Reviews by Jon Portnoy


Devel-Isa-Explainer (0.001000) *****

Very nifty way to quickly get a handle on how a moderately complex codebase fits together & visualize inheritance issues.

Pry (0.003001) *****

Fantastic debug tool, and so much more reasonable than the built-in perl debugger.

A great companion to Devel::Confess; applying '-d:Confess' clues me in to exactly where things went sour, adding 'pry()' gives me a REPL that lets me know what lexicals are in scope & inspect them to determine why.

Moops (0.019) *****

A nice, modern approach to easy class building via arbitrary combinations of Moo/Moose/Mouse/Class::Tiny.

Lots of useful features are available to new classes right out of the box, such as Function::Parameters, Type::Tiny, Try::Tiny, etc.


Module-Runtime (0.013) *****

Correct and useful runtime module loading tools; works around funkyness in old buggy perls that can bite when doing the classic 'eval..require' routine. Also provides module name validation tools.

`use_module($some_class)->new(%params)` is a frequent idiom I use for dynamic class loading and object construction.

Object-Pluggable (1.29) *****

A base class providing a solid implementation of a controllable plugin pipeline. Well-tested as it is an integral part of the popular POE::Component::IRC suite (amongst others) via POE::Component::Syndicator.

The ability to easily control pipeline order (via methods) and event lifetime (via return values) are useful features that often lack in other plugin systems. Plugins are passed references to arguments, and therefore have the ability to alter event arguments before they are handed off to the next plugin in the pipeline.

Worth a serious look if implementing any kind of pluggable class -- POE users should probably also look at POE::Component::Syndicator, a subclass of Object::Pluggable.

Net-IP-Minimal (0.06) *****

A convenient minimalist module for determining whether an IP address is IPv4 or IPv6. Works as-advertised, and I rarely need the rest of Net::IP.

strictures (1.004004) *****

strictures is sort of dual-use: in typical usage (on your users' systems, for example), it is effectively the same as "use strict; use warnings FATAL => 'all'" -- but if it appears code is being run from a development repository (or if extra tests are explicitly enabled), you also get indirect object syntax, bareword filehandle, and multidimensional array ("I meant to type @hash{1,2} not $hash{1,2}") checks.

Pros: This has saved me from myself and others more than once.

Cons: Fatal-by-default warnings are a con for some people. You may need to think a little harder about which warnings you care about. Sometimes perl warns for some silly stuff, and that can change from one version to the next.

Role-Tiny (1.002005) *****

Roles are a sane approach to code reuse with reasonable and predictable behavior, as opposed to doing ugly and unpleasant things to your classes via inheritance.

Role::Tiny brings you the minimal set of useful role-building tools modelled after Moose's implementation of the concept; it is less restrictive than other models (such as Role::Basic), and provides goodies like `around` / `before` / `after` method modifiers.

Roles have solved a lot of design headaches for me; this module appears to be the nicest "just roles, please!" implementation available.

Moo (1.002000) *****

A slim-line Moose-alike without the costs and features most people don't need (plus Moose compatibility if it turns out you did); easy to sell to folks concerned about the overhead inherent to Moose. Very much simplified my object-heavy code.

List-Objects-WithUtils (2.003001)

While I understand educated_foo hates anything that smells like an object, and I get that "arrow-infested" syntax like `$hash->sliced('foo', 'bar', 'baz')` is less readable to some folks than writing a classic hash slice with an exists() check (for example), I think that his "send it to Acme!" review is a mischaracterization of what my module does.

Core operators are present -- they also live alongside other bundled tools and toys for working with collections (List::Util, List::MoreUtils, List::UtilsBy, junction objects, etc) packaged in a way that encourages thinking in functional terms.

Most methods that manipulate a list return new objects; avoiding mutable lists is easy/encouraged (or enforced via immutable objects).

Version 2 also adds type-checking objects (mutable and immutable) via integration with Type::Tiny.

I have simplified a fair bit of my in-house code this way -- at the (admittedly relatively heavy) cost of method call overhead -- which is why it is on CPAN ;-)