Elixir: Scalable and Efficient Application Development

In this video, we will understand basic literal types in Elixir and how we can begin writing Elixir programs. We will cover the following topics:

• Introduce numeric types and operators
• Introduce logical (Boolean) types and comparison expressions
• Introduce text types – Strings – and some functions to manipulate them

In this video, we will learn to build more complex data structures using the built-in collection types in Elixir. We will also understand its uses. We will cover the following topics:

• Present lists and their building blocks
• Introduce tuples and how do they compare to lists
• Present key-value types and an example of their usage

In this video, we will understand what pattern matching is and how does it differ from assignment. We will also learn the uses of pattern matching.

• Introduce the concept of assignment
• Define pattern matching as opposed to assignment
• Present the pin operator

In this video, we will see how can we leverage pattern matching to extract data from complex structures. We will cover the following topics:

• Introduce pattern matching in collection types
• Present the binary data type in Elixir
• Extract binary data using pattern matching

In this video, we will understand functions in Elixir. We will learn to define and compose them. This video will cover the following topics:

• Recap the concept of a function, now applied to Elixir
• Define call and chain functions together
• Define functions in modules and compose them

In this video, we will understand how we can leverage pattern matching in function calls and match a call with specific arguments to a concrete function. This video covers the following topics:

• Present a use case and a concrete problem
• Provide a solution for the problem using pattern matching
• Introduce function guard clauses and complete use case

In this video, we will understand what anonymous functions are and their part in making code reusable. We will also explore how does this play with functional programming. This video covers the following topics:

• Recap high order functions
• Present a use case and sample solution
• Analyse the Enum module as a use case

In this video, we will learn recursion and understand its designing recursive computations. This video will cover the following topics:

• Recap the concept of a function, now applied to Elixir
• Define recursion using functions
• Learn the types of recursion

In this video, we will understand how to execute branching paths in Elixir along with using them in control flow. This video will cover the following topics:

• Recap pattern matching
• Explain conditionals using an age discount example
• Learn the different types of conditionals

In this video, we will see what exceptions are and how can we trigger and handle them. This video will cover the following topics:

• Start from a single function
• Use an example to handle any exception
• Learn how to raise exceptions

In this video, we will learn standard IO and see how can we write strings to the terminal screen along with reading from the keyboard. We will cover the following topics:

• Define standard IO and IO module devices
• Use this in an example to read from the keyboard
• Learn how to write on screen using standard IO

In this video, we will learn the manipulation of files using Elixir. We will cover the following topics:

• Define the file module
• Learn how to create a directory
• Learn the different actions in a file

Now that we have most of the basics of processes in Elixir, let's try out some examples and applications.

There will be a progression through these examples. We will start pretty small and grow in complexity.

Work pools are similar in concept to thread pools. There is some static allocation of worker threads that are able to execute general purpose work. Given some task, the thread or worker will run off, compute the work, and return the result.

Many topics surrounding Erlang/Elixir and OTP require us to be careful about our verbiage. We discussed before the difference between Erlang processes and OS processes. Similarly, we need to be careful about applications.

In this video, we will cover the following topics:

• Present the Mix toolset and how to create an GIF generation application
• Show the structure of a common application and its files
• Compile an application and run it interactively with iex -S mix

In this video, we will see how can we leverage the use of third-party dependencies to enrich our application. Where we can get these dependencies and how do we make them work with our application. We will cover the following topics:

• Present a use case for dependencies on our application
• Use the Hex package manager to search and import a dependency
• Configure dependencies and test the application with them

In this video, we will see what are unit tests, how we can test our application automatically to ensure everything is working as expected and isolate the components of our application to test them effectively.

• Complete the GIF generator application with all functionality
• Present unit tests and discuss their viability with the current application structure
• Change the application structure to allow for isolated unit testing

Before we dive into the depths of metaprogramming, we need to discuss some related functionalities of Elixir that provide polymorphic features to the language. These are behaviours and protocols.

ASTs are not just a concept of your programming language course. They are real and very useful in the real world.

Since macros are about injecting code, special care must be taken for the context, of both the caller and the context of the macro.

We've mentioned process trees several times already, and it's time we discuss them in-depth.