Dashbit Blog

I'm at a relatively early stage VC-backed startup and from day 1 it's been written in Elixir. It was a fantastic choice, for many reasons, with some being: - Elixir is good for just getting stuff done. I came from a previous startup that used Go and Elm. - The community isn't as small as people make it out to be, or, it's quality over quantity. ;) - There's a lot of good modules out there, and if you need to write your own, it's easy and there's well-defined patterns. E.g. I recently improved our internal Zendesk client and it was a breeze. - https://dashbit.co/ for paid support/advice is amazing. - The console for experimentation, debugging, inspection, etc. is fantastic. - The let it crash, and other Elixir/Erlang philosophies, have been very helpful. - There's a solid amount of batteries-included, but not in an overbearing/restrictive way. - It's such a pleasant day-to-day dev experience. I didn't know Elixir before joining this startup. For myself, and workmates who also didn't have prior experience, it's been a breeze to get up to speed in.

I’m surprised the original source wasn’t linked to this blog. https://dashbit.co/blog/why-elixir-best-language-for-ai https://autocodebench.github.io/

I'd argue that it's one of the best, especially with Tidewave: https://dashbit.co/blog/why-elixir-best-language-for-ai

LLMs work great with Elixir. Running tsc in a loop while generating code still catches type errors introduced by an LLM and it’s faster than generating additional tests. Elixir is also succinct and highly functional. If you can’t find a specific library it’s easier than ever to build out the barebones functionality you need yourself or use NIFs, ports, etc. https://dashbit.co/blog/why-elixir-best-language-for-ai

Here are some thoughts on it from José Valim: https://dashbit.co/blog/why-elixir-best-language-for-ai LLMs absolutely understand and write good Elixir. I've done complex OTP and distributed work in tandem with Sonnet/Opus and they understand it well and happily keep up. All the Elixir constructs distinct from ruby are well applied: pipes, multiple function clauses, pattern matching, etc. I can say that anecdotally, CC/Codex are significantly more accurate and faster working with our 250K lines of Elixir than our 25K lines of JS (though not typescript).

As with my comment in another tree, no, none of the Elixir core team or Dashbit employees are directly involved with this effort, though they may be advising informally and will likely submit a PR here and there. https://dashbit.co/#team https://elixir-lang.org/development.html#team https://github.com/elixir-lang/expert/graphs/contributors

> if your a company which is fully bought into ephemeral containers running on Kubernetes then Elixir is probably not going to be a great fit for you As a community, we have got to stop saying this stuff. It's false. Nothing about Elixir or k8s precludes using the other. Elixir applications can and do run just fine in containers and k8s deployments. In fact, they're complementary: https://dashbit.co/blog/kubernetes-and-the-erlang-vm-orchestration-on-…

While Elixir is my current favorite language to hack in, it is very alien and downright hostile to integrating with existing systems. For example, relational database support was postgres focused for a long time (to the exclusion even of SQLite and continued inability to talk to Oracle). Then you have articles like https://dashbit.co/blog/you-may-not-need-redis-with-elixir pushing ETS over Redis. While it's a valid argument, it's not adoption-friendly. Clojure brings about half the novelty of Elixir, runs on the JVM and still struggles to replace Java.

not anymore, Elixir community as usual delivers some great tool for their beloved developers and users https://dashbit.co/blog/rustler-precompiled (it's similar to pre-compiled Python wheels, but it's better developers' side in my opinion)

There were some tradeoffs that caused heavy computations to be a concern for many years. Elixir Nx recently tackled the problem and is probably a worthwhile read if you're curious. https://github.com/elixir-nx https://dashbit.co/blog/elixir-and-machine-learning-nx-v0.1

In Elixir, when performance is needed and it's appropriate, we can use Rustler [0], however it's a PITA to ask developers to install rust, and you need it on CI etc to build the binaries. A recent solution was to precompile these binaries. It's great. [0] https://github.com/rusterlium/rustler [1] https://dashbit.co/blog/rustler-precompiled

There’s already an article on this you can find here: https://dashbit.co/blog/a-new-authentication-solution-for-phoenix The GitHub for the generator is here: https://github.com/aaronrenner/phx_gen_auth Basically if you need something different it might be worth forking the generator. I might look at passwordless login at some point.

