Here's how objects are implemented:

* The high-level idea
---------------------

The Basics:
- we have objects. Anything we consider, if we can consider it, is an object.

Attributes:
- objects basically have attributes. An object is determined by its attributes.
- When you consider an object, most of the time you only consider part of its
 attributes that you consider essential, neglecting the others. It is important
 to know what attributes you consider, and if you want to keep some hidden
 attributes that others may want but not you.

Activity:
- Objects modify with time (if you prefer, what we call an object is a machine
 that has a state, and that reacts to external events, the universal event
 being time). More mathematically, each object is defined by the space of
 the states it can take, and transition functions that return a new state
 and issue output events; which transition is used at each clock tick is
 determined by external input events.
- between the time when an event occurs, and the time when it is received,
 many things can happen.
- Compound objects may be made of of objects linked one with another.
- The Computing Universe is such _closed_ compound object, where all events
 are ultimately caught, no link is pending.
- Constant objects are those whose state space is reduced to one element.
- Objects can that issue events in parallel are said to be multithreaded;
 we can define such multithreaded objects.
- Atomic objects have each atomic transitions, which means the object can have
 only one transition at a time.
- Some objects are passive, others are active. Active objects ultimately
 converge to (return) a passive object, or hang on indefinitely being active.
- Among active objects, some are functions and do not modify outer objects,
 while some are operations,and do modify outer objects.
- Being a function or an operation depends on what outer objects you consider
 and/or neglect.



* Now we consider low-level pcore objects:
-----------------------------------------

- The basic low-level object unit is the cell of memory. It contains data
 of the size of a "long" in C, which must be at least 32 bit. Currently, we
 may assume exactly 32 bits, but we shall reduce this assumption the most we
 can. We assume that pointers and floats are not longer that a cell, else,
 we'll have to change many things inside the package.
- Low level objects are accessed through descriptors; the linker can
 short-circuit these but all accesses to an unlinked object are done through
 these. Note the same memory cells can have several different aspects...
- An object descriptor contains:
 * a cell being (or pointing to) the object's data
 * a cell pointing to a descriptor of the memory manager aspect of the object,
  that contains addresses to 
  methods, including size,compare,copy/link,copy/instanciate,save,load,destroy,
  instanciate the object, a description of the object's fields, and
  object-defined methods.
 * a cell pointing to a user-defined particular aspect of the object
  ml descriptor, that contains pointers to the methods
  of a favored aspect of the object (example, the object being an element of a
  ring).
 * a cell pointing to user-defined external attributes


LL Classes
==========
- they are an encapsulation of


Threads
=======
- threads are a particular kind of active bjects, whose evaluation time is
 high.
- each executing thread has the following attributes:
* "running": true iff the thread is running
* "continue": a function to execute to have the thread running again.
* "stop": a function to execute when preempting the thread, so it can run
  continue again one day.
- threads typically have stack attributes:

Persistence:
- each object has the attribute "logout" that saves an object to disk,
 cutting links to other objects (but remembering how to rebuild again each
 cut link).
- there are two formats, compact (binary), or expanded (text).
 Actually, data is converted to compact format, then possibly translated into
 expanded format for human readability.
- outlogged objects are identified by their name and a unique identifier
(unique in time as well as space). Then, each

Compact format:
- many files are created (may appear as only one on your filesystem, as they
 are concatenated).
- The first file is a directory, and contains information about the others:
 sizes, etc.
- The second one is a symbol string list
- The third one is a list of binary relocational descriptors
- The fourth one contains actual code and data.

Garbage collecting:
- none in this implementation at the moment. An object must detect itself
 that it is unuseful, and commit suicide properly, freeing its memory. We
 hope this won't create holes in memory that would prevent further allocation
 of objects too big, while total free memory size is big enough. If this is
 the case, better save the machine state and relaunch, assuming we reserved
 the memory necessary for this operation.


Linker:
- currently, we DO NOT try to make any link better ("optimize"), but we sure
 should in a near future.
- 



Activation records:
------------------
* An execution stack.
* A return stack (with a continuation at the end).
* A context.