May 2020
Issue #4
June 2020 Issue
Collins Software's Newsletter
Oct 2020
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 development.
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 JavaScript as a example. It maintains the Name, Datatype, Length, 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

"In 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

"It does not matter how slowly you go as long as you do not stop." -- Confucius


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.

If the 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 Jane system.

A = 13 as Atomic Number;
B =;
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 this structure.

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:

  1. throw an exception
  2. B is an integer (39)
  3. 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.

Author: Clif Collins
Houston, Texas
June 1, 2020