Free what is object oriented programming software for linux

The Object Oriented Database Kit is a set of tools to help database applications developers to handle database communication, reporting, and printing. It has a solid, stable, and easy to use API. The project is also GUI toolkit agnostic and portable.

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.

Qu is a powerful full-featured object oriented programming language. It is an Open Source software. The Qu Programming Language is absolutely free (as in free lunch) and distributed under the GNU General Public License (GPL).
Qu is inspired by other languages. Most noticeably Perl, Python, Ruby and C. It mostly resembles Python except that the syntax is more flexible, the internals are simpler, and Qu allows you to use either indentation or non-indentation style.
Qu has a clean syntax designed to promote readability. There is no need for semi-colons and commas to separate items except in rare cases when the end of an expression is not obvious.
Qu is a procedural language. A program consist of statements and expressions evaluated in the order they appear.
Qu is a strong semi-dynamic (optional-static) typing language. Adding a number to a string will throw an exception. A variable can hold anything or you can attach a validator to it. Validators can be as simple as a class, a constant object (Array, Range, Struct, etc.) or even a validator function.
Arrays, dictionaries, and sets can be constrained to hold only a specific "type" of data as well.
Everything in Qu are objects, including numbers, strings, etc. The number 123, for example, is actually an instance of the builtin Int class. Classes are instances of the builtin Class class, etc. But this does not mean that you must write your programs in an object oriented manner. That is entirely up to you.
Documentation can be embedded in the source code. The compiler will skip them. The documentation builder will extract them. The builder is included as part of the standard distribution.
In fact, when you install Qu or Qu modules, the documentations are automatically built for you.
Qu is entirely written in C. Readable documentations are embedded in the C sources directly.
Writing C modules for Qu is as easy as it can get!
Main features:
- fast
- clean syntax
- strong semi-dynamic typing
- module management
- multithread
- deadlock detection
- label loops, break, continue, redo
- loop, while, for, atomic, do
- fast exceptions
- try, catch, else, finally
- nested function
- lexical closure
- accummulator
- generator
- coroutine
- type validator
- run once function
- full and safe eval
- buffered printing
- auto self
- private, public and static attributes
- read/write & read-only attributes
- class property and methods
- dynamic attribute access
- single inheritance with mixins
- multiple constructors
- super class attribute access
- finalizers
- multiple assignment
- variable and default arguments
- argument flattening
- uniform attribute access
- complex number
- big integer
- mark & sweep garbage collector

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.

AspectES is an implementation of Aspect-Oriented Programming in JavaScript 1.5, as standardized by EcmaScript Specification 262.
AspectES project contains core classes that enable software engineers to gracefully develop JavaScript applications that have clear, well-documented designs that incorporate Aspect Oriented Programming.
This project only uses standardized Web technologies: JavaScript 1.5, with no proprietary extensions. The framework is documented with JavaScriptdoc.
Mission:
Produce a superior implementation of Aspect-Oriented Programming in JavaScript v1.5, as standardized by EcmaScript Specification 262.
Scope: A package framework that contains core classes that enable software engineers to gracefully develop JavaScript applications that have clear, well-documented designs incorporating Aspect Oriented Programming.
Agenda:
Current:
- This framework powers the drag-and-drop capability in the (open-source) Gigapan Explorer Application, delivered to the United States NASA in late 2005.
- This project only uses standardized web technologies: JavaScript 1.5, with no proprietary extensions.
- Enjoy complete JavaScriptdoc as you develop this codebase.
- See the Coding Standard.
- See the tips on Debugging JavaScript.
Immediate Future:
- Develop a test suite that completely exercises the existing functionality.
- Log and fix bugs on said functionality.
- Identify additional desired functionality.
- Build a pluggable module for generating JavaScriptdoc from AspectES aspects and their associated yarn.
Enhancements:
- This version is now contained in its own tigris.org project, separate from the Gigapan Explorer application for which it was originally developed.

