Free persistence framework software for linux

Simple is an XML serialization framework for Java. Simple XML Framework goal is to provide an XML framework that enables rapid development of XML configuration and communication systems.
This framework aids the development of XML systems with minimal effort and reduced errors. The framework borrows ideas and concepts from existing XML tools such as C# XML serialization and other proprietary frameworks, and combines those ideas resulting in a simple yet extremely powerful tool for using and manipulating XML.
Simple framework with powerful capabilities
The framework used to provide XML serialization is simple to use and revolves around several annotations an a single persister object used to read and write objects to and from XML.
It requires absolutely no configuration
Unlike many of the XML frameworks for Java there are no mappings or configuration required to serialize objects regardless of its complexity. The XML schema is represented using field annotations.
Extremely rapid development with XML
Developing XML configuration and communication systems can be done much quicker that through the use of XML frameworks such as DOM, SAX, and even other frameworks such as Digester and XStream.
Converts to and from human editable XML
A primary goal for the framework is that the XML data used to deserialize a serialize objects is human readable. All XML elements and attributes take a simple structure that can be easily created with a text editor.
Enhancements:
- Concurrency and class loading improvements have been made in this release.
- The persister can now be used by multiple concurrent threads using any of the stock strategies.
- Class loading has been greatly improved so that it can be configured for use in a wide range of environments.

BeanKeeper project was formerly called "Simple Persistence for Java" and is a full featured, powerful object/relational persistence and query library for Java.
Philosophy
Java enterprise software, and according to some, the Java language itself tends to go in the direction of extreme softcoding, or at least, in the direction of additional complexity. Weve seen it happen with the EJB framework, and more recently, the Java Server Faces.
That does not need to be so! Other Java persistence frameworks such as Hibernate, TopLink or pBeans already are catching up to the philosophy of simpleness over "abstractness", however, we think there are more steps that can be taken in this direction.
From a developers point of view, especially in a high-level language such as Java, it is a sane assumption, that I do not have to (do not want to) get into the gory details of storing an object, I do not want to hold the databases hand on how to store my object, I do not want to tell it how to create approriate tables, columns, indexes, how to join tables, how to manage connections, how to allocate disk space, how to optimize queries, etc. I assume a "database" as such, should know how to do that without my help, thats why its called "database".
So the point is, a good library should not get in the programmers way, but adapt to the usage of the programmer, and adapt to patterns commonly used. This is what BeanKeeper tries to do. You dont need to (and you cant even) tell it how to store objects, it simply does. You dont need to specify the schema, relation model, id/key attributes, fetching algorithms, database dialect, or anything like that, you can focus on writing the business logic.
Implementation
So how does all this philosophy stuff translate to a persistence software library? The library is not only supposed to handle all low-level database operations transparently, but also some of the more high-level functions. This must be done in order to enable the developer to concentrate only on writing logic.
Main features:
- Simple usage, which is possible with learning only 3 methods, and reading the tutorial.
- Zero-configuration. Nothing needs to be configured, only the database url is needed for the library to initialize.
- Scalability. The library is capable of distributed operation, from virtually unlimited nodes.
- Relations like references to other objects, Lists, Maps, Sets, Collections are handled 100% transparently by the library.
- Large result sets are automatically paged! Paging is 100% transparent, so a million-record result list can be given directly to the presentation layer, without caring for memory usage and database load!
- Transactions are always serializable. Meaning: during a transaction nothing can influence the result of queries from outside the transaction. This practically means, a programmer does not have to care about other transactions possibly influencing the logic inside his transaction.
- Full (transparent) polymorphism support ensures that (most of the time) the library does not get in the way of the programmer. The model is persisted just in the way the programmer expressed through inheritence, and is recalled with all the attributes of polymorphism.
- A custom, object oriented query language ensures, that no complicated SQL needs to be written.
- Scalar query support enables view-centric, more efficient data recall.
- Real portability between databases. BeanKeeper hides all database specific behaviour from the programmer, like: null value handling, empty strings (oracle), case sensitive and insensitive searches, reserved names, etc. That means, one can switch between database implementations, and can assume that (with the exception of a few documented cases) the software build upon the library will continue to work.
Enhancements:
- All known bugs were fixed.
- Primitive type handling was enhanced, so container types (Set, List, and Map) can now contain boxed primitive types too.
- This also means that JDK5 generics are now handled correctly. List member attribute implementation was corrected, so it preserves ordering and can contain duplicate objects.
- The library was relicensed to the LGPL v3.

