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 this
was an obvious enhancement, "dynamic variable 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
single
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 is 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.

“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.

"To improve is to change; to be perfect is to change often." ―
Winston S. Churchill (A critical flaw in our software design;
it must, forever be changable -- clif)

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 means 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 allows information to be stored,
transported, and accessed without the need to reformat the data.

The language must be transparent, this is, 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,
so how do I expect other to benefit from their misuse. To me it's so
simple... to build a house get a hammer and a saw and get to work,
nothing special or magical, I can hire anyone to do that... "don't
look behind the [green] curtain..."

Every program and every compiler ever written, a programmer "decides"
that "this" is old and "this" is new. That this is "neat" or this is
"cool". That I must force "my" conventions onto everyone, "I" will not
use "that" old stuff. Yet billions of hours when into making "that" what
it was, and the programmers, from lack of knowledge, throws it away...
you stupid bastards.... I do not want to negate anyone's work.

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. I don't think so!

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 tables, a unique type of object, much more
complex)

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 are 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 information is handled by horizontal partitions, not
forgotten, 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.