Apparently José Valim is no longer at plataformatec: https://twitter.com/josevalim/status/1219264309202771968 Now at https://dashbit.co/

Anecdotally, it is very much different in Elixir land. I occasionally see bugs related to something being unexpectedly `nil` but it's pretty rare IME. I'd love to evidence what I'm saying with specific numbers since this kind of discussion would benefit from being as objective as possible. Sadly I don't have them. But I still believe what I'm saying and I have a few guesses about some of the causes: 1. Immutable data - so, so many bugs are caused by data mutating out from under you in subtle ways. If you write `x = 1` in your Elixir function, nothing can change the value of `x` except an explicit rebinding. You can then write e.g. `y = f(x)` and know `x` remains unchanged after. Note: this is also true even if the variable is a composite type. `my_struct = blah()` will remain the same in it's entirety no matter what you do with `my_struct`. This is different than in JS where e.g. you can change the contents of an object even if it's declared `const`. 2. Assertive style - the Elixir community favors writing things in an "assertive" fashion [1]. Briefly, this a way of writing code that will fail the moment an assumption is broken rather than letting the issue propagate. 3. Pattern matching (somewhat like destructuring in JS) - Elixir code actually ends up feeling "typed" with pattern matching. E.g. `%Time{} = today = Date.utc_today()` will attempt to bind `today` to the result of `Date.utc_today()` and will raise a `MatchError` when the result, a `%Date{}` struct, fails to…

