Unit management core

The unit management core contains the basic data management functions: entity access by reference, creation with a referred primary type, manage aspects and field values. These functions do not contain any collection yet. In order to test it, I have to add the boot initialization structures and codes to insert one or perhaps more units with their type etc declarations. In a monolithic application, this is also the end: the code uses these functions to access predefined entities - which means the monolithic application must have a generated conde on boot level, containing all the type declarations, and it should refer to the generated identifiers as well.

So the next step is

1. to create the unit manager boot init
2. create a test application that initializes the unit manager
3. write a code that accesses the data in the unit manager (static entities only)
4. create the channel management
5. extend the initialization with message processors
6. write test code for the communication

Practically at this point the lowest, monolithic application model is POC ready - single threaded, static data objects. Such applications are the basic event processing and dispatching applications like embedded systems: simple user interfaces with leds, LCD segments and buttons. Perhaps I should write a simple demo application with emulation of such an interface (fixed, coded, because this canát even process a configuration: the configuration is the code written manually).

After this point I can go on towards dynamic type management: generated code for the type management data, syntax module, dynamic entity creation, dynamic binary loading. This is the environment of a single-threaded, plugin-based application. This is the complex console application level. The sytax module will allow me to make the first useful tool: the one that generates C sources from type declarations (header files with constants, and sources for boot time initialization).

The nex big stuff will be the GUI, to have a full, still single threaded desktop application. The target is the starter version of the DustLab. Resource stuff... this will be a hard one. I must separate the GUI text content and the structure; formatted text and resource templates apply here. I should also extend the type management with proper message templates here (logging, message sending, routing).

Then comes the persistence layer with some real connector (database, ldap, filesystem). This is the beginning of the real entity invocation - when the entity instance lifecycle separates from the application. I should move the DustLab content into a persistence service layer for both editing and instance resolution.

Next is the parallel processing - both for the same application (event management, separate GUI and process threads, parallel processors) and connectors (when multiple applications connect to each other, server/client or p2p models). Big stuff is the lock, clone-on-write mechanisms, transaction management.

Impressive... :-D