When comparing Julia vs Elixir, the Slant community recommends Elixir for most people. In the question“What is the best programming language to learn first?” Elixir is ranked 9th while Julia is ranked 12th. The most important reason people chose Elixir is:
Leverages the existing Erlang BEAM VM
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Almost as fast as C
Julia runs almost as fast as (and in fact in some cases faster than) C code.
Pro Strong dynamic typing
Dynamic and high level, but does not isolate the user from properly thinking about types. Can do explicit type signatures which is great for teaching structured thinking.
Pro Great standard REPL
Out of the box Julia has a very good Read-Eval-Print-Loop, which both completes functions and types, as well as completion based on history of previous statements. It integrates well with the shell and has an excellent online help system.
Pro Nice regular syntax
Julia code is easy to read and avoid a lot of unnecessary special symbols and fluff. It uses newline to end statements and "end" to end blocks so there is no need for lots of semicolons and curly braces. It is regular in that unless it is a variable assignment, function name always comes first. No need to be confused about whether something is a method on an object or a free function.
Unlike Python and Ruby, since you can annotate the types a function operates on, you can overload function names, so that you can use the same function name for many data types. So you can keep simple descriptive function names and not have to invent artificial function names to separate them from the type they operate on.
Pro Written in itself
The Julia language is written in itself to a much larger extent than most other languages, so a budding programmer can read through the depths of the standard library and learn exactly how things work all the way down to the low-level bit-twiddling details, which can be englightening.
Pro Powerful n-dimensional arrays
Julia has built in n-dimensional arrays similar in functionality as Python's numpy.
Pro Function overloading
You can have multiple functions with the same name, but doing different things depending on function arguments and argument types.
Pro Amazing learning curve
Julia requires no boilerplate code – a beginner needs to write only the parts they care about. This combined with the REPL provides the best learning experience available.
Pro High-level code
Julia provides a high level of abstraction, making platform-independent programming trivial and easing the learning curve.
Pro Function and operator broadcasting
You can perform operations on scalars, for example 2^2 or [1, 2, 3].^2.
Pro Strong Metaprogramming
Julia allows you to edit Julia code in the language itself and write powerful macros. It is a great introduction to metaprogramming features
Pro REPL-based
The Julia REPL allows quickly testing how some code behaves and gives access to documentation and package management immediately in the REPL.
Pro Great for concurrency
Leverages the existing Erlang BEAM VM
Pro Great getting started tutorials
The tutorials are very clear and concise (even for a person not used to functional programming). Plus they are also very mobile friendly.
Pro Powerful metaprogramming
Write code that writes code with Elixir macros. Macros make metaprogramming possible and define the language itself.
Pro Full access to Erlang functions
You can call Erlang functions directly without any overhead: https://elixir-lang.org/getting-started/erlang-libraries.html
Pro Scalability
Elixir programming is ideal for applications that have many users or are actively growing their audience. Elixir can easily cope with much traffic without extra costs for additional servers.
More details can be found here.
Pro Great as a first functional programming language!
Pro Great documentation
Elixir's documentation is very good. It covers everything and always helps solving any problem you may have. It's also always available from the terminal.
Pro Syntax is similar to Ruby, making it familiar for people used to OOP
All of the benefits of Erlang; without as steep a learning curve of prolog based syntax. Elixir is heavily inspired by Ruby's syntax which many people love.
Pro Easy to download libraries
Comes with built in build tool called "mix". This will automatically download libraries and put them in the scope of the application when you add them to the "deps" function and run mix deps.get
Cons
Con Young language with limited support
Julia was released in 2012. Due to its short existence, there is a limited amount of support for the language. Very few libraries exist as of yet, and the community is still quite small (though growing quickly).
Con 1-based array and column major
This design probably comes from Matlab, but makes it unnatural to interface C and C++ and python.
Con Deployment is still not as easy as it should be
Con Some design choices may seem strange
Some design choices could have been a little more appealing, for example: using "do...end" comes natural in Ruby for blocks but Elixir uses them for everything and it looks pretty weird:
Enum.map [1, 2, 3], fn(x) -> x * 2 end
or
receive do
{:hello, msg} -> msg
{:world, msg} -> "won't match"
end