A script is simply a string of words, or a stream, and I will now abstract for a while on what this can give you.
*{stars mean dreams way off, but still concieved.}
*{Ability to wrap the interpreter over pre-existing command streams, such as javascript or perl, this is CONCIEVABLE, yet very bloody hard :).} and is not it's intended purpose.
The subset of commands is not limited at compile time, they can be
extended upon at any time.
*{ In fact, Sync two iXml's and there Definitions Tree's should sync,
enabling a lot easier deployment of systems.. it's auto deploying..
you'd just have it's path set aside from the old path.
When it's done, and working locally, it's already deployed remotely,
disable synching to server (or sync it now), and then delete or
move the old working starting node, and replace it with your new
working starting node :). }
Data in the Tree is bound to DataType by a single attribute, the rest of it is up to logic you set up to control your system of data, your tree structure you make to describe what it is that you are trying to computerise(c), and at the same time be adding the simple scripts to access and handle what they want to do with their data they have modeled within!
The data is being stored and handled as pure Xml, and so others services can communicate and recieve and control iXml Quickest through Xml. *{ for non xml based protocols, iXml has logic and functionality and can interogate to perhaps form xml, or just do the work that it is handling, but this is a bunch of SERVICE scripts that handle Clients.. ( an example of this is WebServer.script ) } so although that above note gets a *{dream} it's been implemented! }
The language is executing upon backward chaining.
That is, it is asking for a function, asking for it's parameters.
If it's parameters are Nested, then it starts over there, until
it has resolved the functions required number of paramters. It
THEN executes this function. Everything more is the next
function to perform. and the cycle sits in a loop waiting for input
as the expected script!
This is simply categorized as a predicate based language.
A Flow chart can describe the stream of words, very simply.
It is a tree of commands after all.. and nestedness is just a
Script UML in the flowchart script/draw tool.
You can draw this tree to represent STOP TIME, or INTERPRET/RUN TIME, and as the 'this' changes, the RUN TIME simply makes the flowchart draw out it's current state from the this, ( it's a this viewer. ) that your linking scripts to run and paramters to use.
STOP TIME design is a lot more boring, and you have type a lot more.
:).
*{ 7/8/9 are very dreamful, but highly concievable with structures. }
*{There is a DTD, so scripts can be written to maintian data structures
if necessary, ( triggers are better ), and can fine tune itself as well
as it can explorer and verify it's surroundings...}
Tuning is done through refining current data, or refining it's own
running function scripts itself, self fine tuning. (aka code morphing)
*{ Code can generate and regenerate itself, it can be scripted to be
aware of it's environment because it is dtd driven, it knows it's rules. }
apply the 1000 monkeys principal to this, but with a billionn
processors, your gunna get some funky shit, that who knows WHY you'd
wanna do this, but ya could...
*{ This is easily conceived. }
compress ALL symbols or Strings or Keys as they are streamed into iXml.