Seems like the main takeaways from this are that concurrency on BEAM is amazing and the JVM can't match that. So it feels like it boils down to whether you like Ruby syntax versus Lisp syntax. For me that is a no brainer, I love Ruby but always worried about the limitations of the runtime. Is there anything else I'm missing? BEAM plus Ruby seems like an absolute winner here.
Elixir is not Ruby, it just has a somewhat Ruby-like syntax. The similarities end there. Elixir does not have the performance issues that Ruby has (although it may have different ones!)
Got that. My point was that you are choosing between a language that looks like Ruby and a language that looks like Lisp. That's a big difference and many people, I would assert, would choose one or the other without hesitation. For me, that would be Ruby.
Yeah, that's what I miss about Beam's actors vs. actor implementations in the JVM - the design pattern was to write actors that blocked, which dramatically simplifies your code - on Akka actors, for example, you very much should not block the actor, because it blocks the JVM thread that is being used to run the pseudo-green threads, which makes it harder to write straightforward code.
I'm not familiar with Elixir (I've just barely played with it, and found it very neat), so please take this with a grain of salt, but access to the whole JVM (+ JS) ecosystem seems like a big thing you are missing.
Also regarding performance, from my limited understanding, BEAM languages are not well-suited for some types of applications (number crunching, for instance). While Clojure is not necessarily designed for those, you can get Java-levels performance (and in some cases better, I believe; cf. Neanderthal and other work by Dragan Djuric).
The responses on TFA seem quite poor in terms of actually comparing Elixir and Clojure for the most part (except those by Robert Virding and Scott Thompson). For example, someone says:
> Elixir-specific: macros. Basically code generators at compile time. Another vastly underrated productivity booster.
Pointing out macros in a comparison of anything vs a Lisp seems kinda weird...
Someone else talks about "jvm patterns" and butter and spinach...
- Desktop apps
- Server-side apps
- Mobile apps
- Unity games
- Live coding music performance
- AI apps
- C libraries
- Native apps
I can use libraries with low friction from the following ecosystems:
- JavaScript
- Java
- .NET
- Python
Runtimes include but limited to:
- JavaScript
- JVM
- CLR
- Erlang
- SubstrateVM
Clojure specific advantages:
- Datomic
- Crux
- Datascript
- Datahike
Most "functional" languages bottom out into some highly mutable SQL thing and it's gross
Then there are the cultural things, so as you grew as a programmer you probably went imperative, OO to FP, well with Clojure you go another step: imperative, OO, FP, Data-driven: https://youtu.be/vK1DazRK_a0
Technologies like this: https://unity.com/dots, machine learning etc are showing that data and data processing is likely to yield the next frontiers in computer programming
The next things on the near horizon are data-driven declarative layers to raise the bar of abstraction like https://youtu.be/jkx9F-RIFiY
8 comments
[ 5.5 ms ] story [ 35.8 ms ] threadI'm not familiar with Elixir (I've just barely played with it, and found it very neat), so please take this with a grain of salt, but access to the whole JVM (+ JS) ecosystem seems like a big thing you are missing.
Also regarding performance, from my limited understanding, BEAM languages are not well-suited for some types of applications (number crunching, for instance). While Clojure is not necessarily designed for those, you can get Java-levels performance (and in some cases better, I believe; cf. Neanderthal and other work by Dragan Djuric).
The responses on TFA seem quite poor in terms of actually comparing Elixir and Clojure for the most part (except those by Robert Virding and Scott Thompson). For example, someone says:
> Elixir-specific: macros. Basically code generators at compile time. Another vastly underrated productivity booster.
Pointing out macros in a comparison of anything vs a Lisp seems kinda weird...
Someone else talks about "jvm patterns" and butter and spinach...
I can create
I can use libraries with low friction from the following ecosystems: Runtimes include but limited to: Clojure specific advantages: Most "functional" languages bottom out into some highly mutable SQL thing and it's grossThen there are the cultural things, so as you grew as a programmer you probably went imperative, OO to FP, well with Clojure you go another step: imperative, OO, FP, Data-driven: https://youtu.be/vK1DazRK_a0
Technologies like this: https://unity.com/dots, machine learning etc are showing that data and data processing is likely to yield the next frontiers in computer programming
The next things on the near horizon are data-driven declarative layers to raise the bar of abstraction like https://youtu.be/jkx9F-RIFiY