-*- Text -*-
   This is the file .../MOOSE/info/HLL.nfo, which contains info
about the MOOSE High Level & Stack Language.


File: HLL.nfo		Node: Top	Up:(MOOSE.nfo)

* Menu:

About the HLL:
* Intro::			What is the HLL ?

Using the HLL:

Semantics:
* HLL principles::		General HLL orientation.

* Defining objects::
* Classes::
* functional primitives::	Functions as a universal concept.
* Objective primitives::	Objects as a universal concept.
* Side effects::		Side effects as an unescapable issue.
* Parallelism::			Parallelism complicates side effects.
* Object annotations::		Annotating eases considerably object use
				and side effects in particular.
* Relational primitives::	Relations ARE knowledge by the computer.
* Program proofs::		a major programming issue: being sure of
				the good behavior of the computer.
* Implicit programming::	inversing relations IS understanding from
				the computer.
* Persistent objects::		the way to a universal distributed database
* Reversible programming::	How to use the computer in an essentially
				reversible way.
* Optimization::		How optimizing your objects is a combination
				of all the above.

Generic Objective Libraries:
* Genericity::			What is genericity ?
* Objects::			What are objects and their semantics.
* Implementation::		How are objects implemented for this nth time.

System Externals:
* Time::			why the so-called "Real-time" modules should
				not be an extension to the system.
* Sound::			Sound is a good application of the above.
* 2D Graphics:(2DG.nfo).	Graphics are eaiser, though.
* 3D Objects::(3DG.nfo).	3D Graphics are more beautiful.
* 4D Objects::(4DG.nfo).	optimized transformation of 3D objects through
				time.

Interfacing with other languages:
* OSL in HLL:			OSL as an HLL subsystem.
* HLL in OSL:			HLL as an OSL extension.
* Links:(Links.nfo).		The Links set of library for linking OSL and
				external languages.

Node: Intro

   A computer is meant to replace man for all mechanical tasks. Physicists
will tell you that everything is ultimately mechanical. Thus, anything a man
would rather let a machine do in his place could be done one day by a machine.
   Now, telling the machine to do your work is itself a mechanical task, so
why not have the machine do it itself ? I mean, you just want to give the
machine simple (to you) orders and expect the machine to understand. That's
what a High Level Language is made for: give a machine clean, human
understandable orders, and let the machine do the dirty work, checking limit
conditions or exceptional values, and so on. But for the human to trust the
machine, the Language must provide the human the security that the machine's
understanding corresponds to what the human expects: the human must have
the complete control of what he meant through a sentence in the language, and
of what the computer should do.

   The MOOSE HLL is the Ultimate programming language, which does it all.
The computing system becomes a database containing all that is needed for
the computer to understand its master human's order. As the master has
specialized needs and concerns, the database must record information about
these for further use. As these needs and concerns are multiple with very
strong to very weak links, the computer must order the information according
to the context in which it is valid. As these links are not organized linearly
(A is linked to B, which is linked to C, which in turn is linked to D, etc),
as each object has a relatively small number of links to random other objects,
the language must provide a way to navigate through these links, to see the
different objects through multiple different aspects.

File: HLL.nfo, Prev: Intro, Node: HLL principles, Next: Objective primitives,	Up: Top

   T


File: HLL.nfo, Node: Objective primitives, Prev: HLL principles, 		Next: functional primitives, Up: Top

File: HLL.nfo, Prev: Objective primitives, Node: functional primitives,		Next: Side effects, Up: Top

File: HLL.nfo, Prev: functional primitives, Node: Side effects,			Next:Parallelism, Up: Top

File: HLL.nfo, Prev: Side effects, Node:Parallelism, Next: Object annotations,	Up: Top

File: HLL.nfo, Prev: Parallelism, Node: Object annotations,			Next: Relational primitives, Up: Top

File: HLL.nfo, Prev: Object annotations, Node:Relational primitives,		Next: Program proofs, Up: Top

File: HLL.nfo, Prev: Relational primitives, Node: Program proofs,		Next: Implicit programming, Up: Top

File: HLL.nfo, Prev: Program proofs, Node: Implicit programming,		Next: Persistent objects, Up: Top

File: HLL.nfo, Prev: Implicit programming, Node: Persistent objects,		Next: Reversible programming, Up: Top

File: HLL.nfo, Prev: Persistent objects, Node: Reversible programming,		Next: Optimization, Up: Top

File: HLL.nfo, Prev: Reversible programming, Node: Optimization, Up: Top

   Optimization reversibly is done by annotating an object by other
objects that are semantically equivalent if you strongen the semantics,
and are smaller according to some criterion.


To add:
* Genericity::			What is genericity ?
* Objects::			What are objects and their semantics.
* Implementation::		How are objects implemented for this nth time.
* Time::			why the so-called "Real-time" modules should
* Sound::			Sound is a good application of the above.
* 2D Graphics:(2DG.nfo).	Graphics are eaiser, though.
* 3D Objects::(3DG.nfo).	3D Graphics are more beautiful.
* 4D Objects::(4DG.nfo).	optimized transformation of 3D objects through
* OSL in HLL:			OSL as an HLL subsystem.
* HLL in OSL:			HLL as an OSL extension.
* Links:(Links.nfo).		The Links set of library for linking OSL and




Language syntax

aspects: by default, they are partial aspects only. That is attributes
defined in an aspect do not represent all the object, but part of it.

   Beware: declared equations relating operations on an aspect of an object are
always valid; but some of them may be valid only relative to the particular
aspect.
   Example: The interactive clad stack may be considered as an intermingling
of 
valid, but
