
Elixir tiene una barrera que romper en la adopción de la industria, sin embargo hay mucho potencial y beneficio en el lenguaje.

**Por ejemplo:**

* Las convenciones y las herramientas promueven, la separación de responsabilidades, el uso de una arquitectura modular, etcétera.
* Proporcionar una interfaz clara para interactuar con la lógica empresarial.
* Facilitar las pruebas y el mantenimiento.
* Re-utilización de la lógica de dominio en diferentes partes de la aplicación

Frecuentemente he escuchado que Elixir es un lenguaje de programación funcional concurrente, de propósito general y de alto nivel que se ejecuta en Erlang VM (BEAM). Sin embargo lo más importante proviene de su origen, ya que fue creado a partir de necesidades específicas que no se estaban cubriendo en ese momento por ningún otro lenguaje.

**José Valim, creador de Elixir, explica por qué Erlang le llamó la atención:**

> Lo más importante _para Elixir como lenguaje de programación es Erlang VM, que fue creado para construir centrales telefónicas. Lo que se busca de una central telefónica es que no sólo maneje dos conexiones, sino que sea altamente concurrente. [...] Entonces la gente se dio cuenta de que nuestro escenario es similar a la web. Tenemos navegadores conectados al servidor._

Cabe destacar que Ruby era el lenguaje de programación principal de José, pero su máquina virtual de resonancia magnética tenía limitaciones fundamentales. José tomó prestadas algunas filosofías de sintaxis y experiencia de desarrollador de Ruby, como capacidades de meta-programación, convención sobre configuración y enfoque en la satisfacción y productividad del desarrollador. Esta familiaridad tiene como objetivo facilitar la transición para los desarrolladores de Ruby y brindar una experiencia de desarrollo productiva.

## Características de Elixir

### La máquina virtual de Erlang

Es una máquina virtual diseñada para crear sistemas altamente concurrentes, de baja latencia y tolerantes a fallas. A

### Programación funcional

Estructuras de datos inmutables y la composición de funciones. Esta diferencia fundamental en los paradigmas de programación distingue a Elixir de Ruby y contribuye a sus ventajas en cuanto a concurrencia y tolerancia a fallos.

### Modelo de concurrencia

Elixir heredó el modelo de actores de Erlang y la concurrencia de procesos livianos, que difiere radicalmente del modelo de concurrencia basado en subprocesos de Ruby.

### Tolerancia a fallos y auto-recuperación

Una de las principales fortalezas de Elixir es su tolerancia a fallas y sus capacidades de auto-recuperación heredadas de la máquina virtual Erlang. Las aplicaciones de Elixir pueden recuperarse de fallas y continuar ejecutándose, una característica que no está incorporada en Ruby, lo que garantiza una mayor confiabilidad y tiempo de actividad del sistema.

> Los rasgos únicos de Elixir surgen de la fusión armoniosa de sus principios y fundamentos básicos.

Elixir integra a la perfección el poder de la máquina virtual Erlang, los principios de la programación funcional, un modelo de concurrencia sólido, tolerancia a fallos y un enfoque en la satisfacción del desarrollador para crear un lenguaje que se destaca en múltiples dominios. A partir de esta sólida base, Elixir ha obtenido una variedad de potentes características y ventajas, entre las que se incluyen:

### Sintaxis concisa y expresiva

1. _Productividad y expresividad_*
2. Meta-programación
3. Consumo reducido de recursos para mantenimiento y ampliación.

### Potente máquina virtual

1. Simultaneidad y escalabilidad
2. Tolerancia a fallos
3. Uso optimizado de la infraestructura

### Comunidad y ecosistema

1. Contratación de personal altamente cualificado
2. Aprovechar el ecosistema Erlang existente
3. Desarrollo basado en pruebas

