Developing and debugging UIs can be a pain. When something
goes wrong, it's not always obvious why. You can waste hours
writing logging statements only to find out that a widget is
in the wrong container, or an attribute wasn't set correctly.
Developing isn't much better either. Ever spend time writing
temporary code just to test a new feature, code you know you're
going to throw away in an hour, and yet you end up spending the
next 20 minutes debugging your temporary code? Sucks, doesn't
it?
What your program really needs is a good Parasite infestation.
Parasite is a debugging and development tool that runs inside
your GTK+ application's process. It can inspect your application,
giving you detailed information on your UI, such as the hierarchy,
X window IDs, widget properties, and more. You can modify properties
on the fly in order to experiment with the look of your UI.
convertible provides a typeclass with a single function that is designed
to help convert between different types: numeric values, dates and times,
and the like. The conversions perform bounds checking and return a pure
Either value. This means that you need not remember which specific function
performs the conversion you desire. Also included in the package are
optional instances that provide conversion for various numeric and time
types, as well as utilities for writing your own instances. Finally, there
is a function that will raise an exception on bounds-checking violation,
or return a bare value otherwise, implemented in terms of the safer function
described above. Convertible is also used by HDBC 2.0 for handling
marshalling of data to and from databases. Convertible is backed by an
extensive test suite and passes tests on GHC and Hugs.
libarena is a custom memory allocator interface and implementation. Four
allocators are provided: flat LIFO arena allocator, object pool allocator
and two malloc(3) wrappers: one which returns the pointers unadulterated
and one which obeys the requested, arbitrary alignment. These can be used
directly, or through their exported prototype interfaces.
libarena is meant to provide a baseline interface so allocators can be
stacked, and to provide a simple and well defined interface for libraries
and applications without becoming mired in features or capabilities. It is
not meant to restrict or confine what custom allocators can actually
accomplish. For instance, the included pool and arena allocators include a
suite of string utilities which aren't available in the generic exportable
interface. Note that these string utilities are built upon a generic
interface (see util.h) which can take the prototypical allocation context,
so they are also available to any 3rd party compatible allocators.
Libdict is a compact, ANSI C library which provides access to a set of
generic and flexible ``dictionary'' data structures. All algorithms
used in libdict have been optimized, and, with one very small exception,
are not recursive but iterative. It was written by Farooq Mela, and is
released under a BSD style licence.
Libdict implements the following data structures: AVL Tree, Red-Black
Tree, Splay Tree, Treap, Weight-balanced tree, Path-reduction tree,
Hashtable (Chained).
These structures can be used to efficiently store and retrieve key-data
pairs. Each of these structures can be accessed using its direct API, or
it can be accessed using a dictionary abstraction. Despite it's name,
libdict can be used to store any kind of data and any kind of key (provided
it fits into a 'void' pointer on your system).
The Hoard memory allocator is a fast, scalable, and memory-efficient
memory allocator for shared-memory multiprocessors.
Multithreaded programs that perform dynamic memory allocation do not
scale because the heap is a bottleneck. When multiple threads
simultaneously allocate or deallocate memory from the heap, they will
be serialized while waiting for the heap lock. Programs making
intensive use of the heap actually slow down as the number of
processors increases. (Note: If you make a lot of use of the STL, you
may not know it, but you are making a lot of use of the heap.)
Hoard is a fast allocator that solves this problem. In addition, it
has very reasonable bounds on memory consumption.
Config::IniFiles provides a way to have readable configuration files
outside your Perl script. The configuration can be safely reloaded upon
receipt of a signal. Configurations can be imported (inherited,
stacked,...), sections can be grouped, and settings can be accessed from
a tied hash.
USAGE
Get a new Config::IniFiles object with the *new* method:
$cfg = Config::IniFiles->new( -file => "/path/configfile.ini" );
$cfg = new Config::IniFiles -file => "/path/configfile.ini";
Optional named parameters may be specified after the configuration file
name. See the *new* in the METHODS section, below.
INI files consist of a number of sections, each preceded with the
section name in square brackets. Parameters are specified in each section
as Name=Value. Any spaces around the equals sign will be ignored, and the
value extends to the end of the line.
A perl module that is designed to provide easy to use settings
files for your project. You subclass the basic Config::Setting
class in one of your own modules, and then provide an interface to
your code using it. When set up, you can then override the settings
on a per-host basis, or even using an environment variable.
By default a win.ini style of configuration is used, but this can
be overridden and an XML based configuration is also included. The
access mechanism can also be overridden, the setting don't have to
come from a file, but (maybe) from a web site. You'll have to write
your own there, though.
The module Data::Flow provides its services via objects. The objects
may be obtained by the usual
$request = new Data::Flow $recipes;
paradigm. The argument $recipes is a hash reference, which provides the
rules for request processing. The objects support two methods, set() and
get(). The first one is used to provide input data for processing, the
second one to obtain the output.
The unit of requested information is a field. The method set() takes a
pair field => value, the method get() takes one argument: the field.
Every object is created without any fields filled, but it knows how to
construct fields basing on other fields or some global into. This
knowledge is provided in the argument $recipe of the new() function.
This is a reference to a hash, keyed by fields. The values of this hash
are hash references themselves, which describe how to acquire the field
which is the corresponding key of the initial hash.
File::ShareDir::PAR provides the same functionality as File::ShareDir but tries
hard to be compatible with PAR packaged applications.
The problem is, that the concept of having a distribution or module specific
share directory becomes a little hazy when you're loading everything from
a single file. PAR uses an @INC hook to intercept any attempt to load a module.
File::ShareDir uses the directory structure that is typically found in the
directories that are listed in @INC for storing the shared data. In a PAR
enviroment, this is not necessarily possible.
WARNING:
This module contains highly experimental code. If you want to load
modules from .par files using PAR and then access their shared directory
using File::ShareDir, you probably have no choice but to use it.
INTRODUCTION --- WHAT IS NOWEB, ANYWAY?
noweb is a literate-programming tool like FunnelWEB or nuweb, only
simpler. A noweb file contains program source code interleaved with
documentation. When noweb is invoked, it writes the program source
code to the output files mentioned in the noweb file, and it writes
a TeX file for typeset documentation.
noweb is designed to meet the needs of literate programmers while
remaining as simple as possible. Its primary advantages are
simplicity, extensibility, and language-independence. noweb works
``out of the box'' with any programming language, and supports TeX,
latex, and HTML (Mosaic) back ends. A back end to support full
hypertext or indexing takes about 250 lines; a simpler one can be
written in 40 lines of awk. The primary sacrifice relative to WEB
is that code is not prettyprinted.
If you're brand new to literate programming, check out the FAQ for
the USENET newsgroup comp.programming.literate. There are also some
resources available through the noweb home page: