Functional Programming and Erlang Platform

Table Of Contents Functional Programming Paradigm Imperative Programming Declarative Programming Object-Oriented Programming (OOP) Functional Programming Paradigms Used by Erlang and Elixir Basic Principles of Functional Programming Erlang Development Platform Highly Available Systems Concurrency in Erlang A Complete Development Platform References Functional Programming Paradigm Every programming language is built upon one or more programming paradigms, which are distinct ways of thinking that shape how we write code, manage data, and structure solutions. Understanding these paradigms helps us choose the most effective approach to solve a problem. Let’s explore some commonly used paradigms. Imperative Programming The imperative paradigm is a programming approach where we give the computer step-by-step instructions on how to complete a task. We explicitly define the sequence of actions, from initialization to the final steps of the process. Here’s an example in Python: total = 0 for i in range(5): total += i This code sums the numbers from 0 to 4. Each step is clearly defined: initializing the variable, looping, and accumulating the total. Languages like Python, C, and Java support this paradigm very well. Declarative Programming The declarative paradigm focuses on what you want to achieve, rather than how to achieve it. You simply declare your goal and let the system (such as a compiler or runtime engine) handle the implementation details. Here’s an example in SQL: SELECT * FROM users WHERE is_active = 1; We don’t explain how to scan the table or filter the data; we simply state that we want all active users. Other examples of declarative programming can be found in HTML and regular expressions (regex). Object-Oriented Programming (OOP) The object-oriented paradigm is an approach that organizes an application into a collection of objects. Each object holds data (called state) and provides methods (functions) to operate on that data. These objects interact with each other to form the logic of the application. Here’s an example in Java: class Car { String brand; void moveForward() { System.out.println("Moving Forward -->"); } } Car myCar = new Car(); myCar.moveForward(); In this example, we define a Car class that specifies attributes and behavior, then create an object myCar that executes its own logic. This paradigm helps organize code by combining data and behavior into a single unit. Languages like Java, Python, and JavaScript provide strong support for object-oriented programming. Functional Programming The functional paradigm is an approach that builds programs from many small functions composed together. Each function takes input, processes it, and returns output without modifying anything outside itself (no side effects). Here's an example in Elixir: numbers = [1, 2, 3, 4, 5] numbers |> Enum.filter(fn x -> rem(x, 2) == 0 end) |> Enum.map(fn x -> x * 2 end) This code filters even numbers and then doubles them. The data transformation flows from one function to the next. This style encourages writing clean, modular, and testable code. Languages like Erlang and Elixir are designed to support this paradigm. Paradigms Used by Erlang and Elixir Erlang and Elixir combine two main paradigms: Declarative - Focused on what you want to achieve, not how to achieve it. The runtime handles execution details. Functional - Logic is built from pure functions that can be composed into more complex behavior. This combination enables a concise, modular, and testable coding style, which is ideal for building reliable, large-scale, and high-availability systems. This is why the paradigm is widely used in telecommunications, real-time services, and distributed applications that demand high reliability. Basic Principles of Functional Programming Here are some fundamental principles of functional programming: Immutability - In this paradigm, data is immutable, meaning it cannot be altered once it is created. If we want to "change" its value, what actually happens is that a new copy is created with the updated content. This approach is called data transformation rather than modification. Immutability helps us avoid many bugs caused by unexpected changes to data and makes it easier to trace the flow of data in the program. Pure functions - A pure function always produces the same output for the same input. It does not depend on any external data and does not modify anything outside its own scope. Such functions do not perform input/output operations, do not access global variables, and do not introduce side effects. Because of their predictability and purity, pure functions are easier to understand, test, and maintain. First-class functions - In functional programming, functions are treated as first-class citizens. This means we can handle

May 28, 2025 - 19:40

Functional Programming and Erlang Platform

Functional Programming Paradigm
- Imperative Programming
- Declarative Programming
- Object-Oriented Programming (OOP)
- Functional Programming
- Paradigms Used by Erlang and Elixir
Basic Principles of Functional Programming
Erlang Development Platform
- Highly Available Systems
- Concurrency in Erlang
- A Complete Development Platform
References

Functional Programming Paradigm

Every programming language is built upon one or more programming paradigms, which are distinct ways of thinking that shape how we write code, manage data, and structure solutions. Understanding these paradigms helps us choose the most effective approach to solve a problem.

Let’s explore some commonly used paradigms.

Imperative Programming

The imperative paradigm is a programming approach where we give the computer step-by-step instructions on how to complete a task. We explicitly define the sequence of actions, from initialization to the final steps of the process.

Here’s an example in Python:

total = 0

for i in range(5):
    total += i

This code sums the numbers from 0 to 4. Each step is clearly defined: initializing the variable, looping, and accumulating the total. Languages like Python, C, and Java support this paradigm very well.

Declarative Programming

The declarative paradigm focuses on what you want to achieve, rather than how to achieve it. You simply declare your goal and let the system (such as a compiler or runtime engine) handle the implementation details.

Here’s an example in SQL:

SELECT * FROM users WHERE is_active = 1;

We don’t explain how to scan the table or filter the data; we simply state that we want all active users. Other examples of declarative programming can be found in HTML and regular expressions (regex).

Object-Oriented Programming (OOP)

The object-oriented paradigm is an approach that organizes an application into a collection of objects. Each object holds data (called state) and provides methods (functions) to operate on that data. These objects interact with each other to form the logic of the application.

Here’s an example in Java:

class Car {
  String brand;

  void moveForward() {
    System.out.println("Moving Forward -->");
  }
}

Car myCar = new Car();
myCar.moveForward();

In this example, we define a Car class that specifies attributes and behavior, then create an object myCar that executes its own logic. This paradigm helps organize code by combining data and behavior into a single unit. Languages like Java, Python, and JavaScript provide strong support for object-oriented programming.

Functional Programming

The functional paradigm is an approach that builds programs from many small functions composed together. Each function takes input, processes it, and returns output without modifying anything outside itself (no side effects).

Here's an example in Elixir:

numbers = [1, 2, 3, 4, 5]

numbers
|> Enum.filter(fn x -> rem(x, 2) == 0 end)
|> Enum.map(fn x -> x * 2 end)

This code filters even numbers and then doubles them. The data transformation flows from one function to the next. This style encourages writing clean, modular, and testable code.

Languages like Erlang and Elixir are designed to support this paradigm.

Paradigms Used by Erlang and Elixir

Erlang and Elixir combine two main paradigms:

Declarative - Focused on what you want to achieve, not how to achieve it. The runtime handles execution details.
Functional - Logic is built from pure functions that can be composed into more complex behavior.

This combination enables a concise, modular, and testable coding style, which is ideal for building reliable, large-scale, and high-availability systems. This is why the paradigm is widely used in telecommunications, real-time services, and distributed applications that demand high reliability.

Basic Principles of Functional Programming

Here are some fundamental principles of functional programming:

Immutability - In this paradigm, data is immutable, meaning it cannot be altered once it is created. If we want to "change" its value, what actually happens is that a new copy is created with the updated content. This approach is called data transformation rather than modification. Immutability helps us avoid many bugs caused by unexpected changes to data and makes it easier to trace the flow of data in the program.
Pure functions - A pure function always produces the same output for the same input. It does not depend on any external data and does not modify anything outside its own scope. Such functions do not perform input/output operations, do not access global variables, and do not introduce side effects. Because of their predictability and purity, pure functions are easier to understand, test, and maintain.
First-class functions - In functional programming, functions are treated as first-class citizens. This means we can handle functions just like any other data: we can store them in variables, pass them as arguments to other functions, or return them as the result of a function. This approach enables us to build program logic from small, flexible, and composable pieces. The result is cleaner, more modular, and more maintainable code.

Erlang Development Platform

Before studying Elixir, it's important to understand the Erlang platform. Why? Because Elixir is built on top of this platform, and without Erlang, Elixir wouldn't be able to run.

Erlang is a development platform created by the Swedish telecommunications company Ericsson in the mid-1980s. Its main goal was to develop a phone network that could operate continuously, even in the face of challenges such as high call volumes, unexpected software bugs, or hardware and software upgrades. The system needed to keep running!

Erlang, originally known as Ericsson Language, was developed by Joe Armstrong, Robert Virding, and Mike Williams. Though it was initially used only within Ericsson, Erlang was released as open-source software in 1998. Since then, it has been adopted by various industries, including telecommunications, banking, multiplayer game development, and more.

Highly Available Systems

Joe Armstrong, one of the creators of Erlang, once said in a 2013 interview with Rackspace, "If Java is write once, run anywhere, then Erlang is write once, run forever." This quote perfectly captures Erlang’s design goal: to build systems that run continuously and remain available, even in the face of unexpected failures. To achieve this, Joe Armstrong and his team designed Erlang to meet several key criteria:

Fault Tolerance: Erlang ensures that the system keeps running even when something goes wrong, such as software crashes or hardware failures. When an error occurs, the system can recover automatically and continue operating without requiring manual intervention.
Scalability: Erlang allows systems to scale up without needing to reboot. This makes it easy to handle increased workloads without interrupting ongoing operations.
Distributed System: Erlang supports distributing system operations across multiple machines. This reduces the risk of a single point of failure that could bring down the entire system if one component fails.
Responsiveness: Erlang systems are designed to handle heavy loads and high demand efficiently, even in situations that require immediate responses, such as managing large volumes of phone calls in a short time.
Live Updates: Erlang supports live code updates without shutting down the server. This minimizes downtime and keeps services available during upgrades.

Concurrency in Erlang

Erlang is designed to handle systems with extremely high concurrency demands, such as managing thousands or even millions of processes at once. Rather than relying on operating system threads or processes, Erlang introduces the concept of the Erlang process. These processes are lightweight and efficient, enabling massive scalability without overloading the system. All Erlang processes run on the BEAM virtual machine, which has its own scheduler to distribute work efficiently across multiple CPU cores.

One of the main advantages of Erlang processes is memory isolation. Each process runs independently, so if one fails, it doesn't affect the others. Erlang also includes built-in mechanisms for failure detection and automatic recovery, helping the system stay stable and recover quickly from errors.

For inter-process communication, Erlang uses asynchronous message passing. This approach avoids the need for complex synchronization between processes, which often leads to performance bottlenecks. As a result, the system remains responsive and efficient even under heavy load.

Additionally, Erlang offers efficient input/output management and per-process garbage collection, ensuring the system stays responsive even when under intense workloads.

A Complete Development Platform

Erlang is more than just a programming language; it’s a complete development platform made up of four key components:

Erlang Programming Language - Erlang is a functional programming language designed for applications with high concurrency needs. Erlang code is compiled into bytecode that runs on the BEAM virtual machine, allowing applications to run across different platforms while maintaining consistent performance.
BEAM Virtual Machine - BEAM is a virtual machine that manages processes efficiently and in isolation. Processes running on BEAM don’t interfere with each other and can communicate quickly. BEAM also handles the workload to ensure the system remains responsive, even under heavy load.
Open Telecom Platform (OTP) Framework - OTP is a framework that simplifies application development with Erlang. It includes essential features like concurrency management, process distribution, error detection, and live code updates. OTP is often considered an inseparable part of Erlang and is referred to as Erlang/OTP.
Development Tools - Erlang provides a set of tools that streamline the development process, such as an interactive shell and application management tools directly connected to BEAM instances. These tools support multiple operating systems and allow for flexible deployment of Erlang applications across various platforms.

As an open-source project, Erlang is freely available and can be accessed via the official website or the Erlang/OTP GitHub repository. Ericsson, which played a crucial role in Erlang’s initial development, continues to contribute and regularly releases new versions.

References

IONOS Editorial Team. (2021, May 21). Imperative Programming. https://www.ionos.com/digitalguide/websites/web-development/imperative-programming
Federico Pereiro. (n.d.). Declarative Programming: Is It A Real Thing? Retrieved May 23, 2024, from https://www.toptal.com/software/declarative-programming
Saša Jurić. (2024). Elixir In Action (3rd ed.). Manning Publications.