Free persistence length software for linux

Lexical::Persistence is a Perl module for persistent lexical variable values for arbitrary calls.

SYNOPSIS

#!/usr/bin/perl

use Lexical::Persistence;

my $persistence = Lexical::Persistence->new();
foreach my $number (qw(one two three four five)) {
$persistence->call(&target, number => $number);
}

exit;

sub target {
my $arg_number; # Argument.
my $narf_x++; # Persistent.
my $_i++; # Dynamic.
my $j++; # Persistent.

print "arg_number = $arg_numbern";
print "tnarf_x = $narf_xn";
print "t_i = $_in";
print "tj = $jn";
}

Simple persistence for Java is an object/relation mapping framework for Java. It is designed to be easy to use.
There are no XML files to write, no tables to create, no IDs to generate, and no primary keys to fiddle with; just point it to the database, check the API documentation for three basic methods, and code away.
Simple persistence for Java supports transactions, has its own simple query language (very similar to SQL), and can handle object references, lists, and maps.
You may ask: Why another O/R mapping library? Well.. Ive searched the net for a suitable O/R tool for a long time now, also tried a few in live projects, but each time, at the end of the project, I had always had a few thoughts to simplify the database interaction code. Ive started with EJB around 2000. Now, I think everyone who used EJBs also at least once wondered why saveing a friggin object requires a separate server installation, the extensive knowledge of a 200+ page documentation, generating 3 classes/interfaces per object, installing stubs, rmi, and other things I dont even want to know about. Lets just skip this chapter of my life directly to my last experience with an O/R library: pbeans. This library is generally good, I can recommend it for those, who want a stable O/R mapping tool, but it was not the one for me. I found a few points I couldnt get over:
- Save and insert should be one method. I usually dont care if an object is inserted or saved phisically, as long as its saved.
- It should handle Lists and Maps. Well, "Lists should be enough for everybody", but sometimes Maps are handy too. Lists are used very often, I think it should be handled automatically.
- The query code is too difficult, and at the same time does not offer enough features.
- The code you have to write wont be "pretty". It requires classes to be parameters, at least for queries, and I cant read the query itself.
- The Id handling is not transparent.
Enhancements:
- A major scalability feature has been added: the library is now capable of working in a distributed environment, such as load-balanced Web server clusters.
- All the library nodes connected to the same database will form a self-regulating, self-organizing, failure-tolerant network to manage exclusive resources (such as locks, etc).
- The documentation and site were updated accordingly.

Cyphesis is a WorldForge server suitable running small games. Cyphesis is also designed by be used as an AI subsystem in a network of distributed servers.
It includes a terrain engine based on the Mercator library, a persistence system based on PostgreSQL, and an AI engine using goal trees implemented in Python. It is the server used in most current WorldForge games.
Current releases of cyphesis use the re-written C++ core, based on the design of the original python core.
Enhancements:
- The way rules data is handled is now much simpler to make it easier for game designers to create what they want.
- A lot of hard-coded functionality has been removed from the compiled core program.
- Core functionality is now associated with properties, and so can be applied to any entity.
- Most of Mason has been reimplemented as task scripts, which are cleaner and more flexible.
- There are more helpful messages when inconsistencies are detected in rule data.
- This release works more reliably as an autopackage.

JDOInstruments is an embedded object oriented database programmed in java, it is also an implementation of Suns Java Data Objects (JDO) specification for the transparent persistence of Java objects.
Because of this, it doesnt need a JDBC driver or a relational database. JDOInstruments uses its own object store thus it allows storage and retrieval of persistent data with little work from you.
It is integrated with Netbeans IDE (via Plugin module) allowing developers to build pure object-oriented systems.
It is free and Our license is GNU LGPL providing the code and executables (JARs) free of charge. You are free to use JDOInstruments in your projects.
Main features:
- Byte-Code Enhancement of classes
- Byte-Code Compatibility
- Datastore identity
- Optimistic Transaction
- Nontransactional Read
- Retain values
- Restore values
- Second Class PersistenceCapable objects
- J2EE Integration
- Query (JDOQL)
- Index
- Schema Evolution

Password Creator is a great tool to generate passwords with criteria like uppercase letters, numbers or even specified characters.
It has virtually no limitation on the pasword length and the password quantity or the characters to use.
Enhancements:
- Fixed the excellent rating bug when one character length.
- Fixed pronoucable passwords to not start with two vowels.

Demokritos is a server implementation of the Atom Publishing Protocol.
Demokritos also provides a library that can be used for the development of other Atom-related applications.
Usage:
To run a test server, cd to test directory and run test_server.py
client_test.py in the same directory will run through a sequence of tests on this.
Enhancements:
- Duplicates are now handled in URI minting.
- A feeds updated property after a removal of an entry is now current datetime (not that of the latest entry).
- Posts missing a media type now throw an exception.
- A bug where entry collections were being retrieved from the persistence layer as media collections has been fixed.

Getopt::Long is an extended processing of command line options.

SYNOPSIS

use Getopt::Long;
my $data = "file.dat";
my $length = 24;
my $verbose;
$result = GetOptions ("length=i" => $length, # numeric
"file=s" => $data, # string
"verbose" => $verbose); # flag

The Getopt::Long module implements an extended getopt function called GetOptions(). This function adheres to the POSIX syntax for command line options, with GNU extensions.

In general, this means that options have long names instead of single letters, and are introduced with a double dash "--". Support for bundling of command line options, as was the case with the more traditional single-letter approach, is provided but not enabled by default.