Hello, Elixir: Basic Types and Immutability

What you'll build

A small greeting and price script that uses atoms, strings, interpolation and arithmetic, and shows that "changing" a value really means creating a new one.

The idea

Elixir is a functional language that runs on the BEAM, the Erlang virtual machine built for telecom systems that must never go down. It's known for concurrency (millions of lightweight processes), fault tolerance, and the Phoenix web framework (with LiveView for real-time UIs).

Run code with:

iex                      # the interactive shell
elixir script.exs        # run a script
mix new my_app           # create a project (mix is the build tool)

Basic types: integers (any size), floats, atoms (named constants like :ok, :error; true, false and nil are atoms too), strings (UTF-8, double quotes, "#{expr}" interpolation), lists [1, 2], tuples {:ok, 1} and maps %{name: "Ana"}.

Immutability: data never changes in place. String.upcase(name) returns a new string; name is untouched. Variables can be rebound to new values, but the old value itself is never modified, which makes concurrent code safe by default.

IO.puts prints a string; IO.inspect prints any value in its literal form (great for debugging, and it returns the value so you can drop it into pipelines).

The code

name = "ana silva"
status = :active
price = 19.99
quantity = 3

IO.puts("Hello, #{name |> String.split() |> Enum.map(&String.capitalize/1) |> Enum.join(" ")}!")
IO.puts("Status: #{status}, is an atom: #{is_atom(status)}")
IO.puts("Total: #{Float.round(price * quantity, 2)}")
IO.puts("Integer division: #{div(7, 2)}, remainder: #{rem(7, 2)}, float division: #{7 / 2}")
IO.puts("Big integers are fine: #{2 ** 100}")

upper = String.upcase(name)
IO.puts("upper: #{upper}, original still: #{name}")   # functions return new data

name = "ben"                                         # rebinding points the name at a new value
IO.puts("rebound: #{name}")

IO.inspect({:ok, "saved"})
IO.inspect(%{name: "Ana", langs: ["Elixir", "Rust"]})
IO.inspect(String.length("héllo"), label: "characters")
IO.inspect(byte_size("héllo"), label: "bytes")

Hello, Ana Silva!
Status: active, is an atom: true
Total: 59.97
Integer division: 3, remainder: 1, float division: 3.5
Big integers are fine: 1267650600228229401496703205376
upper: ANA SILVA, original still: ana silva
rebound: ben
{:ok, "saved"}
%{name: "Ana", langs: ["Elixir", "Rust"]}
characters: 5
bytes: 6

Common mistakes

• Single quotes. 'hello' is a charlist (a list of code points), not a string; use double quotes.
• Expecting mutation. String.upcase(name) alone does nothing visible; bind or pipe the result.
• length vs byte_size. Strings are UTF-8; String.length counts characters, byte_size counts bytes.
• / returns a float. Use div/2 and rem/2 for integers.

Key points

• Elixir runs on the BEAM: concurrency and fault tolerance built in.
• Atoms (:ok), strings with #{} interpolation, lists, tuples, maps.
• Data is immutable; functions return new values; variables can be rebound.
• IO.puts for strings, IO.inspect for any value (with label:).

Further reading: Elixir getting started: basic types.