Aranea is 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.
The framework enforces programming using Object-Oriented techniques with POJOs and provides a JSP tag library that facilitates programming web GUIs without writing HTML.
Main features:
- Small core. Aranea core consists of ca. 10 interfaces, some conventions concerning how to use them and a number of default or base implementations.
- Component-oriented. In Aranea everything is a component and everything is reusable, the framework itself is assembled from a number of components with specific responsibilities. The framework itself is assembled from a number of components with specific responsibilities and programmer also writes the code in terms of components. The components have very simple interface which has about 4-6 methods.
- Event-driven. The whole programming model is based on components reacting to events generated by the user. One typically doesnt have to deal with request or determine what button was pressed since the event handler just calls the appropriate listener or method.
- Plain Old Java. The components in Aranea are pure Java objects supporting polymorphism, inheritance and encapsulation.
- Explicit state management. Aranea component fields are persistent and framework will automatically determine component lifecycle without limiting to any scopes.
- Powerful navigation. Aranea out-of-the-box supports the so called flows and flow nesting, which allows to create nested processes that preserve the previous process state and restore it when finished.
- Type safe. Since there is no playing around with session attributes and no XML mappings the Java compiler is able to verify that all types and classes match and navigating between components is as easy as holding Ctrl and clicking.
- Secure. Since components are created explicitly when needed and removed when they are needed no more there is no need to protect the controller URLs with roles or privileges.
- Testable. Testing pure Java is as easy as it sounds, and there is no need for any J2EE containers. And since Aranea can be used with Dependency Injection containers like Spring, it makes testing even easier.
- AJAX-ready. Aranea supports natively both partial page updates and AJAX-enabled components like autocompletion search boxes. Aranea can also be used as a controller for a purely AJAX application.
Enhancements:
- Some bugfixes and additions were made to BeanFormWidget.
- TcdAndTldMerger is now present in aranea.jar and does not need to be compiled separately.

Clover.ETL is a Java based ETL framework which can be used to transform structured data. While using JAVA technology it allows for platform independence.
Clover framework can be used standalone as an application run from command line or can be embedded into Your application. Clover.ETL is released under LGPL License.
Clover.ETL is used by many individual developers and several companies, which embeds it into their solutions.
Enhancements:
- The internal transformation language has been improved.
- All reader and writer components support the same set of parameters (dataPolicy, skipFirstLine, skipRows, numRecords, etc.).
- Several new transformation components have been added.

Helma is an open source web application framework for fast and efficient scripting and serving of your websites and Internet applications.
It is written in Java and employs Javascript for its server-side scripting environment, removing the need for compilation cycles and reducing development costs while giving you instant access to leverage the whole wealth of Java libraries out there.
Helma pioneered the simple and codeless mapping of application objects to database tables, which has only recently come into vogue with other web frameworks. In addition, an embedded object-oriented database performs automatic data persistence of unmapped objects.
Helma has proven itself to be stable and fast, capable of serving high traffic sites with hundreds of thousands of dynamic pages per day. The Austrian Broadcasting Corporation, popular weblog hosting sites such as antville.org, twoday.net, and blogger.de, among many others, have successfully been deploying Helma for several years.
Enhancements:
- This release adds subskins, macro pipes/filters, an update to Rhino 1.6, E4X support, the ability to define getters/setters, and many improvements to the host objects in the JavaScript environment.

Macs MVC Framework is a open source, MVC Framework with an in-built templating engine. The project was made with future extendability in mind, ease of install, ease of use, and more over has a very short learning curve.
It also comes bundled with many PHP Libraries and Javascript Libraries to allow you to create the application you want.
The framework generates SEF (Search Engine Friendly) URLS, right out of the box, this site was created over the framework, click on the nav bars an see the SEF URLs.
Enhancements:
- An AJAX driven CMS was added.
- siteURL and siteDir auto-detection were improved.