Calling Perl's in-built system() function is easy, determining if it
was successful is hard. Let's face it, $? isn't the nicest variable
in the world to play with, and even if you do check it, producing a
well-formatted error string takes a lot of work.
IPC::System::Simple takes the hard work out of calling external
commands.
IPC::MM provides an interface to Ralf Engelschall's mm library, allowing
memory to be shared between multiple processes in a relatively
convenient way.
IPC::MM provides methods to create and destroy shared memory segments and
to access data structures within those shared memory segments, as well
as miscellaneous methods. Additionally, it provides a tied interface
for scalars and hashes.
Inline::C is a module that allows you to write Perl subroutines in C. Since
version 0.30 the Inline module supports multiple programming languages and each
language has its own support module. This document describes how to use Inline
with the C programming language. It also goes a bit into Perl C internals.
This module is a simple wrapper around Locale::Maketext::Lexicon,
designed to alleviate the need of creating Language Classes for module
authors.
If Locale::Maketext::Lexicon is not present, it implements a minimal
localization function, so the program can function normally.
Log::Any::IfLOG will load Log::Any only when LOG environment variable is true.
Otherwise, the module is not loaded and if user imports $log, a dumb object will
be returned instead that will accept any method but return false.
This is a quick-hack solution to avoid the cost of loading Log::Any under
"normal condition" (when LOG is not set to true).
Lvalue takes an object produced by some other package and wraps it
with lvalue functionality implemented with the object's original
getter and setter routines. Lvalue assumes its object uses the
relatively standard getter / setter idiom where any arguments is a
setter, and no arguments is a getter.
`Memoizing' a function makes it faster by trading space for time. It
does this by caching the return values of the function in a table. If
you call the function again with the same arguments, memoize jumps in
and gives you the value out of the table, instead of letting the
function compute the value all over again.
The "Log::Dispatch::Perl" module offers a logging alternative using
standard Perl core functions. It allows you to fall back to the
common Perl alternatives for logging, such as "warn" and "cluck".
It also adds the possibility for a logging action to halt the current
environment, such as with "die" and "croak".
Log::Dispatchouli is a thin layer above Log::Dispatch and meant to
make it dead simple to add logging to a program without having to
think much about categories, facilities, levels, or things like that.
It is meant to make logging just configurable enough that you can find
the logs you want and just easy enough that you will actually log
things.
Log::Log4perl::Tiny yet another logging module. Nothing particularly fancy nor
original, too, but a single-module implementation of the features the author use
most from Log::Log4perl for quick things, namely:
- Easy mode and stealth loggers (aka log functions INFO, WARN, etc.)
- Debug message filtering by log level
- Line formatting customisation
- Quick sending of messages to a log file