DEV Community: Carlos Ramírez

Elixir data types Part 2

Carlos Ramírez — Mon, 08 May 2023 14:51:41 +0000

Introduction

In the previous part, we learned about some basic data types in Elixir, such as atoms and booleans. In this part, we will explore some more data types that are commonly used in Elixir programs: integers, floats, and strings.

Integers/Floats

Integers and floats are numeric data types that represent whole numbers and decimal numbers respectively. They can be used for arithmetic operations, such as addition, subtraction, multiplication, and division. For example:

# Integers
iex> 1 + 2
3
iex> 10 - 5
5
iex> 3 * 4
12
iex> 20 / 4
5.0

# Floats
iex> 1.5 + 2.5
4.0
iex> 3.14 - 1.0
2.14
iex> 2.0 * 1.5
3.0
iex> 10.0 / 3.0
3.3333333333333335

Notice that dividing two integers always returns a float, even if the result is a whole number. This is because Elixir uses floating-point arithmetic to perform division, which can introduce some rounding errors. If you want to get an integer result from division, you can use the div/2 function instead:

iex> div(20, 4)
5
iex> div(10, 3)
3

You can also use the rem/2 function to get the remainder of a division:

iex> rem(10, 3)
1
iex> rem(20, 4)
0

Integers and floats can also be written in different formats, such as binary, octal, hexadecimal, scientific notation, and underscore separators. For example:

# Binary
iex> 0b1010 # equivalent to 10 in decimal
10

# Octal
iex> 0o12 # equivalent to 10 in decimal
10

# Hexadecimal
iex> 0xA # equivalent to 10 in decimal
10

# Scientific notation
iex> 1.0e3 # equivalent to 1000.0 in decimal
1000.0

# Underscore separators
iex> 1_000_000 # equivalent to 1000000 in decimal
1000000

Strings

Strings are data types that represent sequences of characters enclosed in double quotes. They can be used for storing and manipulating text data, such as names, messages, and commands. For example:

# Strings
iex> "Hello"
"Hello"
iex> "World"
"World"

Strings can be concatenated using the <> operator:

iex> "Hello" <> " " <> "World"
"Hello World"

Strings can also be interpolated using the #{} syntax:

iex> name = "Alice"
"Alice"
iex> "Hello #{name}"
"Hello Alice"

Strings are encoded using UTF-8, which means they can contain any Unicode character:

iex> "こんにちは"
"こんにちは"
iex> "👋"
"👋"

Strings are also binaries, which means they are sequences of bytes that can be manipulated at a low level using binary pattern matching and functions from the Bitwise module. For example:

# Binary pattern matching on strings
iex> <<first::utf8, rest::binary>> = "Hello"
"Hello"
iex> first # the code point of the first character 'H'
72 
iex> rest # the rest of the string 'ello'
"ello"

# Bitwise operations on strings
iex> "Hello" &&& <<255>> # bitwise AND operation on each byte of the string with 255 
"Hello"
iex> "Hello" <<< 1 # bitwise left shift operation on each byte of the string by one bit 
<<136, 162, 162, 162, 176>>

Summary

In this part, we learned about three more data types in Elixir: integers, floats, and strings. Integers and floats are numeric data types that can be used for arithmetic operations and can be written in different formats. Strings are sequences of characters that can be used for text data and can contain any Unicode character. Strings are also binaries that can be manipulated at a low level using binary pattern matching and bitwise operations.

Thanks for reading! My goal is to make Elixir accessible and easy to understand for everyone. If you have any questions or feedback, please don't hesitate to reach out. And be sure to check back regularly for more articles on https://dev.to/calbertora, as I strive to make each post as clear and readable as possible.

Elixir data types Part 1

Carlos Ramírez — Tue, 02 May 2023 13:53:01 +0000

Introduction:

When it comes to programming in Elixir, understanding the different data types is crucial. We'll cover the main data types in Elixir and how to work with them effectively. In this first part, we'll explore atoms and booleans, two of the simplest yet most fundamental data types in Elixir.

Atoms

Atoms are constants that represent names or values. They start with a colon (:) followed by a sequence of alphanumeric characters, underscores, or @. For example, :hello, :ok, :user_id, and :@name are all valid atoms.

