Free object oriented programming tutorial software for linux

KDE Simple Programming Tutorial is a tutorial for developing a KDE application.

With the only requirement of a little C++ knowledge, and using the latest KDE snapshots, the reader will learn how to build his/her first KDE application from a simple "Hello world" button to a Web browser with a DCOP interface that communicates with a bookmark application running in a separate process.

Theres also a spanish and a romanian version of the documentation.

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.

AspeCt-oriented C project implements an aspect-oriented extension to C and offers one possible language design for an aspect-oriented C language.
Main features:
- an aspect-oriented extension to C, aspect-oriented software development for C, and an ACC language design option
- full ANSI-C compliance and gcc source-compatibility;
- compiler and generated code portability;
- seamless Linux, Solaris and Windows support;
- simple integration in existing builds and code transparency through source-to-source transformations;
- an open source license and compiler.
AspeCt-oriented C enables:
- modularization of crosscutting concerns for C-based software;
- research on concern separation tailored to C and imperative programming;
- research on aspect-orientation on C-based systems;
- development of highly customizable and easily configurable software in C;
- development of feature-rich software product lines in C.
Enhancements:
- set()/get() join point and pointcut support was added for global variables, and compiler options were added for manipulating join points.

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.

Object Relational Membrane is a Python package that provides the functionality of an object relational layer like EJB or other persistence storage systems.
Object Relational Membrane is a thin compatibility layer between SQL table layouts and Object Oriented Python. While providing a good deal of functionality, it tries to be as small and simple as possible. It currently works with PostgreSQL and Gadfly.
Adapters for Firebird and MySQL are planed.
Enhancements:
- A number of small changes and enhancements.
- The last release previous to a "beta" release.

Task::Catalyst::Tutorial is a Perl module that installs everything you need to learn Catalyst.

SYNOPSIS

Installs the example "MyApp" described in Catalyst::Manual::Tutorial, and all its dependencies.

Undisposable Clients project provides easy-to-use API kits for using Undisposable.org in various programming languages.
Main features:
- Protects site owners biggest assets; userbase and emails
- Prevents userbase contamination by fake accounts
- As critical as email validity check
- Stops people registering your services with disposable email accounts like jetable.org, pookmail
- Detects public accounts (spread from sites like bugmenot.com) and bans them
- Working principle is similar to spam blacklists like spamhaus.org; power of masses
- Totally free, your donations are welcome
How to use it
Check if there is an API kit for your programming language, if there isnt, connect to our servers manually.
Add a few extra lines to your email validation function which is called from your member registration page. The following is an example in PHP language:
..
function checkEmail($email) {
include_once("undorg/php/rest/undisposable.inc.php"); // include the API kit
if(!undorg_isDisposableEmail($email)) { // check if disposable email
.. // old procedures remain here
} // add this line to close the conditional statement
}
..
?>
Thats all. Very simple...
API kits:
PHP
Supports XML-RPC, REST and PHP serialiation. Stable
@TODO: make it object oriented, test PHP5
Python
Supports XML-RPC. Stable
@TODO: make it object oriented, more protocols
Perl
Supports XML-RPC. Beta
@TODO: test it, make it object oriented, more protocols
Java
Supports XML-RPC. Alpha
@TODO: test it, make it object oriented, more protocols
We need your support for clients in other languages.
Enhancements:
- The isValidEmail function was added for PHP and Python.
- Valid RFC and TLD checks are made in real time, as well blacklist queries against disposable email addressing and public accounts from sites similar to bugmenot.com.

Net::DBus::Tutorial::ExportingObjects is a Perl module that contains tutorials on providing a DBus service.

This document provides a tutorial on providing a DBus service using the Perl Net::DBus application bindings. This examples in this document will be based on the code from the Music::Player distribution, which is a simple DBus service providing a music track player.

CREATING AN OBJECT

The first step in creating an object is to create a new package which inherits from Net::DBus::Object. The Music::Player::Manager object provides an API for managing the collection of music player backends for different track types. To start with, lets create the skeleton of the package & its constructor. The constructor of the super type, Net::DBus::Object expects to be given to parameters, a handle to the Net::DBus::Service owning the object, and a path under which the object shall be exported. Since the manager class is intended to be a singleton object, we can hard code the path to it within the constructor:

package Music::Player::Manager;

use base qw(Net::DBus);

sub new {
my $class = shift;
my $service = shift;
my $self = $class->SUPER::new($service, "/music/player/manager");

bless $self, $class;

return $self;
}

1;

Now, as mentioned, the manager with handle a number of different player backends. So we need to provide methods for registering new backends, and querying for backends capable of playing a particular file type. So modifying the above code we add a hash table in the constructor, to store the backends:

sub new {
my $class = shift;
my $service = shift;
my $self = $class->SUPER::new($service, "/music/player/manager");

$self->{backends} = {};

bless $self, $class;

return $self;
}

And now a method to register a new backend. This takes a Perl module name and uses it to instantiate a backend. Since the backends are also going to be DBus objects, we need to pass in a reference to the service we are attached to, along with a path under which to register the backend.

We use the get_service method to retreieve a reference to the service the manager is attached to, and attach the player backend to this same service: When a method on DBus object is invoked, the first parameter is the object reference ($self), and the remainder are the parameters provided to the method call. Thus writing a method implementation on a DBUs is really no different to normal object oriented Perl (cf perltoot):

sub register_backend {
my $self = shift;
my $name = shift;
my $module = shift;

eval "use $module";
if ($@) {
die "cannot load backend $module: $@" ;
}

$self->{backends} = $module->new($self->get_service,
"/music/player/backend/$name");
}

Looking at this one might wonder what happens if the die method is triggered. In such a scenario, rather than terminating the service process, the error will be caught and propagated back to the remote caller to deal with.

The player backends provide a method get_track_types which returns an array reference of the music track types they support. We can use this method to provide an API to allow easy retrieval of a backend for a particular track type. This method will return a path with which the backend object can be accessed

sub find_backend {
my $self = shift;
my $extension = shift;

foreach my $name (keys %{$self->{backends}}) {
my $backend = $self->{backends}->{$name};
foreach my $type (@{$backend->get_track_types}) {
if ($type eq $extension) {
return $backend->get_object_path;
}
}
}

die "no backend for type $extension";
}

Lets take a quick moment to consider how this method would be used to play a music track. If youve not already done so, refresh your memory from Net::DBus::Tutorial::UsingObjects. Now, we have an MP3 file which we wish to play, so we search for the path to a backend, then retrieve the object for it, and play the track:

...get the music player service...
# Ask for a path to a player for mp3 files
my $path = $service->find_backend("mp3");
# $path now contains /music/player/backend/mpg123
# and we can get the backend object
my $backend = $service->get_object($path);
# and finally play the track
$backend->play("/vol/music/beck/guero/09-scarecrow.mp3");