LiveView: Created processes die instantly

Have you tried debugging the lifecycle of the game process - e.g. using :sys.trace/3 (see GenServer — Elixir v1.20.2) or implementing the terminate callback?

I already tried the latter, adding a terminate callback with a debug message, but it was not called.
The same seems to be true for :sys.trace/3 - I can see the props call but nothing more:

*DBG* <0.461.0> got call props from <0.456.0>
*DBG* <0.461.0> sent #{category => none,current_player => none,
                    ...
addgame: %{category: :none, current_player: :none,...
addgame: #PID<0.461.0>
[info] GET /livegame
[debug] Processing with Phoenix.LiveView.Plug.index/2
  Parameters: %{}
  Pipelines: [:browser]
[info] Sent 200 in 551µs
[error] GenServer #PID<0.466.0> terminating
** (stop) exited in: GenServer.call(#PID<0.461.0>, :get_players, 5000)
    ** (EXIT) no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started

I am new to elixir, am I missing something fundamental about the lifecycle or scope of processes? Are LiveViews in any way different to regular view controllers?

The full code is here https://github.com/citruz/fakeartist, in case that helps.

You’re missing a whole lot about the lifecycle of processes. For starters, you’re calling Game.start_link inside your liveview, which is unusual. Typically start_link should be called by supervisors, you’ll want your games to be supervised, as supervisors are process lifecycle managers. As your code stands, the lifecycle of your game is directly tied to the lifecycle of your liveview (hence the _link). If your lv dies, so does your game.

Also instead of an agent, you probably want to use a registry to keep track of processes with ids that are meaningful (aren’t pids).

Thanks, I was suspecting something like that. Please help me understand what is wrong with my current approach.
I added a Supervisor child in application.ex:

def start(_type, _args) do
    children = [
     ...
      Fakeartist.Global
    ]
    opts = [strategy: :one_for_one, name: Fakeartist.Supervisor]
    Supervisor.start_link(children, opts)
  end

I though that this would create a “global singleton” of my Global Agent which would persist throughout the whole lifetime of the application. By using Game.start_link in Global.new_game I assumed that the lifetime of the Game process would be bound to the Global process and thus to the application.
What did I get wrong?

Ah, I see. Game.start_link is called inside Global.new_game but is not called in the context of that process and thus the Game process was bound to the wrong parent.
I refactored Global into a named GenServer and not its working
Next, I will try to understand the concept of registries… What is the problem with passing around pids?

No problem with passing round pids per se, but using a registry to lookup processes based on a key that has meaning to your application is so much easier. I found the initial setup a bit of a pain tbh, but in use it makes the code a lot easier to follow. Here’s the “recipe” I ended up with. I’m still missing a couple of pieces - for some reason my registered processes keep running even though the start_link for each “game” is called from a liveview process, but I think I should really have another level of supervision in there as per the supervision tree towards the end of The Erlangelist - To spawn, or not to spawn?.

Anyway…

1. In application.ex, start a named registry process. The name is an atom that gets used everywhere else:

children = [
      #You use the value assigned to name everywhere else
      {Registry, keys: :unique, name: :game_registry}, 
    ...]

2. In your Game GenServer module create a via_tuple function that packages your meaningful key into a token that Registry can use to lookup processes. You will need the same name you used in step 1. You can call the function whatever you want, but everyone seems to use via_tuple

  defp via_tuple(game_token) do
    {:via, Registry, {:game_registry, game_token}}
  end

3. In you create_game function, initialise the process and register with the registry using the token

  def create_game(game_token) do
    GenServer.start_link(__MODULE__, <init args as before>, via_tuple(game_token))
  end

4. Implement your API functions using the “meaningful” key to look things up

  def do_some_stuff(game_token, stuff_to_do) do
   GenServer.call(via_tuple(game_token), {:do_stuff, stuff_to_do})
  end