'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.

Ruby is an interpreted scripting language for quick and easy
object-oriented programming. It has many features for processing text
files and performing system management tasks (as in Perl). It is
simple, straight-forward, and extensible.

* Ruby features:

- Simple Syntax

- *Normal* Object-Oriented features (class, method calls, for
example)

- *Advanced* Object-Oriented features(Mix-in, Singleton-method, for
example)

- Operator Overloading

- Exception Handling

- Iterators and Closures

- Garbage Collection

- Dynamic Loading of Object Files (on some architectures)

- Highly Portable (works on many UNIX machines; DOS, Windows, Mac,
BeOS, and more)

'abstract.rb' is a library which enable you to define abstract method
in Ruby.

An implementation of the AMQP protocol in Ruby/EventMachine for writing clients to the RabbitMQ message broker

bcrypt() is a sophisticated and secure hash algorithm designed by The OpenBSD project
for hashing passwords. bcrypt-ruby provides a simple, humane wrapper for safely handling
passwords.

Builder provides a number of builder objects that make creating structured data
simple to do. Currently the following builder objects are supported:

* XML Markup
* XML Events

An easy way to vendor gem dependencies

Simple authorization solution for Rails which is completely decoupled from the user's roles. All permissions are stored in a single location for convenience.