This module allows you to do nominal math on dates. That is, rather
than worrying about time zones and DST while adding increments of
24*60**2 seconds to a date&time object, you simply discard the time
component and do math directly on the date. If you need a time-of-day
on the calculated date, the at() method returns a Time::Piece object,
thus allowing you to be specific about the endpoints of a nominal interval.
Guile-Lib is intended as an accumulation place for pure-scheme Guile modules,
allowing for people to cooperate integrating their generic Guile modules into
a coherent library. Think "a down-scaled, limited-scope CPAN for Guile".
Also, it can be seen as a code staging area for Guile; the Guile developers
could decide to integrate some of the code into guile-core. An example for a
possible candidate is SRFI-35.
The `IO::Tee' constructor, given a list of output handles,
returns a tied handle that can be written to but not read from.
When written to (using print or printf), it multiplexes the
output to the list of handles originally passed to the
constructor. As a shortcut, you can also directly pass a string
or an array reference to the constructor, in which case
`IO::File::new' is called for you with the specified argument or
arguments.
This collection of modules allows programs to be written that perform
asynchronous filehandle IO operations. A typical program using them would
consist of a single subclass of IO::Async::Set to act as a container for a
number of IO::Async::Notifier objects (or subclasses thereof). The set itself is
responsible for checking read- or write-readiness, and informing the notifiers
of these conditions. The notifiers then perform whatever work is required on
these conditions, by using subclass methods or callback functions.
String::Checker - An extensible string validation module (allowing commonly
used checks on strings to be called more concisely and consistently).
Why is this useful? If you're only checking one string, it probably
isn't. However, if you're checking a bunch of strings (say, for
example, CGI input parameters) against a set of expectations, this
comes in pretty handy. As a matter of fact, the CGI::ArgChecker
module is a simple, CGI.pm aware wrapper for this library.
XCAP protocol, defined in RFC 4825, allows a client to read, write, and
modify application configuration data stored in XML format on a server. XCAP
maps XML document sub-trees and element attributes to HTTP URIs, so that
these components can be directly accessed by HTTP. An XCAP server used by
XCAP clients to store data like presence policy in combination with a SIP
Presence server that supports PUBLISH/SUBSCRIBE/NOTIFY SIP methods can
provide a complete SIP SIMPLE solution.
cinc is a program that emulates the Bell Laboratories cardiac computer
(from here on referred to as cardiac). cardiac stands for cardboard
illustrative aid to computation.
casm is an assembler for the cinc emulator. casm reads a casm source program
and translates it to a cinc loadable program that can be executed with the
cinc emulator.
cinc allows you to run cardiac programs on a real computer. The real
cardiac allows the student to learn how computers work internally.
GNU version of Shogi, a game of Japanese chess.
Gnushogi is an updated version of the gnuchess program.
It has a simple alpha-numeric board display, or it can be
compiled for use with the chesstool program on a SUN work-
station or with the xshogi program under X-windows. The
program gets its opening moves from the file gnushogi.book
which is located in a directory specified in the makefile.
To invoke the program type:
gnushogi
HighMoon is a game similar to "Artillery" or "Worms" -- but it takes place
in the universe. There is a planet system between two flying saucers.
The gravitational fields of the planets and moons change inevitably each
ballistic curve. It is not easy to eliminate an enemy. If you miss it,
the shoots can change their direction and become dangerous to the attacker.
HighMoon can be played against a computer or a human opponent in many
planet systems.
TinyMUX is a text-based game server in the MUSH family (which also
includes PennMUSH, TinyMUSH, and RhostMUSH). It is a platform which
allows potentially several thousand players to connect to a single
text-driven environment, interact with each other and with the
environment (which is maintain in a database). The rich programming
environment can be used to build almost anything, limited only by
your own imagination.