Perl scripts and theme files for the irssi IRC client. You can
customize the look and feel and add extra functionality with this
package.

LAM (Local Area Multicomputer) is an MPI programming environment and
development system for heterogeneous computers on a network. With LAM,
a dedicated cluster or an existing network computing infrastructure can
act as one parallel computer solving one problem.

LAM features extensive debugging support in the application development
cycle and peak performance for production applications. LAM also
features a full implementation of the MPI (Message Passing Interface)
communication standard. The documentation is installed in
/usr/share/doc/packages/lam/.

libedit is a command line editing and history library. It is designed
to be used by interactive programs that allow the user to type commands
at a terminal prompt.

A full-featured and high-performance event loop that is loosely modelled after
libevent, but without its limitations and bugs. It is used, among others, in
the GNU Virtual Private Ethernet and rxvt-unicode packages.

libmemcache implements a client for the superior memcached from Danga
Interactive.

Lighttpd is a secure, fast, compliant, and very flexible Web server
that has been optimized for high-performance environments. It has a
very low memory footprint compared to other Web servers and takes care
of CPU load. Its advanced feature set (FastCGI, CGI, Auth,
Output-Compression, URL-Rewriting, and more) makes lighttpd the perfect
Web server software for every server that is suffering load problems.

LZO is a portable lossless data compression library written in ANSI C.
It offers pretty fast compression and very fast decompression.
Decompression requires no memory. LZO is suitable for data compression
and decompression in real-time. This means it favors speed over
compression ratio.

Memcached is a high-performance, distributed memory object caching
system, generic in nature, but intended for use in speeding up dynamic
web applications by alleviating database load.

Danga Interactive developed memcached to enhance the speed of
LiveJournal.com, a site which was already doing 20 million+ dynamic
page views per day for 1 million users with a bunch of webservers and a
bunch of database servers. memcached dropped the database load to
almost nothing, yielding faster page load times for users, better
resource utilization, and faster access to the databases on a memcache
miss.

MPICH is a freely available, portable implementation of MPI, the
standard for message-passing libraries.

msmtp is an SMTP client that can be used as a plug-in for Mutt and
other mail user agents. It forwards mail to an SMTP server that does
the delivery. msmtp supports multiple accounts.

Mini-XML is a small XML parsing library that you can use to read XML
and XML-like data files in your application without requiring large
nonstandard libraries.

This package holds the commandline tools for mxml.

Oniguruma is a regular expressions library. The characteristics of
this library is that different character encoding for every regular
expression object can be specified.

Supported character encodings: ASCII, UTF-8, UTF-16BE, UTF-16LE,
UTF-32BE, UTF-32LE, EUC-JP, EUC-TW, EUC-KR, EUC-CN, Shift_JIS, Big5, GB
18030, KOI8-R, KOI8, ISO-8859-1, ISO-8859-2, ISO-8859-3, ISO-8859-4,
ISO-8859-5, ISO-8859-6, ISO-8859-7, ISO-8859-8, ISO-8859-9,
ISO-8859-10, ISO-8859-11, ISO-8859-13, ISO-8859-14, ISO-8859-15,
ISO-8859-16.

'App::CLI' dispatches CLI (command line interface) based commands into
command classes. It also supports subcommand and per-command options.

get_opt([@config], %opt_map)
give options map, process by Getopt::Long::Parser

interface of dispatcher

cmd_map($cmd)
find package name of subcommand in constant %alias

if it's finded, return ucfirst of the package name,

otherwise, return ucfirst of $cmd itself.

get_cmd($cmd, @arg)
return subcommand of first level via $ARGV[0]

