PerlIO::gzip provides a PerlIO layer that manipulates files in the format used
by the gzip program.

Polymorphic return values are really useful. Often, we just want to know if something worked or not. Other times, we'd like to know what the error text was. Still others, we may want to know what the error code was, and what the error properties were. We don't want to handle objects or data structures for every single return value, but we do want to check error conditions in our code because that's what good programmers do.
When functions are successful they may return true, or perhaps some useful data. In the quest to provide consistent return values, this gets confusing between complex, informational errors and successful return values.
This module provides these features with a simple API that should get you what you're looking for in each contex a return value is used in.

This module allows easy sorting (via comparisons) of mixed text and numeric
strings, similar to the complex "version numbers" that many revision control
packages and shared library systems use.

The CRC32 module calculates CRC sums of 32 bit lengths. It generates the same
CRC values as ZMODEM, PKZIP, PICCHECK and many others.

The Template-GD distribution provides a number of Template Toolkit plugin modules to interface with Lincoln Stein's GD modules. These in turn provide an interface to Thomas Boutell's GD graphics library.

Term::ProgressBar provides a simple progress bar on the terminal, to let the user know that something is happening, roughly how much stuff has been done, and maybe an estimate at how long remains.

A typical use sets up the progress bar with a number of items to do, and then calls update to update the bar whenever an item is processed.

diff() provides a basic set of services akin to the GNU diff utility. It is not anywhere near as feature complete as GNU diff, but it is better integrated with Perl and available on all platforms. It is often faster than shelling out to a system's diff executable for small files, and generally slower on larger files.

Tie::EncryptedHash augments Perl hash semantics to build secure, encrypting
containers of data. Tie::EncryptedHash introduces special hash fields that are
coupled with encrypt/decrypt routines to encrypt assignments at STORE() and
decrypt retrievals at FETCH(). By design, encrypting fields are associated with
keys that begin in single underscore. The remaining keyspace is used for
accessing normal hash fields, which are retained without modification.

While the password is set, a Tie::EncryptedHash behaves exactly like a standard
Perl hash. This is its transparent mode of access. Encrypting and normal fields
are identical in this mode. When password is deleted, encrypting fields are
accessible only as ciphertext. This is Tie::EncryptedHash's opaque mode of
access, optimized for serialization.

Encryption is done with Crypt::CBC(3) which encrypts in the cipher block
chaining mode with Blowfish, DES or IDEA. Tie::EncryptedHash uses Blowfish by
default, but can be instructed to employ any cipher supported by Crypt::CBC(3).

This utf-8 converter is written in plain perl and works with hopefully any perl
5 version. It was mainly written because more recent modules such as Encode do
not work under older Perl 5.0 installations.

XMLTV is a set of utilities to manage your TV viewing. They work with TV
listings stored in the XMLTV format, which is based on XML. The idea is to
separate out the backend (getting the listings) from the frontend (displaying
them for the user), and to implement useful operations like picking out your
favourite programmes as filters that read and write XML documents.

There are two backends at present, grabbing TV listings for Canada, the USA,
the UK, as well as Germany and/or Austria. There are filters to sort the
listings by date, to remove shows that have already been broadcast, and a
couple of programmes to organize your viewing by storing preferences of what
shows you watch. There are a couple of backends to produce printed output.

Python and Perl modules and development tools

BottleRocket is a command-line interface for Unix systems to use the X-10
FireCracker kit. It is easy to use, has all of the major (non-gui)
functionality of the Windows interface, is easy to call from scripts and the
backend code is made to be easily linked into other programs.

syncmail is a script that is used to provide email notification of
changes to a CVS repository. For more information, including
installation instructions, read the syncmail(1) manpage, or type
"syncmail --help".

a small and fast embedded database library.

TCPWatch is a utility written in Python that lets you monitor forwarded TCP
connections or HTTP proxy connections. It displays the sessions in a window
with a history of past connections. It is useful for developing and debugging
protocol implementations and web services.

Indent Finder is a python script that reads a file and tells you what
indentation is used inside the file. It is not tied to any particular language.
It was tested successfully with C, C++, python and Java code.

The Devel::StackTrace module contains two classes, Devel::StackTrace and
Devel::StackTrace::Frame. The goal of this object is to encapsulate the
information that can found through using the caller() function, as well as
providing a simple interface to this data.

The Devel::StackTrace object contains a set of Devel::StackTrace::Frame
objects, one for each level of the stack. The frames contain all the data
available from 'caller()'.

This code was created to support my the Exception::Class::Base manpage
class (part of Exception::Class) but may be useful in other contexts.

This class implements a regex-based RFC 2822 parser that locates email
addresses in strings and returns a list of 'Email::Address' objects found.
Alternatley you may construct objects manually. The goal of this software
is to be correct, and very very fast.

This Perl module is an Encode::Encoding subclass that uses
Encode::Detect::Detector to determine the charset of the input data and then
decodes it using the encoder of the detected charset.

It is similar to Encode::Guess, but does not require the configuration of a set
of expected encodings. Like Encode::Guess, it only supports decoding--it cannot
encode.

Exception::Class allows you to declare exception hierarchies in your modules in
a "Java-esque" manner.

It features a simple interface allowing programmers to 'declare' exception
classes at compile time. It also has a base exception class,
Exception::Class::Base, that can be easily extended.

It is designed to make structured exception handling simpler and better by
encouraging people to use hierarchies of exceptions in their applications,
as opposed to a single catch-all exception class.

This module does not implement any try/catch syntax. Please see the
"OTHER EXCEPTION MODULES (try/catch syntax)" section for more information on
how to get this syntax.

You will also want to look at the documentation for Exception::Class::Base,
which is the default base class for all exception objects created
by this module.

Author: Dave Rolsky

If you wanna "scrub" or "sanitize" html input in a reliable an flexible
fashion, then this module is for you.

I wasn't satisfied with HTML::Sanitizer because it is based on
HTML::TreeBuilder, so I thought I'd write something similar that works
directly with HTML::Parser.

JSON (JavaScript Object Notation) is a simple data format. See to
http://www.json.org/ and RFC4627(http://www.ietf.org/rfc/rfc4627.txt).

This module converts Perl data structures to JSON and vice versa using either
JSON::XS or JSON::PP.

JSON::XS is the fastest and most proper JSON module on CPAN which must be
compiled and installed in your environment. JSON::PP is a pure-Perl module
which is bundled in this distribution and has a strong compatibility to
JSON::XS.

This module try to use JSON::XS by default and fail to it, use JSON::PP
instead. So its features completely depend on JSON::XS or JSON::PP.

"diff()" provides a basic set of services akin to the GNU "diff"
utility. It is not anywhere near as feature complete as GNU "diff", but
it is better integrated with Perl and available on all platforms. It is
often faster than shelling out to a system's "diff" executable for small
files, and generally slower on larger files.

Relies on Algorithm::Diff for, well, the algorithm. This may not produce
the same exact diff as a system's local "diff" executable, but it will
be a valid diff and comprehensible by "patch". We haven't seen any
differences between Algorithm::Diff's logic and GNU diff's, but we have
not examined them to make sure they are indeed identical.

Author:
Adam Kennedy
Barrie Slaymaker