proj-oot-ootFromOthers

On this page we speculate about how one could start with various simple machine paradigms and make them 'more Ootian' without necessarily actually getting something identical to Oot. These thought experiments might help us in thinking of ideas for Core Oot, or perhaps one of them might even end up becoming Core Oot someday.

oot from nock

hypergraphs

the first thing to do is to replace cells with hypergraphs.

to select in a hypergraph, you specify a path from the root node (the node-labeling node). the path is itself a list (e.g. a hypergraph where the edges from the root node are labeled only with consecutive integers). replace lines 12-17 with this.

replace the pair constructor rule, line 19, *[a [b c] d] [*[a b c] *[a d]], either with a rule for inserting a new item into a dict, or two rules, one for inserting a new node, one for inserting a new edge, or a rule for inserting a new hypernode or replacing an old one.

note that we need to define the syntax for [] so that it works with hypergraphs which are also sequences

arithmetic

Nock doesn't have integer subtraction, or integer multiplication and division, or integer overflow, or floating point arithmetic, or bitwise AND, OR, XOR.

Oot should probably have these in some form. Even asm.js has these.

And modulo. Dunno if asm.js has that.

oot from lambda calculus

oot from ram machine with registers

oot from STM

what else?

boundaries in code e.g. transactions, atomic segments, etc

annotations

macros? other metaprogramming of some sort?

types? typechecking? type inference?

views?

attributes/protocols?

laziness?

oot from others languages to compare todos

asm.js JVM CLR LLVM KLambda RPython Lua C- emscripten's LLVM ( https://github.com/kripken/emscripten/wiki/CodeGuidelinesAndLimitations ) nock Dis ometa forth smalltalk js Io scheme metalua the Lisp in The Roots of Lisp

machine models:

possibly: Clojure Guile Shen Fantom Neko