Free serious baby software for linux

Acme::Time::Baby - tell time little children can understand.

SYNOPSIS

use Acme::Time::Baby;
print babytime; # Prints current time.

use Acme::Time::Baby language => du;
print babytime "10:15"; # Prints a quarter past ten in a way
# little Dutch children can understand.

Using this module gives you the function babytime, which will return the time in the form The big hand is on the ten and the little hand is on the three. If no argument to babytime is given, the current time is used, otherwise a time of the form hh:mm can be passed. Both 12 and 24 hour clocks are supported.

When using the module, various options can be given. The following options can be passed:

language LANG

The language the time should be told in. The following languages are currently supported:

en English (this is the default)
br Brazilian Portuguese.
ceb Cebuano (Filipine dialect)
de German.
de_ch Swiss German.
du Dutch.
es Spanish.
fr French.
it Italian.
no Norwegian.
se Swedish.
swedish chef Swedish Chef (from the Muppets).
warez l44+.

If no language argument is given, English is used.
Note that some languages use accented letters. The returned sentences are correct for an ISO 8859-1 platform.

format STRING

This is the format used to represent the time. It will be passed to sprintf, and it should have two %s formatting codes. The other two arguments to sprintf are the position of the minute hand (the big hand) and the hour hand (the little hand). If you have perl 5.8 or above, you could use %2$s and %1$s to reverse the order.

number ARRAYREF

An array with the names of the numbers one to twelve, to be used in the formatted time.

noimport EXPR

By default, the sub babytime will be exported to the calling package. If for some reason the calling package does not want to import the sub, there are two ways to prevent this. Either use use Acme::Time::Baby (), which will prevent Acme::Time::Baby::import to be called, or pass noimport followed by a true value as arguments to the use statement.

SLOOPS - Simple, Light, Object Oriented Persistence System.

SLOOPS is a lightweight Object Oriented persistence system.

If you want to follow the tutorial, uncompress the distribution from command line !

It has been designed with simplicity and reliability in mind. So you should expect:

- VERY EASY AND QUICK implementation of your own datamodel. - VERY EASY retrieving of your data. - Some limitations that are negligable for 90% of cases !

It has been tested in production environment for months, so you can relie on it !
It allows to make objects persistents with just a few lines of declarative code. It supports:

- Inheritance
- Class polymorphism.
- Scalar attributes ( can be Object ! )
- SQL Free queries !
- MySQL database ( other ones in the future ).
- Optionnal caching based on Cache::FastMemoryCache .

It doesnt support :

- nonscalar attributes. So you have to do helper objects to support n-n relations . Is it so bad ?
- transaction . Thats a serious issue. Will be implemented with other database support !

Velosurf is a thin but efficient database mapping layer meant to be used with Jakarta Velocity.
Velosurfs goal is to generate a set of context variables that automatically map database tables and relationships without the need for any recompilation.
Enhancements:
- This is a corrective release that fixes a serious issue in $entity.insert along with a few minor bugs.
- It has some source refactoring and some new test cases.

Storable package contains persistence for Perl data structures.

SYNOPSIS

use Storable;
store %table, file;
$hashref = retrieve(file);

use Storable qw(nstore store_fd nstore_fd freeze thaw dclone);

# Network order
nstore %table, file;
$hashref = retrieve(file); # There is NO nretrieve()

# Storing to and retrieving from an already opened file
store_fd @array, *STDOUT;
nstore_fd %table, *STDOUT;
$aryref = fd_retrieve(*SOCKET);
$hashref = fd_retrieve(*SOCKET);

# Serializing to memory
$serialized = freeze %table;
%table_clone = %{ thaw($serialized) };

# Deep (recursive) cloning
$cloneref = dclone($ref);

# Advisory locking
use Storable qw(lock_store lock_nstore lock_retrieve)
lock_store %table, file;
lock_nstore %table, file;
$hashref = lock_retrieve(file);

The Storable package brings persistence to your Perl data structures containing SCALAR, ARRAY, HASH or REF objects, i.e. anything that can be conveniently stored to disk and retrieved at a later time.

It can be used in the regular procedural way by calling store with a reference to the object to be stored, along with the file name where the image should be written.

The routine returns undef for I/O problems or other internal error, a true value otherwise. Serious errors are propagated as a die exception.