Si deseas conocer más sobre el lenguaje de programación y su adopción, te recomiendo el libro [Adopting Elixir](https://amzn.to/4cKWpPa)

<img src="/images/adopcion-elixir/adopcion-elixir.jpg" alt="Adopting Elixir book" width='350' height='550' />


/app/content/blog/adopcion-elixir/index.md


Elixir tiene una barrera que romper en la adopción de la industria, sin embargo hay mucho potencial y beneficio en el lenguaje.

**Por ejemplo:**

* ...


## ¿Qué es Elixir?

`Elixir` es un lenguaje de programación de propósito general, funcional, concurrente y de alto nivel que se ejecuta en la máquina virtual `BEAM`, que también se utiliza para implementar el lenguaje de programación [Erlang](https://www.erlang.org/). `Elixir` se basa en `Erlang` y comparte las mismas abstracciones para crear aplicaciones distribuidas y tolerantes a fallos.

Fue creado por [José Valim](https://twitter.com/josevalim) en 2011, tuvo su [aparición en Internet en 2012](https://github.com/elixir-lang/elixir/graphs/code-frequency) y está inspirado en otros lenguajes como Erlang, Ruby y Clojure. Elixir se basa en la programación funcional, lo que significa que se centra en la evaluación de funciones y no en la ejecución de instrucciones.

## ¿Por qué aprender Elixir?

Existen varias razones por las que los programadores deberían considerar aprender `Elixir`. Debido a que se ejecuta en la máquina virtual de `Erlang` (BEAM), aprovecha toda las ventajas del mismo. `Erlang` ofrece alta disponibilidad, concurrencia, `hot code reload` (despliegue en caliente) y muchas otros beneficios como resultado de sus 30 años de evolución.

Por su parte, `Elixir` comparte los mismos beneficios para desarrollar aplicaciones distribuidas y tolerantes a fallos. Como valor añadido, `Elixir` brinda una facilidad de uso que a la mayoría (si no es que a todos) los desarrolladores cautiva cuando empiezan a usarlo, destacando su capacidad para manejar grandes sistemas y su facilidad de escritura de código conciso y legible. Además, es un lenguaje escalable, lo que significa que puede manejar sistemas en crecimiento sin comprometer el rendimiento.


## Instalación y configuración de Elixir

Antes de empezar a programar en `Elixir`, es necesario instalar el lenguaje en su sistema. Su instalación es bastante sencilla y se puede hacer utilizando el paquete de instalación adecuado para su sistema operativo. Una vez instalado, se puede comprobar que se ha instalado correctamente utilizando el comando ```elixir --version``` en la línea de comandos.

En windows puedes [descargar el instalador](https://github.com/elixir-lang/elixir-windows-setup/releases/download/v2.4/elixir-websetup.exe).

En **Mac OS** puedes usar [Homebrew](https://brew.sh/):

```bash{.highlighted}
$ brew install elixir
```

y también [Macports](https://www.macports.org/)

```bash{.highlighted}
$ sudo port install elixir
```

Para otras plataformas y conocer más al respecto de la instalación, se recomienda visitar el [sitio oficial de Elixir](https://elixir-lang.org/install.html#distributions)


## Sintaxis de Elixir

El código de `Elixir` se compone de módulos, funciones y expresiones. En `Elixir` se agrupan varias funciones en módulos y las funciones contienen expresiones, mientras que las funciones son bloques de código que realizan una tarea específica. Las expresiones son valores o cálculos que se utilizan en el código.

## Ejemplo de código en Elixir

A continuación se muestra un ejemplo de código en `Elixir` que muestra cómo imprimir "Hola, mundo" en la consola:

 ```elixir
defmodule HolaMundo do
  def saludar do
    IO.puts "Hola, mundo"
  end
end

iex> HolaMundo.saludar()
Hola, mundo

```

Los siguientes ejemplos pueden ejecutarse en un [shell](https://es.wikipedia.org/wiki/Shell_(inform%C3%A1tica)) `iex` o guardarse en un archivo y ejecutarse desde la línea de comandos escribiendo `elixir` <nombre de archivo>.

```elixir
iex> IO.puts("Hello World!")
Hello World!
```

Con el operador `Pipe` (`|>`):

```elixir
iex> "Elixir" |> String.graphemes() |> Enum.frequencies()
%{"E" => 1, "i" => 2, "l" => 1, "r" => 1, "x" => 1}

iex> %{values: 1..5} |> Map.get(:values) |> Enum.map(& &1 * 2)
[2, 4, 6, 8, 10]

iex> |> Enum.sum()
30
```

Coincidencia de patrones (`Pattern Matching`) o mejor conocido como destructurar (`destructuring`):

```elixir
iex> %{left: x} = %{left: 5, right: 8}
iex> x
5

iex> {:ok, [_ | rest]} = {:ok, [1, 2, 3]}
iex> rest
[2, 3]
```

## Recursos para aprender Elixir

Existen varios recursos en línea disponibles para los principiantes que deseen aprender `Elixir`. La [documentación oficial de Elixir](https://elixir-lang.org/) es un buen punto de partida. Otro sitio altamente recomendable y que ofrece documentación en español es [Elixir School](https://elixirschool.com/es).

Si tienes dudas sobre el valor que puede aportar a tu empresa, vale la pena leer el libro [Adopting Elixir: From Concept to Production](https://amzn.to/43HRBGL) escrito por Ben Marx, José Valim (¿ya mencionamos que fue el creador de Elixir?) y Bruce Tate.

Otras recomendaciones para saber más:

* Las primeras impresiones sobre el lenguaje por parte de Joe Armstrong (Co-creador de `Erlang`) después de la primer semana de usarlo: <https://joearms.github.io/published/2013-05-31-a-week-with-elixir.html>

* Un minidocumental sobre Elixir altamente recomendable (en Inglés): <https://cult.honeypot.io/originals/elixir-the-documentary>


/app/content/blog/elixir-primeros-pasos/index.md


## ¿Qué es Elixir?

`Elixir` es un lenguaje de programación de propósito general, funcional, concurrente y de alto nivel que se ejecuta en la ...


La organización del código desempeña un papel crucial en el éxito y la longevidad de un proyecto.

Diversas mentes brillantes en la comunidad han propuesto estrategias sofisticadas que no solo mejoran la legibilidad del código, sino que también facilitan el mantenimiento y la evolución continua. En este artículo, exploramos algunos enfoques.

## Capas según Bruce Tate y James Gray

[Bruce Tate](https://twitter.com/redrapids) y [James Gray](https://twitter.com/JEG2), proponen una organización en capas que aborda diversos aspectos del desarrollo. La estrategia abarca desde la manipulación de datos hasta la gestión y la supervisión de procesos. Con capas claramente definidas, como estructuras de datos (data), un núcleo funcional (functional core), pruebas (test), límites o secciones (boundaries), ciclos de vida (lifecycle) y trabajadores (workers), el código adquiere una estructura profunda que simplifica la comprensión y el mantenimiento. No todos los proyectos tendrán todas las capas mencionadas, pero algunas si.

Este enfoque, respaldado por años de experiencia y estudio, encuentra su mejor aplicación en proyectos ambiciosos. Al separar las responsabilidades en capas, los desarrolladores pueden enfocarse en áreas específicas sin perder de vista la imagen general del sistema.

Tal como lo mencionan en el libro ["Designing Elixir Systems with Otp"](https://www.amazon.com.mx/Designing-Elixir-Systems-Otp-Self-Healing/dp/1680506617), el diseño y capas presentadas no están escritos en piedra. Son un andamiaje, un marco para pensar en soluciones a problemas de diseño comunes.

> Es responsabilidad del autor del código base decidir cuales serán las capas que valen la pena mantener y cuales eliminar.

![Organización de un sistema en Elixir con OTP](/images/organizacion-codigo-elixir/diagram.png)

Cómo siempre, es recomendable leer el libro para facilitar la adopción de este diseño. Se puede apreciar en la imagen que el diseño es más conceptual que físico y gracias a la flexibilidad de Elixir, no es necesario crear los directorios y archivos en un orden o jerarquía en particular, aún así, hay que tener presente que cada equipo de desarrollo deberá definir la estructura de los archivos para que tenga mayor sentido la organización del código.

## Phoenix Framework

En Phoenix es posible entender mejor como se organiza el código porque tenemos ejemplos claros de manera inicial. Siguiendo la línea de los generadores de código de Phoenix se puede ver una estructura de archivos como la siguiente:

```terminal
├── assets/
├── config/
├── deps/
├── lib/
│   ├── hello/
│   ├── hello.ex
│   ├── hello_web/
│   └── hello_web.ex
├── priv/
└── test/
```

Esta organización es más genérico y sencilla, la estructura es fácil de entender, el enfoque está orientado a crear una estructura de archivos más flexible y a su vez proveer un código ordenado sin afectar o influir en la lógica de negocio de cada proyecto.

El código se localiza principalmente en `/lib`, `/lib/hello` y `/lib/hello_web`:

```terminal
lib/
├── hello
│   ├── application.ex
│   ├── mailer.ex
│   └── repo.ex
├── hello.ex
├── hello_web
│   ├── components
│   │   ├── core_components.ex
│   │   ├── layouts
│   │   │   ├── app.html.heex
│   │   │   └── root.html.heex
│   │   └── layouts.ex
│   ├── controllers
│   │   ├── error_html.ex
│   │   ├── error_json.ex
│   │   ├── page_controller.ex
│   │   ├── page_html
│   │   │   └── home.html.heex
│   │   └── page_html.ex
│   ├── endpoint.ex
│   ├── gettext.ex
│   ├── router.ex
│   └── telemetry.ex
└── hello_web.ex

```

Mantener la organización del código como se define con Phoenix es útil y facilita el desarrollo inicial, aún así, se debe re-organizar constantemente porque es muy probable que con el paso del tiempo se vuelva algo complicado de mantener en proyectos grandes. Hay que recordar que organizar el código de forma que sea más productivo y fácil de entender para el equipo de desarrollo es prioritario y alguien debe hacerse caso de esto.

Un ejemplo de una estructura re-organizada usando Phoenix pero pensando en la necesidad del proyecto puede ser:

```terminal
├── assets/
│   ├── css/
│   │   ├── app.css
│   │   └── components.css
│   ├── js/
│   │   └── app.js
│   ├── vendor/
│   │   └── topbar.js
├── config/
│   ├── config.exs
│   ├── dev.exs
│   ├── prod.exs
│   ├── qa.exs
│   ├── runtime.exs
│   └── test.exs
├── deps/
├── lib/
│   ├── app/
│   │   ├── accounts/
│   │   │   ├── accounts.ex
│   │   │   └── user.ex
│   │   ├── analysis/
│   │   │   ├── analysis.ex
│   │   │   └── export.ex
│   │   ├── analytics/
│   │   │   ├── analytics.ex
│   │   │   ├── event.ex
│   │   │   └── reports.ex
│   │   ├── email/
│   │   │   ├── email.ex
│   │   │   ├── job_failed.html.eex
│   │   │   ├── process_ready.html.eex
│   │   │   └── report_ready.html.eex
│   │   ├── mailer.ex
│   │   ├── release.ex
│   │   ├── repo.ex
│   │   ├── s3.ex
..
...
│   ├── app.ex
│   ├── app_web/
│   │   ├── auth.ex
│   │   ├── controllers
│   │   │   ├── auth/
│   │   │   │   ├── fallback_controller.ex
│   │   │   │   ├── session_controller.ex
│   │   │   │   ├── user_controller.ex
│   │   │   ├── error_html/
│   │   │   │   ├── 403.html.heex
│   │   │   │   ├── 404.html.heex
│   │   │   │   └── 500.html.heex
│   │   │   │   └── error_html.ex
..
...
│   │   │   └── plugs
│   │   │       └── authorize_roles.ex
│   │   ├── endpoint.ex
│   │   ├── gettext.ex
│   │   ├── health_check.ex
│   │   ├── live/
│   │   |   ├── admin.ex
│   │   |   ├── analytics_live/
│   │   |   │   ├── index.ex
│   │   |   │   └── index.html.heex
│   │   |   ├── components/
│   │   |   │   ├── charts.ex
│   │   |   │   ├── modal_component.ex
│   │   |   |   └── modal_component.html.heex
│   │   |   ├── core_components.ex
│   │   |   └── live_helpers.ex
│   │   ├── router.ex
│   │   ├── telemetry.ex
│   │   ├── templates/
│   │   |   ├── auth
│   │   |   │   ├── session
│   │   |   │   │   └── error.html.eex
│   │   |   │   └── user
│   │   |   │       ├── form.html.eex
│   │   |   │       ├── new.html.eex
│   │   |   │       └── show.html.eex
│   │   |   └── layout
│   │   |       ├── app.html.eex
│   │   |       ├── live.html.heex
│   │   |       └── root.html.heex
│   │   ├── views/
│   │   |   ├── auth
│   │   |   │   ├── session_view.ex
│   │   |   │   └── user_view.ex
│   │   |   ├── error_helpers.ex
│   │   |   ├── error_view.ex
│   │   |   └── layout_view.ex
...
│   │   │
│   │   └── app_web.ex
├── priv/
└── test/
```

Algunos puntos relevantes a destacar en esta organización de archivos es la separación de lógica de negocio (`lib/app`) de la funcionalidad web (`lib/app_web`), por otra parte, algunos proyectos podrían organizar el código en esquemas (`schemas`) o contextos (`context`) y clasificar los módulos de acuerdo a su funcionalidad (`behaviors/`,`jobs/`, etc). En la organización de ejemplo que se presenta, el objetivo es dejar los archivos lo más simple posible para su localización y fácil entendimiento sin perder de vista en que parte del proyecto tiene sentido ubicar cada archivo.

Para conocer más sobre la organización de archivos en Phoenix, se puede consultar [la documentación en línea](https://hexdocs.pm/phoenix/directory_structure.html).

## Handlers, services, finders and values

[Marcelo Lebre](https://remote.com/blog/author/marcelo-lebre), presidente y co-fundador de [Remote](https://remote.com/), propone una estrategia basada en cuatro patrones clave: manejadores (`handlers`), servicios (`services`), buscadores (`finders`) y valores (`values`). Este enfoque se diferencia al fragmentar principalmente la lógica de negocio, proporcionando una estructura pensada en la [escalabilidad](https://es.wikipedia.org/wiki/Escalabilidad) (o [extensibility](https://en.wikipedia.org/wiki/Extensibility) en Inglés) y mantenimiento a largo plazo.

![Esquema sugerido por Marcelo Lebre](/images/organizacion-codigo-elixir/patterns.png)

Al organizar el código en estas categorías, se logra una separación de responsabilidades, Marcelo Lebre [menciona en su ponencia](https://codesync.global/media/four-patterns-to-save-your-codebase-and-your-sanity-cbv2020-sept/) que su propuesta la basa en su experiencia y siguiendo los principios [SOLID](https://en.wikipedia.org/wiki/SOLID).

![Principios SOLID](/images/organizacion-codigo-elixir/solid_principles.png)

Aunque no presenta un proyecto de ejemplo o bien no hay un ejemplo publico disponible referenciado por él o la comunidad, explica que el patrón lo ha aplicado en otras tecnologías y que ha ayudado de acuerdo a su experiencia en la productividad del equipo.

## Importancia del desacoplamiento

Independientemente del enfoque elegido, todos los expertos enfatizan la importancia del desacoplamiento. La capacidad de realizar cambios, [refactorizaciones](https://es.wikipedia.org/wiki/Refactorizaci%C3%B3n) o actualizaciones sin complejidad no prevista depende en gran medida de cómo esté estructurado el código. En el dinámico entorno de desarrollo, una estructura desacoplada es la clave para afrontar los desafíos con agilidad y confianza.

## Conclusión

Cuando se exploran las estrategias la organización del código, queda claro que la comunidad está comprometida en mejorar constantemente sin importar la tecnología empleada. Cada estrategia aborda desafíos específicos, pero comparten un objetivo común: construir sistemas que sean comprensibles, que faciliten el mantenimiento y adaptables a medida que evolucionan.

Estos enfoques no son dogmas, sino guías valiosas que pueden ajustarse según las necesidades específicas de cada proyecto. A medida que se avanza en el desarrollo de software, la organización del código continuará siendo un área de innovación y experimentación, donde cada nueva idea contribuirá al crecimiento y la excelencia de nuestros proyectos.

## Referencias

1. [Thomas, D.](https://www.amazon.com.mx/stores/Dave-Thomas/author/B001HMRWHY?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true). (2018) *[Programming Elixir. Pragmatic Bookshelf.](https://www.amazon.com.mx/Programming-Elixir-1-6-Functional-Concurrent/dp/1680502999/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=25J300PH41R98&keywords=Programming+Elixir.+Pragmatic+Bookshelf&qid=1703897999&sprefix=programming+elixir.+pragmatic+bookshelf%2Caps%2C339&sr=8-1&ufe=app_do%3Aamzn1.fos.4e545b5e-1d45-498b-8193-a253464ffa47)*
2. [Martin, R. C.](https://www.amazon.com.mx/dp/B085D95SX5?binding=kindle_edition&qid=1703898240&sr=1-1&ref=dbs_dp_rwt_sb_pc_tukn). (2008) *[Clean Code: A Handbook of Agile Software Craftsmanship.](https://www.amazon.com.mx/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=1VVE4UOETQOTJ&keywords=Clean+Code%3A+A+Handbook+of+Agile+Software+Craftsmanship.&qid=1703898240&s=digital-text&sprefix=clean+code+a+handbook+of+agile+software+craftsmanship+%2Cdigital-text%2C238&sr=1-1)*
3. [McCord, C.](https://twitter.com/chris_mccord), Tate, B., & [Valim, J.](https://github.com/josevalim) (2019). *[Programming Phoenix](https://www.amazon.com.mx/Programming-Phoenix-1-4-Productive-Reliable-ebook/dp/B084NV65T8/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=P2XHP7UTHU1H&keywords=Programming+Phoenix&qid=1703898447&s=digital-text&sprefix=%2Cdigital-text%2C262&sr=1-1).*
4. [Marcelo Lebre](https://twitter.com/marcelo_lebre) - [President and co-founder at Remote at Remote](https://remote.com/blog/author/marcelo-lebre)
5. [Evans, E.](https://www.amazon.com.mx/stores/author/B001KDCO2I/about) (2003). *[Domain-Driven Design: Tackling Complexity in the Heart of Software](https://www.amazon.com.mx/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=340A2GTRP04TR&keywords=Domain-Driven+Design%3A+Tackling+Complexity+in+the+Heart+of+Software&qid=1703899106&sprefix=domain-driven+design+tackling+complexity+in+the+heart+of+software%2Caps%2C198&sr=8-1&ufe=app_do%3Aamzn1.fos.4e545b5e-1d45-498b-8193-a253464ffa47).*


/app/content/blog/organizacion-codigo-elixir/index.md


La organización del código desempeña un papel crucial en el éxito y la longevidad de un proyecto.

Diversas mentes brillantes en la comunidad han ...

Publicaciones sobre Elixir

La adopción de Elixir

Elixir primeros pasos

¿Qué es Elixir?

Estrategias para organizar el código en proyectos con Elixir