[Savannah-hackers] savannah.gnu.org: submission of Simple And Tiny Object Model

[thomas . degris]

A package was submitted to savannah.gnu.org.
This mail was sent to address@hidden, address@hidden


Thomas <address@hidden> described the package as follows:
License: gpl
Other License: 
Package: Simple And Tiny Object Model
System name: satom
This package wants to apply for inclusion in the GNU project

Hello,

the aim of the Satom project is to provide a common communication
platform between software components written in different langage,
using different technology to fill their need. The first need of a
communication platform is to define the part of the system that will
communicate.

In Satom, like any others systems like it (COM, CORBA) will use
components that implement interfaces. If a piece of software wants to
use a component, then he will asks for an interface: the protocol used
to communicate between component. An interface is only a set of abstract 
functions. There is two different levels of communication between component. 

The first one (and the easiest) is the langage used when people are
developing their component. Let say a guy is writting in C++ a piece
of software using a component that he doesn\'t know the langage used
for it. Then, to be able to use the component, she will have to
specify to his compiler what interfaces (in C++) it will get from this
component. That means a common language for specifying an interface
will be translated into C++, or another language if the developer is
using another language. This common langage used to be in \"Interface
Definition Language\" (IDL or MIDL, I leave you with the question of
what the \"M\" means). I think people doesn\'t need to learn an old
language and this is the reason why I am using XML, much simpler, to
specify components and interfaces. So, this is the way that the
component are communicating in static.

The second one (and the hardest) is the protocol used when components
are loaded dynamically in memory and have to communicate through their
interfaces. Then, I want to use Virtual Table of Functions as in a C++
compiler. So, an interface will be represented in the memory by a
table of functions to call in order to run the code associated with
the method. All the communication between in the components loaded
dynamically will go through this table of functions.

When a program requests a component to the system, usually, the system
uses a database to know where it can find the component (this is the
registry base in Windows for instance). To do the system more
reliable, I want to use a system similar to the ldconfig in Linux. A
configuration file specifies in which folder it is possible to find
components implementation and a program generates a database when
parsing files in these folders.

I know this is technically possible to do Satom, but I don\'t know how
much time is needed, how much work it represents or how well it can
fit with all the piece of software already existants. But I am SURE,
it worths it.

Other solutions already exits under the name of CORBA (see the ORBit
implementation), COM (only on the Windows platform) and DCOP (part of
the KDE project).