--------------------------------------------------------------
EDMA: Entorno de Desarrollo Modular y Abierto
Object Oriented and Componentware Framework  

Copyright (C) 1998, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010
           by David Martnez Oliveira

See file COPYING and COPYING.LESSER for copying conditions
--------------------------------------------------------------

GNU EDMA 0.18.1
CORIE Module

http://www.gnu.org/software/edma
David Martnez Oliveira [dmartin <at> uvigo <dot> es]
-------------------------------------------------------------------------

About 0.18 Release
------------------
This is the first attempt to release an stable version of GNU/EDMA. The main improvements with respect to previous versions are:

- Improvement on class repositories management
- Fixed lots of bugs
- Addition of several tests and examples

This version even when intended to be stable should be considered as in Beta state as almost no third-party testing has been performed so far. 


About GNU/EDMA CORIE
--------------------
This is the main core (aka CORIE) of the GNU/EDMA project. This is a working beta release, so you can find bugs as well as features not completely implemented. It's also possible that some code was broken due to the heavy API changes from v 0.7.2 to 0.9.x. If you found some of these errors, please report it.

For any question, suggestion, comment or whatever, you can use the mailing list in the savannah's GNU/EDMA page:

http://savannah.gnu.org/edma

or contact me directly at: dmartin <at> uvigo <dot> es

Note that this is the CORIE release and the classes included here can change at any time. Foundation Classes will be defined when GNU/EDMA API get frozen in a later version, for now only a basic set (mostly for testing) of classes is provided.

Bellow you can find some extra comments about the most important GNU/EDMA's features available in this release. For a detailed list look at the Changelog and NEWS files.

What's new?
-----------
The main new features in this release are listed in the NEWS file.
Detailed information is included in the ChangeLog file.

What's broken?
--------------
In this release some features of previous versions are broken.

* Virtual object features was removed
* SIU integration with inheritance primitives. Just level 1 SIU proxies allowed. 
* Multimethod, method invocation with signature. Not fully tested 

What's safe?
------------
In this release nothing is safe :). We need external Beta Testers for full test the whole system.

If you are testing this release and you find some bug or you have any comment or suggestion, please report it directly to me or use the mailing lists at savannah.

Simple unit test are provided for the following features. They should work fine in most of the cases

- Object Creation and Destruction
- Method invocation and Property access (method/properties locators)
- Cloning features
- Dynamic super-like inheritance
- Anchor Point management (overwrite, remove)
- Virtual Methods
- Static methods

What's unsafe?
---------------
Some features has not been tested that much and therefore should be considered unsafe even when, eventually will be become stable. This is the list.

- Hotswap features. This is a work on progress and only very simple cases have been tested so far. You may expect changes in the related API function in future although this feature is intent to be completely transparent.
- SIU Proxies level 2 and 3. SIU proxies integrated on levels 2 and 3, basically inheritance and virtual methods, are not safe.
- The concurrency support for this GNU/EDMA version has been improved, however it is not yet complete. Therefore multi-thread application could be unstable and multi-process actions (dynamic class installation) can produce unexpected results.

What's incomplete?
------------------
The following features are still incomplete and you should expect them to do not work properly in any case:

- Dynamic class installation is only working on shared repositories. There is no mechanism so far to notify to processes using local repositories that they had been updated.
- Subsystem extensions have to be installed on shared repositories. The subsystem extension list (SIU Proxies, IngriDF parsers and EMI handlers) are stored in shared memory. For that reason if one of this components is declared in a local repository, all other processes in the system will see then, but they will not be able to use them, unless they also uses the local repository than the extension.
- Meta-Classes API. This is also incomplete. In this version, the run-time class definition can be used to dynamically define local classes, and therefore can be used for a meta-class to produce new classes. 
- Serialization. Serialization classes treats objects as binary blobs and therefore will not work to interchange data before different platforms.


What's GNU/EDMA?
----------------
GNU/EDMA is an Object Oriented and Component Based environment for application development. What makes GNU/EDMA different from other systems is that GNU EDMA does most of the processing dynamically, that is, at run-time. We call this, generically, Loosely Coupled Object Oriented Systems (LOOCOS). Other people names this systems: delegation based, object inheritance based,...

So, you can establish inheritance relationships among objects or even, you can dynamically override virtual methods, while the applications is running. Working this way you can build more real_life-like models and simplify a lot of common operations which, in most cases, needs complex patterns. Design patterns like Factories, Facades, Proxies, etc... are implicit in the GNU/EDMA programming model (in general in any delegation based system).

In addition to all this, the programming interface provided by GNU/EDMA is mostly based on strings so, concepts like automation or interactive managing are directly supported by the system in a very easy way.

GNU/EDMA provides some features normally found in programming language, but it is not a programming language. It's a system midway from OO programming language to a component-based environment. So GNU/EDMA allows you to use OOP even on non-OO programming language or at least that is its aim.

Additionally, GNU/EDMA provides facilities to build evolvable software. Plug-in based application becomes trivial when using GNU/EDMA. Applications can be directly updated in a modular way (just install the new components required by the new version), even at run-time.

Current version supports instalation of new versions of given components while applications are running. Currently available object continue using the old version, but new instances of the just installed component/class will automatically use the new version.

Heavy hot-swapping features are experimental in this version.

What's CORIE?
-------------
CORIE is the GNU EDMA core, that is, the library that provides the main functionalities of the system, as well as, a minimum basic set of classes/components to begin working with GNU EDMA.

The classes library is still barely populated, but we are working to add the basic components needed by most applications. 


Quick Start
--------------------
Here you can find the instructions to give a quick try to GNU/EDMA:

- Install it in a temporal directory:

  ./configure --prefix=/tmp/edma
  make && make install

- Run the script to setup the GNU/EDMA environment

  . /tmp/edma/bin/edma-env.sh

- Go to the test directory and compile the examples using make -f XXX.mk

There are some classes that are not automatically installed by the system. For instance, the ANNA_PYTHON_INTERP, is one of those. Those classes are not yet completed but they are provided to allow users to test some of the experimental features. In the previous example (ANNA_PYTHON_INTERP) the class is intent to interface GNU/EDMA with the Pyhton interpreter and it is used by the hotswap examples.

To compile and install those classes use:

make -f FILE.mk                (ex. make -f ANNA_PYTHON_INTERP.mk)
make -f FILE.mk install        (ex. make -f ANNA_PYTHON_INTERP.mk install)
ines_class_register FILE.ines  (ex. ines_class_register ANNA_PYTHON_INTERP.ines)

Finally, test programs are not compiled automatically neither integrated in the autotools compiling process. They must be compiled manually using the provided makefiles. In general you need to run a commond like this:

make -f file.mk

You will find those make file (file.mk) within the test directory.

Remember to use the Savannah mailing list to get further information:

BUGS: bug-edma@gnu.org
HELP: help-edma@gnu.org
INFO: info-edma@gnu.org

Enjoy!