Config::Crontab reads and writes (and pretty-prints) your crontab(5)
files. It is compatible with Vixie-style crontabs (and all subsets,
including Solaris' SysV-style crontabs).

Config::Crontab has a simple, object-oriented syntax. Crontab files are
broken into "blocks" (paragraphs, each separated by two or more
newlines); the Block is the basic unit of a Config::Crontab object.

You can re-order entire blocks within a crontab file, re-order lines
within blocks (there are three types of lines: comments, environment
settings, and crontab commands or events), remove blocks or lines
within blocks, add new blocks or lines within blocks, etc. See the
Config::Crontab manpage for full details.

This module opens a config file and parses its contents for you. The *new*
method requires one parameter which needs to be a filename. The method
*getall* returns a hash which contains all options and its associated
values of your config file.

The format of config files supported by *Config::General* is inspired by
the well known Apache config format, in fact, this module is 100%
compatible to Apache configs, but you can also just use simple name/value
pairs in your config files.

In addition to the capabilities of an Apache config file it supports some
enhancements such as here-documents, C-style comments or multiline options.

The DBD::CSV module is yet another driver for the DBI (Database independent
interface for Perl). This one is based on the SQL "engine" SQL::Statement
and the abstract DBI driver DBD::File and implements access to so-called
CSV files (Comma Separated Values). Such files are often used for exporting
MS Access and MS Excel data.

See the DBI manpage for details on DBI, the SQL::Statement manpage for
details on SQL::Statement and the DBD::File manpage for details on the base
class DBD::File.

IO::Pager is lightweight and can be used to locate an available pager
and set $ENV{PAGER} (see "NOTES") or as a factory for creating objects
defined elsewhere such as IO::Pager::Buffered and
IO::Pager::Unbuffered.

*List::MoreUtils* provides some trivial but commonly needed functionality
on lists which is not going to go into the List::Util manpage.

All of the below functions are implementable in only a couple of lines of
Perl code. Using the functions from this module however should give
slightly better performance as everything is implemented in C. The
pure-Perl implementation of these functions only serves as a fallback in
case the C portions of this module couldn't be compiled on this machine.

'Path::Class' is a module for manipulation of file and directory
specifications (strings describing their locations, like
''/home/ken/foo.txt'' or ''C:\Windows\Foo.txt'') in a cross-platform
manner. It supports pretty much every platform Perl runs on, including
Unix, Windows, Mac, VMS, Epoc, Cygwin, OS/2, and NetWare.

The well-known module 'File::Spec' also provides this service, but it's
sort of awkward to use well, so people sometimes avoid it, or use it in a
way that won't actually work properly on platforms significantly different
than the ones they've tested their code on.

In fact, 'Path::Class' uses 'File::Spec' internally, wrapping all the
unsightly details so you can concentrate on your application code. Whereas
'File::Spec' provides functions for some common path manipulations,
'Path::Class' provides an object-oriented model of the world of path
specifications and their underlying semantics. 'File::Spec' doesn't create
any objects, and its classes represent the different ways in which paths
must be manipulated on various platforms (not a very intuitive concept).
'Path::Class' creates objects representing files and directories, and
provides methods that relate them to each other. For instance, the
following 'File::Spec' code:

my $absolute = File::Spec->file_name_is_absolute(
File::Spec->catfile( @dirs, $file )
);

can be written using 'Path::Class' as

my $absolute = Path::Class::File->new( @dirs, $file )->is_absolute;

or even as

my $absolute = file( @dirs, $file )->is_absolute;

Similar readability improvements should happen all over the place when
using 'Path::Class'.

Using 'Path::Class' can help solve real problems in your code too - for
instance, how many people actually take the "volume" (like 'C:' on Windows)
into account when writing 'File::Spec'-using code? I thought not. But if
you use 'Path::Class', your file and directory objects will know what
volumes they refer to and do the right thing.

The guts of the 'Path::Class' code live in the 'Path::Class::File' and
'Path::Class::Dir' modules, so please see those modules' documentation for
more details about how to use them.

The SQL::Statement module implements a pure Perl SQL parsing and execution
engine. While it by no means implements full ANSI standard, it does support
many features including column and table aliases, built-in and user-defined
functions, implicit and explicit joins, complex nested search conditions,
and other features.

SQL::Statement is a small embeddable Database Management System (DBMS).
This means that it provides all of the services of a simple DBMS except
that instead of a persistent storage mechanism, it has two things: 1) an
in-memory storage mechanism that allows you to prepare, execute, and fetch
from SQL statements using temporary tables and 2) a set of software sockets
where any author can plug in any storage mechanism.

There are three main uses for SQL::Statement. One or another (hopefully not
all) may be irrelevant for your needs: 1) to access and manipulate data in
CSV, XML, and other formats 2) to build your own DBD for a new data source
3) to parse and examine the structure of SQL statements.

DelimMatch is a Perl 5 module that provides functions for locating
delimited substrings with proper nesting.

UNIVERSAL::require - require() modules from a variable

This module provides a Perl interface to the *libsyck* data serialization
library. It exports the 'Dump' and 'Load' functions for converting Perl
data structures to YAML strings, and the other way around.

*NOTE*: If you are working with other language's YAML/Syck bindings (such
as Ruby), please set '$YAML::Syck::ImplicitTyping' to '1' before calling
the 'Load'/'Dump' functions. The default setting is for preserving
backward-compatibility with 'YAML.pm'.

PVM is a software system that enables a collection of heterogeneous
computers to be used as a coherent and flexible concurrent
computational resource.

The individual computers may be shared- or local-memory
multiprocessors, vector supercomputers, specialized graphics engines,
or scalar workstations, that may be interconnected by a variety of
networks, such as ethernet, FDDI. User programs written in C, C++ or
Fortran access PVM through library routines.

After installation you find in /usr/share/doc/packages/pvm/ the
documentation as PostScript file pvm-book.ps. Furthermore some
examples are packed together in two tar archives. Those archives
should be extracted into your HOME directory which leads to
~/pvm3/examples/ or ~/pvm3/gexamples/ in your HOME directory. The call
`aimk all' (see manual page aimk(1)) e.g. in ~/pvm3/examples/ compiles
the examples for the PVM system.

The PVM web home page is at http://www.epm.ornl.gov/pvm/pvm_home.html .

The SCGI protocol is a replacement for the Common Gateway Interface
(CGI) protocol. It is a standard for applications to interface with
HTTP servers. It is similar to FastCGI but is designed to be easier to
implement.

This package contains the python bindings.