To retrieve data stored to disk, use retrieve with a file name. The objects stored into that file are recreated into memory for you, and a reference to the root object is returned. In case an I/O error occurs while reading, undef is returned instead. Other serious errors are propagated via die.

Since storage is performed recursively, you might want to stuff references to objects that share a lot of common data into a single array or hash table, and then store that object. That way, when you retrieve back the whole thing, the objects will continue to share what they originally shared.

At the cost of a slight header overhead, you may store to an already opened file descriptor using the store_fd routine, and retrieve from a file via fd_retrieve. Those names arent imported by default, so you will have to do that explicitly if you need those routines. The file descriptor you supply must be already opened, for read if youre going to retrieve and for write if you wish to store.

store_fd(%table, *STDOUT) || die "cant store to stdoutn";
$hashref = fd_retrieve(*STDIN);

You can also store data in network order to allow easy sharing across multiple platforms, or when storing on a socket known to be remotely connected. The routines to call have an initial n prefix for network, as in nstore and nstore_fd. At retrieval time, your data will be correctly restored so you dont have to know whether youre restoring from native or network ordered data. Double values are stored stringified to ensure portability as well, at the slight risk of loosing some precision in the last decimals.

When using fd_retrieve, objects are retrieved in sequence, one object (i.e. one recursive tree) per associated store_fd.

If youre more from the object-oriented camp, you can inherit from Storable and directly store your objects by invoking store as a method. The fact that the root of the to-be-stored tree is a blessed reference (i.e. an object) is special-cased so that the retrieve does not provide a reference to that object but rather the blessed object reference itself. (Otherwise, youd get a reference to that blessed object).

phpsniffer shows that PHP really is the right tool for every programmnig task imaginable (humor, laugh), I submit for your amusement, phpsniffer.

phpsniffer is a packet sniffer written entirely in PHP without any PECL/PEAR extensions. (It is recommended that you check out Phpcap for any serious sniffing at http://alcane.newffr.com/phpcap/).

phpsniffer has some limitations:

- You probably will only see one side of a conversation.
- You might miss packets with a short TTL.
- Currently only IP,ICMP,UDP, and TCP headers are decoded.
- Sockets must be enable in your PHP build.

Ridentd server application is meant for the totally paranoid that need access to servers that require ident and dont want to give any information about local users to the remote server or its other users.
Ridentd is a stand-alone replacement for identd that uses a random selection of a ispell dictionary to use as fake ident responses. The ident response is based on a (one-time randomly initialized) modulus of the local port in order to assure that one session will return the same identity during a TCP session.
The really paranoid may wish to start ridentd a few times a day from their cron in order to reseed both the random set of dictionary words and the port modulo. When using in the cron it is adviced to use the SILENT option.
At this moment this software should be considdered release-ready for the Linux platform, beta for any other *nix platform. It depends on the availability of the strings , ps binaries, and the pressence of at least one ispell dictionary file.
Enhancements:
- Addresses a serious locally exploitable symlink bug that allowed a random local file to be overwritten to with the process ID of the newly started daemon.

snowdrop provides a stenographic text/code watermarking tool.
snowdrop is a steganographic text document and C code watermarking tool that uses redundant, tamper-evident and modification-proof information embedded in the content itself, instead of the medium, to simplify tracking of proprietary code leaks, sensitive information disclosure, etc.
Snowdrop is intended to bring (relatively) invisible and modification-proof watermarking to a new realm of "source material" - written word and computer source codes.
The information is not being embedded in the least significant portions of some binary output, as it would be with a traditional low-level steganography, but into the source itself.
The idea, at least for English, isnt new - there was some serious work done by Mikhail Atallah from Purdue University. Snowdrop is merely an attempt to
provide a reliable, useful tool to implement those source-level watermarking / steganography capabilities. Because of some tricks, such as using specially crafted MD5 shortcuts, it gives certain additional advantages to its
potential users, such as integrity and privacy of embedded information, or an ability to demonstrate the origin of a document to the public (see section 2
for more details). Separate logical channels are used to carry highly redundant watermark to ensure it is extremely difficult to remove this information by accident, simple reformatting, etc.
Enhancements:
- Fixes an annoying bug that caused the code to segfault when there is no sync near the end of the watermarked file.
- Bit walk algorithm is still a bit broken, and the overall performance and storage capacity sucks, the code needs to be eventually rewritten.