Design Goals of Elixir

If you’re trying to study a new programming language, we suggest checking out Elixir and the design goals of elixir. Elixir is a process-oriented, useful programming language that runs on the Erlang virtual machine (BEAM). The language became prompted by Ruby. This idea may be seen and felt in Elixir’s environment and tooling options. Elixir is considered smooth to study and broadly relevant in the software program development industry.

Elixir is a general-purpose, useful, concurrent programming language created by José Valim. Valim worked at the Ruby on Rails team, and he was determined to develop Elixir after experiencing problems while looking to enhance the overall performance of Ruby on Rails. He aimed to create a language that would run on the height of Erlang’s VM, BEAM, and that would be like-minded with the Erlang environment.

This blog is a summary of those talks, focusing on the design goals of elixir: compatibility, productiveness, and extensibility.

Compatibility

Elixir is supposed to be well-matched with the Erlang VM and the present environment. When we speak about Erlang, we can break it into 3 parts:

• A useful programming language, known as Erlang
• A set of design/layout principles, known as OTP
• The Erlang Virtual Machine called EVM or BEAM

Elixir runs withinside the identical digital device and is well-match with OTP. Not only that, all of the tools and libraries to be had withinside the Erlang environment also are to be had in Elixir, definitely due to the fact there’s no conversion fee from calling Erlang from Elixir and vice-versa.

We regularly say that the Erlang VM is Elixir’s most powerful asset.

All Elixir code is done by internal lightweight techniques (actors), each with its state, that exchange messages among each other. The Erlang VM multiplexes the one’s techniques onto many cores, making it trivial to run code concurrently.

In reality, in case you assemble any Elixir code, which includes the Elixir source, you’ll see all cores in your device getting used out of the box. With technology like Parallella turning into extra handy and affordable, it’s far more difficult to disregard the energy you may get out of the Erlang VM.

Finally, the Erlang VM become designed to construct systems that run forever, self-heal, and scale. Joe Armstrong, certainly considered one of Erlang’s creators, has currently given a great talk about the design selections at the back of OTP and the VM.

Productivity

Productivity is, in general, a tough aim to measure. A language productive for developing computer programs might not be productive for mathematical computing. Productivity relies directly on the sector in that you intend to apply the language, the to-be-had tools withinside the atmosphere and the way smooth it miles to create and increase the one’s tools.

For this reason, we’ve got opted for a small language core. For instance, even as some languages have if, case, try, and so on as language keywords, each with its very own regulations withinside the parser, in Elixir they’re simply macros. This permits us to implement a maximum of Elixir in Elixir. And additionally permits developers to increase the language usage of the equal tools we used to build the language itself, frequently extending the language to the particular domain names they’re operating on.

Since a macro gets the code representation as arguments, we can surely convert an unless into an if at compile time.

Macros also are the base assemble for meta-programming in Elixir: the cap potential to write down code that generates code. Meta-programming permits developers to effortlessly put off boilerplate and create effective tools. A common instance referred to in talks is how our test framework makes use of macros for expressiveness. 

Syntax

Although syntax is typically one of the first subjects that comes up when Elixir is discussing. It was never an aim to definitely offer distinctive syntax. Since we desired to offer a macro system, we knew that the macro system could best be sane if we should constitute Elixir syntax in terms of Elixir’s very own data structures in a straight-ahead fashion.

Extensibility

By constructing on the top of a small core, the maximum of the constructs withinside the language may change and prolong. As it is required by developers to goal unique domains. However, there’s a specific area that Elixir is inherently suitable at. That’s constructing concurrent, distributed applications, thanks to OTP and the Erlang VM.

Elixir enhances this area by offering a general library with:

• Unicode strings and Unicode operations. 
• An effective unit test framework.
• More Data Structure like ranges, inclusive of novel implementations for units and dictionaries.
• Polymorphic records (in the evaluation of Erlang’s compilation-time best records).
• Strict and lazy enumeration APIs.
• Convenience features for scripting, like operating with paths and the filesystem.
• A PM tool to compile and check Elixir code. 

And a lot more.

Summing up the Design Goals of Elixir

The aim of this blog became to summarize the design goals of elixir: compatibility, productivity, and extensibility. By well suited to the Erlang VM, we’re offering developers some other tool sets for building concurrent, distributed, and fault-tolerant systems.

We additionally desire to have clarified what Elixir brings to the Erlang VM. In particular, meta-programming via macros, polymorphic constructs for extensibility, and a data-focused well-known library with extensible and constant APIs for various types. It consists of strict and lazy enumeration, Unicode handling, a test framework, and more.

BACK