Nov 2019
December 2019 Issue
Collins Software's Newsletter
Jan 2020

"Big Blue":
The IBM mainframe software development paradigm is the world we still live in.  Where an Application is written to run on one machine, isolated in its own closed context. 

We have yet to solve the difficulties in writing a single process application. The problem is how to combine independently written sub-processes into a perfect program. In reality it cannot be done using current technologies. Or to be a little more specific, it cannot be done, lasting for any length of time, without infinite resources. Every application begins to erode before it is even completed.

Division of Intelligence:
The knowledge base of software is separated into three parts:
  1. The value itself
  2. The hardware instruction that processes it
  3. The application that uses it

Each part is independent and ignorant of the other parts.  So information cannot be completely transferred without sending all three parts. This is never done (now) due to the fact that it is impossible in our current technology.  We can send values, and sometimes we can send the format of each value, but we never send the purpose, or the hardware instructions, or the code to use the values.

"Divide your elephant into small pieces" -- Sunday Adelaja

"Any system based on competition will inherently promote inequality, division, and conflict." -- Joseph Rain

"Religion divides us, while it is our human characteristics that bind us to each other." -- Hermann Bondi

"To create mass discord, make the people believe there is great prestige for being the first to speak an idea." -- Tom Althouse

"Believe those who are seeking the truth. Doubt those who find it." -- Andre Gide

"I love all mythical creatures... vampires, werewolves, unicorns, kids who listen." -- Anonymous

"To call you stupid would be an insult to stupid people!" -- A Fish Called Wanda

"I refuse to answer that question on the grounds that I don't know the answer" -- Douglas Adams


"Tiny Red":
A world where software is developed like "Big Blue" but runs across multiple independent hardware and independent processes.

The one absolute truth in software development is that "there can only be one copy of anything". There can never be two independent applications that produce identical results. Therefore we must create one application that executes, serially and in parallel, on more than one machine, as a single process. The development process must do most of the work for the developer.

The application development environment will be one source code file. Compiled into a single executable that transfers data and hardware instructions back and forth between systems as if in a single memory space.

Objective of Multiple Process Executable:

  • No Documentation required, it's your program you are running
  • Removes all version dependencies. changes to all applications are universal
  • Removes all Hardware, Software and Data Structure Incompatibilities
  • Removes all Logic Limitations
  • Does not waste development time, Jane handles all that it can
  • Access to all hardware capabilities
    Increases speed of CPU intensive applications, run your application on multiple machines at the hardware level
  • Uniform Hardware Instruction Set, a consistent instruction set, independent of programming language

Transferable Data and Logic:
The values and the logic on the values will be transferable. This will be a two way communication, setup by the compiler as a set of primitive hardware instructions. The number of Instructions:
  • 13 Assignment Operators
  • 8 Comparison Operators
  • 8 Arithmetic Operators
  • 7 Logical Operators
  • 5 Bitwise Operators

240  = 40 time 6 (integer, real, text permutations) basic operations.

60 = Basic jump, looping, exceptions, flow control, call, find and other instructions

About 300 total overall instructions with an average of 10% actually used by any one application. These instructions should be emulated and execute as hardware instructions, depending on the requirements and capabilities of the target system

The Executable:

A multi-hardware process that acts as if it were running on a single "Big Blue" box. More importantly it transfers all information necessary for complete knowledge transfer in a run-time application.

It is this knowledge transfer that is a change in technology. Our current technology is limited in the way we divide intelligence. To change an executable it must have the ability to perform "Mitosis" which is the ability to replicate (Prophase, Metaphase, Anaphase, and Telophase) with a mixture of "Meiosis" which is the ability to reproduce. It is a requirement for each cell within an application have the ability both to replicate itself, and also to have the ability to union with a foreign entity.

The technology of division and joining together of data, logic and purpose will have to be one of the base functions of every pieces of an application. Much like, but different, from how humans reproduce and cells replicated.

The concept here is to treat the complete body of an application as a group of individual cells, each cell with an assigned purpose. Each cell is to contain all the parts required for it to function on its own and can be used anywhere for its original programmed purpose.

To describe logic is like trying to give a useful name to every grain of sand of the beach. Yet, this is exactly what we must do. Each piece of sand has a purpose, performs a function, and has a history. Without this knowledge it is just a grain of sand taken out of context with no real use.

The transfer of knowledge from one system to another will require a new technology. This new technology will require a complete redesign of our software development methodologies. The current computer languages and executables cannot be used to perform what is required, not without a huge amount of work for each implementation. So the proposed system will be to design transferable logic and values as if it were in the memory space of the running application. It must also have an enriched foundation for the handling of knowledge to take as much of this work out of the programmer's hands as possible.


Author: Clif Collins
Houston, Texas
December 7, 2019