Free object oriented programing software for linux

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

Php Object Generator on short POG is an open source PHP code generator which automatically generates clean & tested Object Oriented code for your PHP4/PHP5 application.
Over the years, we realized that a large portion of a PHP programmers time is wasted on repetitive coding of the Database Access Layer of an application simply because different applications require different objects.
By generating PHP objects with integrated CRUD methods, POG gives you a head start in any project and saves you from writing and testing SQL queries. The time you save can be spent on more interesting areas of your project. But dont take our word for it, give it a try!
Main features:
- Generates clean & tested code
- Generates CRUD methods
- Compatible with PHP4 & PHP5
- Compatible with PDO
- Free for personal use
- Free for commercial use
- Open Source
Enhancements:
- POG now fetches result set arrays where possible (which provides a big performance boost).
- Data encoding is handled within the database.
- A new plugin interface is used.
- A data encoding sanity check was added to setup.
- Siblings can be deleted without deleting children.
- Getlist() accepts column names as filters.
- Getlist(), GetChild(), and GetSibling() return all results if no arguments are passed.
- A database wrapper class for PDO was added.
- The PDO performance was improved.
- The plugin API, POG base API, and database API were made uniform to prevent plugin versioning.

Luban is a component oriented scripting language. Luban is free and open source. Luban is named after a legendary ancient Chinese civil engineer and carpenter two thousand year ago whose constructions are still in use today.
The programming language spectrum seems crowded. Do we have all the tools we need? The author of Luban likes the scripting languages in general because of their usability. Though he always feels the pain for the lack of suitable component model for scripting.
And he personally considers object oriented scripting is too complicated for scripting purpose and will never compete with C++/Java. He eventually created Luban, a scripting language with a robust component model tailored for scripting purpose. Luban is an easy scripting language that is as clean and manageable as Java.
There have been numerous discussions about software component without clear definition. Lubans definition of component is property based object that is similar to Java Bean. User interacts with component by reading and writing property values, and computation could be triggered by the interactions.
The idea of Luban programming language that scripting language needs a different component model other than conventional class hierarchy to fit its scripting environment. A complete mechanism is built in Luban to define, save and categorize components, which is a fundamental feature of Luban.
Enhancements:
- This release adds the new feature to iterate through the elements in Java container objects.
- The following Java types can now be iterated in Luban: Java array, java.util.Collection, and java.util.Map.

Keystone is a cross-platform, object oriented application framework which allows applications to be written to build on the target platforms of GNU/Linux and Win32 without modification of their source.
Keystone Application Framework implements several modern Web standards, including SVG graphics and the XUL user interface description language.
Enhancements:
- A significant development in this release is the optional use of the GDI+ (Win32) and CairoGraphics (Linux) rendering backends to render SVG content.
- In addition, support for SVG paths has been much improved with the ability to render bezier and elliptical segments.

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

The Complex Language project is an object oriented programming language intended for scripting or rapid prototyping of applications.
The design goals were to have very few simple but powerful concepts and to be easy to use and easy to learn. The project provides a working interpreter along with a complete specification of the language.
Enhancements:
- This is the first release of the specification and the corresponding interpreter.
- The corresponding library is very poor, and there are probably still bugs in the interpreter.

Tree::Binary is a Object Oriented Binary Tree for Perl.

SYNOPSIS

use Tree::Binary;

# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)

# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);

# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"

# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);

# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"

# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);

# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"

# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);

# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"

# be sure to clean up all circular references
$btree->DESTROY();

This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.

Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.

This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.

This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.