Goodbye Elixir

It's a year since #elixir was declared "officially, a gradually typed language". I've done a lot of soul searching since. But, with a heavy heart, I've decided to stop investing in Elixir as a platform.

My thinking goes something like this....

Joe Armstrong, who gave us #erlang, pointed out that Erlang is one of the best languages for practicing #oop. He pointed out that the "3 tenets of object oriented programming are that it's based on message passing, that you have isolation between objects and have polymorphism", and that Erlang has awesome support for all three.

In contrast, general platforms such as #java or #csharp, make it harder to implement messaging as the primary way to implement interactions between "objects". Instead, there is an overwhelming tendency toward strongly-typed, procedural programming, enhanced with state internal to objects created from classes. This is, by and large, the "object-oriented" model which we have received from the C++ branch of OOP. Message passing is either "implied" by the definition of strongly-typed methods, or a higher-level abstraction via messaging libraries built "on-top" of the underlying "object" system. Sometimes we even imply distinct engines (like RabbitMQ's AMQP - ironically, an Erlang product...)

So, really, since Smalltalk compromised to try and compete with C++ (and failed), and hangers-on like #objectivec have given way to more "modern" platforms like #swift, Elixir was really the only truly "message-oriented" language left which had modern tooling and general support. Even #javascript has largely given way to #typescript which inherits much of the C++ style of OOP from C#, and there are standards afoot in the #ecmascript community to add typing to javascript itself.

Now, Elixir too has given in to market pressure to add strong typing. The arguments I have heard are usually that the system can't scale adequately for large teams.

I understand that. There's a reason strong typing has been on the rise over the last 20 years. Teams without it tend to fall into a mire of unusable code more quickly than those without it.

Of course, I'd argue that this is merely hiding the cause of the problem by suppressing the symptom of over-complex engineering. But, nevertheless, it has made commercial sense.

What I'm most sad about is that Elixir was placed to innovate in ways which non of the other communities were. Elixir could have been, should have been, the language to innovate beyond the need for type systems. Elixir was a perfect language to carry us toward new mental models which more cleanly reflected message-oriented programming. With the introduction of typing, Elixir will inevitably fall into the well trodden paths of other languages, moving further away from the truly innovative roots that Joe Armstrong brought us.

And so, I find myself going back to javascript these days. At least there I can implement message-oriented systems in ways which benefit from the highly optimised, looser typing which modern javascript engines bring us.

But, as mentioned above, this can only be a temporary stopping point. Javascript too is moving toward strong typing. And, I don't think it will be able to hold off the paradigm for much longer.

Maybe #golang can save us? It's certainly true that Go has excellent primitives for light-weight programming. But, things like client-side interfaces are so beautiful that I don't tend to write much message-oriented programming in Go.

I think, I hope, that truly new things will emerge soon. Rust came along and upset the C++ applecart in ways we never expected. So, perhaps, the next big thing will restore message-oriented programming to its rightful place.

Until then, I think I'm going to go back to Erlang and the BEAM for the work I was doing in Elixir. Maybe it's time for a new BEAM-based language?