Mutation

The language point reached, the activity now comes completely different.

Now, the jQuery library has been implemented instead of Prototype : jQuery comes with a bunch of all-managed HTML scripties (panels, tabs, ...)

The jsDebug page (allowing to enter NUL code in an editor, evaluate it, ...) has been replaced by a console : this console can be run as the firebug console for a page using NUL or stand-alone as a sand-box.

The page system is not planned to be finished soon; not The Big Work is about "compilation" or, as it is javascript, the equivalent of "pre-compilation" : building output javascript unreadable files out of the code - The 'challenge' is to have a debug and a release version : both with jquery and 3rd parties compiled and unreadable, one with the NUL program the same and a 'debug' version where the NUL program is kept clear and source files loaded dynamically (to use in firebug and/or other browser debuggers)

After it, I still letted some white pages where a lone "TODO" stand or a pre-algorythm like the recursion management and the "solve" best-case chooser. This will come up to me : it is pure algorythmics I let for the end, half because the "coinditions are still not perfect" and it's still be a fuss, half because I can feel lazzy toward the task and there are still other things to do, and half like you let the last tasty bites for the last fork of the meal.

Language reached point

I had a bug hunt yesterday late night; I got out of the run with the heart beating strong !

And for the cause : It closes mostly the "language" part duties.

I had fun these days cleaning, documenting, spending days just to verify there is no useless variables declared and such.

Now, all the "static language" features are running and it is documented why.

The "zebra" test is still running : even if it works, it still needs some hours though.

I now got greatly involved in the "data" part : accessing the web-page content, some external XML, some databases, ... The structure gets kind of kicking.

Lately, I will still have to implements more computational stuffs like NUL assertions (that produce an error/exception instead of simply failing), some debugging tools (the one for now are used to debug the javascript NUL program, not the NUL programs), ordering, the "distinct" concept and much more.

Now; I'll mostly take time to access data and make an environement to test NUL programs out of the nulDbg.html ...

Back on stage

Aha! I think again I wrote "next week" ...
What a joke, I had fa much more to do !

The knowledge representation system was not enough, I had to refactor it strong ... I waited some month until I had the ideas clear and the courage to do it ... and here it is done.

I begun by the other side though - so some of the old features are "not implemented yet" - like for instance the addition of numbers !
So, now, it just "knows" stuffs. A lot of algorithms are already tryable - the ones that have a finite sets of objects.
For instance, the "brother" (prolog helo world) was the first one implemented :
"given a familly tree as a list of pairs (parent, child), given that are brothers the ones who have the same parents, who is the brother of John ?"

I finished the recursion problems (indeed, I fixed some little bugs, the recursion problem is "solved" by itself in this representation)

Now, the problem is different : I just have to add the ability to add numbers for the language to become complete enough.

I moved a lot these times and I'll do again this next month, but it doesn't avoid me to move forward quickly with NUL. I really hope the remaining will come within the month.
I try to rest a bit now (I spent some week just programming), comment what I did, make tests, and hope to find all the mistakes I have in the present code.

Of course, all these are available in the sandBox and the wiki is really renewed - only the old pages (older than 1 month) can be really - I mean really! - out of date

Second revolution

This revolution was started "on purpose" but turned out to be more important that what I estimated.

A lot of stuffs were finally added, even the entity "subset" allowing to say :

set(N :- N) F

aka : F is a subset of the set that apply any natural number to a natural number : in short, F is a function from N to N.

Will also come some formulations like "n Stuff ; N n" : "n" stuff (if n is a natural and "Stuff" a set of stuffs), like "5 Q" is a set containing five numbers, equivalent to { Q a, Q b, Q c, Q d, Q e }

I had to make a lot of theory and my lazzyness to "try and correct if it doesn"t work" was hardly punished and everything has an happy end.

I would estimate to one or two weeks to have an operational version of this revolution.

Attributes, objects and types

The "programming mood" craze is back again ...

I threw my first "Type missmatch" today - primitives and types are now in and some expressions of the unittesting are already giving semantic errors instead of laxist working.

Back to NUL

Hoolydays ended and programation starts on slowly.
The client/server system is not begun though, I more felt like to finish a bit the "object" system and attributes.
Beside some little corrections, the "operator+" c++ euivalent works now.
It is still trange though, while the "number 5" has a set "operator+" that associate 8 to 3 (it is so the equivalent of a one-argument function)
Operators are "native functions" for numbers, strings and sets and will be overridable (I just have to find a syntax now). With this will come the need not to evaluate every attributes if not needed. I'm thinking for instance to the "length" attribute of a string (also, native "number" : it's not a function for a given string, just a number) : it should make a call to the JS "length" ... but it should make this call only if needed.
I guess the first versions will just call everything and waste precious CPU time ...

Hollidays

The language part is now 98% ready (2% remaining while the Zebra won't solve and a lot of optimisations can be made)

The "data" part has its roots and just wait the "pluginability". I still have though to fix the details about what goes where into an SQL command or such and how to tranlate properly : basically, to send an SQL command to a server directly or such.

Though, I'm out of 2 month hard programing so I take some 2-weeks "hollidays" to walk a bit around West Asia.
This will let me the time to fix the theory about the data-part of NUL, even if I got already precise ideas about that...


Have fun !