Gain insights into data processing and concurrency in Elixir. Explore GenServer, GenStage, Flow, and Broadway to enhance performance, set up pipelines, and handle increased workloads efficiently.

Concurrent Data Processing in Elxir by The Pragmatic Programmer-01.png

myDokcer.tar.gz

ch1_1

ch_3

ch_3.1

ch1_1-task supervisor

ch_4.1

ch_5.1 RabbitMQ

Ch_5.2 RabbitMQ

Most engineers don’t think that concurrency is distinct from programming. Data processing includes transforming information in some way, like reporting, data aggregation, or analytics. On the other hand, concurrency involves significantly improving performance.

This course is designed to help you navigate the world of concurrency tools available in the Elixir ecosystem. You’ll explore popular modules and libraries like GenServer, GenStage, Flow, and Broadway. You’ll be able to ingest data, set up pipelines, and run concurrent processes with Elixir.

By the end of the course, you’ll have a wide range of new techniques to simplify your product, improve code performance, and make your application more resilient to increased workloads.

Concurrent Data Processing in Elixir

We used `Task.Supervisor` to isolate a process crash, but it may seem strange that we didn’t prevent the crash by simply adding error handling in the `send_email/1` function. In this particular case, we did so on purpose to simulate an unexpected exception. In practice, we should provide error handling when we expect an error to occur, and leave the rest to the supervisor as a last resort.

# Error handling in Elixir

<p align="center">
<img src="/udata/1Mpxp2xLXvz/Error.png" width=200px/>
<p>

When discussing error handling for Elixir, the phrase “let it crash” is often used. As a result, some people assume that “let it crash” means that Erlang and Elixir developers don’t do any error handling, which is not the case. Pattern matching and the `macro` construct in Elixir make working with `{:ok, result}` and `{:error, msg}` tuples easy. This approach is widely used in the community. Elixir also has `try` and `rescue` to catch exceptions, similar to `try` and `catch` in other languages.

However, as much as we try, we know that errors can happen. This often leads to something called **defensive programming**. It describes the practice of relentlessly trying to cover every single possible scenario for failure, even when some scenarios are very unlikely to happen and not worth dealing with.

# Defensive programming in Erlang and Elixir



Understand how to stop a program from crashing using error handling.

Getting Started

Easy Concurrency with the Task Module

Long-Running Processes Using GenServer

Data Processing Pipelines with GenStage

Process Collections with Flow

Data Ingestion Pipelines with Broadway

Concluding the Course

Understand the “Let It Crash” Philosophy

Error handling in Elixir