They had a fictional education

DAILY MAILStudy: 25% of students say they were traumatized by the 2016 election

Full working join chain

I can debug an app that is running raw text to memory.  Insert the 'continue' statement and the app script drops down to consol executive, and from there I enter debug with access to everything, including special code to display structures.

I discover that the join system actually works, the matched keys get stored in structured memory, accessible as input in proper order/. I exit the debug back to the application and it runs the next round of scripts, sending memory to the console in structured order.

All of this with four or five script statements which just switch the flow between different triplet slots. I mathes fast, 3,000 character from text matched against a list of 20 words is a blink.

I can make it step on each pass through the loop but I figure that to be unnecessary.  The loop is and remains staboe for a long time since the traversal bering simplest has an obvious optimum set of steps; a well solved problem..

Crashy like

October Auto Sales Tumble: "Our Car Sales Are Down 12 Percent"

This channel outta had been learnt well. 

Likely at 12% drop is OK in their volatile world.  But still, any sector reporting down more than 4% are scary, more than 10% seems crashy.

Bad year for pension funds

The market has no gains fn in 2018. The ten yer yields 3.2%, the public sector pension funds cannot even make 5% this year.  Local government funding will be exhausted to make up the difference.

I still have back taxes to negotiate.  I don;t want my IRS coiunterparty worrying about pensions.

Simple debug for join, my first app

There is a 'continue' script for the command handler, it is just like "quit" but with a different exit code. When I debug script, I leave a continue after the first join. Then my return code tells the app to call console_loop. I can interrogate the stable state of the machine. When done, I enter "continue" and then script continues processing where it left off. I can only debug between joins.

 I could define the debug mode, and the join operation will have one more test in the loop.  At the bottom of the join loop it is perfectly reasonable, or should be, to call the console_loop(), and check the return for an abort or continue.

 Debugging a stack of joins will be easier than we assume, especially given the native MEM format used, MEM almost always has the intermediate results, and can be examined intelligently. 

Application format

Not much ode in the applicqtion interface. his one executes a scroipt then goes to interactive mode.

int exec_shell_command(char *);
int console_loop(void);
int main(void){
 int i=0;
 int count = sizeof(script)/sizeof(char *); 
 printf("%d %d\n",sizeof(script),count);
 while(i < count) {
   exec_shell_command(script[i]);
  i++;
 }
 console_loop();
 return 0;

The script is just static text I use for testing. Here is the example. I run the script in two parts or one part, each time join terminates and leaves the 'databes' attachments in a consistent state. So I can manually start up the second instance, taking output from the MEM structure already resident. Two external call here, one to the console loop and one to the executive with script.  Very simple.

<
static char* script[] = {
 "list",
 "set LAZYJ 0 json.txt 100",
 "set TEXT 1 grammar1.txt 10000",
 "set CONSOLE 2 20 2000",
 "list",
 "join"};
 "dup 2,3",
 "set CONSOLOE 5",
 "set LAZYJ 4 join.txt",
 "join" };


/pre>


<

I rearranged the code, likely for the last time

Applications, like a test applications needed to be simplified, so I built the slot system discussed earlier. The executive, console commands, knows about slots and cursors. Apps only know about setting up an managing slots. Apps send simple commands to the executive to control join. Good enough for my test applications, making it easy to run myriad of configurations and step through the miserable bugs.

Reading equities in join

We want a uniform presentation of a summary balance sheet for some variety of financial descriptions. Our search graph is just that, the definition of the normal form balance sheet and cash flow. Company financial information may be a bit scattered, but join learns the company, it sniffs through company text and develops key word list that help it organize financials. So we have new text, unseen from the company. We let join sift through it using is collection of categorized word lists. Do this fast, I mean fast; bring all the world list, reat4 them automatically. It can do feature detection if the feature hierarchy can be seen as directed graph, from general to specific. Feateurs mayber ber bit maps, match is adptd to find partial matches. Search for one or more close matches to known graphs. Math geeks know about which I speak. Handwriting analysis, finger print, image detection. The ability to stem roll though stacked layers of lists makes it work. Anyplace you have big data, treat is as set classification by learning, and keep the hierarchy of canonical sets developed by learning. This machine is thinking.

String arguments

The application interface is dealing with am small list of integer indices indicating the slots the application occupies. There are about six things the application might do with slots, all of them needing only simple, short arguments.

So, dump the header file, only one entry is needed and the string argument list ultimately gets passed in as a variable argument list, it is parsed. It is a quick process and sending the join system short text message eliminates a lot of complexity.

It also means I am about done.

Isolation of the application in join

Applications work with an integer index defining a slot in the stack of active join instances, the triple stack. They select the attachment, get an index onto the triple stack and their fine. Applications have a data object to be joined, they have to k ow about that, and so does the attachment. 

 Mainly the application needs to view the data as a structured branch and descend data structure, Dotted sequences of the Comma separated. The application is moving data results from slot to slot, while the attachment removes cursors after a Done, automatically. The application is free to throw different cross reference files at join, filling its empty slot, like a piping system, a message switch. A very powerful tool in all kinds of analysis, especially since the attachment controls the Match process and delivers data as needed.  Every attachment sees the same data structure, key/op pair with an implied position in the graph. The sufficient and minimum information needed for the task.

The console commands are about slots, what is in them, what are the triples, feeding one slot to the other, and filling a slot. For example, when the application is satisfied, it has narrowed down the unknowns, then it can pipe tre results from MEM to CONSOLE, really by using a dup_slot, and new_slot calls.  Then it can list slots, and list the attachments available.  Application developers do not worry about join support, the rules of convolution are fairly obvious, and recreating join in various forms easy. 

Pausing in stacked joins.This is one of the grammar rules, when should one triple puse?  One strategy is to pause after ending a sequence, let the further triple digest that.  The other is tpo pause when the a slot is empty or full. Whatever he default rule, the attachments can over ride the rule, pausing according to its own idiosyncrasies.   The switch concept is asynchronous, one flow dependent upon another.

Typical application flow:

You hve a list of word list, in some hierarchical arrangement and you can intelligently cross reference you word lists with raw text, narrow it down.  You end if with a bunch of if then.  
If it matches well with list a then try list b,c,d and f; otherwise go try ;list X or Z and so on...

That is interpreted as filtering lists from slot to slot, a simple procedure for most applications, no worse than plumbing.  Join puts the AI power in the hands of little folks. This idea will be on every computer.

Easy setup

Just have gthe console do a get string back from the application, then the application can deliver simple byte codes as needed to control join. Not even a header file: do_join_op(char*), in c will link in the application in., the application then  then return command codes specifying actions. Type help art console and those are the command codes and format for standard attachens.

. The attachment needs to know more, it needs to know what a cursor is.