The open ended xcb nterface, on the Bus

// A box of xcb goodies
typedef struct {
xcb_connection_t *conn;
xcb_screen_t *screen;
xcb_window_t  win;
xcb_gcontext_t gc;
xcb_void_cookie_t cookie;
xcb_value_mask_t mask;
xchars_rect_t rect; // has gc and user stuff
void * link;
} Box;

xchars can take that box of xcb goodies and fill in a specified xcb call entry, as long as the coller fills in the box correctly.  The interface is a one liner written on a per xcb entry basis; Bus to xcb.  Some of the things in the box are redundant, I am sure. Just use the proper xcb names and the unused stuff eventually goes way.

The call will be:

XCBCall box method;

Xhars will do a switch on method, and fill in the values and make the call, having no clue and keeping no state. The windows can be part of current xchars windows, in which case the calls are a kind of overlay.  Or the calls can impose widgets, dialog boxes. Xchars is clueless.

The join interface

Join is a separate high speed data path, the real MA likely accelerated by join hardware. All he attached grammars to join adapt their data so it is subject to step,skip,fetch,append, match.  The data source is ad hoc, much of it scraped fro the web.  All of these grammars, and the join machine, needed configuration and control, that is what started the console project and xchars. And, the join system, like many others, will need its own name space, and Default has to support that, and it is fairly easy to do with a generic symbol table.

Givewn the ability of args to map other interfaces, an interface between join and args would be a  map of args to one of the memory index methods, and keep valid memory index files pointing back to source. Thus, any snippet has direct access to the high speed, real DMA hardware, managing directed graphs. In AI world, this is like direct bit buffer access in graphics, the holy grail.  In the enterprise, for example, any snippet can grab a complete picture, organized by significance, of all the goings on at that particlkar moment, within data uncertainty error.

Note on uncertainties:

mathematically, the market and data uncerainties always boil down to serialization queues, really the uncertainty of consensus checks.  It is closely related to consensus algorithms, and queuing is closely related to all of it.

Join itself is a c programmers reference rctecture

The rules, mostly work as a model of a hardware implementation, a multi processor.  That is what is happening in AI, chips that can do multiple Skip,Step,Fetch,Appends,Match;all on a single die.  They look at blogs like mine, get ideas, then check them against the pros. And i react by learning stuff.  The result is the join concept subsumes most of what we can know about the singularity, as hundreds of thousands of these join machines will be processing a levels much more complex than we can track. All the trading pits are essentially join machines, the html readers, enterprise managers, government advisories.  All of it reacting to hordes of image,sound and most and importantly, price clicking; billions of data sources, all active.  Humans can never track it because there is hardware certainty, the exact significance of any known even is only accumulated  after the event has passed.