Jun 2017
April 2018
Flow Control:

As if there is something called compiler theory. I have been able to find only one change to compilers over the past 80 year, and even then is was an obvious enhancement, "dynamic value creation".

The rest of compiler theory remains the same, which includes the order in which statements are executed [flow control], which has not changed since the first assembler programs were written in 1949. The "function" is the basic unit for programs, a named set of statements with values passed to it through registers, an action is performed, and a value is returned.

Flow control could be so much more, and in doing so changes the full dynamics of software development.

function A passes control to B, B return control to A. This is the current model for all languages. I have extended statement flow to permit flow back and forth between functions, with the ability to pass values.  Recovery from exceptions is also possible, asynchronous function waiting, screen refresh, program exit, and parallel statements.

An interesting side effect, of better flow control, is that program logic permutations are reduced. This makes programs smaller, easier to change, less prone to errors, better security, and better error reporting. This is due to the fact that the context of a function [task] can now be isolated which reduces the number of conditionals and make the program far easier to read. I did not expect this when I started to change flow control, this was the one aspect that I have always desired in writing programs, the ability to write functions that were only concerned with a specific task.

Logic isolation with application specific recovery. As an example say the task is to read a database table, in this table there are 2 values which require separate security logins, one from accounting, and one from HR. A is the calling function, B is the function to read the table.

B finds a field "PAY RATE" passes control to A with login required. A logins to accounting and returns to B. B finds "SSN" passes control to A with login to HR required. A returns to B telling it to skip this field.  B finishes.

B [read table] is going to come to conditions (logic) that is or could be application specific, that code is no longer in B but in the calling application. The recovery and flow control of B is now in A's absolute control. 


"Progress is man's ability to complicate simplicity" -- Thor Heyerdahl

“There is a social responsibility for those in the know to protect those that do not know.” -- Steven Magee

“We still live in the era in which information is rich and insight is poor.” -- Pearl Zhu

“The goal is to transform data into information, and information into insight” -- Carly Fiorina

My daughter wanted a Cinderella theme party, So I invited all her friends over and made them clean the house.


Humans out of the loop:

The ability to improve computer technology is to get humans out of the development cycle. The current development system requires human input for every character of logic, when in fact it requires very little human interaction.

Jane is not an application. People say to me, "I want to see Jane do something... another application..." Jane does not do anything. Jane does absolutely nothing, it is just a change to technology to remove humans from the development process.

Every two days we get a new application that will solve the "problem" but nothing changes, more training, more documentation, more nothing. 

Jane is a system that reduces the human contribution, of software development, to the very minimum. The very minimum mean that no documentation or prior training is required to develop software.

So, how is this done Jane? 

First we need one development language. A language that is 100% complete. A language that gives absolute control of the environment with the fewest possible characters.  The language therefore must handle all knowledge in an unchangeable environment. Every piece of information is therefore known to Jane and managed without human intervention. So the creation, change, storage, movement and access is done for us. Even logic should be known, accumulative, and known to Jane. The language should be minimalistic, this requires that absolute control of the changes to the language is done by professionals.

Second, the information managed by Jane is  hardware, application, and version independent. This means that information can be moved to any hardware, never goes out of date, and is accessible from any application. To accomplish this Jane manages the information as a single entity, with no restrictions or limitations. Jane uses common Ground 3000 (cg3) data structure for all information which allow information to be stored, transported, and accessed without the need to reformat the data.

The language must be transparent, this is, at all times the programmer must know what the words mean and what the compiler will do without documentation. I try not to use "computer" terms because I don't know what they mean.

Every program and every compiler ever written, a programmer "decides" that, that is "old"  and "this" is new. That this is "neat" or "cool". That I must force "my" conventions onto everyone.

The design of the language should be for the human. That every basic logic should be done by the compiler when possible. Two examples are "unit conversion" and "text compare".

B = 5 feet * 4 inches,  does "clif" equal "Clif"

Back to the 1949 standard that current compilers use now, do only the 4 basic operations, "compare", "subtract", "branch", and "move". Let the programmer do everything else. No!

Partitioning of Information:

The limits on the human mind requires us to think in blobs of knowledge, and we communicate with words these ideas. When we have no words, we provide names or addresses. Yet none of our compilers provide any partitioning of information or logic.

I have included both vertical and horizontal partitioning to objects and to tables. (I extended objects to include table)

I should explain that Jane has removed the need for databases, for it has its own which is tied directly to the compiler. The compilers extended its name space to include all external information structures, such as, folders, files, tables, hardware, and all digital knowledge. This means no more API's all information is now one name space.   alert(CPU.type);

Vertical partitions is a named subset of the names of an object or table. This permits columns to be qualified for easier reference. Objects are difficult to manage due to their complex usage, circular references, references for convenience, temporary storage, any number of categories.  With vertical partitions movement and storage of information can be optimized by the compiler, reducing the need for complex logic.

Horizontal partitions is the physical separation of rows in an array, or table based on one or more values. Jane as extended the physical separation to include physical hardware, to permit isolation and unique storage methods based on application requirements.

There is no limit on the number of vertical or horizontal partitions or on their depth. Vertical partitions is simply a lookup table, horizontal partitions is a user defined function to return the partition's name space based on the values of the object to be inserted or modified.

Vertical and Horizontal partitions is for hierarchical separation. I also looking to collapsible networks, one where logical and connectivity networks can be stored managed and queried with Jane's name space.  Information has three modes, attributes, geographical, and logical. Current compilers only deal with attributes. Jane will handle all three mode. Time based is handled by horizontal partitions, not forgotten, just I think managed as a part of a larger scope.

Partitioning is a basic capability of every object and table. The capabilities of the compiler enables access to Jane's database using dynamic name resolution, but it also includes load on demand of the values only when required. Until a value is actually needed (or requested) does the value need to be retrieved from its storage location. This permits infinite size files and databases, with access controlled and optimized by the compiler, which reduces the burden on the programmer to zero for all information requests.

Author: Clif Collins
Houston, Texas
March 1, 2018

email: c1@CollinsSoftware.com