HTML::Tree::AboutObjects is an article: "Users View of Object-Oriented Modules".

SYNOPSIS

# This an article, not a module.

The following article by Sean M. Burke first appeared in The Perl Journal #17 and is copyright 2000 The Perl Journal. It appears courtesy of Jon Orwant and The Perl Journal. This document may be distributed under the same terms as Perl itself.

Time::Piece is a Perl module that contains Object Oriented time objects.

SYNOPSIS

use Time::Piece;

my $t = localtime;
print "Time is $tn";
print "Year is ", $t->year, "n";

This module replaces the standard localtime and gmtime functions with implementations that return objects. It does so in a backwards compatible manner, so that using localtime/gmtime in the way documented in perlfunc will still return what you expect.

The module actually implements most of an interface described by Larry Wall on the perl5-porters mailing list here: http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2000-01/msg00241.html

USAGE

After importing this module, when you use localtime or gmtime in a scalar context, rather than getting an ordinary scalar string representing the date and time, you get a Time::Piece object, whose stringification happens to produce the same effect as the localtime and gmtime functions. There is also a new() constructor provided, which is the same as localtime(), except when passed a Time::Piece object, in which case its a copy constructor. The following methods are available on the object:

$t->sec # also available as $t->second
$t->min # also available as $t->minute
$t->hour # 24 hour
$t->mday # also available as $t->day_of_month
$t->mon # 1 = January
$t->_mon # 0 = January
$t->monname # Feb
$t->month # same as $t->monname
$t->fullmonth # February
$t->year # based at 0 (year 0 AD is, of course 1 BC)
$t->_year # year minus 1900
$t->yy # 2 digit year
$t->wday # 1 = Sunday
$t->_wday # 0 = Sunday
$t->day_of_week # 0 = Sunday
$t->wdayname # Tue
$t->day # same as wdayname
$t->fullday # Tuesday
$t->yday # also available as $t->day_of_year, 0 = Jan 01
$t->isdst # also available as $t->daylight_savings

$t->hms # 12:34:56
$t->hms(".") # 12.34.56
$t->time # same as $t->hms

$t->ymd # 2000-02-29
$t->date # same as $t->ymd
$t->mdy # 02-29-2000
$t->mdy("/") # 02/29/2000
$t->dmy # 29-02-2000
$t->dmy(".") # 29.02.2000
$t->datetime # 2000-02-29T12:34:56 (ISO 8601)
$t->cdate # Tue Feb 29 12:34:56 2000
"$t" # same as $t->cdate

$t->epoch # seconds since the epoch
$t->tzoffset # timezone offset in a Time::Seconds object

$t->julian_day # number of days since Julian period began
$t->mjd # modified Julian date (JD-2400000.5 days)

$t->week # week number (ISO 8601)

$t->is_leap_year # true if it its
$t->month_last_day # 28-31

$t->time_separator($s) # set the default separator (default ":")
$t->date_separator($s) # set the default separator (default "-")
$t->day_list(@days) # set the default weekdays
$t->mon_list(@days) # set the default months

$t->strftime(FORMAT) # same as POSIX::strftime (without the overhead
# of the full POSIX extension)
$t->strftime() # "Tue, 29 Feb 2000 12:34:56 GMT"

Time::Piece->strptime(STRING, FORMAT)
# see strptime man page. Creates a new
# Time::Piece object

FlexiRecord is a ruby library for object oriented access to databases. Each table is represented by a class, each row of that table is represented by an object of that class.
This library is especially aimed to properly support database transactions. By now only PostgreSQL (version 8.2 or higher) is supported as a backend.
Please note that this is an alpha release. This means the library is incomplete and mostly untested yet. Use it at your own risk.
FlexiRecord is free for private and commercial use, no warranty, subject to the license agreement in the software.
Enhancements:
- Database connections in the connection pool are now re-established if they are broken.