Sunday, October 21, 2018


gcc was always too strict for me, but I adapt and got all of the compiler warnings out, gone. Now I can run two compilers, my sloppy one and the strict one, depending upon my mood. But join now compiles on gcc with no warnings. I will testing it on the minGW linux compatible system under windows.

Saturday, October 20, 2018

My console works!

I can join the console input with another console input, making it easy to test:

console = console join console

The system will just do a read from the keyboard on a fetch, and write on an append.  Manually operated databases, makes it easy to test.

More socialism from an NRA gun nut

During a visit to the White House in February, Pollack said, “It is not about gun laws. That is another fight, another battle. Let’s fix the schools and then you guys can battle it out whatever you want. But we need our children safe.”

Sorry for losing your daughter, but why would we prefer more police socialism?

The problem since the beginning was Florida Repubs violating the 'regulated militia' clause, that is violating the Second Amendment.  Florida Repubs hand out AR15s to the mentally ill.

The federal government is not going to provide police service for every school.  Parents have to decide.  If they live in a state that hands out guns to the mentally ill, then put your children in private school.  Don't come and tax me because politicians want mass shootings at schools, go talk to the Florida and Texas Repubs who cause the problem. 

Matching modifiers for join

The output can collect all matches, just the first, some count of, or colelects only unmatched (diffs).  The modifier is applied to the output and does not effect either of the joined graphs.  This approach, putting modifier onto the output attachment is the intuitive place one would expect.

otherwise, output works fine, at least the console version of append. It reports all matches from join, in their proper descend and branch order. So I am almost done!

Command files for join

My shell can execute the following file:

set LAZYJ 0 json.txt 1000
set TEXT 1 grammar.txt 2000
mode All

Which is a command file for the simple join console.  This file sets up three cursors and join the first two, being the left,right. The third is output, the  console . It sets the mode to collect all matches. Then we call join call join.  There are two utilities, list displays parameters for all active cursors on the list. Type tells me how many attachments are active.

All I need to know is something about what arguments the attachments want.  MEM needs no files, it starts empty, like the null database.  LAZYJ and TEXT both work from files, unless the console iio is active.

My output will always be a structured graph of all matching paths.

Sample output from the list command.  It gives the relevant state variables for each cursor in te active list. Cursors come in triples, and multiple cursors can be active in different triples, just dup a cursor for the same attachment.  This gives me the capability to run the multi-level text analysis.

:  0  0  LAZYJ   3   None 1105a00
:  0  1   TEXT   1   None 1105f06
:  0  2 CONSOLE   4   None 0
:  3 Empty
:  4 Empty
:  5 Empty
:  6 Empty
:  7 Empty
:  8 Empty

Friday, October 19, 2018

Millions and millions of the horde

Folks coming for the old California socialism.
They will live in camptowns like this one in LA. 

Zero Hedge is reporting a typhus outbreak.

Maybe the issue is confusing, but inviting millions of poor to lice in Skid Row LA seems like a con game.

How's the software, you ask?

I made applications simpler, they need only request the cursors they want and insert their triples onto the instance stack.  Join will find and process the request.

All of that is working, I am now trying out simple applications, like text searching. The whole chain compiles and I run  simple joins from plain text sources.  Unit test is basically done, full system test and adjust is what I do now, and that is only a few days of work. All the basic attachments seem to work, and we have four.  All based on plain text.

I added a simple shell with two or three command utilities to interrogate the instance stack and see what is happening. Next I want to attack the complex multi-level joins through the memory attachment.

Thursday, October 18, 2018

Tax day

Another I form.  But I am set up now, they go fast.

The match function in join

Specific to the attachment and unique match functions powerful. The match function modified on the fly if your attachment support wildcard modifiers. My text processor can match just most of the characters, solves he spell function..

The text model associater a file name with each instance. So start multiple searches, just specify the file name an load a tne triple, the same text attachment appends to another file. Set a wildcard, nd wun with the Null graph, we get pass through, like reading the file.

One attachment is a console. Fetch is scanf, Append is printf. When it scans for user input, the triple is put on pause, other instances can run. The console is a left side and result side, both at the same time.

We can just drag a random file of a word list on out widget screens, and underneath will compute the intersection of the huge files.  All extremely fast, all simple interfaces, all successively refining the text.

Across the internet

Simple get and put onto the internet should. be easy. The instance fetching or getting over the net issues the pause while waiting, and its sub graph can work on past data collected.

Chaining attachments is unobservable, just gethe triple onto the cursor list. The internet attachment is like the console, two methods, responds with pause and Null.  Generally works with the match all modifier because it is pass through. The internet attachment is always attached, just request a cursor pointer from it.

Up and running

The entire join chain.  I have all three interfaces running, and I have five that work.

Few bugs but issues regarding the search modifying wild cards remains unresolved.  What these might be is a market function. I have solutions for lazy J, but they don't count too much.