Computers Imitate Reality:
At least that is what our intentions are when we build hardware and
write software. Unfortunately we fail miserably to provide complete
solutions of real world objectives. In this newsletter I will look at
what I will call "understanding" as the key failure of software
The Computer and Human Program:
Programs are 98% human effort. Every value and use of each value is
understood, to the human, at some point in the development and use of a
software program. The computer knows about 1% of reality, what is
missing is the what, where, and why of the values in a program.
Static and Dynamic Values:
Compiler that create named values at compile time are static values,
those that create named values at runtime are dynamic.
Static values are hardcoded in the source code using declaration
statements. The declaration statements define the name, length, address
and datatype of the value, and no more. The human is responsible for
insuring consistency of the declaration in all source code and during
executable reference to each value. The attributes of a value are
not accessible by the compiled program.
Dynamic values are created during program execution. I will use
Address, and two flags (Locked and Hidden).
"It is useless to attempt to reason a man out of a thing he was
never reasoned into." -- Jonathan Swift
"Histories make men wise; poets, witty; the mathematics, subtle;
natural philosophy, deep; moral, grave; logic and rhetoric, able to
contend." -- Francis Bacon
"We may not yet know the right way to go, but we should at least
stop going in the wrong direction." -- Stefan Molyneux
a chronically leaking boat, energy devoted to changing vessels is more
productive than energy devoted to patching leaks." -- Warren Buffett
"No intelligent idea can gain general acceptance unless some
stupidity is mixed in with it" -- Fernando Pessoa
"If you want
to make God laugh, tell him about your plans." -- Woody Allen
Programming With Complete Knowledge:|
Programming is 98% data structure, and 2% logic. Current technologies
maintain the very minimum data structure, this is generally less than 1%
of all knowledge that is actually known. Out of the 2% that is logic,
98% of this 2% is common and can be implemented by the compiler.
data structure is "13". In modern language this is it. But if I tell you
this is an atomic number, there are possibly millions of facts that are
known: It's Aluminum, aka Aluminium, its density, electrical properties,
.... I don't have enough space... So if we program with this
knowledge known, we would approach infinite knowledge. Not hard at all,
and doing the math it becomes obvious that we would have very little
work, almost nothing left to do, in programming any application with the
A = 13 as Atomic Number;
B = A.name;
C = B.year discovered;
D = the previous sibling of A;
E = A.parent; (periodic tables)
By knowing what something is, provides context that can be exploited
by the compiler. It is this context that also provides near perfect
logic. Since the compiler knows what something is it can provide the
logic necessary for the storage, use, transfer, and maintenance of every
structure an application is likely to encounter.
Jane's natural language compiler is possible, since the subject of
the sentence is known to the compiler. The rest of sentence diagramming
can be customized for a company's specific use. This may not be
required in the future, (better sentence diagramming tools) but is does
provide a strict vocabulary for specific technologies. The
Predicates, Directives, Direct Objects, Adjectives, Nouns, Verbs,...
might be defined by Nationality, Science discipline, or other
consideration. The intent of a language should make it easy to
change, and powerful enough to be understood by everyone.
A contradiction, how to change and not change. This is the job of
Jane, to provide context at all levels. Time, Location, Discipline,
Nationality, Culture, Age of the user should have a unique language.
Good enough for ME:
The montra of programmers. The unfinished logic that gets the work
done for a given application: then STOP!. This inhibits the ability
of future programmers to make changes without completing the unfinished logic.
Which in most cases is impossible.
The example of "13" as an atomic number brings out the fact that even
though "13" is an Integer, it is actually a Counting Number, and a label
of the number of electrons. As such no math operations or inequality
operations are among the realistic operations that can be performed on
The reality of context is that even though everything is possible on
a data structure, does not mean that it is probable. This means that
some operations on a given data structure might be forbidden, or forced
into an alternate data structure. The Atomic Number if multiplied by 3,
could throw an exception, or it could move the context of the result
into a simple counting Number, or produce a new atomic number. We must
accommodate for real world situations and inform the compiler which of
the paths are expected. The compiler cannot assume anything, or be so
narrow minded to choice for us.
A = 13 Atomic number;
B = A * 3;
alert(what is B);
There are 3 outcomes for the above code:
- throw an exception
- B is an integer (39)
- B is an Atomic Number (39)
All of which requires the human to guess at what the compiler is
going to do. This breaks the first law of compilers: "Human must
never assume". The language must be explicit enough to allow all
three possibilities, be understood by everyone, and be generic for all
context. Something like (TBD):
B = A * 3 as Atomic Number;
This is just one example out of hundreds of thousands data structures
and all of the operations between them. The reality is there is much
that must be added to the software development technology. We have not
begun to program.
This is my last newsletter. I will now produce the result of the
newsletters up to this point.