No More Applications


Current software technology is built on the premise that we can build a perfect "Application".  The concept of an "Application" is flawed. Every "Application" that has ever been written is incomplete by the fact that the hardware instruction set is incomplete and therefore anything built using it is also incomplete. So we need a new technology that has logic that is complete. Complete in the since that a piece of computer logic is finished and can not be improved.  The "Jane" Software development environment primary objective is to erase the concept of the "Application".

First every piece of code we have today is an "Application", from the bootstrap to the power down sequence is a set of code that performs a predefined set of instructions.  "Applications" are independent code that are hard coded to a single programmer's personal preferences for a given solution. The side effect of this is that the users of an "Application" have no real knowledge of what or how an "Application" works.  To remove the concept of an "Application" simply means that we will know without reservation what will happen when we make a computer request. So instead of writing "Applications" we write "complete logic for every request that we will ask of the computer".

Easer said than done, for one: things change, so what is complete today may not be complete tomorrow.  Another thing is that the effort to complete some piece of logic can exceed the available resources needed to write the code. The system we build only needs to have the capability of containing complete logic. It does not necessarily require that the logic exist, but rather that it can exist, and that it can be changed without affecting reality.

My approach is to have the compiler know everything there is to know about every value. Also have a way to classify every value, along with all of its derived values. Every value also contains all of the logic for the opcodes and uses that apply to each of the derived values.

For instance: a "Value Type" like "Number" has many variations with a set of opcodes which can derive other "Value Types".  A "Value Type" can be qualified into a "Term" like a "Whole Number" which is a "Number" from 0 to Infinity, or the "Term", "Counting Number" which is a "Number" from 1 to infinity. The "Value Type" of "Number" can be qualified as to a specific internal and external binary representations such as a "Real Number". All of these variations are handled by the compiler for every "Value Type"  and "Term" that we use to represent reality. The compiler maintains the logic to handle the transformations, transport, storage and opcode operations for each value used by the system. The result will be to have the compile perform all of the logic that current technology sees as an "Application" by defining higher and higher levels of terms that we can use to control reality with a computer.

 

	Declare my applications
	{
		Counting Number 	= Number:{Format=Integer; Minimum Value=1, Increment=1};
		Real Counting Number 	= Counting Number:{Format=Real};	
	}
 
	variable A is a Real Counting Number;
	
	for (A[1-4])
	{
		alert(A);
	}