Atoms are useful for naming things, such as keys in maps or messages in processes. Atoms are also used to represent the result of some operations, such as true and false for boolean expressions, or :error and :ok for error handling.

Atoms are also very efficient, as they are internally represented by an integer and are globally unique. This means that two atoms with the same name will always refer to the same value, regardless of where they are defined or used.

At first this data type may seem not useful, but in future posts you will sure see how powerful this data type is.

Booleans

Booleans are a special kind of atom that can only have two possible values: true and false. Booleans are used to represent logical conditions, such as comparisons or predicates.

Booleans can be combined with logical operators, such as and, or, and not, to form more complex expressions. For example:

true and false # false
true or false # true
not true # false

Booleans can also be used in control flow constructs (more of this in a next post), such as if, case, and cond, to execute different branches of code based on some condition. For example:

if true do
  "Positive"
else
  "Negative"
end

Summary

In this article, we learned about two of the basic data types in Elixir: atoms and booleans. We saw how atoms are constants that represent names or values, and how booleans are a special kind of atom that represent logical conditions. We also saw how atoms and booleans can be used in various ways in Elixir programs.

I hope this article was helpful for you. If you want to learn more about Elixir data types, you can check out these sources:

Basic types - The Elixir programming language
Typespecs and behaviours - The Elixir programming language
Elixir - Data Types
Typespecs — Elixir v1.12.3

Mix

Carlos Ramírez — Tue, 25 Apr 2023 14:01:04 +0000

This is going to be the last (I hope) post that is not focused on programming. But, for me, it's important to know all the aspects I've written before dive into the language, because all of them are important tools in a day to day writing code in Elixir.

Mix is a build tool and package manager for Elixir. It is used to create, compile, and manage Elixir projects.

Mix is designed to simplify the build process of Elixir applications by automating tasks such as compiling modules, managing dependencies, and generating documentation. It also provides a testing framework to help developers ensure the quality of their code. In addition, Mix comes with a powerful set of tasks and plugins that make it easy to manage project tasks like running migrations or deploying code to production.

For example you can create Elixir projects with this:

> mix new my_elixir_project

If you need to add dependencies to your projects you have to add them to your mix.ex file and then in the terminal download those dependencies:

> mix deps.get

You can also run your tests to check that everything is working as expected:

> mix test

If you want to see all the options you have you could use the help

>  mix help
mix                   # Runs the default task (current: "mix run")
mix app.config        # Configures all registered apps
mix app.start         # Starts all registered apps
mix app.tree          # Prints the application tree
mix archive           # Lists installed archives
mix archive.build     # Archives this project into a .ez file
mix archive.install   # Installs an archive locally
mix archive.uninstall # Uninstalls archives
mix clean             # Deletes generated application files
...
...
...

Overall, Mix is an essential tool for any Elixir developer and helps to streamline the development process.

iex

Carlos Ramírez — Mon, 17 Apr 2023 14:01:01 +0000

Welcome back to my series on Elixir! In this post, we'll be exploring one of the most powerful tools in the Elixir developer's arsenal: iex. Short for "Interactive Elixir," iex is a command-line interface that allows you to interact with the Elixir language in real-time, making it an indispensable tool for debugging, testing, and exploring the capabilities of the language.

Whether you're a seasoned Elixir developer or just getting started, iex is a tool that you'll want to have in your toolkit. In this post, we'll be taking a deep dive into what iex is, what it's used for, and how you can use it to supercharge your Elixir development workflow. So grab a cup of coffee, fire up your terminal, and let's dive in!

As we saw previously, to start iex you just need to type iex in your terminal:

iex
Erlang/OTP 24 [erts-12.0.4] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit]

