My cellular automata does not work

While it’s nice you posted a GitHub repo proving what you need does not work, it’s still considered polite to demonstrate you have made an effort to fix the problem(s).

What have you tried?

None of the Cell processes ever start because they try to register with a registry that isn’t started (or even defined):

https://github.com/A-Grunder/Cellular-Automata-in-Elixir/blob/3ba53ba3efa445e08d0dabc0e401c3918ad66e59/lib/cell.ex#L112

You’ll need a line like:

{Registry, keys: :unique, name: CellularAutomata.Cell.Registry}

in your supervision tree.

I also suspect you’ll want to call Registry.update_value rather than register here, since passing the via tuple to GenServer.start_link as name will already have done the registration.

Closing out tabs and I noticed the updates to the repo - looks like the next headache is going to be timeouts:

08:33:34.984 [error] GenServer #PID<0.228.0> terminating
** (stop) exited in: GenServer.call(CellularAutomata.World, :get_grid, 5000)
    ** (EXIT) time out
    (elixir 1.16.2) lib/gen_server.ex:1114: GenServer.call/3
    (cellular_automata 0.1.0) lib/scenes/home.ex:25: CellularAutomata.Scene.Home.init/3
    (scenic 0.11.2) lib/scenic/scene.ex:1335: Scenic.Scene.handle_continue/2
    (stdlib 5.2.1) gen_server.erl:1085: :gen_server.try_handle_continue/3
    (stdlib 5.2.1) gen_server.erl:995: :gen_server.loop/7
    (stdlib 5.2.1) proc_lib.erl:241: :proc_lib.init_p_do_apply/3
Last message: {:continue, {:_init, [supervisor: #PID<0.226.0>, stop_pid: #PID<0.226.0>, child_supervisor: nil, name: "_main_", module: CellularAutomata.Scene.Home, parent: #PID<0.220.0>, param: nil, viewport: %Scenic.ViewPort{name: :main_viewport, pid: #PID<0.220.0>, script_table: #Reference<0.2747193118.4261019661.20982>, size: {800, 600}}, root_sup: #PID<0.222.0>, opts: [theme: :dark]]}}
State: nil

08:33:34.990 [error] Scene exited or crashed before it was done initializing.
pid: #PID<0.228.0>, reason: {:timeout, {GenServer, :call, [CellularAutomata.World, :get_grid, 5000]}}
module: CellularAutomata.Scene.Home, id: "_main_"

The root cause is that between line 20 and line 25, the World process is starting 250,000 Cell processes. The handle_cast for :start_state doesn’t return control to the GenServer receive loop until that’s done, so the message sent by World.get_grid doesn’t get handled within GenServer.call’s default 5-second timeout.

Following up on this, I don’t think a process per cell is a particularly good model for how cellular automata work. There’s no real concurrency in play, as the whole program has to operate in a stepwise fashion. Each cell depends on the state of the previous cell, which if those are different processes will result in a lot of message passing.

Now, from a “let’s play with it” standpoint, go for it! But may lower the process count to start with to make debugging easier, and grow it as you gain confidence in how the program is working.

You are technically correct for existing definitions of CA, but …

1. It should be possible for each cell to keep previous/current values as state, execute updates with messages, then roll the state when it has provided prev to all neighbors, and updated curr from all neighbors, e.g. a simple countdown message counter state for each generation, and a monotonic generation counter ID state also provided in all messages.

2. Asynch CA is much more interesting to me, because the real world is async. Sure the actual results will depend on BEAM scheduler and the random seed, but evolving structure, statistics and stability would be fascinating (not to appeal to authority, but joearms was a physicist and I’m sure he would agree).

P.S. Apologies, I have not looked at the repo, and have not searched for previous work on Asynch CA.

I have put up a quick hack to illustrate 1 & 2:

https://github.com/mike-french/expaca

There are synch and asynch simulations using GoL rule,
with output to bitmaps, images and video/gif
(if you have ffmpeg installed).