The main difference is that the structural composition of atomatrices is significant while with a mataobject the interface is significant.  An atomatrix has no interface, but the metaobject has a system dependant interface.  Several atomatrices could be the composition of a metaobject if bound in such fasion.

Personally, I plan to use this project as the basis environment to accomplish my mastery of Computer Science.  Most of the work I do on this project is to create all the possible tools that may be needed at the time of the mastery project.  I want to optimize my time to complete the mastery of Computer Science with the right tools.  I feel I need a dynamic compiler that can handle a clustered and distributed virtual environment to accomplish this goal.  The compiler is usable just like many popular object orientated languages.  I plan to write a new program language, so I have not documentated all the previous program language or bytecode details except for what exists in source code.

Clustered systems share resources.  The Atomatrix OSS shares memory resources, mainly, to accomplish asynchronus procedures.  If compared to the metaobjects of popular object orientated languages, we could look at how the metaobject "presists" at a low-level (automatically to the programmer) between threads or processes.  An atomatrix does not automatically presist or share resources with other processes or threads.  Instead, the program can generate several atomatrices to create a metaobject that then clusterizes across processes or threads.  That setup allows the system to manipulate atomatrices at a local level to a single thread or process; thus, it does not have to slow down one process to wait for other processes to update.

Distributed systems let many process work together for a result.  The processes usually do not share resources as with clusterization.  For example, one process could send commands to several other processes located throughout a network of computers that are local and far away to accomplish a result.  All the process that attempt to accomplish the result only need to send or receive a portion of the entire process that each is set to work on.  The Atomatrix OSS is able to generate distrubuted objects.  Ionica is a framework that can generate and distribute such objects.

Most source code compilers have a predefined instruction set that the compiler uses for bytecode assembly, yet the Atomatrix OSS allows itself to redefine the set of rules and instruction codes to create the bytecode.  The Atomatrix OSS always compiles ("just-in-time") any program on demand that is not already compiled for that instance the Atomatrix OSS uses, so the set of rules and instructions can change.  The Atomatrix OSS continually optimizes the changes at an internal bytecode level.  Currently, the system uses a mixture of a predefined instruction set and the dynamics of run-time redefintion of the compiler.  The usual way to redefine the compiler actions is by common object orientated design techniques.   The more low-level method is to create a code library that interfaces with the OSS and redefines or adds instruction sets.  I have implemented just enough of a dynamic compiler that current technology can handle effectively.  I plan to rewrite the compiler to a fuller dynamic level.  And, it remains fast because it only compiles the essential parts of an object as needed.

-- Ballard, Jonathan  20040801