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

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

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

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.

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.

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.

The easiest way I've found is to include a simple Google Form in the product. It's super rewarding to get feedback from users. Ask simple questions like: "What's your favorite thing about X", "What's your least favorite thing about X", "How did you learn about X" and "Anything else you wanted to let me know?". And make all the questions optional so there's a minimal amount of friction.

A little bit more about it here: https://katafrakt.me/2021/10/13/app-with-elixir-business-log...

You'd call Gleam code like this inside Elixir:

`:game.move(game, player_1, :left)`

And you'd receive an Elixir map `%Game{}` which you can then use in LiveView. If that makes sense.

I've thought about adding a library of default Svelte components which mirror the core components you get from Phoenix out of the box. But then again you lose forms and changesets etc, it's just annoying.

Where I see LiveSvelte fit is where you really need a lot of complex client side state. Sprinkle it in, but keep using phoenix components as your default, even with hooks

Maybe I'll pick it up at some point, but also open to other people working on it if they're interested. I'd be open to partner up with someone to eventually make it monetized. It's not open source as I wanted to add paid features (cosmetic features, not pay to win).

A solution for most of these issues is a modifier system. I have a basic one in place and wanted to experiment with different modifiers. A modifier can be anything, like prevent spawning in the center, to increasing rewards for capturing cities, to even allow crossing the border of the map into the other side, like pacman (which could address point 1). Then the goal would be to see which modifiers stick with the player base, and make them the default, while still allowing for custom games with different modifiers. Generals has a similar system in place and they sometimes make the modifier the default for the day, which I like a lot.

It's a clone of https://generals.io/

It's built with LiveSvelte. It doesn't need any predictive features as it's basically a board game and runs at 2 ticks per second. It does use optimistic updates to show game state before it actually updates on the server. The server overrides the game state if they're not in sync.

All game logic is done inside Elixir. To do predictive correctly, you'd need to share logic between the server and the client. Otherwise you're writing your logic twice and that's just a recipe for disaster.

One possible solution which I didn't investigate, but should work, is to write all game logic in gleam (https://gleam.run/). Gleam is compatible with Elixir, AND it also can compile to js, so you could in theory run the same code on the server and the client.

Now this is a big mess to understand, you could say "why don't write it all in js and be done with it" and you'd make a very good point and I'd probably agree. The main advantage you get is that you can use the BEAM and all it's very nice features, especially when it comes to real time distributed systems. It's perfect for multiplayer games, as long as you don't take into account the frontend :)

https://github.com/tonydangblog/liveview-svelte-pwa