Elixir supports true and false as booleans:
iex> true
true
iex> true == false
false

as Perl

  %{}   for hash
  &()   for function

       iex(1)> 1..5 |> Enum.map(&(&1 + 3))
        [4, 5, 6, 7, 8]
       iex(2)> 1..5 |> Enum.map(fn x -> x + 3 end)
        [4, 5, 6, 7, 8]

    
  use Module

as Ruby

  def funcname        
  do                      # in Ruby without 'do'
    ...
  end

  --------------------------
  ruby        elixir
  ---------------------------
  :symbol     :atom
  param:      param:


  function params without brackets
  last param - code block with do:

vs Erlang

      ---------------------------------------------------------------------------
      erlang                                elixir
      ---------------------------------------------------------------------------      
      vars start with      Capital          vars start with        sMALL
      atoms start with       sMALL          atoms start with       :s|Small
      lambdas       fun -> ... end          lambdas            fn -> ... end
      ---------------------------------------------------------------------------
      -behaviour (application).             use Application
      -behaviour (supervisor).              use Supervisor
      -behaviour (gen_server).              use GenServer
      -behaviour (gen_event).               use GenEvent
               -                            use Agent
               -                            use Task
      -include_lib(".../eunit.hrl").        use ExUnit.Case, async: true
      ----------------------------------------------------------------------------
            Pid ! {hello}.                  send pid , {:hello}
      ----------------------------------------------------------------------------
  

messages

  send/2 
  receive/1

      iex> send self(), {:hello, "world"}
      {:hello, "world"}
      iex> receive do {:hello, msg} -> msg ; {:world, msg} -> "won't match" end
      "world"

spawn/1 and spawn_link/1 are the basic primitives for creating processes in Elixir

Input/Output

      iex> IO.puts "hello world"
       hello world
       :ok
      iex> IO.gets "yes or no? "
       yes or no? yes
       "yes\n"

    
      iex> {:ok, fd} = File.open "hello", [:write]
       {:ok, #PID<0.47.0>}
      iex> IO.binwrite fd, "world"
       :ok
      iex> File.close fd
       :ok
      iex> File.read "hello"
       {:ok, "world"}