The easiest method to get comfortable input from the user is to write a separate cursor manager which accepts commands from Console and executes them in xchars. Then we have separated the rectangle input controls from xcars almost completely. The cursor manager can run the message loop with xcb.
This is the best set up, it allows swappable method for command line editing, and keeps xchars as a strictly font to rectangle machine. And, it allows simple testing, my favorite. Cursor snippet can run on its own thread.
Cursor manager is smart and has a high speed symbol table, like xchars; they talk packed char. SO it has commands with xchar style semantics:
NewCuror conn mygc mycursor; // Cursor receives this
SetGC mygc mycursor; // Issues this
Cursor manage knows how to erase the cursor at one position and redraw it. It knows the line editing controls and reads the chars, it echos chars under mode control, and it collects a line of input and returns to Console loop, which requested it. And so forth, strictly working the current input rectangle.
Most of all, cursor manager can keep a great command list control for automatic expansion, command line history, and the rest. It echos what it think is a command format, then console lloop executes, including any macro expansion. The actual line of input remainsthe original string, the source , syntax engine insures.
It keeps the links between cursors and connections. It requires the syntax engine above make sure variable names are properly synchronized, once again, not at this layer..
Monday, December 31, 2018
Back to Default
I need the macro capability to simplify using xchars. Macros seem to basically work, but not robust, and adding double chars made spaghetti which needs fixing. I made a few passes at high speed testing with xchars, and it mostly works except strings do not fold properly in rectangles.
But interactive script is essential, and the Default error recovery has become robust. So loading up multiple loadables at a time should be done with a robust Default macro capability, simple, but error proof.
Struct mapping to args list
All the applets should use a standard struct set up to map and use args list:
struct * { char *, self; char * rect; char *string} MyCommand = args;
Or something like that, the pros know how to do this. Then on close of command:
*argc += sizeof(MyCommand)/4;
I don't use structures at this level, and it is painful because many errors are just that, fouling *argc. Protecting and using *argc is the thing that underpins the whole system. It is powerful because argc is exposed and sub systems are expected to manage it.
If you hit cntrl c (no vowels allowed) during a complex syntax, the console loop will kick you out of the syntax, set argc and args back to zeroed out, reset mode and ask for another line of input, in command mode.
Until you hit cntrl C, you remain in syntax mode unless you syntax engine change the return integer from CONTINUE to SUCCESS. Default does pass thru fine, I can leave it in Defaule, then invoke a macro any time:
MyMacro();
So, I have a robust console, cntrl c sets me to the beginning, but I can add a command to completely reinitialize easily enough.I want to be able to write while loops on the fly with simple expressions. I am mostly there and making macros robust is worth the next step.
But interactive script is essential, and the Default error recovery has become robust. So loading up multiple loadables at a time should be done with a robust Default macro capability, simple, but error proof.
Struct mapping to args list
All the applets should use a standard struct set up to map and use args list:
struct * { char *, self; char * rect; char *string} MyCommand = args;
Or something like that, the pros know how to do this. Then on close of command:
*argc += sizeof(MyCommand)/4;
I don't use structures at this level, and it is painful because many errors are just that, fouling *argc. Protecting and using *argc is the thing that underpins the whole system. It is powerful because argc is exposed and sub systems are expected to manage it.
If you hit cntrl c (no vowels allowed) during a complex syntax, the console loop will kick you out of the syntax, set argc and args back to zeroed out, reset mode and ask for another line of input, in command mode.
Until you hit cntrl C, you remain in syntax mode unless you syntax engine change the return integer from CONTINUE to SUCCESS. Default does pass thru fine, I can leave it in Defaule, then invoke a macro any time:
MyMacro();
So, I have a robust console, cntrl c sets me to the beginning, but I can add a command to completely reinitialize easily enough.I want to be able to write while loops on the fly with simple expressions. I am mostly there and making macros robust is worth the next step.
Waddya know!
According to Bloomberg, it is rumored that Facebook is currently developing its own Stablecoin with the purpose of being implemented through Whatsapp. In its first stage, the Stablecoin will serve as a currency for remittance in India, to allow for money transfer through the messaging app. However, the project is still in its developing phase, which is why they’re continuing to analyze the financial market in order to develop a workable strategy to implement such project in the market.
Zuck bites the on the apple, like clockwork. This means Giggles has to do something, as well as Apple and Amazon.
What is the deal here? I can produce a bot that does a very nice stable coin, and anyone can use it. But I need cooperation from banks, or else the bot needs thumb printed permission to act as power of attorney.
But ultimately the Fed will rebel, in that case, I can put a bot on the currency markets to back up stable coin. Failing that, I can open an automatic S&L system for pre-qualified clients and whoop the tax dollar from the get go.
None of this is a problem, the problem is NSA shutting things down with federal court order..
iPython, sort of competitor
I like what they do. They use the browser to get an equivalent of xchars. And they seem to have an attachable Bus, somehow,=(I need to look deeper). I think of them as tackling the whole problem,while my plot was just to get a basic understanding of bus and Universal interface, let the snippet authors go to town.
But, it is nice to know I am not alone. As I inch along the real good stuff I find will get incorporated into other similar packages, and visa versa.
The California rule is not state law
But Brown recently told reporters that California could be financially distressed again if the California Supreme Court rules in a case titled Cal Fire Local 2881 v. California Public Employees' Retirement System against Brown's 2012 California's Public Employees' Pension Reform Act that stopped the state and local selling of "airtime" that allowed public employees to spike their pension benefits by purchasing up to five years of unworked service credit seniority.California drastically increased public employee pension benefits in the fall of 2003, when the state allowed employees to purchase "airtime." Prior to the pension spike, a 50-year-old fireman making $89,000 a year could retire at age 50 after 30 years of service and collect an $80,100-a-year pension with life expectancy of 76.3 years. But under "airtime," the fireman could purchase extra years of seniority at a cost per of $0.18022 per year for every $1 of salary. For $80,197.90, the fireman could increase his pension by $13,350 to $93,450. Such an investment in "airtime" would return a spectacular income stream of $351,105 over the next 26.3 years of life expectancy.
The state can modify contracts, I suppose, but the California Rule was always an understood agreement between voters and firemen. A any given point, the tax payers were free to quit agreeing, they never did. One might say that the taxpayers never got a vote in California, and if so, that is a fundamental violation.
So Jerry, you cannot have it both ways. You cannot fool the voters, as you did, about union contracts, then demand a law to prevent you from fooling the voters. Ripping off voters is a fundamental right of California politicians, you cannot create a law that says voters have to have brains. You are stuck, California voters have fouled their budgets pretty much for good.
Double ops make spaghetti
I have discovered the issues, not insurmountable with double op.
++,-- work but () and {} just mean empty, they are not doubles. So I got some more spaghetti. Maybe I find consolidation later, but now I live with spaghetti.
++,-- work but () and {} just mean empty, they are not doubles. So I got some more spaghetti. Maybe I find consolidation later, but now I live with spaghetti.
It wasn't the Fed that raised rates, it was the Brad and the kanosians:
No. The Fed Was Wrong to Raise Interest Rates
There, see the red line following the blue line? That blue line is you, Brad, you demanding more treasury debt as you have done since the crash.
Now you got the interest charges you demand, how did you plan on spending the money? You have some big investment for government that we do not know about?
But wait, you say, the natural rate is lower.
The government is naturally borrowing money and driving up rates, about as natural for this republic as usual. It is perfectly natural for politicians to give into the borrow impulse. and perfectly natural for economists to demand more debt, and perfectly natural for the USA to have eight year boom/bust cycles, nothing unnatural about it, we been doing it since the founding.
I just never figured out what this huge investment is I have been paying for.
Sunday, December 30, 2018
Lindsey Graham, socialist welfare bum
"The President Is Reconsidering": Syria Pullout On Thin Ice After Lunch With Lindsey Graham
It is always bigger government with that guy, he is your typical Republican Communist party member.
Adapting our new double to high speed namespace
I want to do with names the same that linux does with file names, a descending, subdivided set.
I write a selector methor for units of high speed table look u[:
Val v = ./xchars/Screen/Themex; //Themex is struct * with goodies
SetGC(mygc,Val); // Change users screen theme
Val was assigned the entry Themex, as discovered in the descending table look ups, each table look up limited to eight chars. So names are automatically names paced by the limitation to unsigned long, and strings, in this set up, and in chunks of eight chars.
I will use the famous technique of letting Val be anything it wants, we are only interested in the names and their classification.
What does // mean? I would imagine start at the top level console loop, while ./ means start in the local table, and .. implies the previous table which must be saved.
Once all the snippets agree to text8, then we standardize on name segmentation, by the obvious eight chars selects a descendent. This is easy to do with the universal interface, the utility is based on rapid table look up.
Here is the neat thing about text8 symbols, use a well designed naming system and the frequent, short calls can take the shortest path to their entry point, often three steps, one to get to the shorties, and two selects one of four shorties. These are test and jump, almost instantaneous at our time frame.
Using the selecdtors for argument expansion:
macro(a,b) {
set = ./here; // anchors the local selector to arguments
mv set/a set/b; // console will pipe to mv, if it needs to
}
// Later
macro(./xchars, ./so/xchars); // works fine
The local anchor is set at top level to linux, as that is the only consistent user, linux and me. But if the methods are available, selectors can be typedefed to a symbol table selector, and in this case Default can set up a simple selector on the arguments laid out, right there in args list. We get a great new,flexible syntax and we solve a whole bunch of problems by promulgating symbol table interfaces and universal interface formats...
Why not use the dot, like Golang?
Like this: objec1.object2.method;
Great idea. ledt us make the leading dot free floating, set by an operator .. or ./ or //, introduce those and the top of dot can be re-assigned, floating, a pointer. So, arguments are:
local = ./here; // here understood.
then we have local.a and local.b picks up the arguments. We are c dudes snipper, we don't have interpreters, we like to free float the selector, re-anchor it.
Dot and slash:
Dot means, is an element, slash means is a subset of. With slash you may continue iterating on the selection obtained, with dot that is not guaranteed. The slash is a consistent iterator, in the expression. The dot adapts to the method selected.
I write a selector methor for units of high speed table look u[:
Val v = ./xchars/Screen/Themex; //Themex is struct * with goodies
SetGC(mygc,Val); // Change users screen theme
Val was assigned the entry Themex, as discovered in the descending table look ups, each table look up limited to eight chars. So names are automatically names paced by the limitation to unsigned long, and strings, in this set up, and in chunks of eight chars.
I will use the famous technique of letting Val be anything it wants, we are only interested in the names and their classification.
What does // mean? I would imagine start at the top level console loop, while ./ means start in the local table, and .. implies the previous table which must be saved.
Once all the snippets agree to text8, then we standardize on name segmentation, by the obvious eight chars selects a descendent. This is easy to do with the universal interface, the utility is based on rapid table look up.
Here is the neat thing about text8 symbols, use a well designed naming system and the frequent, short calls can take the shortest path to their entry point, often three steps, one to get to the shorties, and two selects one of four shorties. These are test and jump, almost instantaneous at our time frame.
Using the selecdtors for argument expansion:
macro(a,b) {
set = ./here; // anchors the local selector to arguments
mv set/a set/b; // console will pipe to mv, if it needs to
}
// Later
macro(./xchars, ./so/xchars); // works fine
The local anchor is set at top level to linux, as that is the only consistent user, linux and me. But if the methods are available, selectors can be typedefed to a symbol table selector, and in this case Default can set up a simple selector on the arguments laid out, right there in args list. We get a great new,flexible syntax and we solve a whole bunch of problems by promulgating symbol table interfaces and universal interface formats...
Why not use the dot, like Golang?
Like this: objec1.object2.method;
Great idea. ledt us make the leading dot free floating, set by an operator .. or ./ or //, introduce those and the top of dot can be re-assigned, floating, a pointer. So, arguments are:
local = ./here; // here understood.
then we have local.a and local.b picks up the arguments. We are c dudes snipper, we don't have interpreters, we like to free float the selector, re-anchor it.
Dot and slash:
Dot means, is an element, slash means is a subset of. With slash you may continue iterating on the selection obtained, with dot that is not guaranteed. The slash is a consistent iterator, in the expression. The dot adapts to the method selected.
No header needed when one snippet talks to another
Below is my tester snippet, it creates a command for xchars, snippet then has the console loop tokenize it, then directly calls for command search.
EntryType * Exec;
enum { NOTFOUND=0,CONTINUE,EXIT,QUIT,SUCCESS,ERROR};
int exec_cmd(int *argc,void * args[] ,char * src) {
char str[40];
strcpy(str,src);
memset(args[0],0,40);
int status;
args[0] = "Tokenize";
args[1] = str;
status=Exec(argc,args);
status=Exec(argc,args);
return(status);
}
int Test(int *argc,void * args[]) {
exec_cmd(argc,args,"NewConn conn;NewWin conn win");
return(SUCCESS);
}
So tester is freely talking across the Bus and all it knows is what it read in the Xchars user manual, it puts that in plain text, tokenizes and the rest is the miracle of fast symbol look up and universal bus interface. No headers, no interface conflict, got a problem? Check version match, but skip the friggen header stuff.
The only information console loop needs to share is NOTFOUND=0 and CONTINUE=1; If snippets know those two return codes, then anything can talk to them. The snippet is given the search command (Exec) entry point when loaded, every snippet has an Init. So, don't look anywhere, just start writing your snippet, it will work, no need to explain except the plain text part.
The only information console loop needs to share is NOTFOUND=0 and CONTINUE=1; If snippets know those two return codes, then anything can talk to them. The snippet is given the search command (Exec) entry point when loaded, every snippet has an Init. So, don't look anywhere, just start writing your snippet, it will work, no need to explain except the plain text part.
The system goal is to get all the symbol look up down to Log2(symbol size), then five step test and jumps get you 32 entry points per snippet. That set up is often faster than formatting the argument stack. Argc and args can generally be optimized out of the call set up from one snippet to the other.
EntryType * Exec;
enum { NOTFOUND=0,CONTINUE,EXIT,QUIT,SUCCESS,ERROR};
int exec_cmd(int *argc,void * args[] ,char * src) {
char str[40];
strcpy(str,src);
memset(args[0],0,40);
int status;
args[0] = "Tokenize";
args[1] = str;
status=Exec(argc,args);
status=Exec(argc,args);
return(status);
}
int Test(int *argc,void * args[]) {
exec_cmd(argc,args,"NewConn conn;NewWin conn win");
return(SUCCESS);
}
A few more things working
Multiple statements per line:
NewWin conn win1; NewWin conn win2; // Exec loop continues until line no more to do
Also verified I can have multiple modules loaded with no conflicts. I load a tester which pounds on xchars. The new double, (//,./,..) are such a breeze, knowing the syntax gets linux file names.
After I fix up xchars with string folding and fully test multiple threads as well as all the delete methods, then back to Default, finish that.
NewWin conn win1; NewWin conn win2; // Exec loop continues until line no more to do
Also verified I can have multiple modules loaded with no conflicts. I load a tester which pounds on xchars. The new double, (//,./,..) are such a breeze, knowing the syntax gets linux file names.
After I fix up xchars with string folding and fully test multiple threads as well as all the delete methods, then back to Default, finish that.
The universal interface and multi-threading
Easily done because every subsystem has a single universal interface. here is xchars mutex method. As soon as it it ready to execute, it protects state.
// Command arg1 rg2 ...
int Entry(int *argc, void *args[]) {
int status;
PSym enter;
pthread_mutex_t xchars_mutex;
if(!strcmp(args[*argc],"Init")) return(Init(argc,args));
printf("%s\n",(char *) args[*argc]);
enter = check_arg(args[*argc],entry_t,&status);
if(!status) return(0);
pthread_mutex_lock(&xchars_mutex);
enter->def.entry(argc,args);
pthread_mutex_unlock(&xchars_mutex);
return(1);
}
Currently testing NewWin and DelWin at high speed, make sure no memory leak. Xchars will make as many windows as you call, makes no effort to coordinate them except that they are attached to a connection.
// Command arg1 rg2 ...
int Entry(int *argc, void *args[]) {
int status;
PSym enter;
pthread_mutex_t xchars_mutex;
if(!strcmp(args[*argc],"Init")) return(Init(argc,args));
printf("%s\n",(char *) args[*argc]);
enter = check_arg(args[*argc],entry_t,&status);
if(!status) return(0);
pthread_mutex_lock(&xchars_mutex);
enter->def.entry(argc,args);
pthread_mutex_unlock(&xchars_mutex);
return(1);
}
Currently testing NewWin and DelWin at high speed, make sure no memory leak. Xchars will make as many windows as you call, makes no effort to coordinate them except that they are attached to a connection.
More testing
I have verified that the double ops get tokenized properly. (<< >> ++ --) and the new ones (// ./ ..) The new double ops are file object expressions (complete file names), although Default intends to expand the use of those operators into sub command namespace classifiers.
xchars loads properly, for example:
Load ./xchars; // Works fine ( I have not actually tested the semicolon terminator)
That is the Default syntax, so:
MyMacro() { // Lay out this macro definition
Load ./xchars;
Load ../hardly/stacks;
Load //home/loadables/sqlite;
}
MyMacro(); // Causes the actions above
That will eventually work fine. The default settings on this are not rreconfigurable, and the allowed chars on file names is a distinct set includes the asterisk. Room to just recompile and try different settings by changing the valid chars.
xchars loads properly, for example:
Load ./xchars; // Works fine ( I have not actually tested the semicolon terminator)
That is the Default syntax, so:
MyMacro() { // Lay out this macro definition
Load ./xchars;
Load ../hardly/stacks;
Load //home/loadables/sqlite;
}
MyMacro(); // Causes the actions above
That will eventually work fine. The default settings on this are not rreconfigurable, and the allowed chars on file names is a distinct set includes the asterisk. Room to just recompile and try different settings by changing the valid chars.
Saturday, December 29, 2018
The plot thickens
Forcing word alignment of string pointers
typedef union {
unsigned long l;
char * s;
void * lp;
} Val;
int main() {
struct {
char ch;Val v; } st;
printf("%x %x \n",&st.ch,&st.v);
}
Seems to work. Thus we should be able to assign packed chars directly onto a word.
unsigned long l;
char * s;
void * lp;
} Val;
int main() {
struct {
char ch;Val v; } st;
printf("%x %x \n",&st.ch,&st.v);
}
Seems to work. Thus we should be able to assign packed chars directly onto a word.
The wonders of the Bus
I have new xchars up on console loop, I can make screens.
But i can also write a small test program, with a universal interface, load it and it can run and pound on xchars, allowing me to use the c compiler to generate text and windows on my xchars screen. The process so simple that it defers the near term use of Default.
I exposed tokenizer to the Bus:
Tokenize(argc,args);
The first arg is the sting to tokenize. The tokens laid out immediately following on args list allowing the caller to immediately call another subsystem.
args[0]= "Tokenize";
args[1] = "PutStr rect \" Hello World \" ";
ExecCommand(argc,argv);
I can compile that in c, part of a small loadable for testing xchars. The real fast character graphics will always work with the tokens, never resorting to string. The args list can be recast as integer, simple enough. A great shared memory model.
Error recovery is a no brainer. Exec Command sets the long jump, and on error return it need only restore argc c to the the error and get a replacement statement. All of the console built ins work on args list, maintain its proper state.
But i can also write a small test program, with a universal interface, load it and it can run and pound on xchars, allowing me to use the c compiler to generate text and windows on my xchars screen. The process so simple that it defers the near term use of Default.
I exposed tokenizer to the Bus:
Tokenize(argc,args);
The first arg is the sting to tokenize. The tokens laid out immediately following on args list allowing the caller to immediately call another subsystem.
args[0]= "Tokenize";
args[1] = "PutStr rect \" Hello World \" ";
ExecCommand(argc,argv);
I can compile that in c, part of a small loadable for testing xchars. The real fast character graphics will always work with the tokens, never resorting to string. The args list can be recast as integer, simple enough. A great shared memory model.
Error recovery is a no brainer. Exec Command sets the long jump, and on error return it need only restore argc c to the the error and get a replacement statement. All of the console built ins work on args list, maintain its proper state.
A contraction
Swamped With Inventory, U.S. Companies Turn to ‘Mobile Storage’
The distribution has become unbalanced and unsettled, that is a non adiabatic change. Our economy is contracting, likely Q1 2019. It could be one of those Q1, 'go to zero dips', then a rebound in Q2. It my be as mild bump, not meeting blue bar standards. The key, watch California.
Truck trailers increasingly are being parked to hold goods as warehouses, logistics networks overflow
The distribution has become unbalanced and unsettled, that is a non adiabatic change. Our economy is contracting, likely Q1 2019. It could be one of those Q1, 'go to zero dips', then a rebound in Q2. It my be as mild bump, not meeting blue bar standards. The key, watch California.
Then the prior discussion leads too...
A slight simplification of tokenizer.
The new rue is that a file name is recognized by a ./ or / with no left operand. Tokenizer then just flushes the filename to a token of its own, like a quote., but with a hidden char for an operator., or a doble like the ++ and <<. Someway to identify a selector function for later evaluation. But I like the double slash:
// home /filename; // works exactly like the other doubles in token terms
This form is great because the selector identified easily captured and held uniquely. If I just picked the double slash right now, it removes about five lines of code, simply because all the rest, escaping and configuration, re required anyway.
And as a bonus, the double slash is recognized as top level by linux. So Default says, yes to any file name with the double forward slash. So I am going back to the original tokenizer, leave out escapes and configuration and just get file names through.
So, in the default cae, Default onlyaccepts the top level selector, it has no other methods, and the top level defaults to linux file directory. This adds a few lines of code, I skip the rest and I am back to where I was, deferring the other work to later. And that is why I do the default.
So, three days wasted? No, the experiment resulted in a point of convergence, one way or the other // will have meaning. So why not just introduce the double ops, and move on. Three days to discover the default selector syntax? Well worth it, Default is unlikely to be incompatible.
The other forms of selector would be ./ and ../; and linux pros can be able to live with that. Doing so makes file names a first class variable via the selector syntax.
Done, the double slash filename selector works in Default
// It is a first class operator. Works in LoadModule but later Default will define something for this besides pass thru. Escaping strings left out. The dash flag -f flag, left out, but that becomes a first class operator, maybe, dunno.
Load //home/so/xchars; // don't bother with extensions.
I can load Xchars and run Default, at the same time! Double ops token work, though not implemented in Default.
The new rue is that a file name is recognized by a ./ or / with no left operand. Tokenizer then just flushes the filename to a token of its own, like a quote., but with a hidden char for an operator., or a doble like the ++ and <<. Someway to identify a selector function for later evaluation. But I like the double slash:
// home /filename; // works exactly like the other doubles in token terms
This form is great because the selector identified easily captured and held uniquely. If I just picked the double slash right now, it removes about five lines of code, simply because all the rest, escaping and configuration, re required anyway.
And as a bonus, the double slash is recognized as top level by linux. So Default says, yes to any file name with the double forward slash. So I am going back to the original tokenizer, leave out escapes and configuration and just get file names through.
So, in the default cae, Default onlyaccepts the top level selector, it has no other methods, and the top level defaults to linux file directory. This adds a few lines of code, I skip the rest and I am back to where I was, deferring the other work to later. And that is why I do the default.
So, three days wasted? No, the experiment resulted in a point of convergence, one way or the other // will have meaning. So why not just introduce the double ops, and move on. Three days to discover the default selector syntax? Well worth it, Default is unlikely to be incompatible.
The other forms of selector would be ./ and ../; and linux pros can be able to live with that. Doing so makes file names a first class variable via the selector syntax.
Done, the double slash filename selector works in Default
// It is a first class operator. Works in LoadModule but later Default will define something for this besides pass thru. Escaping strings left out. The dash flag -f flag, left out, but that becomes a first class operator, maybe, dunno.
Load //home/so/xchars; // don't bother with extensions.
I can load Xchars and run Default, at the same time! Double ops token work, though not implemented in Default.
File names as iterators
The goal is to promote file naming convention to first class objects. Here is a proposal, the forward slash means: 'to iterate on':
home/me // me is a selection of home which is indexable.
/home // home is an iterator of the null set.
./file // An iteration on the current set
Then we have:
FILE * fin = /home/me/myfile.ext; // no quotes, and the name is parsed
The absolute pointer to fin found, up to but not including any change of state for fin. But, after the statement:
fopen(fin); // works fine
Then, of course, the iterator function predefined and typed elsewhere. Thus, the files module need only write iteration methods, the parsing and identifying of files pushed up to the syntax engine.
For namespace organization:
execl(/Xchars/OutString, rect, str); // works fine, no quote neede3d
I have redefined chars as a specific form of iterable set, wrote the methods. The method in this case is a sub table look up for each '/'. The last look up should reveal a terminal, executable at the linux level.
Or at the console loop:
./Xchars/OutSring rect "Hello World";
The process of identifying which form of the forward slash is context dependent according to typedef, relative precedence with expression operators, and syntax definition. The Default standard is that all selector/selected methods refer to a snippet, thus relieving the console loop of bloat. If no method is available, the default selector methods keeps the whole string and defers its parsing to places unknown down stream. Default thus has a restriction in its document: Default limits the use of thge general selector types to snippet accessable entry table. That is, all Default can select on is a list of entries in a module subdommand table. A restriction because Default restricts itself to default-like things, things that would happen if no module was loaded or no configuration applied. However, Default will support redirection of the selector function to another snippet entry point.
Snippet MySnippet;
home = /MySnippet/mysubcommand;
Or:
Snippet FILE;
FILE * = /Myroot/me/file; // works fine
Identify FILE as equivalent to a snippet. Then point to its method and parse the file name. In this case, the entry table for the FILE module is the directory itself. The name is tokenized up front, but Default knows what to do and on execution will directly sift through the file directory, unknowingly performing the ls function. It works because it is all driven from the same symbol table format implied in the universal interface.
The slash solves the command line macro problem:
Iter X = /Xchars; // Causes Default to look up the name Xchars and attach it to X
so:
X named_subcommand arg...; // X is expanded inside the Default interpreter.,
Xchars precedes the actual command on output. This works on default because of the common symbol table with ExecCommand, but it needs a few lines of code.
But his whole discussion is about introducing the iterator method in a form we already are destined to use anyway. Context specific use is not bad, easy for humans. We do the context specific with ++, <<; the doubles, we do it a bit with brackets and semi-colon. Let us reframe the forward slash, just use the file name syntax for all sort of set selection, like the python iterator.
Facts are facts, we are not giving up the linux file naming syntax, not me, you or anyone else, so just accept the forward slash generic iterator function; And, selection is is the most functional equivalent to divide in set theory anyway so the reuse of forward slash is intuitive.
home/me // me is a selection of home which is indexable.
/home // home is an iterator of the null set.
./file // An iteration on the current set
Then we have:
FILE * fin = /home/me/myfile.ext; // no quotes, and the name is parsed
The absolute pointer to fin found, up to but not including any change of state for fin. But, after the statement:
fopen(fin); // works fine
Then, of course, the iterator function predefined and typed elsewhere. Thus, the files module need only write iteration methods, the parsing and identifying of files pushed up to the syntax engine.
For namespace organization:
execl(/Xchars/OutString, rect, str); // works fine, no quote neede3d
I have redefined chars as a specific form of iterable set, wrote the methods. The method in this case is a sub table look up for each '/'. The last look up should reveal a terminal, executable at the linux level.
Or at the console loop:
./Xchars/OutSring rect "Hello World";
The process of identifying which form of the forward slash is context dependent according to typedef, relative precedence with expression operators, and syntax definition. The Default standard is that all selector/selected methods refer to a snippet, thus relieving the console loop of bloat. If no method is available, the default selector methods keeps the whole string and defers its parsing to places unknown down stream. Default thus has a restriction in its document: Default limits the use of thge general selector types to snippet accessable entry table. That is, all Default can select on is a list of entries in a module subdommand table. A restriction because Default restricts itself to default-like things, things that would happen if no module was loaded or no configuration applied. However, Default will support redirection of the selector function to another snippet entry point.
Snippet MySnippet;
home = /MySnippet/mysubcommand;
Or:
Snippet FILE;
FILE * = /Myroot/me/file; // works fine
Identify FILE as equivalent to a snippet. Then point to its method and parse the file name. In this case, the entry table for the FILE module is the directory itself. The name is tokenized up front, but Default knows what to do and on execution will directly sift through the file directory, unknowingly performing the ls function. It works because it is all driven from the same symbol table format implied in the universal interface.
The slash solves the command line macro problem:
Iter X = /Xchars; // Causes Default to look up the name Xchars and attach it to X
so:
X named_subcommand arg...; // X is expanded inside the Default interpreter.,
Xchars precedes the actual command on output. This works on default because of the common symbol table with ExecCommand, but it needs a few lines of code.
But his whole discussion is about introducing the iterator method in a form we already are destined to use anyway. Context specific use is not bad, easy for humans. We do the context specific with ++, <<; the doubles, we do it a bit with brackets and semi-colon. Let us reframe the forward slash, just use the file name syntax for all sort of set selection, like the python iterator.
Facts are facts, we are not giving up the linux file naming syntax, not me, you or anyone else, so just accept the forward slash generic iterator function; And, selection is is the most functional equivalent to divide in set theory anyway so the reuse of forward slash is intuitive.
Our price for the intelligent tokenizer
My version is coming in at 120 lines of code, not likely to grow much or shrink much. The swapping between file name mode and expression mode was easy, it was dealing with four extra possibilities of op code strings, adding the quoting/ escaping function, and then the configuration function. Enugh hooks to get bu for a couple of console versions without a major rewrite. But, as always, consider this a cutnpste reference, and look to other solutions. Look before leaping, we are setting a standard for snippet authors for years to come, it is an interactive process.
I integrated the new tokenizer with console loop and posted it, untested, uncompiled, on the right side under links.
I integrated the new tokenizer with console loop and posted it, untested, uncompiled, on the right side under links.
OK, then quasars
The complexity is no longer supportable by a rank 3 system. The bits of vacuum find symmetry with an equivalent rank 5 complexity graph, they five color. Essentially, in the furnace, the spatial sampling is greatly aliased and the number of significant side lobes goes from 2 to 4, plus the center. The side lobes get quantized, a huge gravitation ripple occurs locking them in state.
We get pentarks, a pentuple of quarks that cannot be separated except by degeneration to a three color. But, there has to be a limit, dunno but I would think the quasar is the limit. The capability of the vacuum has to be a small dimensional number, removing the symmetric cases, I would think five or seven.
We get pentarks, a pentuple of quarks that cannot be separated except by degeneration to a three color. But, there has to be a limit, dunno but I would think the quasar is the limit. The capability of the vacuum has to be a small dimensional number, removing the symmetric cases, I would think five or seven.
OK, so how does the vacuum compute distance
The vacuum uses counts instead of meters. The axis is symmetry for a motion is the perpendicular where the 'particles' all stay with a specific 'action count' or a factor of the 'fundamental action' count, where count is in the Planks sense of actions are with counts. That is why string theory ends up with vibrating strings, they vibrations are counts, and coherent counts relative to an axis it what constitutes the L spots. This brings us back to abstract algebra and groups,rings and fields as my college text called it. But, in general is is queuing theory, the vacuum queues up a bit, congests. We use the expansion of space time to describe it in a metaphor so the engineers can relate to their graph paper. But is is simple the bits of vacuum sometimes ends up waiting a bit longer to register their count.
To see the queuing effect watch stocks. A few months back I posted the Huffman graph of the SP500 over a ten year period. The period was a stable trend up with two major down turns and recoveries. The Huffman tree shows the two glitches as an unbalanced tree, not all price settings had equal probability. Ex post, the market maker designing the queues for this market would have those traders with large, rare trades having to go an extra step in the queue. But those traders with the small, more frequent trades get two fewer steps in the queue. The market maker, ex post, performed a trick of relativity, he gave those more frequent trades an extra degree of symmetry, their job job is to hang around the stock market store wandering the shelves, waiting to hedge the longer term, riskier trader, keep him/her backed up in line.
The queue is maintained by counts, counting the queue size, but it appears as distance, more count the longer the distance from start to finish. That is us, in our heads, using the convenience of Newton's grammar, ex post. Complexity seems like a longer distance traveled, go ask the traveling salesman.
To see the queuing effect watch stocks. A few months back I posted the Huffman graph of the SP500 over a ten year period. The period was a stable trend up with two major down turns and recoveries. The Huffman tree shows the two glitches as an unbalanced tree, not all price settings had equal probability. Ex post, the market maker designing the queues for this market would have those traders with large, rare trades having to go an extra step in the queue. But those traders with the small, more frequent trades get two fewer steps in the queue. The market maker, ex post, performed a trick of relativity, he gave those more frequent trades an extra degree of symmetry, their job job is to hang around the stock market store wandering the shelves, waiting to hedge the longer term, riskier trader, keep him/her backed up in line.
The queue is maintained by counts, counting the queue size, but it appears as distance, more count the longer the distance from start to finish. That is us, in our heads, using the convenience of Newton's grammar, ex post. Complexity seems like a longer distance traveled, go ask the traveling salesman.
Tokenizer and macro expansion on the command line
The two are relted, it seems to me. Macro expansion, direct substitution of arguments when enabled, happens on input of command line, not the output of a syntax engine. The syntax engine has access tto the console macro table, and sets up argument macros prior to use, available on input. Since the attached syntax egine is in console loop address space, it should be able to substitute its own macro expansion call, turning the function off in console loop.
But, in either case, the console loop is out of the process, this again defuatlts to tokenizer functionality. The answer to the puzzle will come as we attempt to run our snippets we will discover what works and what doesn't. Default assumes their is some level of macro expansion in tokenizer on start up. How, I dunno, yet. Which is why I hesitate to take Default too far, it uses the default settings, and those are decided by snippet authors.
My guess on snippet authors is that they would rather do their own symbol look up in input, the way Xchars does it. In that case,the console loop table is available, and can be managed by Default, if the requirements are simple. A macro capability tied to the peculiar semantics of the snippet make sense. We are better making a multi-functional symbol table function available as a separate snippet, loadable and swappable, on the Bus.
But, in either case, the console loop is out of the process, this again defuatlts to tokenizer functionality. The answer to the puzzle will come as we attempt to run our snippets we will discover what works and what doesn't. Default assumes their is some level of macro expansion in tokenizer on start up. How, I dunno, yet. Which is why I hesitate to take Default too far, it uses the default settings, and those are decided by snippet authors.
My guess on snippet authors is that they would rather do their own symbol look up in input, the way Xchars does it. In that case,the console loop table is available, and can be managed by Default, if the requirements are simple. A macro capability tied to the peculiar semantics of the snippet make sense. We are better making a multi-functional symbol table function available as a separate snippet, loadable and swappable, on the Bus.
Friday, December 28, 2018
Tokenizer and quoted strings
Quoted strings are de-escaped in place. The leading quote is left attached, though this might change. That is currently the default format. All variables names and string constants are null terminated, in the current address space by tokenizer. Just going over quote rules a bit looking at the code. Defaul always assumed he leading quote remained. Most application prefer this, it identifies the current null terminated string as possibly having spaces,commas, quotes, whatever, a nice warning to have.
Tokenizer remains bloated though I keep working it better. Bu here is where we want to invest effort, here is what attracts authors of snippets, the idea that their arguments come neatly arranged in an array with pointer. I would like to hear what the iPythoin folks think, they deal with exactly the same issue. But a solid, conrollable tokenizer, up front, that is ideal for snippets, a real productivity tool.
I dropped the latest version below the fold.
The Hardly plan remains, a full 64 bit high speed stack machine available as a byte code on the bus. It executes stack operations right from args list, built for that. It has full stack rate, stack based objects, and built in, configurable, shunt for converting your emperitives to rpn notation. Default is 95% though testing, the syntax not operational, console loop is fine. The plan is to connect up Default an Xchars fr final testing of both.
Tokenizer remains bloated though I keep working it better. Bu here is where we want to invest effort, here is what attracts authors of snippets, the idea that their arguments come neatly arranged in an array with pointer. I would like to hear what the iPythoin folks think, they deal with exactly the same issue. But a solid, conrollable tokenizer, up front, that is ideal for snippets, a real productivity tool.
I dropped the latest version below the fold.
The Hardly plan remains, a full 64 bit high speed stack machine available as a byte code on the bus. It executes stack operations right from args list, built for that. It has full stack rate, stack based objects, and built in, configurable, shunt for converting your emperitives to rpn notation. Default is 95% though testing, the syntax not operational, console loop is fine. The plan is to connect up Default an Xchars fr final testing of both.
A matter of market collusion
One has to ask whether getting the central bank involved with the pension mess is a good idea. Ned just concerned a market conclusion group, I hear. Roger Farmer likes the idea, corporations are more efficient than government.
Ned cannot get clue, the slugging will continue until moral improves. The problem is all eyes are focused on what the mark to market will be on pension costs, another reason for the collusion, end of the year accounting. Investors would be especially nervous with Gavin in the hot seat, and Calpers being ion the edge of gigantic in market weight. California has suddenly become the point of uncertainty, especially the South.
No one wants to bring back a 127 year old Jerry to convene the board of elders.
Ned cannot get clue, the slugging will continue until moral improves. The problem is all eyes are focused on what the mark to market will be on pension costs, another reason for the collusion, end of the year accounting. Investors would be especially nervous with Gavin in the hot seat, and Calpers being ion the edge of gigantic in market weight. California has suddenly become the point of uncertainty, especially the South.
No one wants to bring back a 127 year old Jerry to convene the board of elders.
Xchars, the plan
The current untested feature of significance is folding strings inside their rectangles, a subject of some complexity. Default uses the default fold settings, but it has not been implemented.
Beyond that, the plan is to convert the naming of text methods to double text8, two words, each having 8 chars. Tha only adds one step in look up, and removes a conversion step on input, things will speed dramatically, good enough for game dynamics based on character graphics.
Then I still have to tset fonts and colors,but otherwise, the symbol table and xcb interfacer seems solid, as does the mapping of arguments. I am not working on it, at the moment is the problem.
Beyond that, the plan is to convert the naming of text methods to double text8, two words, each having 8 chars. Tha only adds one step in look up, and removes a conversion step on input, things will speed dramatically, good enough for game dynamics based on character graphics.
Then I still have to tset fonts and colors,but otherwise, the symbol table and xcb interfacer seems solid, as does the mapping of arguments. I am not working on it, at the moment is the problem.
One to ten at 14 basis points
The long slope. The cost of trading, we found a few years ago, was 15 basis points. Wall Street is packed with volunteers at the moment.
A flat curve is like a flat spectrum, unsustainable without energy input. The risk of trading the small things, more frequently, is higher than the risk of doing fewer, but larger, trades. It cannot last, we do not have the energy,the productivity.
A flat curve is like a flat spectrum, unsustainable without energy input. The risk of trading the small things, more frequently, is higher than the risk of doing fewer, but larger, trades. It cannot last, we do not have the energy,the productivity.
Not quite
Angela Merkel: Nation States Must "Give Up Sovereignty" To New World Order
I think we be giving up our sovereignty to a dense web of bots crawling the graph of knowns.
Angela is going to be a problem regarding pure digital cash, she will be a big obstacle.
Angela is going to be a problem regarding pure digital cash, she will be a big obstacle.
Then is light constant?
What we know is that the engineer needs an infinitely divisible X axis on his graph paper. Infinitely divisible means that unit always samples the other units with perfect clarity, no aliasing. That is a necessary condition for using graph paper and assuming rectangularity.
Now I stretch my assumptions, but it seems to me the physicist could have chosen another X axis, say say momentum, and said the exact speed of light was known only to planks constant, but momentum could always be keptin proper order underinfinite subdivision.
I would think the proper answer is, the unit of vacuum offer a finite dimensional superposition of all passages, and their total is constant relative to a mutli dimensional coordinate axis. But in our less compressed world, we never see more than a three dimensional superposition, except possiblly on some rare occasions when some transmissions seem too fast.
Now I stretch my assumptions, but it seems to me the physicist could have chosen another X axis, say say momentum, and said the exact speed of light was known only to planks constant, but momentum could always be keptin proper order underinfinite subdivision.
I would think the proper answer is, the unit of vacuum offer a finite dimensional superposition of all passages, and their total is constant relative to a mutli dimensional coordinate axis. But in our less compressed world, we never see more than a three dimensional superposition, except possiblly on some rare occasions when some transmissions seem too fast.
The world has confidence in our millennials
Russia Blames Fed Interest Hike For Low Oil Prices
Our young kids are not like French millennials,always griping about paying someone else's interest charges. Our kids say, "yea, pile it on, I was never planning on spending that do-re-me anyway".
Life restored
Tokenizer working as usual again, have not yet tested file naming. Default treats the forward slash as just another valid variable character. Default should probably treat is with a special file methods built in, bu hat is another day.
How much spaghetti? I don't know yet, right now every single special character test is configurable, except double character like ++,--; those wait version 3. So it is wa over defined, I did lot of copy and replicates.
The next step is to try t in real live situations, like loading Xchars with a complete filename path. hat is what failed a day ago.
Let's dump extensions on loadables. Skip the part about gleaning information from the file name, if we want to know when a file name leads to a loadable, then load it. The definition of loadable is,"Has the universal interface". The load will fail immediately when the interface is not present.
Xchars version; // returns the version number
The namespace has a rule, the module with some name ets that name as a sub command spot. Otherwise, it is every module for themselves on fighting for namespace, and getting first on the search list. The solution to that problem comes from somewhere else, the best console loop can do is maintain some key values in module symbol entry. Otherwise it remains clueless.
How doesthe user see tokenizer?
When console loop fresup, with Default off, then there is no syntax except valid linux commands, file names pass through always, every thing works. Then you enable de3fault, but it is notinvokded, everything is fine.
Then you enable Default:
Default; // start deault
Then the following rule applies, the default condition at the start of each 'newline' is filenames allowed util an expression char arrives. At that point the mode is switched to expression names and not reset to file names until end of line. Any syntax engine that wants to switch back and forth, each line, is in violation.
How much spaghetti? I don't know yet, right now every single special character test is configurable, except double character like ++,--; those wait version 3. So it is wa over defined, I did lot of copy and replicates.
The next step is to try t in real live situations, like loading Xchars with a complete filename path. hat is what failed a day ago.
Let's dump extensions on loadables. Skip the part about gleaning information from the file name, if we want to know when a file name leads to a loadable, then load it. The definition of loadable is,"Has the universal interface". The load will fail immediately when the interface is not present.
Xchars version; // returns the version number
The namespace has a rule, the module with some name ets that name as a sub command spot. Otherwise, it is every module for themselves on fighting for namespace, and getting first on the search list. The solution to that problem comes from somewhere else, the best console loop can do is maintain some key values in module symbol entry. Otherwise it remains clueless.
How doesthe user see tokenizer?
When console loop fresup, with Default off, then there is no syntax except valid linux commands, file names pass through always, every thing works. Then you enable de3fault, but it is notinvokded, everything is fine.
Then you enable Default:
Default; // start deault
Then the following rule applies, the default condition at the start of each 'newline' is filenames allowed util an expression char arrives. At that point the mode is switched to expression names and not reset to file names until end of line. Any syntax engine that wants to switch back and forth, each line, is in violation.
So what is the fabric of space-time?
It is the rectngular graph paper on the engineers desk, that is space time, time on horizontal and space on vertical. Newton defined the conditions in which order is preserved as the engineer gets more and more granular graph paper. If the engineer meets the conditions, he can use rectangular graph paper.
The physicists have to deal with a divide by zero violation:
1/(Vl-Va), something on the bottom goes to zero when a physical object approaches the maximum speed. In the limit, the space-time rules will not work, by definition of mass. Physicists defined mass to be point source, and speed limited; a conflict.
So, simple enough, make it not a violation by presupposing another hidden symmetry of motion, then along that perpendicular, mass has space to move and can be treated as a point source again. They factor this four dimensional operator, the tensor, which adjusts the equation to provide the additional motion that avoids the divide by zero. The polynomial degree jumps, like adding a pretend force. That pretend symmetry is the odd orbit of Mercury, which we can see.
From the engineers point of view, his graph paper will bulge a bit, and slightly rotate to always present the current center point as rectangular.
Is the hidden point of symmetry real? It sure is, if you assume bits of vacuum having interactions. Which is why all the unifying theory come out as making he vacuum a finite dimensional vibrator. The outcome is that mass is squashed vacuum.
I put a copy blow the fold, and you can see it got bloated badly. Much of that bloat will slowly be removed.
The physicists have to deal with a divide by zero violation:
1/(Vl-Va), something on the bottom goes to zero when a physical object approaches the maximum speed. In the limit, the space-time rules will not work, by definition of mass. Physicists defined mass to be point source, and speed limited; a conflict.
So, simple enough, make it not a violation by presupposing another hidden symmetry of motion, then along that perpendicular, mass has space to move and can be treated as a point source again. They factor this four dimensional operator, the tensor, which adjusts the equation to provide the additional motion that avoids the divide by zero. The polynomial degree jumps, like adding a pretend force. That pretend symmetry is the odd orbit of Mercury, which we can see.
From the engineers point of view, his graph paper will bulge a bit, and slightly rotate to always present the current center point as rectangular.
Is the hidden point of symmetry real? It sure is, if you assume bits of vacuum having interactions. Which is why all the unifying theory come out as making he vacuum a finite dimensional vibrator. The outcome is that mass is squashed vacuum.
I put a copy blow the fold, and you can see it got bloated badly. Much of that bloat will slowly be removed.
Boomers trapped in LA
Southern California home sales plunged in November from a year earlier, while prices increased at the slowest pace in three years amid a housing market slowdown, reported Los Angeles Times. The 12% decline in November sales from a year earlier was the fourth consecutive monthly drop for the eight southern counties, including Imperial, Los Angeles, Orange, Riverside, San Bernardino, San Diego, Santa Barbara, and Ventura.
A batch of boomers missed an opportunity to sell high and run off to Arizona.
New tokenizer runs
Probably not correctly, yet. I just need to know the configuration goes through is paces, and the default configuration works for Default. So, we now we will have some sort of ability to pass through file names properly.
Let's talk relatively
When we say the speed of light is constant everywhere, then we, in sample data tersms, that the sample spectrum of light is infinite, or in number theory, divide works, one can always crank a divide to enough significance.
That means that ordering is always preserved, two points retain the same relative order no matter how long you crank the divide machine. That induce Isaac to consider cases where one can crank the divide machine and show that the difference between two points converge, thus allowing us to consider summations that always converge, and their properties. Isaac called that calculus.
One of the out comes of calculus is that surface without inward information can be represented as a point source. And that idea fields the sun as a point source of gravity, and the gravity equation was born, built because the change in gravity is always transmitted at a constant rate, the divide machine always get a significant answer with enough cranks.
Constant means any point can reference itself to a perfectly unchanging number, so all points maintain their relative references via the constant. True for the gravitation constant, if you preserve ordering you are demanding a constant somewhere, a point of symmetry to do the algebra.
Now standard gravity tidal forces are not relativity, they can still use the newtonian gravity equation by reconstructing one body as a set of bodies, granular enough so that their relative ordering is within the constant.
Another outcome of the point source and constant system is that, in gravity, we get L points of symmetry, that spot between two bodies where the force of gravities cancel. Still an outcome of Newtonian calculus, one can rewrite the equations from the point of view of an L spot, the two point source look stable.
Relativity is a product of mass, mass is the condition that a body cannot travel faster that light, that means a mass under samples light. Mass exists because the vacuum has finite sampling bandwidth. What happens inside Mercury the planet when it travels a bit closer to the speed of light? Mass develops side lobes, spatially, in some fixed configuration that depends on total energy. The L spot tends to wobble in 3D space, Newton no longer works, until we add another dimension for the ordering. Thus, in all four dimensions, the L1 is stable, and Newton restored, we can do calculus, but that fourth dimension has to be found, by the mathers, first. It is a mathematical construct, designed to capture and stabilize the L spot.
From out 3d point of view, it appears the l spot is wobbling, an impossibility in Newtonian, it means there is no convergent position for the L spot, math will not work. Einstein painstakingly went though the dimensional analysis to point toward the standard method of defining the fourth dimension to restor the L spot bak to convergence. Along that dimension, one can infinite resolve the position of the L spot so its relative ordering remains.
Understanding the point of view of side lobes is what unifies gravity and the standard theory, they are both born of the same limitation, mass defines points to be a bit spread. Everything abut mass, from its inception in the heat of compression, to its gravity property all boil down, mathematically, to an under sampling problem. Quarks are quantized side lobe from severe under sampling.
In relativity we add another mathematical dimension to restore the perpendicular property, essentially finding the point of symmetry about which the wobble of L spots occur, so as to apply the canceling term. Along the perpendicular, divide works, that is the definition of divide actually.
OK, so we compress and compress and reach a point where restoring the L spot to its symmetry means it exists inside the surface, we get black hole. But, the vacuum is finite dimensional, five at best gets you a quasar for some time, but I think they are unstable. That is why we get quarks, Einsteins little trick fails, the bits of vacuum do not have enough structure, in this universe, to hold all the terms Einstein needs. So the bits of vacuum are aliased, their surfaces deform inward dents that fail Newtonian's assumption, and they get stuck there.
The assumption of Einstein, noting is faster than light coupled with Planks constant, mass under samples and has spread spectrum; those two are related.
Is gravity real? First, meeting the Newtonian assumption means our view of gravity is point source in 3D. The second outcome of Newton is that we can construct forces in 3D because we have 3D perpendiculars over which divide works. I all of this we have never left the realm of mathematics. Thus, the math predicts that we will see a point source and call that a center of gravity emitting a force.
The reality is that entropy always seems to increase meaning redundant motion is always removed. The universe sphere packs, bit of vacuum seek to minimize the number of interactions needed to limit stay 'whole'. Thus, over the evolution, maximizing entropy predicts 3D points of illusionary symmetry about which redundant interactions are minimized. As if the bits of vacuum listened to Einstein and are trying their best to stabilize the L spots.
So, if the bits of vacuum have finite bandwidth then how can light be constant? Because we set that to be a point of symmetry, by definition. We say, time is the point of symmetry along the basic perpendicular ta the first dimension. That is, if we want to be Newtonian, then we can do that. But spend tome time within Planks constant and find that ordering is not preserved, as Plank would tell us. But, in any dimension less than than the dimensional capability of the Vacuum, there will be a point of symmetry about which light can be assumed constant. If light is wobbling, it is because there is some dimensional history in the vacuum, some rememberance of the furnace.
Consider quantum weirdness, the property that particles can transmit their spin state faster than light,it seems. Why did we conclude that? Because the equations of physics obey Newton's law in a 3D world and relativity cannot solve the paradox. The physucus assumes energy is conserved in the system, yet the light spins seem to group themselves, consuming energy. There seems to be a hidden point of symmetry, they nicknamed it the quantum field. The name implies we are seeing a collapsed view, in fact the bits of vacuum do sometimes find symmetry about a fourth dimension, a hidden law of physics. In reduced dimensions, no point of symmetry, energy not conserved, Newton fails, divide has a repeating remainder. light is constant in the totality of all the dimensionality supported by the vacuum.
That means that ordering is always preserved, two points retain the same relative order no matter how long you crank the divide machine. That induce Isaac to consider cases where one can crank the divide machine and show that the difference between two points converge, thus allowing us to consider summations that always converge, and their properties. Isaac called that calculus.
One of the out comes of calculus is that surface without inward information can be represented as a point source. And that idea fields the sun as a point source of gravity, and the gravity equation was born, built because the change in gravity is always transmitted at a constant rate, the divide machine always get a significant answer with enough cranks.
Constant means any point can reference itself to a perfectly unchanging number, so all points maintain their relative references via the constant. True for the gravitation constant, if you preserve ordering you are demanding a constant somewhere, a point of symmetry to do the algebra.
Now standard gravity tidal forces are not relativity, they can still use the newtonian gravity equation by reconstructing one body as a set of bodies, granular enough so that their relative ordering is within the constant.
Another outcome of the point source and constant system is that, in gravity, we get L points of symmetry, that spot between two bodies where the force of gravities cancel. Still an outcome of Newtonian calculus, one can rewrite the equations from the point of view of an L spot, the two point source look stable.
Relativity is a product of mass, mass is the condition that a body cannot travel faster that light, that means a mass under samples light. Mass exists because the vacuum has finite sampling bandwidth. What happens inside Mercury the planet when it travels a bit closer to the speed of light? Mass develops side lobes, spatially, in some fixed configuration that depends on total energy. The L spot tends to wobble in 3D space, Newton no longer works, until we add another dimension for the ordering. Thus, in all four dimensions, the L1 is stable, and Newton restored, we can do calculus, but that fourth dimension has to be found, by the mathers, first. It is a mathematical construct, designed to capture and stabilize the L spot.
From out 3d point of view, it appears the l spot is wobbling, an impossibility in Newtonian, it means there is no convergent position for the L spot, math will not work. Einstein painstakingly went though the dimensional analysis to point toward the standard method of defining the fourth dimension to restor the L spot bak to convergence. Along that dimension, one can infinite resolve the position of the L spot so its relative ordering remains.
Understanding the point of view of side lobes is what unifies gravity and the standard theory, they are both born of the same limitation, mass defines points to be a bit spread. Everything abut mass, from its inception in the heat of compression, to its gravity property all boil down, mathematically, to an under sampling problem. Quarks are quantized side lobe from severe under sampling.
In relativity we add another mathematical dimension to restore the perpendicular property, essentially finding the point of symmetry about which the wobble of L spots occur, so as to apply the canceling term. Along the perpendicular, divide works, that is the definition of divide actually.
OK, so we compress and compress and reach a point where restoring the L spot to its symmetry means it exists inside the surface, we get black hole. But, the vacuum is finite dimensional, five at best gets you a quasar for some time, but I think they are unstable. That is why we get quarks, Einsteins little trick fails, the bits of vacuum do not have enough structure, in this universe, to hold all the terms Einstein needs. So the bits of vacuum are aliased, their surfaces deform inward dents that fail Newtonian's assumption, and they get stuck there.
The assumption of Einstein, noting is faster than light coupled with Planks constant, mass under samples and has spread spectrum; those two are related.
Is gravity real? First, meeting the Newtonian assumption means our view of gravity is point source in 3D. The second outcome of Newton is that we can construct forces in 3D because we have 3D perpendiculars over which divide works. I all of this we have never left the realm of mathematics. Thus, the math predicts that we will see a point source and call that a center of gravity emitting a force.
The reality is that entropy always seems to increase meaning redundant motion is always removed. The universe sphere packs, bit of vacuum seek to minimize the number of interactions needed to limit stay 'whole'. Thus, over the evolution, maximizing entropy predicts 3D points of illusionary symmetry about which redundant interactions are minimized. As if the bits of vacuum listened to Einstein and are trying their best to stabilize the L spots.
So, if the bits of vacuum have finite bandwidth then how can light be constant? Because we set that to be a point of symmetry, by definition. We say, time is the point of symmetry along the basic perpendicular ta the first dimension. That is, if we want to be Newtonian, then we can do that. But spend tome time within Planks constant and find that ordering is not preserved, as Plank would tell us. But, in any dimension less than than the dimensional capability of the Vacuum, there will be a point of symmetry about which light can be assumed constant. If light is wobbling, it is because there is some dimensional history in the vacuum, some rememberance of the furnace.
Consider quantum weirdness, the property that particles can transmit their spin state faster than light,it seems. Why did we conclude that? Because the equations of physics obey Newton's law in a 3D world and relativity cannot solve the paradox. The physucus assumes energy is conserved in the system, yet the light spins seem to group themselves, consuming energy. There seems to be a hidden point of symmetry, they nicknamed it the quantum field. The name implies we are seeing a collapsed view, in fact the bits of vacuum do sometimes find symmetry about a fourth dimension, a hidden law of physics. In reduced dimensions, no point of symmetry, energy not conserved, Newton fails, divide has a repeating remainder. light is constant in the totality of all the dimensionality supported by the vacuum.
Thursday, December 27, 2018
How is the new tokenizer?
I have the code done, starting test. The design is all driven by the current set of punctuation list and the client can =swap out those operator lists. There are a couple of operator strings, the eol strings identifies the end of line markers. Then we have expr marks as well as file name marks and expression marks, all four can be set independently in one call using a mask and a list of stings pointers. I use loadable address space, so in fact, the client can actually change them independent of a console command.
Call this version 2 of the intelligent tokenizer, and wait until version 3 before concluding it works completely. I need another day of test for the version 2. The double ops (--, ++, += ,-= ,/= ,*=.>>,<<, &&.||) are not working yet. I have no figured out the double ops yet.
It is not glamorous work, not like Hardly working.
Call this version 2 of the intelligent tokenizer, and wait until version 3 before concluding it works completely. I need another day of test for the version 2. The double ops (--, ++, += ,-= ,/= ,*=.>>,<<, &&.||) are not working yet. I have no figured out the double ops yet.
It is not glamorous work, not like Hardly working.
Environmentalists caused the pollution
Efforts to limit pollution by building housing near transit centers meet stiff resistance
It was California environmentalists who built useless transit centers in the first place. They built these expensive and worthless transit system for the explicit intent of causing more, not less, global warming. The original design was about giving the liberal political class clean, public ride to work,l energy efficiency came in about third place in these designs. Now California is stuck with the most energy inefficient transportation. Cal environmentalists cause more global warming. Then they want an inflation adjustment in their public salaries, to cover the increased cost of energy.
When an engine like iPython uses the tokenizer
The console loop knows then we are in syntax mode and will not reset the args list and the default syntax engine immediately gets the tokenized result, but it is still tokenized. The syntax can check its own rules for line continuation or filenames and set the tokenizer controls appropriately, then call its own parsing routine. On first start, like :
Python with starting statements; // Python knows this is first time activated
Thus, on start and on each line, the Python manager can set the tokenizer controls.
Python with starting statements; // Python knows this is first time activated
Thus, on start and on each line, the Python manager can set the tokenizer controls.
Stocks down, oil down
Stocks down another 3%. So, yesterday, pension funds had to crowd the market due to synchronous regulatory demands, and the next day, congest is gone, and prices down. The pension funds paid an additional cost of 1% for that stunt.
On the margin, we want oil at about $60 to save the frackers, otherwise we get bad and sudden layoffs, a possible recession. Oil is $45 and dropping, the frackers will take a dive. This is important because fracking was a big employment driver for about two years, after the stimulus drove oil prices back above $100 in 2010.
Cities in CA are taking a big pension hit, there will be layoffs. Oil cities in Tx are taking a big hit, there will be layoffs. Together they are a tipping point I fear. The rather sudden drop in oil should drive us to almost negative inflation for at least a quarter, causing a compound effect on debt costs. I do not consider this a crash, yet, but that point seems to be a lot closer today. Another 5% market drop and we are in deep doo doo.
The one,two, and five year points on the treasury curve are still contracted, so banking will have to hit the brakes, issue some lay offs. The mass layoffs will start to pile up, and we crash.
The one,two, and five year points on the treasury curve are still contracted, so banking will have to hit the brakes, issue some lay offs. The mass layoffs will start to pile up, and we crash.
My tokenizer rule on filenames
The tokenizer recognizes end of statement as either a semi or a new line. After end of statement, filenames are first class. If an equals or left parenth is encountered, then filename characters change and filenames will be split along the forward slash char. I can force Default to live with that. So:
Load /home/so/xchars; // works fine
Load = /home/so/; // fails; attempts the divide
Load = "/home/so "; // works fine
Load (/home/so); // fails, filename treated as argument expression.
./a.out; // Works in default mode, console will pipe to execl if all else fails
In the last case, piping can be turned off and excl can be turned off.
In addition, the tokenizer should recognize standard escaped sequences inside quoted text, unless told not to.
Our architecture has created the need for a smart tokenizer with command line token rules good for both syntax engine and linuxfile format. All the syntax engines should agree on what ends a statement and what starts an expression inside a statement. The tokenizer makes a quick check on mode, and in defuult at the start, then duplicates code to minimize steps. There should be no speed impact. Otherwise, the syntax engine needs to configure the tokenizer. Default uses the tokenizer default mode.
I am spending the day working on just the tokenizer, and not the first time. Pull it out and blast it with text strings until all the possibilities work. I expect another29 50 lines of code on tokenizer, if I count what we need to set the console token controls. . It is going to be a tad slower with an extra checks per char.
Load /home/so/xchars; // works fine
Load = /home/so/; // fails; attempts the divide
Load = "/home/so "; // works fine
Load (/home/so); // fails, filename treated as argument expression.
./a.out; // Works in default mode, console will pipe to execl if all else fails
In the last case, piping can be turned off and excl can be turned off.
In addition, the tokenizer should recognize standard escaped sequences inside quoted text, unless told not to.
Our architecture has created the need for a smart tokenizer with command line token rules good for both syntax engine and linuxfile format. All the syntax engines should agree on what ends a statement and what starts an expression inside a statement. The tokenizer makes a quick check on mode, and in defuult at the start, then duplicates code to minimize steps. There should be no speed impact. Otherwise, the syntax engine needs to configure the tokenizer. Default uses the tokenizer default mode.
I am spending the day working on just the tokenizer, and not the first time. Pull it out and blast it with text strings until all the possibilities work. I expect another
Wednesday, December 26, 2018
Tokenizer and filename!!
The new bug introduced by the new Default architecture. The console loop really needs prohibited chars from names, but that list grows large. o what about the dots and dashes in file names? Hmmm... Now I am back to ponder.
Somethings I know, everyone will want the dot as part of a name file or variable, no problem there. Separating the dot is optional, and default is that is dots are parts of names. I would prefer leaving slashes out of the picture; and I hat quotes especially when filenames are considered self quoting.
Still pondering. On the command line, file names are first class objects, don't need quoting. Inthe syntax engines they are always quoted. So in default mode, Derfault would treat:
ls /home
as ls divided by home, and attempt that. IPython has similar problems,. trying to embed a syntax into thee command line. I am thinking a smart tokenizer, one that knows when to tokenize the filename and when to not.
Tokenize rule
All the new apps will follow the standard tokenizer rule on this, they want their arguments in neat linear arrays. yntacengines andgeneral purpose tokenizers can cooperatel, via tokenizer control words and some common sense.
This violation I remember well:
gcc -fmax-erros=4 ./myfile.c
That cause an equals to appear before the file name in a sequence, to difficult for tokenizer. Note the dash is another problem. The distinguisher is the equals sign, if both engines and snippets could at least start there, leave out the equals unless you really mean it.
The other healer is the syntax mode the console lop is in because syntax engines can load tokenizer controls, or turn it off. But if the syntax engines shut tokenizer off, then we get a host of complaints from snippet authors. We need an intelligent method so filenames are always first class, without conflict.
A problem, not a sow stopper and we can attack it little by little as it becomes a problem. Default says the tokenizer can use the equals flip flop. Tokenizer recognizes start of statement and will, upon seeing the equals, begin tokenizing filenames until end of statement.. Tokenizer agrees, the two bots met, hashed out. That plus whatever tokenizer conrols e can make available.
Somethings I know, everyone will want the dot as part of a name file or variable, no problem there. Separating the dot is optional, and default is that is dots are parts of names. I would prefer leaving slashes out of the picture; and I hat quotes especially when filenames are considered self quoting.
Still pondering. On the command line, file names are first class objects, don't need quoting. Inthe syntax engines they are always quoted. So in default mode, Derfault would treat:
ls /home
as ls divided by home, and attempt that. IPython has similar problems,. trying to embed a syntax into thee command line. I am thinking a smart tokenizer, one that knows when to tokenize the filename and when to not.
Tokenize rule
All the new apps will follow the standard tokenizer rule on this, they want their arguments in neat linear arrays. yntacengines andgeneral purpose tokenizers can cooperatel, via tokenizer control words and some common sense.
This violation I remember well:
gcc -fmax-erros=4 ./myfile.c
That cause an equals to appear before the file name in a sequence, to difficult for tokenizer. Note the dash is another problem. The distinguisher is the equals sign, if both engines and snippets could at least start there, leave out the equals unless you really mean it.
The other healer is the syntax mode the console lop is in because syntax engines can load tokenizer controls, or turn it off. But if the syntax engines shut tokenizer off, then we get a host of complaints from snippet authors. We need an intelligent method so filenames are always first class, without conflict.
A problem, not a sow stopper and we can attack it little by little as it becomes a problem. Default says the tokenizer can use the equals flip flop. Tokenizer recognizes start of statement and will, upon seeing the equals, begin tokenizing filenames until end of statement.. Tokenizer agrees, the two bots met, hashed out. That plus whatever tokenizer conrols e can make available.
Take Xcharts, for example
I just invented the snippet. It does basic charts in xcb, likely borrowing the Xchars Xcb interface. It can keep at the same a basic, quick level as Xchars, and use Xchars for much of the annotation. Xchars is mostly a string manager, and symbol table. An Xcharts can share the same approach, and they work together but as separate snippets. Add a spread sheet formatter.
Endless opportunity, great productivity enhancement because of the ability to do part of the tasks, a small part, and still add significantly to a project.
Intellignet tokenizer with controls and some consensus oamong syntax developers.
Or..
Make tokenizer dependent on the line completion control. Once we have Xchars, hen we get controls codes, hidden, from the command loop. An up arrow takes you tough the old command list, exclamation means line completion, and a couple of others. These are first character, non echoed controls. We make file tokenizing part of file completion. A comma is nt echoed and turns off file name tokenizing all together. We include some first character controls to modify the argument macro expansions in command lines, which is off by default.
plus syntaxengine overrides.
All three, the aim is to keep filenames as first class objects,otherwise a huge pain.
Naturally, with all syntax engines turned off, we retain the linux filename standard, where filenames are the firstest among equal in use of punctuation marks.
Endless opportunity, great productivity enhancement because of the ability to do part of the tasks, a small part, and still add significantly to a project.
Intellignet tokenizer with controls and some consensus oamong syntax developers.
Or..
Make tokenizer dependent on the line completion control. Once we have Xchars, hen we get controls codes, hidden, from the command loop. An up arrow takes you tough the old command list, exclamation means line completion, and a couple of others. These are first character, non echoed controls. We make file tokenizing part of file completion. A comma is nt echoed and turns off file name tokenizing all together. We include some first character controls to modify the argument macro expansions in command lines, which is off by default.
plus syntaxengine overrides.
All three, the aim is to keep filenames as first class objects,otherwise a huge pain.
Naturally, with all syntax engines turned off, we retain the linux filename standard, where filenames are the firstest among equal in use of punctuation marks.
Who maintains Xchars?
In total, it comes in at 560 lines, without the test code. Add a hundred lines for keyboard and mouse; this is still a snippet. Email it, cut and pasted it pass it round. Just keep it under 800 lines of code, or I will. Keep the universal interface. Add 8 more APIs only to delete stuff and start messages and set controls. The whole idea here is to make add on packages, so the enhancement might be to make a universal graphics buffer based compositor, Wayland compatible, then add on a bunch of various packages, small, just like Xchars. The concept is the users mix and match snippets to make a complete application. They are guided by their powerful enterprise syntax engine.
I keep my loadables in /home/so, and all files have the extension so, nothing more, as in: xchars.so. Then I fire up console loop and load em up. The snippet is small, has no version number in the file name Instead snippet users agree n a version command with standard output that a bot can read. So rather than go fire up the file manager to pickout the name, you might say: module xchars version, and the module built in will execute the command line query. But is is all inside your current address space, you still make the one and only system call, this time t the loadable itself, on disk, as a main(arg,argv) program.
So, in everything, Default, console loop, loadable, snippets, Bus control; kick it upstairs to python, node.js, Golang, Forth,... Stay down and dirty at the bus level generating snippets.
Snippets, an industry
The snippet community agrees to some basics, like version and help commands. Then they break into families of snippets, the group sharing a name space and interactive protocol. The important idea is to recast that args line into useful structures, then build tightly integrated systems by sharing the bindings. Very powerful method to manage large projects with independent developers because of the independence. Any snippet developer can re-purpose their snippets to different semantics via bindings and the Bus. And snippets are fun fun fun, especially when you are in an industry of growing snippet buyers and sellers; very liquid, easy to adapt, and great snippet writers, like trading bot writers, make bucks.
Right now I am debugging a Load error I introduced by specifying /home/so as default. But I will be in console loop tonight, with Xchars and Default both loaded.
I keep my loadables in /home/so, and all files have the extension so, nothing more, as in: xchars.so. Then I fire up console loop and load em up. The snippet is small, has no version number in the file name Instead snippet users agree n a version command with standard output that a bot can read. So rather than go fire up the file manager to pickout the name, you might say: module xchars version, and the module built in will execute the command line query. But is is all inside your current address space, you still make the one and only system call, this time t the loadable itself, on disk, as a main(arg,argv) program.
So, in everything, Default, console loop, loadable, snippets, Bus control; kick it upstairs to python, node.js, Golang, Forth,... Stay down and dirty at the bus level generating snippets.
Snippets, an industry
The snippet community agrees to some basics, like version and help commands. Then they break into families of snippets, the group sharing a name space and interactive protocol. The important idea is to recast that args line into useful structures, then build tightly integrated systems by sharing the bindings. Very powerful method to manage large projects with independent developers because of the independence. Any snippet developer can re-purpose their snippets to different semantics via bindings and the Bus. And snippets are fun fun fun, especially when you are in an industry of growing snippet buyers and sellers; very liquid, easy to adapt, and great snippet writers, like trading bot writers, make bucks.
Right now I am debugging a Load error I introduced by specifying /home/so as default. But I will be in console loop tonight, with Xchars and Default both loaded.
Make a simple clock in xchars
Simple, in string form.
GetConn clock;
GetWin clock win;
GetGC clock gc;
GetRect win gc rect 10 10 60 30;
while(1) {
// Then using the system, get
// the clock put it to a string
str=SysCall time str;
PutStr rect str;
sleep(1);
}
The console loop will support threaded loadables in version 3.. Default should soon be supporting these kinds of simple loops with pass thrus.
At some point the SysCall call arg1 agr2.. will become:
SysCall(cmd,ar1,..);
An enhancement of Default (allowing function arguments) that sooner or later will arrive, by me or someone else.
I try and keep Xchars updates in the file links. It is a fun project, no recursions and lots of flashes. Ultimately we have some great ncurrses games that need porting. I be neglecting Default.
GetConn clock;
GetWin clock win;
GetGC clock gc;
GetRect win gc rect 10 10 60 30;
while(1) {
// Then using the system, get
// the clock put it to a string
str=SysCall time str;
PutStr rect str;
sleep(1);
}
The console loop will support threaded loadables in version 3.. Default should soon be supporting these kinds of simple loops with pass thrus.
At some point the SysCall call arg1 agr2.. will become:
SysCall(cmd,ar1,..);
An enhancement of Default (allowing function arguments) that sooner or later will arrive, by me or someone else.
I try and keep Xchars updates in the file links. It is a fun project, no recursions and lots of flashes. Ultimately we have some great ncurrses games that need porting. I be neglecting Default.
Why is a balanced Huffman tree an optimally packed sphere ?
Principle of maximum entropy computations, Huffman trees are both balanced and optimally quantized over their complete sequence. The distance from root to branch is the same everywhere, to the limits of precision. The queues at each node stable, and optimum (meet spin exclusion actually).
The principle of homomorphic mappings between graph representations at maximum entropy hols. The Huffman graph is configured to compute pi, and we see that this balanced tree operates as close to the maximum second derivative of tanh, the ratio. It meets the hyperbolic differential equation. Go look there, I found Phi, very close to Pi, and down the end or that something close to the fundamental electron uncertainty ratio, representing the longest Huffman path supported before inventory goes to zero along the path.
The theory of everything. I can mix and match semantics form different fields and fit them into sentences formed on congestion theory. All science.
Spin exclusion, for example. At WalMart there are zero or one clerks queued per checkout, but one or two customers. The clerks got spin excluded, spin exclusion is a result of optimally congested queues must have flow (Hawkins) and be asymmetric (sphere packers). So at optimum congest we have only one minimal configuration that mantains flow. Occasionally customer will be first in a line with no clerk. Computational equivalence at maximum entropy, go with that, it leads to TOE.
Here is an example:
(a+b+c) // three vars two adders!
The bots are square rectangular fellows and will say, no, one ar on op; always in pairs. But the corner condition is Huffman encoded, it does not waste a unique, short path through the parse tree. The variables compress the adders, sphere packing. It is in language, grammar is a a queuing problem. If you are quantized, stable, you have asymmetric net flow and turbulence is contained to a constant ratio everywhere.
Sandbox generalizes.
Sandbox traders assume,true, that the uncertainty is bound and set by the activity f current trader bots, in the pits. The spreadsheet function is not so bold as set uncertainty, in general, the market sets that level at the speed of computation in the serializing pit boss. The currency banker is the gold standard, and one can normalize its measured uncertainy to 1.5 sigma, I think, leaving the surplus for re-quatization insurance. But it can run larger currency risk, thus multiplying market uncertainty down the chain.
The principle of homomorphic mappings between graph representations at maximum entropy hols. The Huffman graph is configured to compute pi, and we see that this balanced tree operates as close to the maximum second derivative of tanh, the ratio. It meets the hyperbolic differential equation. Go look there, I found Phi, very close to Pi, and down the end or that something close to the fundamental electron uncertainty ratio, representing the longest Huffman path supported before inventory goes to zero along the path.
The theory of everything. I can mix and match semantics form different fields and fit them into sentences formed on congestion theory. All science.
Spin exclusion, for example. At WalMart there are zero or one clerks queued per checkout, but one or two customers. The clerks got spin excluded, spin exclusion is a result of optimally congested queues must have flow (Hawkins) and be asymmetric (sphere packers). So at optimum congest we have only one minimal configuration that mantains flow. Occasionally customer will be first in a line with no clerk. Computational equivalence at maximum entropy, go with that, it leads to TOE.
Here is an example:
(a+b+c) // three vars two adders!
The bots are square rectangular fellows and will say, no, one ar on op; always in pairs. But the corner condition is Huffman encoded, it does not waste a unique, short path through the parse tree. The variables compress the adders, sphere packing. It is in language, grammar is a a queuing problem. If you are quantized, stable, you have asymmetric net flow and turbulence is contained to a constant ratio everywhere.
Sandbox generalizes.
Sandbox traders assume,true, that the uncertainty is bound and set by the activity f current trader bots, in the pits. The spreadsheet function is not so bold as set uncertainty, in general, the market sets that level at the speed of computation in the serializing pit boss. The currency banker is the gold standard, and one can normalize its measured uncertainy to 1.5 sigma, I think, leaving the surplus for re-quatization insurance. But it can run larger currency risk, thus multiplying market uncertainty down the chain.
Re-entrant stack
I worked this problem, unsuccessfully my first job.
Let us define a protocol on args list.
We have one process filling, another emptying args list from two separate indices, and empty and fill. The args list is assumed infinite until it is not, then the fill thread can safely stop filling. There is a stable initial point where both indices are at zero.
The one never writes index the other. But can one leave its own pointer in an intermediate unstable state? Well, he has to write the updated value of its index in an atomic operation. If that assumption is met, then the emptying process will always seethe fill process incrementing or standing still, before it updates its own index. Thus the empty process will be ale to test its index without error as less than or equal, the stable condition, before updating its index. The filling process never looks at the emptying pointer.
I think this works. I think the Xchars can run is own thread at mouse time and just use a push and pull stack on args list. When Xchars reaches the end of infinite, it stops the messages until restarted. The empty process can execute a restart in its own thread at Xchars, and Xchars will handle the handshake transparently.
In string format we have simple mouse and key messages.
KeyPress code;
PtrClked code x y;
Ican't think of any more, it is either keyboard, mouse; well, touch pad?
Touched x y;
Just pipe those message back to client, xchars provides calls for any shut,restart,echo, etc; Plus simple cursor select and place calls. All this in version 3, unless I find a good snippet already done the job.
Let us define a protocol on args list.
We have one process filling, another emptying args list from two separate indices, and empty and fill. The args list is assumed infinite until it is not, then the fill thread can safely stop filling. There is a stable initial point where both indices are at zero.
The one never writes index the other. But can one leave its own pointer in an intermediate unstable state? Well, he has to write the updated value of its index in an atomic operation. If that assumption is met, then the emptying process will always seethe fill process incrementing or standing still, before it updates its own index. Thus the empty process will be ale to test its index without error as less than or equal, the stable condition, before updating its index. The filling process never looks at the emptying pointer.
I think this works. I think the Xchars can run is own thread at mouse time and just use a push and pull stack on args list. When Xchars reaches the end of infinite, it stops the messages until restarted. The empty process can execute a restart in its own thread at Xchars, and Xchars will handle the handshake transparently.
In string format we have simple mouse and key messages.
KeyPress code;
PtrClked code x y;
Ican't think of any more, it is either keyboard, mouse; well, touch pad?
Touched x y;
Just pipe those message back to client, xchars provides calls for any shut,restart,echo, etc; Plus simple cursor select and place calls. All this in version 3, unless I find a good snippet already done the job.
XChars c bindings
int xchars(int *argc,char * args[]) { // should return NOTFOUND=0 or a non-zero.
// PutStr rect gc string
struct { char *cmd; char * rect;char * string
} *PutStr_ptr;
// NeWin conn win
struct { char *cmd; char * rect;char * string
} *NewWin_ptr;
// NewConn conn win
struct { char *cmd; char * conn;char* win;
} *NewConn_ptr;
// NewGC conn gcname
struct { char *cmd; char * conn;char * gc
} *NewGC_ptr
// SetFont gc font_name
struct { char *cmd; char * gc;char* font_name;
} *SetFont_ptr;
// SetRGB gc for_rgb back_rgb
struct { char *cmd; char * gc;char* fore_digits;char* back_digits;
} *SetRGB_ptr;
// NewRect win gc rect x y width height
struct { char* cmd; char* gc; char* rect;
char* x;char* y;char* width;char* height;
}*NewRect_ptr;
// SetRect rect gc
struct { char* cmd; char* rect; char* gc;
} *SetRect_ptr;
// for example:
SetFont_ptr = (void *) args;
printf("%s %s %s\n",
ptr->cmd,ptr->gc,ptr->wfont_name);
}
OK, this was semi-automated using the look and type method, but it is simple. Use them in the proper order. Notice, the struct pointers are just mapped to args list for use. Thislikely does not exactly compile, but this is the correct c binding approach.
Your basic Xchars API for the window. Later we get Xmice and Xboard. Use SetRect api to associate a rect with another gc. Basically this replaces putchar on the command line to putstr on the box. Everything is null terminated text, names, digit strings. The general rule is, readable names less than eight chars, but string arguments to the screen any length. The front end symbol table isd faster than anything we need, ad small, but really greases the interface.
The mouse events and keyboard events will be equally simple, and there will be a declared call back type. I think when we have mouse then client and xchars will reserve a portion of args list for message passing.
Xchar text files
Not a problem, make a set of line terminated strings in the model above, see in the comments:
NewConn MyConn; // semi colon optional here
NewWin MyConn MyWin;
NewGC MyConn MyGC;
NewRect MyWin MyGC MyRect 10 20 300 200;
PutStr MyRect "Hello World";
Once you have your script use ExecFle file_name; // at the command line
Be sure Xchars was loaded: LoadMod xchar.so; // I think, if I remember
Keep your loadable local. /home/loadables // for example.
Notice the two formats, linux command line text and compiled. The difference between the two is the console loop tokenizer, Default is not involved.
The Xchars symbol table
It will be a balanced tree for most well written scripts. A well written script is Huffman encoded, the script names allocate more char spaces for significant differences between set members. as in:
HeaderGC;
MidTxtGC;
Note, the common group names have shortest character allocation in a name. The simple table will end up sorting on the first part, where character are complex. If the first characters are sufficiently informative, then the symbol tree will be balanced. 32 names becomes a five step hop through the symbol tree, short test and jumps. Putting the fast eight char symbol tables up front of loadables is a good idea. The concept can be extended to 16 char names easily and double your test instruction to two test and jumps.
Making symbols even faster
We need text8 type: `allfitin` // which becomes a long packed with chars. then we have:
struct { text8 cmd; text8 rect; text8 gc } *SetRec_ptr;
Categorizing symbols:
Rare, seldom used symbols cal them nearly the same name:
Rarely000;
Rarely001;
.
This puts all the seldom used ont a separate branch, the informative, rapid fire commands take one step then split the remaining tree amongst themselves. Extreme Huffman encoding, actually the central algorithm for the theory of everything, pure sphere packing.
// PutStr rect gc string
struct { char *cmd; char * rect;char * string
} *PutStr_ptr;
// NeWin conn win
struct { char *cmd; char * rect;char * string
} *NewWin_ptr;
// NewConn conn win
struct { char *cmd; char * conn;char* win;
} *NewConn_ptr;
// NewGC conn gcname
struct { char *cmd; char * conn;char * gc
} *NewGC_ptr
// SetFont gc font_name
struct { char *cmd; char * gc;char* font_name;
} *SetFont_ptr;
// SetRGB gc for_rgb back_rgb
struct { char *cmd; char * gc;char* fore_digits;char* back_digits;
} *SetRGB_ptr;
// NewRect win gc rect x y width height
struct { char* cmd; char* gc; char* rect;
char* x;char* y;char* width;char* height;
}*NewRect_ptr;
// SetRect rect gc
struct { char* cmd; char* rect; char* gc;
} *SetRect_ptr;
// for example:
SetFont_ptr = (void *) args;
printf("%s %s %s\n",
ptr->cmd,ptr->gc,ptr->wfont_name);
}
OK, this was semi-automated using the look and type method, but it is simple. Use them in the proper order. Notice, the struct pointers are just mapped to args list for use. Thislikely does not exactly compile, but this is the correct c binding approach.
Your basic Xchars API for the window. Later we get Xmice and Xboard. Use SetRect api to associate a rect with another gc. Basically this replaces putchar on the command line to putstr on the box. Everything is null terminated text, names, digit strings. The general rule is, readable names less than eight chars, but string arguments to the screen any length. The front end symbol table isd faster than anything we need, ad small, but really greases the interface.
The mouse events and keyboard events will be equally simple, and there will be a declared call back type. I think when we have mouse then client and xchars will reserve a portion of args list for message passing.
Xchar text files
Not a problem, make a set of line terminated strings in the model above, see in the comments:
NewConn MyConn; // semi colon optional here
NewWin MyConn MyWin;
NewGC MyConn MyGC;
NewRect MyWin MyGC MyRect 10 20 300 200;
PutStr MyRect "Hello World";
Once you have your script use ExecFle file_name; // at the command line
Be sure Xchars was loaded: LoadMod xchar.so; // I think, if I remember
Keep your loadable local. /home/loadables // for example.
Notice the two formats, linux command line text and compiled. The difference between the two is the console loop tokenizer, Default is not involved.
The Xchars symbol table
It will be a balanced tree for most well written scripts. A well written script is Huffman encoded, the script names allocate more char spaces for significant differences between set members. as in:
HeaderGC;
MidTxtGC;
Note, the common group names have shortest character allocation in a name. The simple table will end up sorting on the first part, where character are complex. If the first characters are sufficiently informative, then the symbol tree will be balanced. 32 names becomes a five step hop through the symbol tree, short test and jumps. Putting the fast eight char symbol tables up front of loadables is a good idea. The concept can be extended to 16 char names easily and double your test instruction to two test and jumps.
Making symbols even faster
We need text8 type: `allfitin` // which becomes a long packed with chars. then we have:
struct { text8 cmd; text8 rect; text8 gc } *SetRec_ptr;
Categorizing symbols:
Rare, seldom used symbols cal them nearly the same name:
Rarely000;
Rarely001;
.
This puts all the seldom used ont a separate branch, the informative, rapid fire commands take one step then split the remaining tree amongst themselves. Extreme Huffman encoding, actually the central algorithm for the theory of everything, pure sphere packing.
Scheduled, synchronous mark to market
Wells Fargo calculated U.S. defined-benefit pensions fund would need to implement a "giant rebalancing out of bonds and into stocks" - in fact the biggest in history - with the bank estimating roughly $64 billion in equity purchases in the last trading days of the quarter and year, prompting the banks to ask if traders are about to make pension rebalancing "great" again.
Pension funds, like banks, are required to post volatility spikes in the data on a regular basis, like price fixing on an annual basis, about the most idiotic rule invented.
In this case we have the pension funds in large states taking their bear market losses on schedule. They are buying to replenish value lost, and that is an annual requirement. It also means cities in California will be hearing some bad news, officially. All the cities, then synchronously, will report hiring freezes for the near future. But seniors will synchronously enjoy heir cost of living adjustments, as will every other public sector employee.
The cycle is built in, we are required by law to have recessions synchronous to regime change. The method exceeds the bandwidth of the economy, investors get caught and have to retrace some trades, adding a loop to the flow, aliasing we call it, making sidelobes is another name, spinning wheel, snapping the whip, not enough second derivative..
Xchars functional
In test mode the basic operations are working in linux command format. I will hook it up with console loop here in a minute.
Windowing messages do not make sense
Except for mouse and keyboard clicks.
Otherwise I never understood why the graphics package wants to let me know my window is exposed. Is there something out of date in my bit map buffer? How the frig will a graphics co-processor know that?
Wayland does it better. The client knows how accurate is the bit map, let the client signals the graphics processor, the the updated bit map can be exposed when needed.
The mouse clicks make sense for messages. But there is no human punching the screen unless it is touch screen, and touching the screen does not coincide with redrawing it, quite the opposite. The Wayland architecture figured this out, and I guess no one questioned it since the message loop was needed for mouses anyway.
The whole windowing revolution was built around moving bitmaps automatically, which is why you do not need to redraw your bit map whenever it is exposed, you already drew it, so go ahead and expose it, don't tell me. Anyway, I am skipping the message loop. It works for Xchars v2 ,when you put a string, Xchars writes it to bitmap and flushes the message queue. When Xchars does mouse clicks, then Xchars activates the message loop.
The pros will tell me that window draw messages are needed to prevent flicker, when my bit map is not double buffered, the graphics processor needs treat it a bit like shared memory. The event really means just what is says, the window is being moved, and the client requested a warning. This text will not flicker, it will likely be drawn to bit buffer faster than the process timeout.
Otherwise I never understood why the graphics package wants to let me know my window is exposed. Is there something out of date in my bit map buffer? How the frig will a graphics co-processor know that?
Wayland does it better. The client knows how accurate is the bit map, let the client signals the graphics processor, the the updated bit map can be exposed when needed.
The mouse clicks make sense for messages. But there is no human punching the screen unless it is touch screen, and touching the screen does not coincide with redrawing it, quite the opposite. The Wayland architecture figured this out, and I guess no one questioned it since the message loop was needed for mouses anyway.
The whole windowing revolution was built around moving bitmaps automatically, which is why you do not need to redraw your bit map whenever it is exposed, you already drew it, so go ahead and expose it, don't tell me. Anyway, I am skipping the message loop. It works for Xchars v2 ,when you put a string, Xchars writes it to bitmap and flushes the message queue. When Xchars does mouse clicks, then Xchars activates the message loop.
The pros will tell me that window draw messages are needed to prevent flicker, when my bit map is not double buffered, the graphics processor needs treat it a bit like shared memory. The event really means just what is says, the window is being moved, and the client requested a warning. This text will not flicker, it will likely be drawn to bit buffer faster than the process timeout.
Subscribe to:
Posts (Atom)