whichdan

I kinda feel the same way. I loved slowly going through the main story and probably put 50hr into the game, but the sandbox alone (amazing as it is) just doesn't do it for me.

The issue I have with stacked PRs isn't merging, but rather, when I change branch A, and I'm working on branch C, I then need to merge A into B and then B into C just to continue working. Collapsing/merging them at the end is the easy part.

I agree that the stability is quite nice. But there are plenty of areas where the language could use some improvement - for instance, the ergonomics around writing nested Single Page Apps is pretty cumbersome.

There's a lot to love about Elm, and I've written quite a bit of production code with it starting around 0.18.0. But in 2026 I'm not sure why a company would newly choose a language that hasn't otherwise been updated in nearly 7 years.

Honestly the feedback loop of "do math to roll more" would make this an excellent game for kids IMO

Yeah I agree. I grew up in a very blue-collar town, and anything I wanted to learn (outside of public schooling) either came from emaciated websites or whatever books I could find at the library. Having YouTube and Khan Academy and everything else would have made such a huge difference for me.

The nice thing with the Elixir example is that you can easily `tap()` to inspect how the data looks at any point in the pipeline. You can also easily insert steps into the pipeline, or reuse pipeline steps. And due to the way modules are usually organized, it would more realistically read like this, if we were in a BulkEmails module:

  Users.all()
  |> Enum.filter(&Users.is_expired?(&1, Date.utc_today()))
  |> Enum.map(&generate_expiry_email/1)
  |> tap(&IO.inspect(label: "Expiry Email"))
  |> Enum.reject(&is_nil/1)
  |> bulk_send()

The nice thing here is that we can easily log to the console, and also filter out nil expiry emails. In production code, `generate_expiry_email/1` would likely return a Result (a tuple of `{:ok, email}` or `{:error, reason}`), so we could complicate this a bit further and collect the errors to send to a logger, or to update some flag in the db.

It just becomes so easy to incrementally add functionality here.

---

Quick syntax reference for anyone reading:

- Pipelines apply the previous result as the first argument of the next function

- The `/1` after a function name indicates the arity, since Elixir supports multiple dispatch

- `&fun/1` expands to `fn arg -> fun(arg) end`

- `&fun(&1, "something")` expands to `fn arg -> fun(arg, "something") end`

I wonder if the thinner profile will make it more comfortable in smaller hands (both in terms of reach and center-of-gravity), but I'm skeptical.

Oh, don't forget, if you click "Allow (current location)" it will also reload the page.

Elm works a lot like this and it's quite nice.

Totally agree; I started replaying 13 somewhat recently, and just felt worn down after playing for a few hours. The nonstop battles with no real break between them just isn't fun, despite the game having amazing aesthetics.

I'm really bummed there isn't a Mini - I'd be happy with getting one every third generation, even. For the size of my hands, the center-of-gravity is too high in the 6.1" phones, so I can't comfortably hold it with one hand.

I got a 500 on first load, and intermittent issues on subsequent loads, so it's not just you!

Without compile-time type checking, every single line of code needs to be evaluated with a unit test to ensure there won't be any runtime syntax errors.