Rolo is a tool for the Sun workstation which presents a
user interface to a simple database of notes in a manner
which approximates a Rolodex file.
Each note in your Rolo file is meant to simulate a 3x5
card upon which you may scribble anything you like. You
can have any number of cards in your rolodex, Rolo will
keep track of them for you. You may browse around through
them, create new ones, throw old ones away, search for
strings in them, etc.
libuutil is a library of userland utilities originating from solaris
This library provides both a doubly linked-list implementation and a
AVL tree implementation. This has been a private library best known
as a core component for ZFS and SMF.
The performance is considered excellent. As this has always been a
private library, it is not well documented and there is no man page
for it. The best documentation is located in the source code and
reading OpenSolaris/Illumos ZFS and SMF sources will help as well.
cpp-netlib is a collection of network related routines/implementations geared
towards providing a robust cross-platform networking library. cpp-netlib
offers the following implementations:
* Common Message Type -- A generic message type which can be used to
encapsulate and store message related information, used by all network
implementations as the primary means of data exchange.
* Network protocol message parsers -- A collection of parsers which generate
message objects from strings.
* Adapters and Wrappers -- A collection of Adapters and wrappers aimed towards
making the message type STL friendly.
* Network protocol client and server implementations -- A collection of
network protocol implementations that include embeddable client and server
types.
CUnit is a lightweight system for writing, administering, and running unit tests
in C. It provides C programmers a basic testing functionality with a flexible
variety of user interfaces.
CUnit is built as a static library which is linked with the user's testing code.
It uses a simple framework for building test structures, and provides a rich set
of assertions for testing common data types. In addition, several different
interfaces are provided for running tests and reporting results. These
interfaces currently include: Automated, Basic, Console and Curses.
CodeWorker is a parsing tool and a source code generator, available in
Open Source (distributed under the GNU Lesser General Public License)
devoted to cover many aspects of the generative programming. Generative
programming is a software engineering approach for producing reusable,
tailor-made, evolvable and reliable IT systems with a high level of
automation.
The tool interprets a scripting language that drives the processing of
parsing and source code generation in a quite familiar syntax for
developers. It insists on adapting the syntax of the language to the
particularities of tasks to resolve (parse, code generation, procedural)
and on offering powerful functionalities to do intensive source code
generation.
This module provides a single function called dump() that takes a list of
values as its argument and produces a string as its result. The string contains
Perl code that, when evaled, produces a deep copy of the original arguments.
The string is formatted for easy reading.
If dump() is called in a void context, then the dump is printed on STDERR
instead of being returned.
If you don't like importing a function that overrides Perl's not-so-useful
builtin, then you can also import the same function as pp(), mnemonic for
"pretty-print".
Devel::Leak has two functions NoteSV and CheckSV.
NoteSV walks the perl internal table of allocated SVs (scalar values) -
(which actually contains arrays and hashes too), and records their
addresses in a table. It returns a count of these "things", and stores
a pointer to the table (which is obtained from the heap using malloc())
in its argument.
CheckSV is passed argument which holds a pointer to a table created by
NoteSV. It re-walks the perl-internals and calls sv_dump() for any
"things" which did not exist when NoteSV was called. It returns a count
of the number of "things" now allocated.
Description from the home page:
Devel::LexAlias provides the ability to alias a lexical variable in a
subroutines scope to one of your choosing.
If you don't know why you'd want to do this, I'd suggest that you skip
this module. If you think you have a use for it, I'd insist on it.
Still here?
lexalias( $where, $name, $variable )
$where refers to the subroutine in which to alias the lexical, it
can be a coderef or a call level such that you'd give to caller
$name is the name of the lexical within that subroutine
$variable is a reference to the variable to install at that location
Log::Dispatch::Config is a wrapper for Log::Dispatch and provides a way to
configure Log::Dispatch objects with configuration files. Somewhat like a lite
version of log4j and Log::Log4perl it allows multiple log destinations. The
standard configuration file format for Log::Dispatch::Config is AppConfig.
This module plugs in to Log::Dispatch::Config and allows the use of other file
formats, in fact any format supported by the Config::Any module. As a bonus you
can also pass in a configuration data structure instead of a file name.
Moose is a postmodern object system for Perl5. Moose is wonderful.
Unfortunately, Moose has a compile-time penalty. Though significant progress
has been made over the years, the compile time penalty is a non-starter for
some very specific applications. If you are writing a command-line application
or CGI script where startup time is essential, you may not be able to use Moose
(we recommend that you instead use persistent Perl executing environments like
FastCGI for the latter, if possible).
Mouse is a Moose compatible object system, which aims to alleviate this penalty
by providing a subset of Moose's functionality.