Tuesday, July 29, 2008

granularity

Granularity is the key concept that opens our understanding of software. In AgileWiki we have 4:

1. Methods apply to capability objects. These are grouped by aspect and elements are aggregates of, at most, one capability for each aspect.

2. Events apply to elements. Each event is routed to the capability objects of the applicable aspects.

3. Operations apply to rolons, which are DOMish trees of elements.

4. Commands apply to arks, which are a collection of rolons.

element model release 2-1

Browse is now working and supports help, echo and exit commands.

https://sourceforge.net/project/showfiles.php?group_id=106672&package_id=285239

Monday, July 28, 2008

element model release 2-0

Release 2-0 completes the element model. A Hello World! program is also included.

Download

Saturday, July 26, 2008

element model release 1-0

In this release we have implemented a simple ark and event processing.

Friday, July 25, 2008

elementModel release 0-2

http://sourceforge.net/project/showfiles.php?group_id=106672&package_id=285239

The element model, which is really an extensible DOM, has now been roughed out in a minimalistic sense--only the necessary items have been added. It can express itself now as XML, but that was a feature that was helpful for testing.

The idea here is to provide the minimum of code to introduce the concepts. What we have are 4 interfaces and 10 classes, none of them very long.

The download (see the link above) includes the javadocs as before. This time it also includes the source code. For your reading pleasure.

Thursday, July 24, 2008

Element Model release 0-1

What is the point of a framework that no one understands? So we begin again, this time with a simplified element model.

http://agilewiki.wiki.sourceforge.net/

Wednesday, July 23, 2008

a layered approach

One thing I learned when working on COWDB and COODBMS is that it is very difficult to implement things in layers--you really need to know what you are doing.

One thing I learned when working on COWDB2 is that it is very difficult to explain a monolithic implementation. People need to learn things layer by layer.

An important goal in this project is to build a team that can work on, support, and expand on what I have learned these last few years. So a layered approach is the only real option. I have learned a great deal these last few months while working on COWDB2. Hopefully I have learned enough to be able to use the layered approach.

Layer 0 -- This will be the element model. There will be no persistence object (that is moving into the streaming aspect) and this layer will have no knowledge of the aspects, excepting only the Application objects which are what are passed instead of the element.

Layer 1 -- This will be a business object model. Business objects map into XML documents. Multiple business objects will be supported, with links between them. We will implement attributes, containers and links. (The approach taken will be to implement the minimum necessary for each layer. The implementation of a rich set of capability objects can be delayed until and as they are needed.) In this layer, the framework will support the creation/deletion/retrieval of business objects. But there will be no persistence.

Layer 2 -- Here we add well known business, parent/child relationships, operations and roles. Again, a light weight minimal implementation with no persistence. The framework will provide access to well known business objects.

The objective here is to develop the basics and provide the necessary documentation. These three layers will then comprise the core for a more serious effort.

Wednesday, July 09, 2008

COWDB2 release 2-0.3

o Application objects now need only implement an interface with one getter and one setter to be used in COWDB2.
o The diskspacemanagement package is now complete, including javadocs.

Monday, July 07, 2008

COWDB2 release 2-0.2

In this release we have made a big change to the object model. We now pass references to the Application object place of references to the aggregate element, making the object model largely transparent. So when using the API, you pass application objects as arguments and the returned values can simply be cast appropriately. Internally we now also have strong typing, as everything is no longer simply a CElement.

One consequence of this is that for every element need an application object, so we've had to add a lot of Application classes for the various element roles used by the framework.

There has also been a change to the implementation of transactions. They are now simply facods, carrying a reference to their associated element. Facods are strictly transient and are not aggregated into the element.

Saturday, July 05, 2008

COWDB2 release 0.1.3

The control package is now complete, including the Javadocs.

Contributors to this release:
--Naji
--Bill

Thursday, July 03, 2008

COWDB2 release 0.1.2

o Read and write caches are now in place.
o Threading issue addressed in handle.
o Javadocs done for the contents and documents packages.
o New Bytes capability added.

Contributers to this release:
- Naji
- Bill

Tuesday, July 01, 2008

COWDB2 release 0.1.1

o The Java Docs for the elements package been completed.
o Some minor changes/enhancements made to the API.