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
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
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
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.
"Simplicity is prerequisite for reliability." ― Edsger W.
"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
"Two things are infinite: the universe and human stupidity; and
I’m 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
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.
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.
Most say it is impossible. I say that it is
very possible and absolutely necessary.
- Out of sight out of mind
- Physical Access
- Unpublished, unique encryption logic
- 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.
"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.
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
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.