Excellent read! This is the first time I feel like I finally have a good handle on the "what" & "why" of RSCs. It has also sparked a strong desire to see RSCs compared and contrasted with Phoenix LiveView. The distinction between RSCs sending "JSX" over the Wire, and LiveViews sending "minimal HTML diffs"[0] over the wire is fascinating to me, and I'm really curious how the two methodologies compare/contrast in practice. It'd be especially interesting to see how client-driven mutations are handled under each paradigm. For example, let's say an "onClick" is added to the `<button>` element in the `LikeButton` client component -- it immediately brings up a laundry list of questions for me: 1. Do you update the client state optimistically? 2. If you do, what do you do if the server request fails? 3. If you don't, what do you do instead? Intermediate loading state? 4. What happens if some of your friends submit likes the same time you do? 5. What if a user accidentally "liked", and tries to immediately "unlike" by double-clicking? 6. What if a friend submitted a like right after you did, but theirs was persisted before yours? (I'll refrain from adding questions about how all this would work in a globally distributed system (like BlueSky) with multiple servers and DB replicas ;)) Essentially, I'm curious whether RSCs offer potential solutions to the same sorts of problems Jose Valim identified here[1] when looking at Remix Submission & Revalidation. Overall, LiveView & RSCs…

> I keep hearing everyone talk about how Erlang/Elixir gives everything out of the box and you don't need to worry about Queues, RPC or whatever... Many companies are using Distributed Erlang but not the way you described: they are using it to exchange messages between nodes running the same version of the software. Imagine that you are building a web application, you can directly exchange live messages between nodes without Redis/RabbitMQ [1]. If you are deploying a machine learning model, you can route requests through multiple nodes and GPUs without additional deps [2]. If you want to see which users are connected to your app, you can exchange this information directly between nodes [3]. In other words, there is a subset of distributed problems that Distributed Erlang solves very well out of the box: homogeneous systems working on ephemeral data. And some of the scenarios above are very common. If you need to communicate between different systems or you need to persist data, then I 100% agree with you, I would not use Distributed Erlang (at best it would be one part of the solution). I think this distinction gets lost in many conversations and sometimes it leads to false dichotomies: "why Erlang when I have k8s/grpc/redis?" while in practice there is not a lot of overlap. I have written about Erlang/Elixir vs Redis [4] and vs k8s [5] for those interested. [1]: https://hexdocs.pm/phoenix_pubsub/Phoenix.PubSub.html [2]:…

1. Because they've privileged Docker Hub throughout all Docker tooling everywhere, and encouraged everybody to treat it as the central community hub of images. It's not just any registry: it's the core registry for the entire ecosystem, and they've very actively worked to ensure that state (rejecting all requests to make the default configurable, or to deprecate implicit registry references, etc). 2. Because the open-source application form excludes the vast majority of open-source projects. E.g. Curl isn't eligible because the founder additionally offers paid support. I imagine Elixir won't be either as the founder profits from it by running an Elixir consultancy (https://dashbit.co/). Docker Inc itself is marketed as an open-source project, but clearly wouldn't be eligible either. There's no revenue limits, no flexibility, just 'no plan towards >$0 revenue ever'. This is not most people's definition of 'open source'. 3. Because although yes it is a lot of traffic, they're trying to charge the community orgs to host images, whilst simultaneously they already charging the end users to pull these images too! They tightened the rate limits in 2020 so that any serious download usage as a client already requires a paid account. 4. Because they've given only 30 days notice before they'll drop all the existing images, with no redirection or migration options at all - just "pay up or we delete everything". 5. Because this will break every existing reference to every deleted…

I think Elixir would be interesting for your usecase. It's a dynamic, garbage collected language. It's easy to pick up and get going with. As a functional programming language there isn't a lot to learn in the way of language constructs, and you don't even have to do the 'wrestling with the type system' thing that you have to do in compiled functional languages like OCaml or Haskell (like you do in Rust). Its processing 'horsepower' is probably comparable to Python, but it's much better for building low latency things if you want to run something in a bit more of a production use case. This is also improving due to the recent addition of a JIT. The addition of NX is making Elixir an increasingly interesting place to do ML - write Elixir, have it run on GPU etc. See https://dashbit.co/blog/nx-numerical-elixir-is-now-publicly-available Python integration is probably best done using the Erlang 'port' system - running Python as a managed process and communicating with it using messages over stdin/stdout. I use it for C interop and it works well (and fits well with the Elixir/Erlang process model). It's not difficult to roll your own in Python e.g. https://github.com/fujimisakari/erlang-port-with-python/blob/master/er… or look at something like http://erlport.org/

This is very similar to Jose Valim's "Mocks and explicit contracts" from 2015, down to using a Twitter client as example. https://dashbit.co/blog/mocks-and-explicit-contracts

Is this influenced by "Embedding Python in Elixir"? https://dashbit.co/blog/running-python-in-elixir-its-fine It certainly is more attractive in implementation. Well done!

Not sure debian has (a modern) ruby installed by default, but I think you only need to have a working ruby installation and running the script. On a sidenote, this came out recently and could interest you https://dashbit.co/blog/announcing-phoenix-playground

Do you know what other ecosystem comes closest to the existing in Python? I've heard good things about Julia. 13 years ago when I was trying to explore the field R seemed to be the most popular, but looks like not anymore. (I didn't get into the field, and do just a regular SWE, so I'm not aware of the trends). There is also a lot of development in Elixir ecosystem around the subject [1]. [1](https://dashbit.co/blog/elixir-ml-s1-2024-mlir-arrow-instructor)

There's a good article about BEAM + k8s by José Valim [0] [0] https://dashbit.co/blog/kubernetes-and-the-erlang-vm-orchestration-on-… You could certainly get away without some of the other stuff but, as another comment has mentioned, it requires some infra know-how. Like, you can't "just" use ETS as a Redis replacement without setting it up in a way that its data won't get blown away during a blue-green deploy.

If you're extending Elixir with Rust, familiarize yourself with precompiled rustler: https://dashbit.co/blog/rustler-precompiled

Ah same as (precompiled + loaded into memory): https://dashbit.co/blog/welcome-to-our-blog-how-it-was-made

Co-author of Elixir Patterns here :). Really appreciate the kind words and happy to hear that you are enjoying the book! Hugo Baraúna and I have really enjoyed putting this book together and feel that Livebook has become pivotal in explaining certain topics and really understanding how things work under the hood. I wrote a blog post about some of my thoughts around Livebook as a learning tool on the DashBit blog: https://dashbit.co/blog/livebook-as-an-educational-tool

Jose wrote the bulk of the code and he worked on Devise. Blog post (1yr old) from Jose here. https://dashbit.co/blog/a-new-authentication-solution-for-phoenix

Here a good blog post on this exact topic https://dashbit.co/blog/a-new-authentication-solution-for-phoenix

the new numbat library https://dashbit.co/blog/nx-numerical-elixir-is-now-publicly-available exposes primatives for gpu acccellerated math powered by google's xla library. the same one that powers tensorflow.

Have you seen nx[1]? It looks like the first step towards this! 1. https://dashbit.co/blog/nx-numerical-elixir-is-now-publicly-available