xandkar / cellular-automata Goto Github PK

life/001 doesn't go far-enough. Each cell is a process, but it relies on
centralization for discovery of neighbors and failure is not tolerable.

How to do better?

Proximity could be modeled somehow.
Each cell broadcasts state in its proximity.
Broadcast power can also be varied.
Broadcasts beyond proximity can be intercepted and cached for use in some recovery protocol.
What could such a recovery look like?
Maybe earn broadcast-power-increasing credits for participation in recovery?

Display is centralization.
Could be multiple displays scraping broadcasts in an attempt to reconstruct the view or the world.
Some cells maybe visible, some not, some may gossip the state of neighbors, making them visible indirectly.

life/005 constructs new generations and deletes the previous, but we can just use 2 buffers and alternate between prev|curr - no need to generate new ones.

What does it mean for different rules to coexist?

Rules are discretizations of the real world - in other words sets of
approximations. Different sets of approximations are possible, but the real
thing exists underneath. Energy? Maybe... The main idea is that there's
something fine-grain that is happening, while there're different, COMPETING
coarse-grainizations of reality that affect the fine-grain reality underneath.

I emphasize competition because the opposite is cooperation, which implies some
synchronization of the model - if we cooperate - we follow at least a sub-set
of the same rules/approximations; overlapping of the coarse-grainization of the
world view. The competition may not be intentional, but the two will
necessarily conflict with each other unless synchronized somehow.

This sounds like both the animal kingdom and the computer - access patterns to
underlying resources overlap and interact in weird ways, creating both
conflicts and symbiotic relationships: race conditions and things that work for
unexpected reasons. An operating system, for instance, exists to
de-conflict/synchronize the competing world-views of different programs - it
creates that overlap of shared resource-model.

So, to make Polymorphism automata make sense, at least two layers are needed:

1. a single fine-grain reality
2. multiple corse-grain representations