May 2018
Issue
June 2018 Issue
Collins Software's Newsletter
 
Reliability:

The reliability is the scale in which software is judged. The number of issues that make up software reliability is somewhat vague. I find that software developers think a product is acceptable when it does not fail. Reliability of software covers much more than just the correctness of code.

Software is always the tracking of a real world situation. It is the real world that we wish the software to reliability reflect. It is here that the difference between the two systems need to distinguish between the effort, responsibility, reliability and domain of each system. 

Software developers do not and never should deal with "use case" scenarios. Software does not deal in any way with the real world, it simply deals with the past, present, and future information that is maintained about the real world. Or in other words, software provides information in the most covenant way for real world situations to be represented and managed. The subject matter experts, those doing the work, know their jobs. Software simply provides them the information to do so.

The number of real world situations are infinite, the actual number of ways to represent the past, present and future information in a computer is very small. Most brains work with very little logic, the word "elephant" is treaded just the same as the word "apprehensive". The reliability on the brain is not on complexity, but rather on simplicity of understanding.

The word "Elephant", when did I learn it?  is it related to the word "apprehensive"?  How many feet do elephants have? ... "Apprehensive" is it proper to use in mixed company? what part of speech? when did I learn it? is that important?  A Zoo keeps the value "2" about elephants, not a whole lot of knowledge. We do very little programming. Our whole technology base is a two column table of name / value pair.


Quotes:

"Simplicity is prerequisite for reliability." ― Edsger W. Dijkstra

"When someone doesn't like something, it's often because they're not familiar with it, or they're too familiar with it." -- Anonymous

"Women who seek to be equal with men lack ambition." Marilyn Monroe

"Two things are infinite: the universe and human stupidity; and Im not sure about the universe." -- Albert Einstein

"In this life we cannot do great things. We can only do small things with great love." -- Mother Teresa

 

Speed of Software Development:

I hear more major projects failing, more security breaches, and still more new applications that are the rebranding of old solutions.  My clock still cannot set itself.

The speed of software development is related to the the percentage of the known to the unknown. I say we can speed up software development a hundred fold if we simply reduce the unknown and to have the known available. What is left is therefore what we want.

In software development the number of variations, (i.e. permutations) are a vast number of our unknowns. Propitiatory systems, are the key unknowns which are purposely placed there to hijack information and limit your hardware access. Functions and command line arguments cover most of the time consuming  unknowns. Versions in logic and data structures place the final nail in the coffin on the life span of all our work.

To take software development from man-years of work down to a few minutes we simply remove the unknowns and we add what we do know. This is extremely easy to accomplish, far easier than I ever imagined. Start small, units are unknown (to our technology), yet we know them. As each unknown is moved to the known column, the system becomes easier to program. Kind of like the magic of compound interest, the work becomes accumulative. We do the work once, it is done forever.

I have solved the problem of versioning, transport and storage of information for an infinite amount of time. Remove all but one known device driver, thus removing most, if not all, of the key propitiatory unknowns and security leaks. Changes for having application independence of information and logic. Change the concept of what a "function" is, to remove this from the list of unknowns. The command line unknowns are handled with a simple change in logic. The removing of permutation logic will guarantee absolutely unbreakable code. A change to the logic of responsibility and change the design of the hardware instructions to remove all the variations and unknowns at the hardware level.

With the unknowns handled in our existing technologies, we must also include all of the small missing technologies that fall through the cracks. Installation and setup procedures. Missing security and data integrity technologies. Modes of operation, recovery, accountability, replication, and tracing.I see software development going in one of two directions. The first is the current direction, that of all computing being completely controlled by monopolies. The second is to fix software develpment to be absolutely transparent and controlled by the individual.

The "unknown" I talk about, are known, just not by the developer as he/she is typing.

Absolute Security:

Most say it is impossible. I say that it is very possible and absolutely necessary.

  1. Out of sight out of mind
  2. Physical Access
  3. Unpublished, unique encryption logic
  4. Frequency, Phase and Path alternations

There are many other secure alternatives that can be employed, along with just a plain better programming environment.  Security is a joke in our current technology, it forces each developer to make assumptions about someone else's method of security. From databases, to transport, to disk, to libraries, to functions, to hardware is it secure? How do we know, right now we don't, not absolutely. We can never have absolute security until the developer can know with absolute certainly what is happening. Again lack of knowledge, and I do not trust anyone's programming skill, or motive.


Jane's Accountability:

"How do I know anything -- Accountability".  The knowing, of what needs to be known, to function. For any piece of known information, there is always related knowledge that places that information into context. It is this context that humans rely upon to function.

There is always overhead to know something. The knowledge that we keep is often time based. We remember first grade but very little on details, yet we still retain much of this information without the exact historical context.  The computer systems as we know them are not this smart (yet), to have the ability to remember everything and over time get rid of irrelevant knowledge. The brain knows its limits and provides what it can. This system works in humans and in an ant so small that it can barely be seen.

In the accountability of knowledge we must have a way to keep all knowledge from everyone about everything, and still be functional. A central common brain for all to use. Space and speed are not a concern, this seems possible.
 


Knowledge:

One man's trash...  this lead to the problem, or rather dilemma about shared anything.  "elephants" I want to know how many, Bob wants to know the cost of each, and so on and so on... 

What if? one single knowledge record for everyone to use.  Anyone can store any piece of information about anything. This models the real world, rather than the real world modeling itself around stupid fixed computer logic (relational database). Of course we can do both, but we would never really need to know how it is done, or should we care, we let Jane (the system) decide. Bob just wants to know the replacement cost of Jumbo.

 

Author: Clif Collins
http://CollinsSoftware.com
Houston, Texas
June 1, 2018

email: c1@CollinsSoftware.com