(Last modified Saturday January the 14th 1995 at 5:23am)
Low Level Language
The goal of this Subproject is a find a language that will fulfill
all the requirement to be used as for Tunes, or design a new one if
none is found.
LLL requirements
see in the Tunes Identity FAQ...
see the HLL page...
portability accross different architecture
local (real-time ?) and distributed higher-order GC
annotations (typing is done through them)
LLL features
Faré's general idea:
entered around the object/annotation paradigm
Low-level objects
objects can be uniquely identified in some way.
Typically, objects in the local address space are identified by
their 32 bit CPU address
(perhaps with an implementation-dependent offset)
objects outside it are accessed using descriptors/handles inside it,
so need not be considered as special objects wrt the LL memory system.
objects of a same address space must trust each other anyway, so let
them have a cooperative GC and multithreading.
communication between address spaces happens directly through
space-dependent drivers.
Annotations
There are standard mechanisms for annotations and their resolution
Every annotation may have its own implementation, be it a hashtable
of object to value association, or an array of values, or some
executable code.
lazy evaluation and futures, typing, UI interface, scoping are done
through annotations.
for example, an object's concrete type (relative to the GC mechanism)
may be determined from bits in its address, whether statically or
dynamically.
LLL Difficulties
Having some efficient hardware-independent stuff.
Garbage Collecting
Infix pointers (that do not point at some globally constant offset
to the beginning of an allocation unit) greatly complicate the GC. They
should be forbidden whenever possible.
"C" like infix pointers can still be simulated with a segment-offset
pair, with an aligned pointer and an offset inside the segment.
The GC may have to accept infix pointers as for code return addresses.
I propose that code "segments" should not cross, say 4K or 8K boundaries, so
that finding the right code segment is just a matter of checking the list of
segments in the segment obtained by masking the right bits.
LLL Difficulties
Having some efficient hardware-independent stuff.
Providing a GC
To Do on this page
Find all LLL requirements.
Find all implementational problems.
Make first proposals.
Divide into subfiles.
Define separately semantics & representation
Find out how multiple architectures can be made interoperable...
Find some nice implementation for annotations...
Separate annotation mechanisms from annotation resolving policies...