Free serious softball 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.

Stripes is a presentation framework for building web applications using the latest Java technologies. The main driver behind Stripes is that web application development in Java is just too much work! It seems like every existing framework requires gobs of configuration.
Struts is pretty feature-light and has some serious architectural issues. Others, like WebWork 2 and Spring-MVC are much better, but still require a lot of configuration, and seem to require you to learn a whole new language just to get started.
Goals:
- Make developing web applications in Java easy
- Provide simple yet powerful solutions to common problems
- Make the Stripes ramp up time for a new developer less than 30 minutes
- Make it really easy to extend Stripes, without making you configure every last thing
Main features:
- Zero external configuration per page/action (ActionBeans are auto-discovered, and configured using annotations)
- Powerful binding engine that will build complex object webs out of the request parameters
- Easy to use (and localized) validation and type conversion system
- Localization system that works even when you use direct JSP->JSP links
- Ability to re-use ActionBeans as view helpers
- Ridiculously easy to use indexed property support
- Built in support for multiple events per form
- Transparent file upload capabilities
- Support for incremental development (e.g. you can build and test your JSP before even thinking about your ActionBean)
- And a lot of built in flexibility that you only have to be aware of when you need to use it
Stripes aims to provide an experience similar to owning Apple hardware, Sony TVs and luxury German cars (without the price premium); things just work, they feel right and every now and again you get that "oh, it does that too? awesome!" feeling.
Enhancements:
- This release includes several minor bugfixes and improvements.

Personal Toolbar Button is an extension which adds a button to toggle on/off the Personal Toolbar toolbar in Firefox.

Adds a button to toggle on/off the Personal Toolbar toolbar in Firefox. This way you can toggle off your bookmarks for more screen real estate when browsing, and easily toggle it back on when you want to go browse another site. Dedicated to public domain, since it is such a simple extension.

Updated version should resolve most icon/theme problems. It introduces a new bug: the icon is ugly! ;-) If anyone can help, Id appreciate that!

If you have any problems, post a comment or message me on aim J C 2 A S T R O (no spaces) and Ill try to help.

Well, the button worked fine. Made the bookmarks toolbar appear and disappear. Unfortunately, the toolbar was blank the entire time. Uninstalling the extension has not helped. Nothing on the toolbar and it will not accept drag and drop. Very annoying.

Im really sorry you had that problem. It works for me almost perfectly. Data loss is a very serious issue. I dont know how my little extension could cause that. It uses a simple three-line function to toggle a toolbar, and it modifies only one property on the DOM.

I cant replicate your browsers behavior at all. What is your browers configuration? Your problem could be unrelated to my little extension. Which extensions and which version of Firefox do you run?

Found the button :) Its blank with no icon, but works fine.

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 !

Surfboard HTTPd provides a simple HTTP server.
Surfboard is a simple HTTP server. It supports directory indexing, CGI, and custom CGI handlers (e.g. for PHP). It currently has no support for any method except GET, but everything else is fully functional.
Surfboard is incredibly small, very reliable, and easy to use (mainly because of its simplicity). Heres the PR:
Main features:
- Simplicity - The goal of Surfboard is to avoid having to play the classic Apache game of "hunt the option." While capable of keeping people amused for hours, it really isnt helpful when you want to host a website.
- Regular file serving and indexing - Quick and simple, but fully-featured. Multiple and absolute index pages are supported.
- CGI scripting(Beta versions only) - No POST support as yet (coming soon), but an otherwise almost complete CGI 1.1 implementation. See the finger CGI demo
- Extensible(Beta) - CGI handlers can be set in the config file, enabling scripting languages such as PHP (www.php.net) to be used (as I do here)
- Highly configurable - Everything from index pages to what you do and dont want to see in the logs can be specified
- Full logging - everything that goes can be logged. You can specify whether you want it in the logfile or not, but its there.
- Multiple simultaneous transfers - of course! Apparently not all simple httpds can. Beats me why...
Enhancements:
- Fixed a buffer overflow which allows the user running the server to escalate privileges to...herself. Oh, well, there are situations in which its serious, I guess, and anyway its bad practice

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).

OSGlobeLAN project is a Web portal for LAN parties, featuring a seat map system, registration, and more.
Enhancements:
- A lot of changes have been made, but this release is primarily to announce that work on the pre-1.0 codebase of OSGL has been stopped, and will no longer be maintained.
- Serious security-related issues might be fixed, but all focus is now on the 2.0 codebase.

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