Prime

Computer Language Theory.

For any specific hardware architecture, I claim that there is only one prime
language: the language that expressivity and maps the physical
limitations of the hardware onto the perfect lexical architecture (not
regarding a few cosmetic, syntactical distinctions). (See also [kolmogorov]
quotient.) That is, the "vanishing point" for computer languages (where they
ultimately head off to) is/was to get computers to things efficiently (the
engineering), and as expressivity as possible (the
architecture). This "prime conjecture", I'll call it, says these are the only
these two concerns for programming language design and, further, that you only
need one language to do this as long as you allow it to continuously refine
itself. That is, the perfect lexical architecture expands as the programmer's
expertise and knowledge expand about programming itself.

Do you have to change to a language other than English when you want to
express science vs. religion, say? They are two very different subjects. But
yet you don't need to change your language's syntax or semantic structures.
Human language, by the way, will probably also converge into it`s "prime"
expression, at least for a given species/origin of Man (Biblical races vs.
Native/Asiatic races, for example), like speaking Esperanto.

It may be possible that such a language might start with assembly or machine-
code mneumonics, and then continue to add structures, like macros,
parameterized macros (functions), self-contained encapsulations of functions
with data (a "nucleus": essentially "objects" in assembly)], and so forth, to
add more structure to your language. But this new macro language won't look
like machine code anymore and will have to make the same choices about design
and syntax as a regular computer language.

We already know that every language is effectively doing the same thing,
thanks to the Church-Turing thesis, so why create an incompatible language
just for a feature you like? Many things can be stuck into libraries, other
things can be made optional, like static typing. This latter issue is why many
people have moved away from C-like languages -- no one knows their
application`s domain well enough to specify all the engineering details
beforehand (will you use int16s, int 32s or floats?).

One might ask, then, is there one idealized operating system for a given
architecture? Sorta. It goes deeper into [Metaphysics] and transcends the
machine: data. You're generally either building machines to simulate the
universe or to manipulate data and build knowledge. This project focusses on
the latter.

XXX What follows is out-of-date.

A prime aims for a minimal syntax, without losing any [expressivity], that
is fully object-oriented. It is the language used for PositionOS. It is
provably kolmogorov quotient within a small constant difference
(provided no one implements a sub-byte programming language).

Basic objects all follow a simple, universal, GOOP. If an object tries
to go beyond this limitation, a syntax error of sorts is raised: you've
violated the uniform architecture.

A graph could hold the current state of executions. Each object or process is
a node in the graph. Nodes can connect to hardware inputs or outputs. If an
action value at a node is positive, it is in a RUN state. If the value is
high, it is a priority. If it is 0 (idle), it is still capable of queuing up a
small amount of data from other processes or hardware. [STUB] If we store
our objects in a hashable object "space", then this data can just hover around
the object.

XXXconsider: So rather than deal with a buffer in hardware, each object could
have a buffer of, say, 4 words. Objects that are higher up the change have
access to theirs plus all other lower down to stash data.

FUTURE: If the action value of a node is negative, it is in a pull state and
will query a hardware element for state data.

Most keywords are replaced with symbols to make the user code the object of
understanding. In fact, there is only one keyword: while. This, too, could be
replaced in the future with curly braces to identify a looping block.

---

Prime syntax

function_name:

    statement1, related_statement2, [...],
    statement3
    asynchronous_statement // statements separated by commas are assumed to be executed sequentially, the prior line has no comma, ergo this statement is independent in execution of the others.

&"one-line object docstring description" object_name:

   ([init_parameter1=default][, ...]):  //init method
       @.attribute=  ; could have anonymous 4-word attributes here?
   >>: ;