Free java persistence framework software for linux

Aranea framework 1.2.2 is professionally designed as an Open Source Java Hierarchical Model-View-Controller Web Framework that provides a common simple approach to building the web application components, reusing custom or general GUI logic and extending the framework.

Java Parallel Processing Framework is a set of tools and APIs to facilitate the parallelization of CPU intensive applications, and distribute their execution over a network of heterogenous nodes.
Java Parallel Processing Framework is intended to run in clusters and grids.
Main features:
- an API to delegate the processing of parallelized tasks to local and remote execution services
- a set of APIs and user interface tools to administrate and monitor execution services
- real-time adaptive load balancing capabilities
- scalability up to an arbitrary number of processing nodes
- support for failover and recovery
- limited intrusiveness for existing or legacy code
- a dynamic deployment mechanism, that enables the execution of new, or updated, code without having to deploy onto the grid
- fully documented APIs, administration guide and developer guide
- runs on any platform supporting Java 2 Platform Standard Edition 5.0 (J2SE 1.5)
Enhancements:
- JPPF is now licensed under the terms of the Apache License, Version 2.0. Starting from JPPF 1.0 beta1, all releases will be licensed under these terms.
- Prior versions will remain under the terms of the LGPL.
- For the first time, JPPF integrates seamlessly with J2EE. The JPPF Resource Adapter provides J2EE application servers with an access to native grid services.
- Numerous bug fixes, especially with regards to the distributed class loading mechanism.

Business Oriented Framework (BOF) is a Perl application server. It uses SOAP, optionally secured with SSL, to communicate with the client.
The client can use SOAP::Lite or the client module included in BOF, making it easy to connect to the server. User, grou
Enhancements:
- Added support for Schedules and tasks

ProM Import Framework project allows you to extract process enactment event logs from a set of information systems.
These can be exported in the MXML format, which is the standard event log data format for Process Mining analysis techniques.
Process Mining is a family of a-posteriori analysis techniques to extract abstract information from process enactment logs. More in-depth information about the are of process mining is available at processmining.org.
Installation:
- Decompress and extract the provided *.tar.gz archive.
- This will create a folder ProMimport, containing all files necessary.
- Start the application by running the provided shell script start.sh.
- The import filter plugins delivered with your installation package are located in the Plugins folder inside the ProMimport directory.
- Load the plugins (which are packaged in *.jar files) that you want to use from within the running app. For that, use Load filter plugin.. from the Filters menu.
- 3rd party plugins, or plugins developed by you, can be added to the application in exactly the same manner.
- Once imported, filters are automatically added to the applications filter cache, and zre re-loaded on every successive startup. Further, all filter and application configuration data is transparently made persistent by the application.
- Thus, after importing all filter plugins necessary, you can safely delete the Plugins folder.
Enhancements:
- This is the initial release of the ProM framework under the new open source CPL license.
- Installers / disk images are provided for Windows and Mac OS X, while the provided source archive is also executable on all platforms supporting Java 5.0.
- Notice that this release depends on a Java runtime environment of version 1.5 / 5.0 or later.
- Prior JRE releases may yield unexpected errors.

JDBCPersistence project is an Object Relational Mapping Framework. Designed for use in high volume online banking application the package delivers performance matching of that exhibited by hand written JDBC code.

The differentiating features of JDBCPersistence are a result of the focus placed first and foremost on performance followed by making programmer most effective by building on existing knowledge of SQL, JDBC APIs, IDEs and, at the same time, avoiding creation of dependencies on specific libraries, tools, IDEs.

The framework strikes a good balance in what it provides verses what it requires a programmer to do in order to use it, e.g. a programmer could quickly prototype value objects by specifying them as Java interfaces and asking the framework to provide implementation for these interfaces at runtime, thus allowing to go from specifying an interface to using it in no time.

On the other hand, recognizing that data relationships are governed by business rules much more complex than could be specified in a typical ORM configuration file, a programmer is required to maintain such relationships in code.

The focus of the framework is to provide ORM services while leaving other concerns, in particular, data caching, up to the developer to solve in the context of an application. Being aware that the caching requirements may be different in online vs. batch application, the framework does not prescribe a solution. Developer needs to decide on application specific caching policy and implement it in an architectural layer (DAO) designed to function in both contexts.

The framework does not add any behavior to the classes that comprise the application. Classes supplied by the developer are the classes that will be used by the application when it runs.

JDBCPersistence uses bytecode generation technique to create bytecode for classes that implement logic used for persisting the data. Such, for every, loosely speaking "Java Bean", that requires persistence, a persistor class that implements CRUD operations is created. As opposed to using reflection, the approach of generating bytecode is apt to further optimization by JVM.

JDBCPersistence takes bytecode generation a little further by providing a feature that allows generating complete implementation of a value object specified as an abstract class. Similar to generating full implementation for Java interface class that describes value object class, the framework can generate implementation for all abstract methods of an abstract class representing value object.

As all of the bytecode generation takes place at run time, there is no impact on development or build process. The approach of generating bytecode at runtime is also used by RMI implementation of the Java Platform starting with version 5.0.

The API of the framework builds on the existing JDBC APIs. JDBCPersistences public API adds four classes and three interfaces. As the framework uses SQL for queering the data a curve associated with learning framework specific query language is avoided.

In an attempt to "keep it simple" JDBCPersistence only dependency is ASM, which is used for bytecode generation. The footprint of the package is under 200K.

WebMacro is a 100% Java open-source template language that enables programmers and designers to work together while promoting the ModelViewController pattern.
WebMacro is a viable (and proven!) alternative to JavaServerPages, PHP, and ASP. Its the fundamental page technology behind several major websites such as AltaVista.
WebMacro separates concerns about program code from concerns about the way a page looks:
- HTML should not clutter up program code
- program code should not clutter up HTML
- you should OwnYourOwnWork
- no-one should have to work through somebody else

WebWork MVC Framework is a Java pull HMVC Web application framework, designed for creating dynamic websites using minimal effort and maximum flexibility.
It supports multiple views, allowing you to switch between different view technologies, including HTML, Swing, PDF, XSLT, and Velocity, without changing the logic producing the data.
It includes a powerful expression language for navigating its object stack, as well as a small but complete tag library. WebWork MVC Framework supports internationalization, error handling, chaining actions, validation, command driven actions, redirection and type conversions.
Enhancements:
- Full support for Java 5 Annotations and Generics.
- Rich AJAX support using DWR and Dojo.
- A new QuickStart tool makes development easier.
- Client side validation using AJAX or plain JavaScript.
- Built in support for Continuations.
- A rich UI template framework.
- Native support for Spring and Pico IOC containers.
- More intelligent error reporting.
- Developer Mode makes building Web applications easier with improved error reporting.
- A simplified tag syntax.
- An advanced data binding framework that works with any object, including domain objects.