Not a messaih, really

It is already predicted that AI will soon be present in all areas of the workplace, with industry experts saying it will eventually do millions of jobs currently done by people.It is thought that every field – from publishing to factory work – will eventually be dominated by intelligent robots as men and women become increasingly obsolete.But now experts believe more than jobs are at risk in the Artificial Intelligence revolution.Novelist Dan Brown previously warned people may no longer worship God or pray to Jesus – instead putting all their faith in an AI messiah.

It is this intelligent beper in your hand, it watches the world for you in units of  oriceable events   Your contract manager as you wander your time on earth. You will get use to it and rely on it. It, and the connections it makes, will hardly be noticed. It will be meek and humble.

Grouping cursors

One of those, not much work required when managing the cursors.  The cursors are trapped in their own dependency tree, their attachments will pause when waiting for another cursor to catch up.  If join is idle enough to be flipping though the linear stack, then the turn around time is short, round robin access work just like even polling.

I am trying to avoid work here, and let the stack resolve all iots joins naturally by keeping the cursors consistent within a join instance.  The executive need not be smart.  It mostly gathers state information on the data flow, attachments manage themselves otherwise.  So, the join protocol is mostly a consensus, not a technology. It is an agreement about which side, right or left, is mostly searching the other. An agreement to use compatible match functions.  Otherwise, join, all 30 lines of it, is just a step and fetch manager.  More of a human agreement, mostly about a few boundary conditions. Just want to add the skip function to csv files.

PutEnv and GetEnv both working, the macro symbol tables. I wrote them to file as plain text, line by line pairs.  You can edit the list in the editor, then load it back into join all you want, a great productivity tool.

Based on that, iwant to feed it search script via the command processor, using the Console attachment. The Console device opens to the keyboard, but I can direct it to macro processor, make life even simpler for searching. Keep a collection of search strings in g\the macro tables.

Where macros help

Setting up these intermediate memory flows, you want detai in defining maxim sizes, total wize and other constraints.  Setting up for file IO depends on the file and attachment. So the command back to configure are variable number of arguments among the attachments,  Macros solve this, especially going into the  editor and just carefully typing in the set up and go commands. The command set up can be used over ad  over again by different cursor groups. We get a number of environments, all in oncise editable files of plain text.

Take spreadssheets, for example

