Two months ago I started working professionally on an Elixir project. I had no previous Elixir experience, but I am picking it up at a reasonable pace (previous experience with Rust, Haskell and non-blocking programming in general have proved very useful). One of the things that I find myself missing is the top-notch IDE support I used to have in C# and Typescript, which gave me an incredible productivity boost and made it possible to find my way in new codebases very quickly. Unfortunately, IDE support for Elixir is quite basic at the moment, and my productivity suffers from it (though the fact that I am still learning the language also accounts for the productivity hit). Did anyone here have to adapt to Elixir coming from statically typed languages with great IDE support? How did you adapt?
Some concrete things that boost my productivity as a programmer, which I find myself missing, are:
Find all usages of functions, modules, struct fields, etc.
Rename functions, modules, struct fields, etc and have their usages automatically updated.
A strict compiler that catches type errors, enabling things like âtype-error driven developmentâ, where you change something and chase the compiler errors until everything is fixed (it is almost magical to fix all errors and see that the change you introduced âjust worksâ!).
Without these features, I notice that I am much less confident about changing existing code, which I find problematic, because frequent refactoring is often necessary to keep a codebase healthy. Writing new code is not a problem, though.
For the time being, I am using plain textual search a lot (which doesnât really cut it given the size of the codebase, but I know of nothing better at the moment), using @spec wherever it makes sense (it is not as nice as proper types, but it helps a bit) and writing tests to ensure everything is working properly (ExUnit is great).
By the way, I understand that many of these features are incredibly complex or even impossible to have in a language such as Elixir, so it is probably not a matter of waiting until the tooling gets better. That is why I am looking for ways to adapt my workflow as a programmer, since I assume I am not the first one to stumble upon these obstacles.
Iâm looking forward to your suggestions and insights!
Iâd recommend you let it go and use testing (unit testing and property based testing) to get to the same level of confidence. If you write idiomatic elixir/erlang code youâll end up writing pretty robust code (although it might hard to use OTP abstractions at first).
Neovimâs support for elixir through LSP is pretty good and the IntelliJ plugin is nice.
However when I was taught programming it was with a pencil and paperâŠ
Consider writing your core business logic in Gleam because Elixir is not (and is likely never) going to give you the type-driven development experience of Haskell.
I have a modern 50,000 line Elixir codebase that uses best practices like Credo, Dialyzer and test suites for its core business logic and it never gives me enough refactoring confidence.
Iâm considering moving its core business logic to Gleam, which has a lot of Elm influence, and some new IDE support in its latest release (but that aspect is also still a work-in-progress).
Something we often tell people coming to Elixir from Ruby is that despite how it looks with the obvious Ruby influence on syntax, Elixir isnât Ruby and there are some stark and fundamental differences.
So thatâs something I would say here too - keep in mind Elixir isnât C# or Typescript and while you may be leaving some things from those ecosystems behind, you will be gaining others (for instance, whatever the reasons might be why you have found yourself working with Elixir now).
With regards to working with Elixir itself, you might find these threads interesting:
Personally I think neovim is great, and if you want to see it in action (as well as Dialyzer) you may want to go through PragDaveâs course:
Take a look at Compilation tracers , itâs not going to be on the IDE but you could probably write a tracer to dump to a file and use your IDEâs go to file/definition to jump around.
Thanks for your answers! I forgot to mention I am currently using vscode with the ElixirLS and Elixir Test extensions. I assume other IDEs offer a somewhat similar development experience (btw I tried IntelliJ a few months ago, but it didnât work as smoothly).
Right now it looks like I will need to get used to basic IDE / compiler support and hope the features of the language compensate for that. Some that are already proving very useful are:
Process as a first class citizen (I really like the idea of putting state in processes rather than objects, because you are forced to think up-front about supervision)
Easy multi-node programming (I recently had the joy of using a replicated Nebulex cache; with just a few lines of code, everything magically worked, whereas in other language I would have needed to deploy an additional service like Redis)
My hope is that these and other benefits will in the end outweight the limitations caused by lack of static typing (and the great IDE they usually enable). Thanks to @AstonJ for pointing this out!
Now if anyone has any tricks to keep a codebase maintainable, Iâd be glad to hear them (maybe there is a cheat sheet somewhere). One trick I am already applying is to use structs for GenServer state, and pattern match on the struct when handling messages, so you get compiler warnings if you try to access non-existent fields and get autocomplete support in the IDE.
Itâs great for enforcing some architecture/boundaries on a code base and it can also generate nice images of the boundaries that youâve defined in your application.
To OP, welcome⊠and welcome to dynamically typed languages!
For me, Elixir is the perfect balance between Ruby (dynamically typed, interpreted, aka literally zero static analysis) and something like Rust (statically typed, compiled, very strict static analysis). The compiler and dialyzer warnings are enough for me to be happy in dynamically typed land. But it wonât give that ease of refactoring / IDE support as in a static typed language.
This library has just been published, I havenât tried it yet and it seems fairly early stage but it could be helping with the refactoring story.
I understand that Dialyzer and typespecs do not provide the experience youâre looking for, but the new missing_return and extra_returnflags added in OTP25 are quite a nice improvement. I was never able to turn on underspecs/overspecs due to the amount of false positives, but the new flags are catching legit type errors.
Hi @aochagavia! I also came to Elixir from statically typed languages, one of which was F#. I am still struggling a bit with Elixir to a degree because with dynamic languages, there seem to be a wide variety of different styles of programming. For me, I find it unacceptable to have to read a functionâs (and its subfunctionsâ) implementations to understand what it does. I want @typedoc and @spec and the function and argument names to tell me that. I donât think youâll necessarily find that in most Elixir codebases. However, many seemingly seem comfortable moving through such codebases and making changes. Iâm simultaneously impressed but also suspicious, because I have found several bugs because of this in those codebases.
For me personally, I use Visual Studio Code with the ElixirLS extension (ElixirLS: Elixir support and debugger - Visual Studio Marketplace). The extension plus features of Visual Studio Code can help somewhat for your (1) and (2) but definitely not what youâre used to with Visual Studio (I presume). But as far as I know, itâs about as good as youâre going to get right now. For (3), ElixirLS will dynamically display type information, but itâs usually way too generic to be useful. I personally shoot for 100% coverage of typespecs (I see almost no reason not to) and then use Dialyzer. Dialyzer is not really a type checker. Itâs sort of its own thing, but itâs as close as youâre going to get to help with this.
In Elixir, you can accomplish type-driven development, and this is definitely something I strive for. Use structs as much as possible and define @type t() :: ... for them so that you can use that type definition in modules that use your structure, including in the module that defines that struct with __MODULE__.t(). I also heavily use @type definitions to create domain-specific types that help make my code easier to read and understand, while also utilizing Dialyzer.
For the most part, Iâd say 95% of code away from I/O and process/message boundaries in Elixir and Erlang does not need to be dynamic. So, I treat if it was statically typed via detailed @spec usage, clear argument names, custom @type definitions, and using Dialyzer.
This is certainly an opinionated stance, but I personally see no other way to write solid code that is easily read and maintained and can onboard new developers.
There is no fundamental reason why an advanced and modern IDE experience doesnât exist yet. Itâs just that Elixir is new and it hasnât been taken on by somebody.