Screenshot of simulation running in the logs
First in plain text metaphors in poems. A falling apple is a falling knowledge is a crushing meteorite is an elevator.
Then a mobile game that overlayed monsters over phone camera such that you could shoot them when you saw them in the room.
Then a browser game named something like “is your pepper long” that increased the size of a pepper animation based on some activity like clicking or liking.
Then a watch face which represented hours from birth.
Then 2D games with detailed simulation, multiplayer agency and emergent gameplay.
Then simulators that represented human market behaviour as system (liquid) dynamics.
Applicative and monoid behaviour around us, category theory
Platforms for collaborative dashboards and analytics of distributed systems.
Then the distributed system, complex behavior open for public analysis, games as overlays over public distributed systems
Contemplation of novel compsci application leads back to it
- sephiroth tree
- five buddhism
- vera & mera
A gnome that fights with other gnomes based on operations of transfer and trait of Even/Odd.
Let’s say there’s addition, subtraction and identification
So generate a custom gnome face from identification
And they turn evil if their number is odd
And good if their number is even
And each time there is transfer between two gnomes, they can either switch sides or stay
And if they both stay in one camp afterwards we say that they are agreeing
And if they both switched sides we say they fought
This is a kind of overlay for sure, and yet it doesnt’ make apparent the composability.
Provide a toolchain, a constructor UI that lets people set traits to features and see the outcome.
User picks overlays “gnome” and “fight”, and sets them to devices, and show public activity as that.
Under the hood there’s toolchain for matching all monoid devices to monoid overlays
Automated market maker trade operation implements addition, overlay of growing tree implements addition
Connect some overlay to automated market maker
And see trade as gnome wars, or as fish swimming in sea, or as trees growing
And see a forest instead of explorer transactions
Program an addition device, plug it to some source, plug it to some overlay, and a tree would grow on the server when some public API values change
A simulation is where device logic is implemented by an expression instead of connecting to a public API source
Before connecting to API that implmenents addition and subtraction over time, and trying to display fibonacci retracement levels, implement a device with a fibonacci sequence and test overlays against that simulation
A wasm module that implements various traits for data. One can give the device a string, and device will tell you if the string is even or odd. Or one can give the device a number and the device will tell you its color. Device layer is a bunch of wasm modules that transform data Source layer handles input Overlay layer handles visual output As long as an overlay implements the same traits, it could be switched for another. The matching between source, device and overlay APIs can happen manually, or with naive algos, or with code generation, or with a CNN. One wouldn’t fit each overlay representation to each device or source outlet by hand, everlay would find matches like a magnet.
After there are clients it’s a platform where you can develop new parts, assemble the parts, and if you are a product team - integrate an overlay to gamify your economy.
the clock gives a wrapping integer as a stream. A device which can turn integers into strings, colors. An overlay that calls trait methods from the device to show something on a webpage. Overlay changes color of html page according to color-coding of hours, in order, every minute. confusion, perplexion, wonderment, brink of cognitive complexity, flow
wasm still has some issues with state management - usually we store data outside wasm
The promise is about gamification through lateral thinking, alternative interaction, mockery of system rules competition, attention and respect are main values of everlay. Attention concerns, highlights, like your public account turns out to be a rare beast in the overlay. Identification is key for values of competition, attention and respect. Clock is without identity, so it confuses. As long as overlay has identity, it enlightens. For example a specific time zone, or personal hours from birth, if they wrap around meaningful color codes, and one can compare to another - there’s already competition and attention. To achieve gamification and respect, we also add player input. There is a lot of identities and behaviours in the wild web, and we intend to show them all.
The source is a record of callback functions. The device is a wasm module that expects callbacks as “import objects” and exports some methods. The overlay is a function that expects a wasm instance exporting certain API, or a record of wasm instances, and outputs some view, for example raw html or a React component. So you can have several devices with the same API, you can instantiate devices with different source callbacks, and you can pass devices to different overlays.
The source is a single function foo() that returns a number The device is a wasm module that exports one function bar() that calls foo and outputs “true” or “false” when the number is even or odd. The overlay is a function baz(wasm) that returns either text “tik” or text “tok” depending on if wasm.bar() returns true or false.
The function signature of device methods is that of a computed variable, we don’t want to pass any data to wasm. So overlay only calls wasm.bar(), without arguments, like a template that arranges computed variables in a particular way. Any user input is a source by nature and should be passed to SourceFactory on initialization. The application can position input and overlay side by side, can let user switch between sources, between devices, between overlays, can let user input data for sources But still any user input is a source, and any overlay is a read-only template.
The source is a single function foo() that returns current unix time So the device will change between odd and even every second The application is a page that runs the overlay in a loop, and it will change between “tik” and “tock” every second.
To add identification, instead of unix time we use local time zone in the source foo() implementation.
To add user input, we let the user write their date of birth. We use a factory function for source, SourceFactory(birth) returns foo() implementation that counts from birth.
Instead of even/odd bar(num) checks if some num is larger than current time. This again should be done through factory, as it relates to time.
We allow user to move the mouse around the screen, pass pointer position to SourceFactory, transform that position into a midi number in the device and play the note in overlay.