Free system that uses flat files software for linux

Tiny Translator is a very simple class for easily organizing dialogue outputs and creating language tables for multilingual projects.
Tiny Translator uses flat files and does not require a database engine.
Enhancements:
- This release supports MySQL databases for storing phrases.
- It still supports flat files (comma separated).
- The translate() method was split into various methods.
- Deprecated elements were deleted.

Ulteo project is the easiest system to use on computers. Ulteo is a new concept of an easy-to-use open-source operating system which could change the way we all use computers.

As a result, users have to perform tasks that should be reserved to computer specialists, while we think that users should just spend time using the applications they need. Ulteo tries to provide answers to these issues.

The first answer we have is to consider the OS + applications as a whole system that we could call an "Application System". This system should:

1- always provide the most up to date stable features and self-upgrade automatically
2- require no, or very little, administration by the user
3- open users horizon to potentially every application which exists, the simple way

For this release of Ulteo Sirius Alpha1, we have focused on the first point. This means that after the first installation, Ulteo will try to check for any new versions available if a network connection is available, and self-upgrade by using an incremental upgrade mechanism.

What this means is that for the next alpha release version, no installation will be needed. Simply rebooting the system will be enough to get the new features and bug fixes.

Access_user Class is an easy to use system for protecting pages and registering users. The main features are user login, user registration, page protection, forgotten password recovery, and email-based account activation.
The class is powered by MySQL and PHP sessions. Inside the package are examples for all primary methods.
Enhancements:
- Its now possible to store the session data in your database.
- This is much safer if you use sessions on a shared hosting server.
- The password is always encoded with MD5 now.
- session_destroy() was added to the logout method.
- The links used in the email messages are now double MD5-encoded.

Mp3CatgBuilder is a script that can be used to create Web pages for audio files like MP3 and WAV. The Web pages taht you will create include ID3 tags, pictures, lyrics, and playlists.
Main features:
- Multiples parameters to build your own mp3page.
- All in CSS.
- Winamp PlayList for directory.
- ID3 popup (if you use http://getid3.sourceforge.net).
- Integration of cover pictures, cd etc ...
- Possible use on Flat and Recursive Table.
- Integration of lyrics and guitar tab.
- Buildin files statistics.

Tie::ListKeyedHash is a system allowing the use of anonymous arrays as keys to a hash.

SYNOPSIS

use Tie::ListKeyedHash;

[$X =] tie %hash, Tie::ListKeyedHash;


my $live_key = [key,items,live];
$hash{$live_key} = Hello!;

$hash{[key,trees,grow]} = Goodbye!;

print $hash{[key,items,live]},"n";
delete $hash{$live_key};

my @list = keys %{$hash{[key]}};
print "@listn";

untie %hash ;

Alternatively keys are accessible as:

$hash{key,items,live} = Hello!;

(a bare list/array for the key rather than using an anon list/array reference).

But that slows down the accesses by around 10% and cannot be used for keys that conflict with the value of the $; special variable.

Also usable via the object interface methods put, get,exists,delete,clear. The object interface is about 2x as fast as the tied interface.

Tie::ListKeyedHash ties a hash so that you can use a reference to an array as the key of the hash. It otherwise behaves exactly like a normal hash (including all caveats about trying to use a key as both a hash reference and a scalar value).

This frees you from needing to hardwire hash references in code or having to write tree traversal code to reach arbitrary points in a hash tree.
Example:
########################

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

use Tie::ListKeyedHash;

my %example;
tie (%example, Tie::ListKeyedHash);

%example = (
a => {
b0 => {
c => value of c,
d => value of d,
e => {
f => value of f,
},
},
b1 => {
g => value of g,
},
},
h => r,
);

my $b_key = [a,b0];

my $d_key = [@$b_key,d];
my $d = $example{$d_key};
print "d = $dn";

my $e_key = [@$b_key, e];
my $e = $example{$e_key};
print e = . Dumper ($e);

my $f_key = [@$b_key, e,f];
my $f = $example{$f_key};
print "f = $fn";

my $h_key = [h];
my $h = $example{$h_key};
print "h = $hn";

########################

The virtues of this particular way of accessing hash-of-hashes (HoH) vs bare hardwired derefererences or tree crawling are as follows:

1) As the number of levels in a HoH increases, the tied object asymptotically approaches the speed of hardwired hash dereferencing without the loss of flexibility penalty of having to hardwire the keys into code in advance.
This gives an important property that it gets faster the deeper a HoH becomes as compared with the speed of software driven tree traveral.
So you can build and access arbitrarily structured HoH and still access deeply buried elements in the tree quickly.
2) The format was designed to use memory efficiently. It takes only a few hundred extra bytes over the size of an untied HoH in memory or when serialized (via Data::Dumper or Storable for example) regardless of how deep the hash is.
3) A reference to an existing HoH can be passed into Tie::ListKeyedHash->new and all of the OO key lists access methods will "just work".

Example:

use Tie::ListKeyedHash;

my %hash = ( a => { b => c } );
my $obj = Tie::ListKeyedHash->new(%hash);

my $b_value = $obj->get([a,b]);

Dpsyco is a automated system to distribute system configurations to several computers. It is written mainly for the Debian distribution but should be portable (without too much difficulties) to other distributions or Unixes as well.
It consists of a number of shell scripts to perform the desired actions. With it you can handle users, add ssh-public-keys, patch the system, update things using cfengine, install files (overriding other package files), and more.
Main features:
- Handle users.
- Handle groups.
- Handle ssh access.

Webminstats is a basic system static logging application that graphs the results. Its first use is system analysis.

Currently it uses webmin as a base web server and tools package.

The basic design is for a system that can have modules add and removed as easily as webmin itself, well almost.

The current modules are cpu, custom, disk, filesopen, firewall, generic, internet, irq, lm_sensors, load, mem, mysql, network, ping, process, samba, services, snmp, snort, ups, users.

Flatworm project is a Java library intended to allow a developer to describe the format of a flat file using an XML definition file, and then to be able to automatically read lines from that file, and have one or more beans be instantiated for each logical record.

There are a few powerful features in Flatworm worth mentioning. For one thing, a record may consist of one or more physical lines in the file. A record may contain more than one bean once decoded. A flat file may contain more than one type of record, and Flatworm can use line length and substring matching to determine which type of record a line begins.

Besides fielded buffer flat files, Flatworm also supports text files where the different fields are separated by a separator character, e.g. CSV (comma separated values) files.

Last but not least, Flatworm is able to produce flat files from beans and the same definition file.