Todo código Elixir roda dentro de pequenas threads (chamadas processos) que são isolados e trocam informações entre si.

current_process = self()

# Spawns an Elixir process (not an operating system one!)
spawn_link(fn ->
  send current_process, {:msg, "hello world"}
end)

# Block until the message is received
receive do
  {:msg, contents} -> IO.puts contents
end

Devido a sua natureza pequena, não é incomum ter centenas de milhares de processos executando simultaneamente na mesma maquina. O isolamento permite que os processos sejam coletados de forma independente, reduzindo as pausas do sistema e usando todos os recursos da máquina da maneira mais eficiente possível (escalonamento vertical).

Processos são também capazes de se comunicar com outros processos rodando em maquinas diferentes na mesma rede. Isto provê a base para a distribuição, permitindo os desenvolvedores trabalhar entre diferentes nôs (escalonamento horizontal).

The unavoidable truth about software running in production is that things will go wrong. Even more when we take network, file systems, and other third-party resources into account.

To cope with failures, Elixir provides supervisors which describe how to restart parts of your system when things go awry, going back to a known initial state that is guaranteed to work:

import Supervisor.Spec

children = [
  supervisor(TCP.Pool, []),
  worker(TCP.Acceptor, [4040])
]

Supervisor.start_link(children, strategy: :one_for_one)

Programação funcional promove um estilo de código que ajuda os desenvolvedores escrever um código menor, rápido, e mantenível. Por exemplo, pattern matching permite desenvolvedores a facilmente desestruturar informações e acessar seu conteúdo:

%User{name: name, age: age} = User.get("John Doe")
name #=> "John Doe"

Quando misturado com guards, o pattern matching nos permite combinar e afirmar com elegância condições específicas para que algum código seja executado:

def serve_drinks(%User{age: age}) when age >= 21 do
  # Code that serves drinks!
end

serve_drinks User.get("John Doe")
#=> Fails if the user is under 21

Elixir depende muito desses recursos para garantir que seu software esteja funcionando sob as restrições esperadas. E quando não é, não se preocupe, os supervisores têm a sua volta!

Elixir has been designed to be extensible, letting developers naturally extend the language to particular domains, in order to increase their productivity.

Como por exemplo, vamos escrever um simples caso usando um framework de teste para Elixir chamado ExUnit:

defmodule MathTest do
  use ExUnit.Case, async: true

  test "can add two numbers" do
    assert 1 + 1 == 2
  end
end

A opção async: true permite tests rodar em pararelo, usando tantos núcleos de CPU quanto possível, enquanto o assert funcionadade pode introspeccionar seu código, provendo ótimos reportes em caso de falhas. Essas falhas são construidas usando Elixir macros, fazendo isso possível para adicionar novas construções como se elas fossem parte da própria linguagem.

Elixir vem com um grande conjunto de ferramentas para facilitar o desenvolvimento. Mix é uma ferramenta de build que permite você criar facilmente projetos, manusear tarefas, rodar testes e mais:

$ mix new my_app
$ cd my_app
$ mix test
.

Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
1 tests, 0 failures

Mix é também capaz de manusear dependências e integra-las muito bem com o Hex package manager, o qual prove uma resolução de dependências e a habilidade de fazer fetch nos pacotes remotamente.

Ferramentas como IEx (Shell iterativo do Elixir) são capazes de alavancar muitos aspectos da linguagem e da plataforma e proveem auto-complete. ferramentas para debug, recarremento de códgio, bem como documentação bem formatada:

$ iex
Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
iex> c "my_file.ex"        # Compiles a file
iex> t Enum                # Prints types defined in the module Enum
iex> h IEx.pry             # Prints the documentation for IEx pry functionality
iex> i "Hello, World"      # Prints information about the given data type

Elixir roda na VM do Erlang dando aos desenvolvedores um acesso completo ao ecossistema Erlang, usado por empresas como Heroku, WhatsApp, Klarna, Basho e muitas mais para construir aplicações tolerante a falhas e distribuidas. Um programador elixir pode invocar qualquer função sem custo de tempo de execução:

iex> :crypto.hash(:md5, "Using crypto from Erlang OTP")
<<192, 223, 75, 115, ...>>

Para aprender mais sobre Elixir, verifique nosso guia de início rápido. Nós também temos umadocumentação online disponível e um Crash Course para desenvolvedores Erlang.