Free serious software for linux

Karora Moomba is an implementation of the Eclipse Workbench API for the web. For the first time, it brings developers a serious framework for building highly dynamic, pluggable web applications based upon a well known framework. Combined with Karoras Cooee UI framework, developers need only know a small amount of Swing/Cooee/Echo2 and some basic Eclipse interfaces to quickly produce impressive rich web applications.

As Moomba harnesses OSGI (like Eclipse) as its plugin framework, it also gains the dynamic nature of OSGI. This means Moomba plugins can be started, stopped, installed and updated on the fly without shutting down the application server. Something rarely found in a java based web application framework.

Moomba is also one of the first web application frameworks to use and be compatible with the Spring-OSGI framework. This framework brings the power of Spring to the OSGI environment, meaning that all the usual Spring tools are available to your Moomba plugins.

Moomba also makes extensive use of the Karora Orana package - an implementation of Eclipse JFace for Cooee. Through this, developers have access to such expected infrastructure as dialogs, viewers and wizards.

Storable module is a 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).

utf8proc is a library for processing UTF-8 encoded Unicode strings. Unicode normalization, mapping of new line functions (NLF) to standard paragraph and line separators, stripping of default ignorable characters, and case folding are supported.
utf8proc library can be used in C programs, but most of the functionality is also available as a Ruby library. For PostgreSQL, there is an extension providing a function for preparing strings in case-insensitive indices.
Quick start:
For compilation of the C library call "make c-library", for compilation of the ruby library call "make ruby-library" and for compilation of the PostgreSQL extension call "make pgsql-library".
"make all" can be used to build everything, but both ruby and PostgreSQL installations are required in this case.
Enhancements:
- A serious bug was fixed in the data file generator, which caused characters to be treated incorrectly when stripping default ignorable characters or calculating grapheme cluster boundaries.
- Unicode normalization was not affected by this bug.

pfstools project contains a set of command line (and one GUI) programs for reading, writing, manipulating and viewing high-dynamic range (HDR) images and video frames. All programs in the package exchange data using a simple generic file format (pfs) for HDR data. The concept of the pfstools is similar to netpbm package for low-dynamic range images.
pfstools come with a library for reading and writing pfs files. The library can be used for writing custom applications that can integrate with the existing pfstools programs.
pfstools offers also a good integration with a high-level mathematical programming language GNU Octave. pfstools can be used as the extension of Octave for reading and writing HDR images or simply to store effectively large matrices.
Note that pfs in not just another format for storing HDR images (and there are already quite a few of them). It is more an attempt to integrate the existing file formats by providing a simple data format that can be used to exchange data between applications.
Enhancements:
- matlab: pfsview can now display 2D cell arrays
- pfs library: quite serious bug in sRGB transforms fixed
- added: check for GLUT library (unix only)
- added: man page for pfsglview

Flame Project is an Integrated Development Environment (IDE) for producing Flash and Animated SVG files, similar to Macromedia Captivate. It is licensed under the LGPL.

Imagine a free, easy to use GUI authoring environment that helps you create visually impressive and actually useful learning material. The short term goal for this project is to provide such an environment, and were well on the way to a first release for doing that.

Initially similar to Macromedia Captivate, but a big part is the support for Animated SVG. Flash has at least one serious design limitation (from my POV) making it nearly useless for comprehensive eLearning, and this appears to be addressed by the SVG spec.

The long term goal for this project is to provide both a complete authoring solution (like the Macromedia Flash IDE), and the components for server side communication, but thats a long way off. Lets finish the first bits first.

Archiveopteryx is an Internet mail server, optimized to support heavy usage and long-term archiving.
The project stores mail in a PostgreSQL database, and provides access to it through IMAP, POP, and more.
Enhancements:
- A very serious SMTP submit bug was fixed.
- A new feature to copy outgoing mail to the sender was added.
- Support for SMTP+TLS on port 465 was added for Outlook.
- HTTP archive display improvements were made.
- A few minor bugs were fixed.

scanmem is a debugging utility used to isolate the position of a variable in an executing program.
The project is similar to pokefinders used to cheat at games.
Enhancements:
- Performance improvements and reduced scan time, including miscellaneous improvements to various commands.
- A dejagnu test suite was started and the build process was autotooled.
- One serious bug where misaligned variables could potentially be missed by scanmem was fixed along with multiple minor bugs.