November 2022

Information Knows Nothing:
A number of bits and nothing more.  Our current technology hard codes each bit's meaning inside a single application's source code. This means that whoever controls that source code has absolute authority over the use and access to the bits that made up your information.  This applies to all information using our current computer technology. You created the information yet you do not have direct access to it. You are only allowed what the software vendor thinks you deserve.

Stealing your information is just taking advantange of the software development technology. So I will change the technology so that it would no longer be possible. That information you create, you have complete access to it, with security that you control.

Ownership of Knowledge and Hardware:
Information ownership is moving into the world of monopoly control. We never had ownership of our knowledge. We are now moving toward no longer owning the hardware that we purchase. Ownership is therefore defined by the owners of the source code, simply as a byproduct of our current bad computer technology.

Hand Crafted Software:
An Impossibility; A civil war musket has 12 parts. A software product has thousands of parts. Both are unique with a fixed purpose and both are hand crafted.

The parts of the musket are fixable; any adjustment is possible to them fit to the original design. In software once created, there is no record of its design and therefore no knowledge of how to adjust it,  except for a short time period by the original craftsman.

"Interchangeable parts": The first milling machine 1818.  This gave us the precision needed to duplicate parts. Before this, hand craftmanship made it impossible to achieve the precision required. It is the same with our hand crafted software.

"Abuse grows from attitudes and values, not feelings. The roots are ownership, the trunk is entitlement, and the branches are control." -- Lundy Bancroft

"That's what makes it ours: being born on it, working on it, dying on it. That makes ownership, not a paper with numbers on it." -- John Steinbeck (The Grapes of Wrath)

"Great men are seldom credited for their stupidity."  -- Nietzsche

"I have gathered a posy of other men's flowers and nothing but the thread that binds them is mine own." -- John Bartlett

"I think it's wrong that only one company makes the game Monopoly." -- Steven Wright

"She plucked from my lapel the invisible strand of lint (the universal act of woman to proclaim ownership)." -- O. Henry

Application Independent Knowledge:
For Information to be understood, all facts about the information's structure, use, and purpose must be known. Therefore all knowledge about the information must be packaged inside the data structure itself. 

The trouble here is that the amount of knowledge that is known about any piece of information could be infinite. Yet this is exactly what we must handle to truly have application independent information.

  • To move information from memory to storage and back with complete automation. This is to move all field definitions, logic, and to resolve all encoded data and lookup tables.

  • To allow information structures to change over time (i.e. versions of data structures). This is simply a byproduct of automation.
  • Information is never static, therefore no generalization is ever assumed.  This means that there can never be an external data description table.

  • There shall never to be any loss of knowledge within any information structure during a transfer process.

  • There shall never be any assumption of knowledge.  All knowledge context shall be explicit.  You should never assume that the computer knows what you know.

Transfer and storage of information is always complete. The objective is to unload all of an application's information and logic memory structures by converting it into a text document that is readable, understandable, and editable. Then have the ability to take this text document back into any program's memory as an exact duplicate of its original context and capabilities.

This information transfer capability is required for true software development; which is "Access to All Information". This automated capability of memory transfer gives us:

  • Sub-process validatation
  • Program check-points
  • Program restart
  • Splitting a program across machines
  • Automated knowledge transfer
  • Elimination of databases
  • Elimination of Client Server technology
  • Program simulations



Ownership of software:
The ownership of software has fallen under the rule of copyrights. This treats software as a "literary work" intellectual property of its creator. Unfortunately software is, and never has it been, a work of a single effort.

Items that can be copyrighted are originality, creativity, and must be reproducible (fixation). I have never seen any software that was wholly original.  Software always has many parts, and each of those parts could be considered plagiarized. So are we to consider originality of plagiarism unique and therefore copyrightable? 

Is ownership of software to extend to the information that it maintains, derives, or creates? Is the hardware that software controls, or has access to, also owned by the software? In a way; yes.  Software hides and controls information and can limit access to hardware. This capability is, by the nature of software, an inevitable attribute.

We must transfer all the knowledge the human knows into every computer application. We must then be able to transfer this knowledge to any other application or storage device without any loss of intelligence. All of our applications today assumes most of its working knowledge. 

Every application assumes that every data structure is correct. There is no validation to a data structure's correctness. Applications assume units, number of bits in a number, conventions, purpose, and use. This can be seen in every major software failure (737 Max, Mars probe crash, rocket explodes …etc…). Every failure, I know of, was caused by an assumption on the correctness of the information and on the ability of the source code to perform as we assume it will.  However without knowing, all we can do is assume.

Software cannot be written by programmers.  All the above failures could have been caught by a fifth grader if there were no assumptions.

by: Clif Collins