Can recommend Odin[0] if you want to play with Raylib. Great for prototyping, although I'm not sure if it will last further on in development. Still have to figure that one out.

[0] https://odin-lang.org/

What’s special about Odin when it comes to Raylib? (Genuinely curious)

Most of my code in the last year and a half has been Odin. My personal codebase moved from C11 to Odin. I would say that Odin is just more streamlined and easier for a beginner to learn with (which is who Raylib is aimed at.) Both syntax and semantics are simpler; so much so that the (relative to C) smaller ecosystem doesn't pose a problem to learners.

I like Odin because it values the low-friction of C, unlike just about every other "better C" I've tried. It adds friction where you're likely to cut yourself, and reduces friction where it matters; in places like:

- having semantic modules instead of textual inclusion

- having a nice build-system built in

- smart bounds-checking/integer-wrapping semantics (customizable, too!)

- predefined mathematical operators for things like vectors and matrices

- an actually useful core library

I think the magic is still mostly in raylib in that it's a well designed API with high composability. It feels like playing and building. Odin is special in its own right.

There's no particular feature of Odin that really stands out, but where Odin outclasses every language available is that every single feature has been very thoughtfully considered and designed to have the least amount of issues. Once you work with it for a few months, it becomes obvious very quickly its vision is remarkably consistent, leading to a smooth and outright delightful development experience.

I will caution, if you are the type of developer who likes to pull in lots of packages and dependencies to start a project, it's not for you. There's no package manager, and rightly so[1]. You'll have to build most high-level systems yourself. But when you realise that most frameworks and dependencies are trivial to implement by hand, this won't be a bother.

If you're the kind of developer who loves building systems and doing everything yourself, you'll feel right at home.

[1] https://www.gingerbill.org/article/2025/09/08/package-manage...

If you know C, not much because you steer away from the gotchas. If you don't, it's a good language, and with less surprising effects.

I think Raylib satisfies a similar CAPABILITIES-niche to Godot...

I am _not_ talking about ease of use or interface.

For a long time Godot has not been ready for medium-large 3D releases, that is changing, but for the most part both it and Raylib are very reliable and will be perfectly good to release a 2D game with.

I'm not actually sure whether a 3D game with skinned meshes will ever be in-scope for Raylib. Wouldn't seem like it.

They didn't say anything about godot or 3d meshes.

“not sure if it will last further on development”

I interpret this to mean something like “as my game gets more involved” which is not unrelated to a venture into 3D. Why are you policing my comment which is trying to be helpful?

Your comment was so unrelated I thought you replied to the wrong comment.

In Elixir this would be written as:

  db.getUsers()
  |> getExpiredUsers(Date.now())
  |> generateExpiryEmails()
  |> email.bulkSend()

I think Elixir hits the nail on the head when it comes to finding the right balance between functional and imperative style code.

Not a single person in this thread commented on the use of Date.now() and similar - surely clock.now() - you never ever want to use global time in any code, how could you test it?

clock in this case is a thing that was supplied to the class or function. It could just be a function: () -> Instant.

(Setting a global mock clock is too evil, so don't suggest that!)

I was just referring to how pipes make these kinds of chained function calls more readable. But on your point, I think using Date.now() is perfectly ok.

> I think using Date.now() is perfectly ok.

This is why we have tests which we need to update every 3 months, because somebody said this. This is of course, after a ton of research went into finding out why the heck our tests broke suddenly.

I would call those badly-written tests. The current date/time exists outside the system and ought to be acceptable for mocks, and in python we have things like freezegun that make it easy to control without the usual pitfalls of mocks.

What are those mock pitfalls, which are avoided by freezegun which is a mock according even to them? IoC and Clocks solve the same problem. So what are the pitfalls of using those instead of this other mock?

Applying it to the wrong module, a very common mistake in python due to how imports work.

What happens during a daylight savings adjustment?

You use UTC which doesn't adjust daylight savings.

nit picking on the example code while missing the example the code was trying to demonstrate. I see why TAOCP used pseudocode

Agreed! But i didnt miss the example.... i also thought it was interesting that all the various examples of declarative or applicative did Date.now(), which i see as a big thing to avoid.

    bulk_send(
        generate_expiry_email(user) 
        for user in db.getUsers() 
        if is_expired(user, date.now())
    )

(...Just another flavour of syntax to look at)

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`

Not sure I like how the binding works for user in this example, but tbh, I don't really have any better idea.

Writing custom monad syntax is definitely quite a nice benefit of functional languages IMO.

That's a really cool concept, I'd love to see more art like this that uses modern technology. Do you have a demo available somewhere to see what the effect would look like? This is one of those things where you should just do it without asking for permission. The portals[0] art installation in some cities doesn't ask for consent either.

[0] https://www.portals.org/

Something like https://github.com/mrdotb/live_react might be what you're looking for.

https://backpex.live/ is a pretty good Phoenix Admin. Django's admin is still unmatched though.

Does this allow external programs/servers to interact with a workbook (xlsx file)? Or is this just to run more complex calculations inside cell(s)?

There's UNO and there's also openpyxl to interact with workbooks from Python, but both solutions were a bit slow when testing it.

There's a lot of value in having existing workbooks which a lot of businesses already use, and extending them so they can be interacted with or queried from a server. For example to allow further access from a webapp without allowing changes to the entire workbook or hiding the full dataset.

SEEKING WORK | Remote | Part time | Vancouver, Canada

Availability: 20 hours or less per week

Technologies: Elixir, Phoenix, Svelte

- GitHub: https://github.com/woutdp

- LiveSvelte: https://github.com/woutdp/live_svelte

- Website: https://wout.space/

- Contact: hn@wout.space

Full-stack web developer with 10+ years of professional experience. Creator of LiveSvelte, a popular library integrating Svelte with Phoenix LiveView. I'm looking for Elixir/Phoenix projects with a defined scope—preferably fixed-fee or milestone-based. Open to equity or profit-sharing arrangements for the right opportunity.

Fly.io for Elixir is very popular

Memory is actually shared in Elixir until it's required to create new memory because of a change. So even if you have a big dictionary and something changes, part of the dictionary that remained the same will actually share memory until it's required to create new memory because of a change in that part of the dictionary.

So in effect, most immutable languages actually do copy by reference, it's just abstracted away for the programmer and you can reason about it as copy by value.

I can't find the article now but I remember reading about this and someone can probably link it.

If the wristband works well, it'd be a very convenient gadget to wear if it can integrate with a bunch of devices like smart-lights, phones, tv etc...