This is my version of UNCOL (Universal Computer Oriented Language).
The goal is a practical universal intermediate between any conceivable machine and any conceivable language.
I start with a few basic guidelines and then attempt to create a few simple constructs that meet those guidelines.
These building blocks need to be able to accurately and completely describe any program from any language.
As pointed out by John von Neumann, code can be stored in the same memory as data. Both are numbers or bit strings (on some early computers, possibly ternary digits or decimal digits).
Everything in any program, both code and data, can be expressed as a collection of data about data and code.
Each datum (single item of data) a few pieces of information (not all data will have of these pieces of information):
(1) A method for uniquely identifying it, such as a reference number. This method of identification can be implied.
(2) A value. For data this could be a number or bit pattern or string, etc. For code this can be an instruction or operation. It is possible that the item may not always have a values (before initialization or after it is released).
(3) A shape.
(4) A size.
(5) A name.
(6) A type. This may be strong, weak, dynamic, static, etc.
(7) Attributes. Many data will have attributes assigned either by the programmer or by the language.
My plan is to consider pairs of datum and transformation.
A single datum may be a single elementary thing (such as a bit or number or character) or a collection of things (ranging from a pair of bits to an entire program).
We can combine instances of our most simple datum (a single bit) into some pattern. The most obvious pattern is the binary string.
Common elmentary data types that are typically stored in hardware as binary strings include Boolean values, characters (of any arbitrary character set), and numbers (signed and unsigned integers, floating point, arbitrary precision numbers, rational numbers, complex numbers).
More advanced shapes include such things as graphs, tables, trees, lists, stacks, loops, rings, arrays, multi-dimensional shapes.
I started thinking about a single binary bit and the transformations that can be applied to it: logical NOT, always zero, and always one.
Next I considered the transformations that could be applied to two seperate bits.
The most basic two bit transformation are AND and OR. A little more interesting is either the single operation NAND or the single operation NOR.
Either the NAND or the NOR operation can be used in various combinations on pairs (or larger groups) of bits as input and an output (of a single bit, which potentially could be the input for multiple additional NAND or NOR operations) can be combined to create any binary digital computer.
It is convenient to allow other transformations.
The first obvious extension is to allow all of the binary Boolean operations. There are 16, including NAND, NOR, AND, OR, and XOR.
If we extend our datum from a single bit to a bit string, we can start applying a wide variety of additional operations.
Other obvious extensions are the building blocks for common machine operations, such as shifts and rotates, adds (with and without carry), subtract, multiple, divide, and their variations.
Unary, ternary, and larger order operations are useful.
These basic operations can be grouped so that specific operations apply to one or more particular combinations of datum. Building integer addition, as an example, would involve applying add with carry to two binary strings.
The shapes and size of the particular combinations of datum can vary, and may or may not have to match each other. It may be particularly useful to transform between shapes, such as turning a list of data into a tree of data, adding a single node to an existing dynamic structure, or extracting a single node (or other shape) from an existing dynamic structure.
The operation being applied to various datum in a particular shape do not have to be the same. So, while it is useful to have all operations on a simple binary string be a simple rotate, it may also be useful to have a different operation applied to different parts of the binary string (or more complex shape).
The same method is used to describe both data and programs.
Simple versions of these kinds of transformations of shapes can be used to define higher level constructs.
A single datum does not have to be a binary bit, but can be any shape and size. The more complex shapes and sizes are easily described in the lower level constructs.
There is no limit on the possible high level constructs that can be created.
One could even perversely use this method to create either a specification or compiler for any arbitrary programming language.
My interest is in creating accurate and complete descriptions of any program written in any arbitrary prorgamming language that a machine can easily transform into object code for any arbitrary hardware.
This language uses text to avoid the need to keep track of any particular binary encoding scheme (other than the character code) and to make it possible for a human being to read these prorgams.
It is possible for a human to write a program using this language, but I will assume that the vast majority of all non-trivial writing will be done by software or machine.
I further assume that a human would be more likely to read these programs through software that responds to queries. For example, looking at a symbol table created by software examining the prgram or looking at the shape of a critical loop through a visual presentation created by software.
At a more advanced level, it would be possible to create software that looked at different parallelization strategies.
It should be pretty obvious at this point what I am attempting to build and why this method is Turing complete.
I would like to find a method for defining additional transformations or operations that trasncend the limitations of Turing machines.
If you find this interesting and want to contact me, write to Milo, PO Box 5237, Balboa Island, California, 92662, USA.
Names and logos of various OSs are trademarks of their respective owners.