custom multiple flavors of indirect addressing
like the types of meta
connection to the RDF verb/hypergraphs?
subsume the two fundamental hypergraph gets (normal and reified) into one operation with multiple flavors?
---
(lack of) call stacks in the brain; what do we have instead?
are call stacks just an abstraction to make it easier to write stuff down? yes, when they are used in a lambda-calculus-y (with no continuations) way; but no, when 'metaprogrammy' stuff like 'break' within a while loop is used, or when 'return' is used in more than one place in the fn, or when exceptions are used for non-exceptional control flow; in these cases, they are usually being used to inject complex sequential/imperative control flow without writing it out explicitly
what does the brain have instead of call stacks? well, for ordinary (lambda-calc-y) use, it just has substructure of neurons... but perhaps the real answer is dataflow variables (labeled lines), since the 'caller' isn't sitting around waiting for the 'callee' to return, it just continues on with the computation with the current (old) value
---
so i guess parts of the paradigm of brainlike computation are:
- there is no program counter; instructions are nodes that are all running in parallel (of course, for convenience, in Oot we'd provide PC-like sequencing operations anyways)
- each node produces an output value which is duplicated and sent to one or more consumers; eg each node acts as both an instruction and a variable
- variables are dataflow variables; when a variable's value changes, all nodes that take that variable as input immediately (or with some delay) recompute based on the new input
- it's not clear if there are guaranteed delays/sequencing between when one node sees an update and when another one does. i guess in the brain there could be some circuits for which the delays that introduce sequencing in a certain order where that order is important, so we should provide that option; but in lieu of it, i guess the default is just that, when one variable updates, each of its consumers 'eventually' sees the update, with no guaranteed ordering between consumers
- conditionals are generally implemented by running both branches at once, then having a 'gate' node at the end which looks at the condition and uses that to select the output from one or from the other branch
- but since we do want this to be a useful programming language, you can abstract any set of nodes into a function, which then can be called multiple times from various other functions, as if each call was a separate duplicate of all of the nodes in the function.
- We also permit recursive calls without predetermined call depth limits, although i dunno how the brain would implement that (seems like it would have to be a loop with a PC, right?).
- also, dunno how 'routing in the brain' works, of course