This question would be easy if the word "simple" had one meaning.
"Simplicity" depends on the level of abstraction and the sophistication
of subject. One could say that all computer languages
are about binary data because everything is reducable to a string of
bits. But such a declaration misses the purpose and scope of a
language. Computer languages facilitate expression on
different levels of abstraction. A binary string is just one basic
level that cannot do justice to anything but the simplest notions.
The C language, and its spawn (C++, C#, Object-C, etc.), are thought of as a high level languages despite the fact that they still require the programmer to sweat the details of data representation and storage.
C presumes to be capable of unlimited algorithmic
and procedural expression. Presumably any thought can be modeled, (if
not subjectively appreciated). C shines as an elegant script for
managing processor function. C does not contain many profound
algorithms underlying language and thought, aside from the genius
inherent in arithmetic or character strings as linguistic tools.
It has long
been clear that most programming structures, mathematical systems, and
natural languages use a relatively small collection of foundational
notions or algorithms from which all others may be constructed. This is
not a new idea. Grok32`
weaves these algorithms packaged as 32 keywords
corresponding to (mostly) natural language. These 32 keywords,
{Sequence, List, Set, String},
{If, Branch, Expression, Pattern, Type},
{Tally, Function, Slot, Loop},
{Time, Noop, Stream, Trap, Return},
...are grouped together into 8 contexts,
{Logic`, Number`, Construct`, Condition`, Process`, Scope`, Transit`, Compile`}
...which define the Grok32`
language.
There is another way, (versus the standard shown above), to
group the 32 keywords
together into related contexts, which is called the Alternate Grok32` Grouping.
Programmers should not have to concern themselves
with memory management, pointers, machine addresses, or data-type
specifications. Grok32`
handles these details but can still manage and generate these details
when and where necessary. Hopefully, Grok32` keywords embody fundamental linguistic objects. The
goal is to make the process of programming as natural and as simple as
possible.
The ideas embodied by the 32 Grok32`keywords
are believed to be universal. Each keyword is an algorithm or form that
has been repeatedly embodied in programs over the past 50 years of
software development. The English names given
to these 32 Grok32`
keywords have been
carefully chosen so that the words elicit the classic
algorithms.
TRANSLATORS NOTE: Translating the keywords will be easy for anyone who
understands the Grok32`
Language
Specification, because the concepts are universal. Were a language
does not have an appropriate keyword equivalent, an inappropriate word
should not be forced into a keyword's role. The English
example of this is the keyword Noop
which does not have a good modern English
equivalent. Nought
means something very much like Noop,
but it is an archaic word. This fact does not reflect on the
universality of the Noop
concept; rather it says something about the culture of English
speaking people. Other languages have words which appear to embody the Noop concept
very well.
Aside from Xor
and Noop, all of
the keywords are old
words, with a rich history and many definitions. For
example, with
is a word with more then 14 meanings in the 1949
Webster's Unabridged Dictionary. Similarly, "function"
is a word with more then 11 definitions; "type"
has about 20 definitions; "reckon"
has about 8 meanings. These keywords
are typical insofar as they are old and have unusual depth and
complexity of meaning. These words have many meanings because they embody
conceptual forms which we re-cognize
whenever we use them.
Unlike most programming languages, Grok32` uses the same keywords with many elicitations or meanings.
As such, the language is similar to a natural language.
Meaning is constructed from context
in the sense of cognitive threads woven together with other words with
meaning. The fact that the keywords
in Grok32` are
ancient and have an unusually large number of meanings, reflects the
foundation quality of these keywords.
They have many meanings because these simple notions are frequently
used and have many cognitive threads interconnecting them with the rest
of the language. Together they form a whole which may be sufficient to
model all natural language.
Grok32Style
also identifies a local file in `Grok32`Reference`
where it is stored together with the local file,
"Grok32.htm", containing this text.
This document is another HomePage
for Grok32`.
The English language
definitions for words used throughout this Language
Specification are from Websters1949Unabridged.
Used without permission. Presumably, they will not mind since this Language
Specification is, effectively, an advertisement for their
dictionary.
The definitions were transcribed and augmented by
the author from a dictionary which was 56 years old when "plagurized".
It was once, in fact, David Bergamini's dictionary which he purchased
(fresh out of college) in 1949, six years prior to my birth.
English defined by a dictionary from just before the computer revolution appeals to me.
(c) 2004-2007 by
John Van Wie Bergamini.
All rights reserved.