Interactive Elixir (1.13.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>

As you can see, it will show you the Erlang and Elixir version you are currently using. You can easily change this using asdf command as we saw previously.

You can type h to see the commands available in the terminal:

iex(1)> h

                                  IEx.Helpers

Welcome to Interactive Elixir. You are currently seeing the documentation for
the module IEx.Helpers which provides many helpers to make Elixir's shell more
joyful to work with.

This message was triggered by invoking the helper h(), usually referred to as
h/0 (since it expects 0 arguments).

You can use the h/1 function to invoke the documentation for any Elixir module
or function:

    iex> h(Enum)
    iex> h(Enum.map)
    iex> h(Enum.reverse/1)

You can also use the i/1 function to introspect any value you have in the
shell:

    iex> i("hello")

There are many other helpers available, here are some examples:

  • b/1            - prints callbacks info and docs for a given module
  • c/1            - compiles a file
  • c/2            - compiles a file and writes bytecode to the given path
...
...
...

Here, you can also work with Elixir data types and functions:

iex(2)> hello = :world
:world
iex(3)> foo = "bar"
"bar"
iex(4)> one = 1
1
iex(5)> print = fn text -> IO.puts text end
#Function<44.40011524/1 in :erl_eval.expr/5>
iex(6)> print.("Hey there")
Hey there
:ok

As you can see we can define variables, functions and execute those functions (we're going to deep dive into this in a later post)

In this command line you can also compile Elixir files. This is super hyper mega important as you will see in my future posts how we can use iex as a tool in our development process, not only for compiling Elixir files but complete applications.

In conclusion iex is an interactive shell that allows you to execute Elixir code and interact with the language in real-time. This is going to be one of your best friends in your career as an Elixir Developer.

Installing Elixir

Carlos Ramírez — Sun, 09 Apr 2023 00:08:57 +0000

As I said previously, I want to make my posts very short and concise and this is not going to be the exception.

If you're using Windows, I highly recommend install WSL so you will have the best of Linux and Windows at the same time.

Having said so, the commands I show here will work for MacOS, Linux and Windows(WSL).

I highly recommend installing Elixir with asdf since if you are lucky enough to work with Elixir in a professional project, you might find yourself changing the version several times, so for me, this is the best option for doing it so. So this guide will show you how to do it with asdf

The first thing you're going to do is install Homebrew (I know, you can install it directly as the official web page says, but I think it's way easier using Homebrew instead)

So, step 1. Install Homebrew:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Remember to add brew to your .zshrc .bashrc... file (or the one you're using).

export BREW_HOME="/home/linuxbrew/.linuxbrew/bin"
export PATH="$PATH:$BREW_HOME"

Step 2, install asdf:

brew install asdf

Step 3, add Erlang and Elixir plugin with asdf:

asdf plugin-add erlang https://github.com/asdf-vm/asdf-erlang.git

asdf plugin-add elixir https://github.com/asdf-vm/asdf-elixir.git

Step 4, install the latest Erlang and Elixir versions (or the one you want)

asdf install erlang 25.3

asdf install elixir 1.14.4

And that's all, you can change locally or globally your Elixir version with a single command.

Remember to add to your .bashrc (or the one you're using) the shims from asdf

export PATH=~/.asdf/shims:$PATH

You can type iex at your terminal to make sure that everything went well:

iex
Erlang/OTP 24 [erts-12.0.4] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit]

Interactive Elixir (1.13.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>

Note: as you might see I have Elixir 1.13.1 and Erlang 24.

Edit 1:
I added the .bashrc to the files to add the Homebrew variables

I added the shims path.

Introduction to Elixir

Carlos Ramírez — Sat, 01 Apr 2023 19:22:39 +0000

What is Elixir?

Elixir is a dynamic, functional programming language that is designed for building scalable and fault-tolerant applications.
It runs on the Erlang virtual machine, which provides powerful concurrency and distribution capabilities.

Why Elixir?

Elixir is a great choice for building applications that require high concurrency and fault tolerance, such as web applications, distributed systems, and real-time communication systems.

It is also designed to be easy to learn and use, with a simple and intuitive syntax that makes it accessible to developers of all skill levels.

Key features of Elixir

Elixir has a number of key features that make it a popular choice for developers, including:

Immutability: Elixir values are immutable by default, which helps to prevent bugs and makes it easier to reason about your code.

Pattern matching: Elixir uses pattern matching extensively, which allows you to write concise and expressive code.

Macros: Elixir has a powerful macro system that allows you to write code that generates other code, making it easy to create reusable abstractions.

Concurrency and Parallelism: Elixir provides built-in support for concurrency and parallelism through its lightweight processes, which are similar to threads but have much lower memory overhead. This makes it easy to write code that can handle multiple tasks simultaneously.

Getting started with Elixir

To get started with Elixir, you will need to install the Elixir compiler and set up your development environment.

Once you have done that, you can start exploring the language by writing simple programs, using online resources and tutorials to guide you.