What is a large corporate spreadsheet?  A step and skip graph, with integers.  It is easy to forget that simple fundamental.  Given the speed of join, we can imagine accounting based search graphs, traverse corporate accounts and extract peculiar summaries, with structure/  Very simple to write a comma separated file handler that will step and ski[p its way through a spread sheet, as long as the format can include the Dot and Parenth function, and the attachment distinguishes plain text and integer.

We can expand the function, search and distill from huge,and often, inaccurate accounting data. The key here is getting close to standard formats for profit and loss with accounting labels identifying subtended structure.  We get a kind of accounting language at a high level.  "total all accounts receivable then execute a peculiar statistical operation, and so on."  An attachment interpreting such a languagem will match labels, find sequences as needed, a very loose interpretation where data may be located in a variety of places,. Data may be unreliable.  The application relies on its power to step, fetch, match, collect on arbitrary spreadsheets.

My application will be a plug in

As I look at pages, mym bot has already extracted the plain text and is working it over with word lists.  I save and restore match output, in the MEM format, saving structure.

My application can then pop up with references, personal, where have I seen that before.  This is a stupendous reading aid, this application enables a lucrative word list technical industry, plaintext, the language of bots.  Underneath our web surfing, bots exchange word lists describing the stuff they been reading lately.  All their readnwritn is plain words with Dot,Comma and Paranth pair.  Simple structural gramar with easy to manage symbols, Watson in the extreme.

I will write the web put ands get attachment.  It has standard step adn skip grammar, except it steps and skips the dot connected http URL addresses.  Keeps collections if them in structural foram and steps through them, under a matching Lazy graph.  Generates structured plain text to MEM. The human user can point and click on whole classes of word lists for cross reference, extremely fast, right in the browser.  Not only is the human no longer bothered with ads, the human can also ignore the text, video, images and whatever else bloggers dream of. Bloggers, in general have bots that do this backwards I presume.

SaveEnv RestoreEnv

Two standard commands in your typical macro shell. They save ad restore the symbol table, with expansions, on the disk. The actions have nothing to do with operting configurations, paths, cmputer setting, or any of that spaghetti; it just saves the macro expansions and names as strings of characters with pointers,  normally as lines of text/

Geeks and professors sometimes forget the basics, they get into the machine details and neglect to mention the macro shell is simply a text manager, it knows nothing else.

Burt saving and restoring removes a big headache for me, I am out of the lab making the application work. A new environment.  The scientist usually generates a white paper and leaves behind a huge pile of spaghetti, can't do that anymore.

What is spaghetti? It is a pile of random, often redundant, computer statements that do one thing at one specific instance for one person and has an audience of one, it is pure lab code.

Creating a cursor

The first part is calling the join loop, new_cursor, and it delivers a bland version. The attachment is selected via argument and called to make the cursor specialized.  Some cursors get a whole massive text space, they manage it themselves leaving their pointers on the new cursors. Some are just repetitive search strings.

The user application  has the same access to the system as the macro shell, via the exec file, which has all the spaghetti. User doesn't notice, the real path, the step and match path is tens of instruction, if the attachments have simple, mostly Comma dominasted graphs, then join only imposes another 20 processor instructions.

Blazingly fast, and for plain text words comprising some information structure, this machine will do the trick.  Especially our ability to extract plain text from across the web.  Not even centralized, every day people who read web pages can run the scraper, adn dump the results into the company semantic processor. My desk top can run a few hundred word lists in the background, select an encode graphs based on prior knowledge of the word lists. The powers to be can pay us and or bots will read our favorite web pages .

It has one problem, we move the key twice to get to output. A bug, easily fixed/.I pout it there on purpose, as I deal with words, sort in length, so I keep a copy in the cursor, not the pointer.

Dealing with argument arrays

The macro shell delivers an argument array consisting of pointers to the arguments of a command line string.  Since I only deal with int and string, extractin arguments is simple:

void SomeRoutine(int argc, char *args[]) {
char *str;
int number;
str = args[2];
size = atoi(args[3]);
}

Simple enough for the macro processor and the called routines.  I did not do this in the call back after all, I need those call backs extremely short and will have the compiler set up arguments on the stack prior to run.

But is makes the macro processor easier than ever.  It is a complete, but simple macro generic front in for utilities. It needs on external, and executive that does something with parsed argument lines.  Comment out one line and it runs all alone, parsing, defining, ad quoting stuff you type at it, and is always spits out the argument list.  I never bothered to get this right in the lab, didn't care, was willing to go spaghetti, didn't matter in the lab.

But now I can see how useful the macro capability ios, especially with file names and environmental variables.

Progress!

I integrated the new macro shell into the executive of join, added dll load attachment.  I am able to remove a lot of code with symbol tables available, and I removed extra command  loops.

I got Lvalues working so this works as expected:

$Result = LoadAttachment(argc,argv);  // LoadAttachment is a cmdlet
as well as:
$expand
$out= $expand
and various nested versions of right side expression also expand normally.

Having macro expansion available eliminates headaches.  Soon my new web scraper tool with be a dll, loadable on demand.

The DLL interface to join

Attachment produce two APIs, exec and eval.
Give them an api_call(intr argc, void* argv[]); c call convention.

The exec has method identifiers in the first argument. eval generally want the attachment to make a decision about a node pair, and their operator. The key value is char*, in my application. We can force the arguments to be either real pointers or int, via trickery. But the key can be anything, an image , a sound byte.  Match can be anything, a statistical distance, for example, but it must resolve into a step or skip with an optional output emit.

The first argument in the list is always the cursor, defined in cursor.h. If we wanted we can make it:
exec(Cursor* ptr); Then the Cursor structure can hold any argument list, and they would be mostly static.

Simple rules, the cursor has the methods, add one, the attachment has to initialize its own cursor.

Here is an initial classification of the commandlets at the console interface.

• Loading match functions, and attachments,
• Configure and stack instances.
• Initialize and configure the join and any overlay modes
• Grouping and interrogating cursors
• Groupting and interrogating attachment instances.
• Read and write the structured memory to disk
• Maintain static and dynamic argument lists and configuration

//

Joins can do this

A decision tree.  make it highly recursive, add  million decisions.  It is a graph, it does step and fetch and we can do 'one out of many' choices, not stuck with binary.







From Wiki, Join can do this.

Symbolic[edit]

Main article: Symbolic AI

When access to digital computers became possible in the middle 1950s, AI research began to explore the possibility that human intelligence could be reduced to symbol manipulation. The research was centered in three institutions: Carnegie Mellon University, Stanford and MIT, and as described below, each one developed its own style of research. John Haugeland named these symbolic approaches to AI "good old fashioned AI" or "GOFAI".^[144] During the 1960s, symbolic approaches had achieved great success at simulating high-level thinking in small demonstration programs. Approaches based on cybernetics or artificial neural networks were abandoned or pushed into the background.^[145] Researchers in the 1960s and the 1970s were convinced that symbolic approaches would eventually succeed in creating a machine with artificial general intelligence and considered this the goal of their field.

My application, one of many, is about distillinging the symbolic content of text, like Watson. But I am a cog in the giant machine of the join industry.
I have a bold plan, turn the existing web pages into a single, coherent knowledge bases represented by structures of small words lists.

Knowledge-based[edit]

When computers with large memories became available around 1970, researchers from all three traditions began to build knowledge into AI applications.^[152] This "knowledge revolution" led to the development and deployment of expert systems (introduced by Edward Feigenbaum), the first truly successful form of AI software.^[38]Key component on system architecure for all expert systems is Knowledge base, which stores facts and rules that illustrates AI.^[153] The knowledge revolution was also driven by the realization that enormous amounts of knowledge would be required by many simple AI applications.

Now join may not be well suited to neural nets and Huffman trees.  I dunno.   Join can certainly match any tree, binary, trinary and so on. Huffman codes are a probability distribution.  There is a lot of overlap.

Likely, a well written dll can decompose a neural net into a series of tree concolutions that are stacked in the join machine, but I haven 't looked yet.

Here is the fundamental Hopfield equation for neural nets:

The fundamental equation is the accumulation of every node with every other node, except itself generally.  Have to do that with sometimes sparse networks, they are not directed graph.  But join is likely ove kill for a short set of do loops.  But with the match function one has a lot of flexibility The point of the neural net is that it a;ways converges to a guess about the input data.  We can do one of these, maybe read some research.

I look at all this stuff, and I am thinking about what? The macro command processor, can it be set up to configure and run a variety of attachments and match functions simultaneously?