Termbox is a library that provides a minimalistic API which allows the
programmer to write text-based user interfaces. The library is
crossplatform and has both terminal-based implementations on *nix
operating systems and a winapi console based implementation for
Windows operating systems. The basic idea is an abstraction of the
greatest common subset of features available on all major terminals
and other terminal-like APIs in a minimalistic fashion. Small API
means it is easy to implement, test, maintain and learn it, that's
what makes the termbox a distinct library in its area.
The (general | GNU) template generation tools are a set of scripts
for creating a whole set of sources, which may already be compiled
and installed by using the GNU development tools. Think of gtgt as
a program which is able to create an already compilable, very
sophisticated "hello world" program, written in C or C++ and
constituted by a main program, two internal modules (classes), one
static and one shared library. Using gitty-gitty you will get a
template of sources for the main cases you might meet, and which
you can also use as examples for automake, autoconf and so on.
C/C++ preprocessor defines and expands macros and processes '#if',
'#include' and some other directives.
MCPP is an alternative C/C++ preprocessor with the highest conformance.
It supports multiple standards: K&R, ISO C90, ISO C99, and ISO C++98.
MCPP is especially useful for debugging a source program which use
complicated macros and also useful for checking portability of a source.
Though mcpp could be built as a replacement of GCC's resident
preprocessor or as a stand-alone program without using library build of
mcpp, this package installs a program named 'mcpp' which links shared
library of libmcpp and behaves independent from GCC.
This driver uses a database table to store the cache for CHI.
The newest versions of MySQL and SQLite are known to work.
Other RDBMSes should work.
Why cache things in a database? Isn't the database what people are trying to
avoid with caches? This is often true, but a simple primary key lookup is
extremely fast in many databases and this provides a shared cache that can be
used when less reliable storage like memcached is not appropriate. Also, the
speed of simple lookups on MySQL when accessed over a local socket is very hard
to beat. DBI is fast.
The Carp routines are useful in your own modules because they act like die() or
warn(), but with a message which is more likely to be useful to a user of your
module. In the case of cluck, confess, and longmess that context is a summary of
every call in the call-stack. For a shorter message you can use carp or croak
which report the error as being from where your module was called. There is no
guarantee that that is where the error was, but it is a good educated guess.
AutoDia is a modular application that parses source code or data (if a
handler is available) and produces an XML document in Dia format,
essentially a Dia diagram auto creation package. The diagrams it creates
are standard UML diagrams showing dependencies, superclasses, packages,
classes and inheritances, as well as the methods, etc of each class.
AutoDia supports any language that a Handler has been written for -
currently this is C++, DBI, Java, PHP, Perl, Python, SQL and Torque (XML
DB schema).
Adding a handler is easy - read the DEVELOP file for details.
File::Slurp::Tree provides functions for slurping and emitting trees of files
and directories.
# an example of use in a test suite
use Test::More tests => 1;
use File::Slurp::Tree;
is_deeply( slurp_tree( "t/some_path" ), { foo => {}, bar => "sample\n" },
"some_path contains a directory called foo, and a file bar" );
The tree data structure is a hash of hashes. The keys of each hash are names of
directories or files. Directories have hash references as their value, files
have a scalar which holds the contents of the file.
Minilla is a CPAN module authoring tool. Minilla provides 'minil' command for
authorizing a CPAN distribution. The repository created and managed by Minilla
is git install ready, and cpan of course. Minilla is built on only few small
libraries. You can install Minilla without a huge list of dependencies to
heavy modules. Conventions: module written in Pure Perl are located in lib/;
executable file is in script/ directory, if any; module is maintained with
Git and git ls-files matches with what you will release; module has a static
list of prerequisites that can be described in cpanfile; has a Changes file.
Module::Dependency - Collection of modules for examining dependencies
between parents and children, like Perl files
A set of pure-perl modules and helper programs that let you build a
database of the dependency links between a collection of Perl files,
and then query that database, even producing text, HTML, PostScript
or graphical reports.
The database in question is actually a simple Storable image of a
Perl data structure, and you can create as many of these as you want.
You can use the command-line tools, or write your own Perl to query
and manipulate the data however you want.
Consistent hashing is a scheme that provides hash table functionality
in a way that the addition or removal of one slot does not
significantly change the mapping of keys to slots. In contrast, in
most traditional hash tables, a change in the number of array slots
causes nearly all keys to be remapped.
Consistent hashing was introduced in 1997 as a way of distributing
requests among a changing population of web servers. More recently, it
and similar techniques have been employed in distributed hash tables.