May 2020
Issue #1
May 2020  Issue #2
Collins Software's Newsletter
May 2020 Issue #3
We are not programming:
The software we write is not programming, it is the use of applications to write other applications. The limitations in an application are permanent and cannot be overridden. Therefore we must remove all limitations in the application that we use to write other applications.  These are our compilers and assemblers, programs that produce actions at the hardware level.

We have no single programming environment. We are required to use many different applications to create our applications.  The building applications we use change frequently, are limited in scope, and require extensive human tailoring. The creation of an application takes a super massive amount of human effort and time, and they begin to erode even before they are completed.


Perfection in Software:
The quality of perfection is the ability to always produce expected results with a minimum of effort. The reality of obtaining software perfection is to have the computer perform all that it can. In reality that should approach 100% of the actions as a function of time.

The road to perfection starts with access to information and ends with having the required actions available for use.  The quality of perfection is then guaranteed in every application we write.


"An inventor sees electricity and creates the light bulb.  An entrepreneur sees electricity and creates General Electric." -- Marcus Gill

"It's hard not to play golf that's up to Jack Nicklaus standards when you are Jack Nicklaus." -- Jack Nicklaus

"I was never too good in following rules." -- Anonymous

"Learn the rules like a pro so that you can break them like an artist." -- Pablo Picasso

"I take a very practical view of raising children. I put a sign in each of their rooms: 'Checkout Time is 18 years." -- Erma Bombeck

"Invention, it must be humbly admitted, does not consist in creating out of void, but out of chaos." -- Mary Shelley

"Love is a serious mental disease." -- Plato

"I never see what has been done; I only see what remains to be done." -- Buddha

 

Application Independent Data Structures:
A data structure which contains all knowledge about itself whereby it has no dependencies upon its use. The current mindset of software development, down to our conventions at the hardware instruction set, is to program in hardcoded data structures. 

The first fundamental rule for Jane is that all data structures are application independent. This rule can never be broken. Every bit, nibble, byte, word and phrase, at the hardware instruction level and higher, must have complete knowledge of itself. This rule ensures that all stored information and logic:

  1. Never goes out of date
  2. No size limitations
  3. Used by any application
  4. Minimum Application size
  5. Change at any time
  6. Independent of use
  7. No database reformatting version to version

Change Hardware:
All Information processed by hardware instructions have very specific fixed binary length representations, specifically only integer numeric formats. Any information not in this format requires a transformation before processing.  The information needed by an application that is stored on disk, database, or another application requires formatting to and from an internal integer memory format. (floating points are two integers, with/without hardware emulation)

Hardware has one instruction of MOVE to/from memory, of a fixed bit size of either 8,16, 32, 64, 128, 256.... (size is hardware specific). This one instruction is the reason our stored information must be reformatted and why data structures are application dependent. The address, size, and use of memory is hard coded in the application, thereby making it impossible to use this information by more than one application.

Versions of an application happen when the application altered any of these values. Having versions is the reason that you can never have application independent data structures. This happens only when address, size and use are changed.

So... we change this, at the hardware level (or simulate it in software), the address of the value is controlled by the application, but in a way that is referenced by name, not hardcoded in the application. We then move the size and use of the value into the value itself.

The application of size and use is more complex than just one method of implementation. I will describe this process in future newsletters.

 
Data Structure Independent Rules:
The storing, transfer and use of a data structure must be separated from the application in a way that no knowledge is hard coded. The following are the properties that qualify a data structure as "Application Independent":
  1. "Designed" to be application independent
  2. No documentation required
  3. No size limitations
  4. Speed and Size are never a priority
  5. Provide two formats (one or both)
    • Text Editable (for the human)
    • Machine Readable (for the computer)
  6. No value is required
  7. Has no external information
  8. Time independent
  9. Any number of qualifiers and classifiers
  10. Has no assumed use
  11. Size does not matter
  12. Optimized for missing information
  13. Ignores values not relevant
  14. Universal use
  15. Order independent

Coding:
The work involved in coding application independent data structures is complex and extremely difficult to achieve but not impossible. The task is not difficult, rather it goes against everything we have been taught.

In the old world of workstation applications we got so used to knowing the scope of our world. Once we moved away from BIG BLUE the scope of our world changed. However we still use the same paradigm, which does not work since we are constantly moving information from machine to machine. We still think we have one memory space and our coding reflexes this.

We still code like its 1843, to calculate predefined steps in less time than it would take a human to produce the same result.


conclusion:
The objective of Jane is to have the transfer, storage and memory structures to be identical, to process information in one format. At least make it seem that way to the developer.

The parameters of logic guide our thoughts. The objective is to remove clutter and produce clear thinking. As the parameters are adjusted, clarity improves.

Author: Clif Collins

http://CollinsSoftware.com
Houston, Texas
May 7, 2020

email: web1@collinssoftware.com