The Cell

Jane will have a single type of programming structure, called "The Cell".  The JavaScript basic structures
 (string, number, object, array, date, and boolean) are simply specific declarations of "The Cell".

The objective is to have a single declaration that can be used for every value.  This means that every value
has the same capabilities as every other value used in the program. Every value will have an identical set of system functions, this means that whether or not a function actually applies to a value,  say trim an Integer, is not determined by the compiler but rather by the programmer.  Every value uses the same addressing scheme, so a child can be have both a name identifier and/or a numeric identifier. The whole purpose is to have the compiler and not the programmer perform as much logic and data handling as possible.

"The Cell" manages the complete memory life cycle, network transfer, data imports and exports, transforms, and the local and remote storage of every value. This includes all exiting disk, database, and remote data and logic services.

"The Cell" is by default load-on-demand, both for information storage and retrieval, and for all logic requirements.

"The Cell" manages the complete life cycle of a value:

  1. The format and structure of a value
  2. The relationship to other values
  3. How a value is created, modified and destroyed
  4. Internal and external storage options
  5. Name resolution
  6. Math, Logical and Boolean operations
  7. Transfer Options
  8. Vertical and Horizontal Partitioning
  9. Dimensioning (user defined names of), i.e. first dimension could be called "rows" or "records" or "employees", or ...
  10. Assignment operations
  11. Retrieval operations
  12. Domain specifications
  13. Functionality
  14. Restrictions
  15. Import and Export transforms
  16. Index and child resolution (by name and/or index, by range, by content,...)
  17. Infinite and Continuous (IC) storage and retrieval
  18. Events
  19. Display characteristics (labeling, tic marks, borders, graphics,...)
  20. Editing characteristics (keyboard, visual, batch,...)
  21. Storage and Retrieval properties (i.e. MySQL connection logic,...)
  22. Security
  23. Logic resources, availability, and optimization
  24. Searching

"The Cell" Descriptive Language:

  1. All internal and external values are created and maintained by Jane
  2. The "name" for memory resident information is temporary, external variables are permanent.
  3. The "name" of a variable is maintained by the parent Cell of a variable
  4. Any property of the Cell can be altered at any time. The system will automatically perform all necessary operation to restructure the value to meet the new specification
  5. All transfer, storage, and transform operations are transparent to the programming language
  6. Infinite size files and data structures are automatically handled. Jane will optimize the logic to handle external cache and indexing structures. All space and time limitations are load-on-demand into available resources
  7. Cells are tied directly to the compiler for both compile time and run time optimization
  8. Cells maintain their own complete compiler action tables:
    1. Math Operators
    2. Boolean Operators
    3. Bit Operations
    4. Search
    5. Maintenance
    6. Events

JavaScript Types

 

Object = cell{ format{cell},
		operations{
			get{text=Object.get.text,value=Object.get.default},
			set{integer=Object.set.integer,text=Object.set.text,Object=Object.set.Object},
			search{Object.search},
			new{Object.new},
			clone{Object.clone}
		}

Array = cell{ format{cell},
		operations{
			get{text=Array.get.text,value=Array.get.default},
			set{integer=Array.set.integer,text=Array.set.text,Array=Array.set.Object},
			search{Array.search},
			clone{Array.clone}
		}
 
String = cell{ format{text},
		operations{
			get{text=String.get.text,value=String.get.default},
			set{integer=String.set.integer,text=String.set.text,String=String.set.Object},
			search{String.search},
			clone{String.clone},
			+{integer=String.add.integer,String=String.add.String,default=String.add.default},
			+={integer=String.append.integer,String=String.append.String,default=String.append.default},
			=={String.eqality},
			!=={String.not_eqality},
			==={String.same},
			!=={String.not_same},
			<{String.less_than},
			>{String.greater_than},
			>={String.greater_than_or_equal},
			<={String.less_than_or_equal},
			!={String.not_equal}
		}
 
Number = cell{ format{Integer},
		operations{
			get{text=Number.get.text,value=Number.get.default},
			set{integer=Number.set.integer,text=Number.set.text,Number=Number.set.Object},
			search{Number.search},
			clone{Number.clone},
			+{integer=Number.add.integer,Number=Number.add.Number,default=Number.add.default},
			-{integer=Number.subtract.integer,Number=Number.subtract.Number,default=Number.subtract.default},
			*{integer=Number.multiply.integer,Number=Number.multiply.Number,default=Number.multiply.default},
			/{integer=Number.divide.integer,Number=Number.divide.Number,default=Number.divide.default},
			**{integer=Number.exp.integer,Number=Number.exp.Number,default=Number.exp.default},
			+={integer=Number.append.integer,Number=Number.append.Number,default=Number.append.default},
			=={Number.eqality},
			!=={Number.not_eqality},
			==={Number.same},
			!=={Number.not_same},
			>{Number.greater_than},
			>={Number.greater_than_or_equal},
			<={Number.less_than_or_equal},
			!={Number.not_equal}
		}
 
Date = cell{ record{year:Integer,month:C3,day:Integer,hour:Integer,minute:Integer,second:Integer,millisecond:Integer},
		operations{
			get{text=Date.get.text,value=Date.get.default},
			set{integer=Date.set.integer,text=Date.set.text,Date=Date.set.Object},
			search{Date.search},
			clone{Date.clone},
			+{integer=Date.add.integer,Date=Date.add.Date,default=Date.add.default},
			-{integer=Date.subtract.integer,Date=Date.subtract.Date,default=Date.subtract.default},
			*{integer=Date.multiply.integer,Date=Date.multiply.Date,default=Date.multiply.default},
			/{integer=Date.divide.integer,Date=Date.divide.Date,default=Date.divide.default},
			**{integer=Date.exp.integer,Date=Date.exp.Date,default=Date.exp.default},
			+={integer=Date.append.integer,Date=Date.append.Date,default=Date.append.default},
			=={Date.eqality},
			!=={Date.not_eqality},
			==={Date.same},
			!=={Date.not_same},
			>{Date.greater_than},
			>={Date.greater_than_or_equal},
			<={Date.less_than_or_equal},
			!={Date.not_equal}
		}


This example describes a simple grid. It has each row stored externally in a separate physical disk and/or machine location

GRID = cell{	groups{Apple=this.columns[1-3],Pear=this.columns[4-*]},
		partitions{grid.partitionKey},
		format{four byte counting number},
		dimensions{rows{index=1,origin=first} ,columns{index=1,origin=last}},
 
		events{
			beforeChange=grid.on.beforeChange,
			afterChange=grid.on.afterChange,
			}			
		operations{
			+{integer=grid.add.integer, text=grid.add.text},
			-{integer=grid.subtract.integer, text=grid.subtract.text},
			<{grid.less_than},
			>{grid.greater_than},
			>={grid.greater_than_or_equal},
			get{text=grid.get.text,default=grid.get.default},
			set{integer=grid.set.integer, text=grid.set.text, default=grid.set.default},
			search{grid.search},
			new{grid.new},
			change{grid.change},
			delete{grid.delete},
			clone{grid.clone},
			notfound{grid.notfound}
			
	};
 
A = new GRID(10,10);
A.%operations['<'] = myGrid_less_than;
A.%format = 'text';
 
 
A[1,1] = 2019;
A.Apple.rows[1] = [2919,10,20];
A.rows[1] = [2019,2,3,4,5,6,7,8,9,10];
A.columns[1] = [2019,2020,2021,2022,2023,2024,2025,2026,2027,2028];
A.Pear.2019[1,2] = 34;