Recursive machines and computing technology, V.M. Glushkov,
M.B. Ignatyev, V.A. Myasnikov, and V.A. Torgashev, IFIP Information
Processing '74, North Holland Publishing Company, 1974,

Characteristics of a von Neumann computer:
  1. Low level machine language (commands are elemental operations
     performed on elemental operands.)
  2. Sequential centralized control of the computational process.
  3. Linear organization of storage, uniformity of memory cells.

Disadvantages:
  1. An enormous gap between the machine language and the external
     programming language (e.g., Pascal.) Recursion is necessarily
     expensive.
  2. Linear organization of the store does not fit the data or
     program model of most applications. This leads to the construction
     of sophisticated storage managers.
  3. Sequential centralized control increases the complexity of
     operating systems because all programs must be forced into a
     single instruction stream without undesirable (nondeterministic)
     effects.
  4. Throughput depends upon component speed. Wire (communications)
     delay is fast becoming the most dominant cost in computing.

Due to microelectronics, the economics of computing has changed
since von Neumann's day.
  "... the minimum number of logic elements no longer leads to the
  minimum cost of the computer (this is especially true if the
  software is taken into account."

Revision of any one (or two) of the von Neumann principles will
destroy their harmony. (Davis's notion of self-consistency.) Partial
revision involves contradictions between machine structure and
the organization of computational processes. Examples:
  1. Raising the internal level of the machine amounts to
     implementing in hardware some of the features of a programming
     language.
  2. The purely sequential nature of the machine (or
     programming language) inhibits the exploitation of concurrency
     for performance improvement.
  3. Machines for parallel computation distribute the
     computation in some rigidly structured way, usually in to
     some specific application (a SIMD machine for arrays or vectors.)
     These kinds of organizations are incompatible with a single linear
     store.

Recursive computers use an entirely different set of principles.
  1. The language structure does not limit the number of language
     levels and complexity of operators (commands) and operands.
	* Operands may be represented by numbers, strings, vectors
	  or whatever.
	* New types can be defined as long as they can eventually
	  be mapped (recursively) into some primitive structures.
	  (This is incompatible with a sequential program flow and
	  would be most efficiently be executed by many concurrently
	  executing engines.)
  2. All program elements for which operands are available
     are executed. (Provides efficient dynamic concurrency,
     but makes the problem of storage management in a linear
     organization an unsolvable problem.)
  3. Memory structure should be reprogrammable in order to convert
     the structure of data and programs represented in the internal
     machine language. New types/machines are recursively definable,
     one level of machine in terms of several others.
  4. There are no limits to the number of machine elements.
     Performance can be tuned by adding or removing machine elements.
     Availability is improved since broken machines can be easily
     removed or replaced (dynamically in software.)
  5. The RC organization is a flexible, re-programmable structure.
     Programmable communication switches are required between
     RC elements. (An RC element is a processor-memory pair.)

The authors describe the language of their RC machine.

A recursive machine architecture is a multiprocessor consisting of
many processor-memory pairs. One should buy performance through
parallelism. Hence, the machine elements could be quite simple.
If an element is extremely simple, microelectronics can make the
manufacture of an element very inexpensive and very large number
of elements can be employed to increase performance.

The complexity of the storage modules will necessarily increase
due to the extensibility of types and associative retrieval.
Associative retrieval is the mechanism by which "ready" operator and
operand tuples are fetched and executed.