April 2016
May 2017
One year teaching

I took a year off to teach software development at our local community center. I needed time and a reason to research details of software development so I could teach myself the finer points in our current technology. Had I missed something in the design of "Jane" that already exists?  I learned a lot, but nothing that altered my overall design of "Jane". I have 3 1/2 years designing Jane. I decided to not just program, but rather spend more time in design. I needed time to unlearn 40 years of experience. This has been the hardest thing to do.  

One of the classes I taught was to create a JavaScript compiler using JavaScript. I decided to use this work as a basis for the "Jane" language. Three weeks ago I quit teaching to concentrate again, full time, on the development of "Jane". 

Jane, Creating a way to communicate

Using JavaScript syntax / logic as the basis for communicating with Jane. I used a modified LR parser logic to build my own JavaScript compiler. The syntax analyzer I wrote also in JavaScript.  The output can be emulated in JavaScript, and I am also in the process of writing the output directly to X86 and ARM binary executables.

I extended JavaScript in a way that would permit all types of applications be written, from bootable images, SoC, ASIC, FPGA, text editors, device drivers, web pages, to accounting systems,...

ECMAScript 6 — New Features

I looked over the changes someone thought would be useful to the JavaScript language. I did not see anything that I would use, or more importantly that would actually save me time to develop software. I do not need more ways to say the same thing, nor more ways to loop through a list. 15 years to make trivial changes, I think not, change just to change is not necessarily a good thing.

I held back on implementing JavaScript properties (getter / setter) due to the handling of these by the current debuggers. The debuggers execute the get/set functions when you view them, which has devastating results on a running process. The debugger I implement will need to handle these appropriately.


"You’ll never be as lazy as whoever named the fireplace." -- unknown

"Intelligence is the ability to adapt to change." -- Stephen Hawking

“Drawing on my fine command of the English language, I said nothing.” -- Robert Benchley

“I am so clever that sometimes I don’t understand a single word of what I am saying.” -- Oscar Wilde

“If people knew how hard I had to work to gain my mastery, it wouldn’t seem wonderful at all!” -- Michelangelo

“f u cn rd ths, u cn gt a gd jb n sftwr tstng.” -- Anonymous

“A child of five could understand this. Send someone to fetch a child of five.” -- Groucho Marx

The purpose of "Jane"

The purpose of Software Development is to provide others with information to perform a task. Examples are students doing their homework, workers doing their jobs,  software developers writing software,...

The purpose of Jane is to reduce the time to develop all software products from man years of work to man seconds.

JavaScript language changes to save 50% time

I wrote the JavaScript compiler without change. I did add some extensions to save me time in writing software. I estimate that 50% of my time can be saved with just a few minor changes to the compiler. The technology of "Jane" will further reduce the time of development to 0.01% of today's effort. Here is a partial list of changes just to the JavaScript syntax:

  1. added the goto statement
  2. block comment as a string (a = /* hello */)
  3. block comment unique tag /*+a+  .... +a+*/
  4. dynamic language extensions (a = b cross c)
  5. natural language extensions (height is 15 feet)
  6. units (a = 10 feet * 14.3 inches)
  7. properties (a = 10 feet,  a~units = inches)
  8. remove the need to declare local variables
  9. force explicit .vs. implicit global declarations
  10. SQL  (B = select name from A where...)
  11. variable length binary values ***
  12. mutable strings  (A  ="clif", A[0] = 'C')
  13. Matrix object (m = new Matrix(2,4,4); )
  14. Matrix math (m *=  15)
  15. loop statement  (loop m(a,b,c,value) { ... })
  16. Bits object  (b = new Bits(1:6,12,20:50))
  17. sub-range object (b = a[3:7] or b = a[9:-7])
  18. assembler functions (direct hardware access)
  19. binary functions (to work on binary structures)
  20. replace closure with bind
  21. A in ( list )  "a in (12,13,15,19)"
  22. A like ( wildcard-list ) "a like ('a*','b*');
  23. A contains ( wildcard-list )
  24. all values are objects
  25. a "world" object (all machines)
  26. a "local" object (local machine)
  27. a "user" object (user specific)
  28. added an undeclared variable event
  29. expanded alert output "alert(a,b,c);"
  30. locals array of functions (a = 12, return locals)
  31. "this" propagates to sub-functions by parent
  32. library card (all knowledge)
  33. delay fetch of value until actually used
  34. IC technology (Infinite Continuous)
  35. tokens / compile / link  functions
  36. qualified function names "function car.print()"
  37. integer and real numbers
  38. added change value events, (triggers)

There are other changes that are less specific but also add to the "time reduction matrix".  None of these enhancements change the basic JavaScript syntax. The syntax remains as it was with slight additions, not changes. The objective is to reduce the number of characters needed to program, thus removing the human from the equation as much as possible.

The language extensions are not macros but are dynamic extensions to the parsing syntax, which includes precedence. The assembler and binary functions use JavaScript syntax but execute at the hardware level.

Some changes I am still debating on whether to change or maybe allow as an option:

  1. remove the need for keywords
  2. case-insensitive
  3. force semi-colon statement separators
  4. remove the need for the "var" statement
  5. explicit globals
  6. a mode to compile standard JavaScript


Common Ground 3000 (cg3) ***

Item 11 in the list of changes to the JavaScript compiler (center), is probably the most important and useful of the changes. It removes all number limitations, all machine incompatibilities in our current computer technology. It solves all transport of information issues.

I use a format that is the same in memory during transport, and as stored on disk. This means no more stringifing, reformat, or even encryption is needed when moving data between any two systems.  This format also removed all character limitations and the need for Unicode.


The changes to the compiler were easy. I simply moved logic to its proper place, within the language that we communicate with "Jane". Jane's logic should be done by professionals.  I have designed Jane to work as an independent entity who's purpose it to simply provide information, in context, when, and where needed.

If I am able to complete Jane, Jane will remove, either completely or by hiding, logic that the developer needs to write. This means no more operating systems, databases, network or other artificial terms used in development. Jane will use real world terms for information and actions. "Elephant", "Employees", "IBM Employees", "Time of my last Review",...

Not only do I expect the time of development to be greatly reduced, but also there will be an increase to the speed that an application executes. I predict, a minimum increase in speed of 200 times faster. I also expect security will be far better since there will be no holes to exploit. If I had my way security would be an absolute 100% by removing all of the existing hardware security issues.  The speed increase will be a result of removing layers of logic, by direct access to hardware, by taking advantage of our existing technology, and by having time to actually complete software logic by professionals.

Compiler Status

The compiler can compile itself. I hope by the end of April 2017 to have the compiler generate x86 machine code of itself, or any other JavaScript code.

The compiler will then be placed in a new browser with a server side companion compiler.  All development environments, at all levels of software development, will be identical.  Once this is done then the full implementation of Jane can be started.

The 38 changes I've made to the JavaScript are to reduce the time needed to write programs. All changes except "units" and "SQL" required just a few lines of code (at most 200 lines). Why am I still waiting to have these capabilities in the existing compilers?  I hope to gain a reduction of time to programming maybe as much as 50% just with the changes I've make to the compiler. The worst case is that the time is the same. I base my time estimate on a 12 month project, could I do it in 6 months?

Author: Clif Collins
Houston, Texas
April 17, 2017

email: web4@CollinsSoftware.com