Elixir Interview Questions and Answers 2025

Elixir is a functional, concurrent, general-purpose programming language that runs on the Erlang VM.

Elixir emphasizes immutability and first-class functions, which are key principles of functional programming.

The 'mix' tool is used to create, compile, and manage Elixir projects.

A module in Elixir is defined using the 'defmodule' keyword followed by the module name.

Pattern matching is a powerful feature in Elixir that allows you to match and destructure data.

Functions in Elixir are defined using the 'def' keyword inside a module.

The pipe operator is used to chain function calls, passing the result of one function as the input to the next.

An atom is a constant whose value is its own name, often used as identifiers.

Lists in Elixir are created using square brackets, e.g., [1, 2, 3].

Lists are linked lists, while tuples are fixed-size collections stored contiguously in memory.

Concurrency in Elixir is handled using lightweight processes and the Actor model.

The 'Enum' module provides functions for working with enumerables like lists and maps.

Maps in Elixir are defined using the %{} syntax, e.g., %{key: value}.

The 'iex' shell is an interactive Elixir shell used for testing and debugging code.

Immutability means that data cannot be changed once created; instead, new data structures are created.

Supervisors are processes that monitor other processes to ensure fault tolerance by restarting them if they fail.

'GenServer' is used for long-lived processes with state, while 'Task' is for short-lived asynchronous operations.

A struct is a special map with a defined set of keys and default values, created using 'defstruct' inside a module.

The 'Agent' module provides a simple abstraction for managing state in a process.

Elixir uses the 'let it crash' philosophy with Supervisors to recover from errors by restarting processes.

'spawn' creates a new process, while 'spawn_link' creates a process linked to the parent for error propagation.

The 'Stream' module is used for lazy enumeration, allowing you to work with potentially infinite data streams.

Protocols enable polymorphism by defining a set of functions that can be implemented for different data types.

A behaviour is implemented by defining a module that adheres to the callbacks specified in the behaviour.

The 'Registry' module provides a way to register and look up processes by name.

ETS is used for in-memory storage of large amounts of data, accessible by multiple processes.

'send' is used for sending messages to processes, while 'cast' is an asynchronous call in 'GenServer'.

Macros are used to write metaprogramming code by transforming abstract syntax trees at compile time.

'Task.async' is used to start a task and retrieve its result asynchronously.

The 'with' construct is used for chaining multiple pattern matches and handling errors in a clean way.

The OTP framework provides tools and libraries for building robust, fault-tolerant, and scalable applications.

A custom protocol is implemented by defining a protocol using 'defprotocol' and providing implementations for specific data types using 'defimpl'.

The 'DynamicSupervisor' is used to manage a dynamic set of child processes, allowing you to add or remove children at runtime.

Elixir achieves fault tolerance through Supervisors, which monitor processes and restart them if they fail.

'GenServer.call' is synchronous and waits for a reply, while 'GenServer.cast' is asynchronous and does not wait for a reply.

The 'GenStage' module is used to build concurrent and data-driven workflows by defining producers, consumers, and producer-consumers.

The 'Flow' library is used for parallel and distributed data processing, built on top of 'GenStage'.

A stateful process is implemented using 'GenServer', where the state is maintained in the process loop.

The 'Node' module provides functions for interacting with distributed nodes in a cluster.

Inter-process communication is handled using message passing with 'send' and 'receive' constructs.

'Agent' is a simpler abstraction for state management, while 'GenServer' provides more control and flexibility for implementing server processes.

The 'Registry' module allows you to register processes with unique keys and look them up by those keys.

The 'Supervisor.Spec' module (deprecated in newer versions) was used to define child specifications for Supervisors.

A distributed task can be implemented using 'Task.async/1' or 'Task.async/3' with a specific node as the target.

The 'Logger' module is used for logging messages with different levels like debug, info, warn, and error.

The 'Mix.Config' module is used to manage application configuration in Elixir projects.

The 'Application' module is used to define and manage the lifecycle of an application, including starting and stopping processes.

A custom behaviour is implemented by defining a module with 'defcallback' and creating modules that implement the specified callbacks.

The 'Task.Supervisor' module is used to supervise tasks, ensuring fault tolerance and process management.

The 'ExUnit' framework is used for writing and running tests in Elixir, providing features like assertions and test case organization.