temas

2021-02-05

"Elixir Practical Guide", un libro escrito por nuestro CEO Kuroda, ha sido publicado por Impress.

Comprar en Amazon

No recuerdo exactamente cuándo conocí Elixir, el lenguaje de programación objeto de este libro. Digamos vagamente que fue a mediados de la década de 2010. Durante aproximadamente una década antes de eso, utilicé exclusivamente Ruby on Rails (un marco de desarrollo web basado en el lenguaje de programación Ruby, comúnmente conocido como "Rails"). He desarrollado aplicaciones web con Rails y he escrito libros explicando Rails.

Ni siquiera estoy seguro de por qué me interesé por Elixir. Había oído rumores de que existía un "lenguaje de programación funcional" y que era muy interesante. Incluso había investigado sobre otros lenguajes funcionales además de Elixir. Sin embargo, tenía la idea preconcebida de que eran favorecidos por los investigadores y teóricos, pero no eran prácticos, por lo que no quería tomarlos en serio.

Entonces llegó un punto de inflexión para mí: a finales de la década de 2010, las aplicaciones de página única (SPA) se pusieron de moda en el mundo del desarrollo de aplicaciones web. SPA es un término genérico para las aplicaciones web que proporcionan una UI/UX similar a las aplicaciones de escritorio. El uso de frameworks de JavaScript (React, Vue, etc.) para apoyar el desarrollo de SPA se extendió rápidamente. Con el fin de montar esta enorme ola, recogí vigorosamente la información y repetí la prueba y el error. En el proceso, descubrí Phoenix Framework, un marco de desarrollo web basado en Elixir, comúnmente conocido como "Phoenix".

A medida que mi investigación avanzaba, me entusiasmaba cada vez más; Phoenix parecía ser una solución elegante a los diversos problemas a los que me enfrentaba en el desarrollo de SPA en ese momento. Phoenix parecía una solución elegante para muchos de los problemas a los que me enfrentaba en el desarrollo de SPA en ese momento, y al perseguir la programación concurrente en la que Elixir destacaba, podía crear servicios web innovadores que iban más allá de los límites tradicionales. Tuve la corazonada de que Phoenix cambiaría las reglas del juego en nuestro sector.

Una vez que construimos una aplicación web concreta de cierta escala, descubrimos que Elixir era un lenguaje de programación muy fácil de escribir y práctico. La restricción del lenguaje de programación funcional de que todos los datos son inmutables no fue un obstáculo para el desarrollo. Además, Elixir no tiene lo que se llama "herencia" en la programación orientada a objetos (POO), pero sorprendentemente, esto no fue una fuente de frustración.

En comparación con Java, PHP, Python, Ruby, etc., Elixir tiene una historia muy corta y no es muy conocido por el público en general. Sin embargo, predigo que Elixir tendrá una edad de oro en la década de 2020. La razón es el entusiasmo de la comunidad Elixir. El ecosistema de Elixir está madurando rápidamente, con muchas personas con talento y empresas influyentes que se unen a la lucha.

Este libro es una introducción a Elixir. Explica conceptos básicos como "variables" y "enteros" con el mayor detalle posible, para abrir la puerta no sólo a los programadores actuales que quieren probar un nuevo lenguaje, sino también a los principiantes en programación. Además, hemos incluido muchos códigos fuente concretos y sus resultados de ejecución. En particular, hemos tratado de explicar con detalle los ejemplos de códigos fuente incorrectos y las advertencias y mensajes de error que aparecen cuando se ejecutan. De este modo, se evita confundir a los principiantes y desanimarlos en su aprendizaje.

Este libro está dividido en dos partes: primera parte y segunda parte, y ésta es la primera parte. Los temas principales de la primera parte son los módulos, las funciones, los tipos de datos y la concordancia de patrones. La segunda parte abarca las estructuras, el polimorfismo, los comportamientos, la metaprogramación y la programación concurrente. La segunda parte se publicará como "Guía práctica avanzada de Elixir".

La primera parte se divide a su vez en cinco partes. La parte I es una introducción bastante rápida a los conceptos básicos de la programación en Elixir. Aquí aprenderá sobre las especificaciones distintivas del lenguaje Elixir, incluyendo tipos de datos, módulos, funciones, macros, coincidencia de patrones, operadores de tuberías, y más. El procedimiento para configurar un entorno de desarrollo de Elixir se explicará en el capítulo 2.

En la Parte II, discutiremos los módulos y las funciones en detalle. También hablaremos de las macros, pero no con demasiada profundidad. Las macros se tratarán en la segunda parte. La Parte III trata de las estructuras de datos de Elixir. La Parte III trata de las estructuras de datos de Elixir, especialmente las listas (Capítulo 12) y los mapas (Capítulo 14).

La parte IV, titulada "El fascinante mundo de Elixir", se centra en la concordancia de patrones, una especificación del lenguaje que hace que la falta de herencia de Elixir sea una obviedad. Otros temas interesantes tratados en esta parte son la "notación de comprensión" y las "funciones de reducción".

En la Parte V, haremos algunos ejercicios de desarrollo sobre el tema del tres en raya.La primera parte es un trabajo de preparación. Primero, explicaremos cómo utilizar el marco de pruebas de Elixir, ExUnit, y la herramienta de construcción de Elixir, Mix. A continuación, explicaremos los dos conceptos de agentes y GenServer como las herramientas necesarias para el ejercicio. En la segunda mitad de la Parte V, desarrollaremos realmente una aplicación. En la segunda mitad de la Parte V, desarrollaremos realmente la aplicación, y a través de este ejercicio de desarrollo, el lector aprenderá varios conocimientos. Por ejemplo, cómo desarrollar en unidades de "proyecto" combinando múltiples módulos, cómo interactuar con los usuarios en el terminal, cómo mantener los datos en la aplicación, cómo escribir y ejecutar pruebas, etc.

Al final de cada capítulo, desde el capítulo 3 hasta el 25, se incluyen preguntas de práctica. Es difícil aprender un lenguaje de programación sólo leyendo un libro, por lo que le animamos a que se desafíe a sí mismo sin mirar las respuestas en el apéndice al final del libro.

Noviembre de 2020
Tsutomu Kuroda

Índice de contenidos

  • Part 1
    • Chapter 1 Introducción
      • 1.1 ¿Qué es Elixir?
      • 1.2 La relación entre Elixir y Erlang
    • Chapter 2 Construcción de un entorno de desarrollo en Elixir
      • 2.1 Creación de un contenedor de Elixir
      • 2.2 Cómo utilizar los contenedores de Elixir
    • Chapter 3 Conceptos básicos de Elixir(1)
      • 3.1 Cómo funciona un programa en Elixir
      • 3.2 Conceptos básicos
      • 3.3 Ejercicios
    • Chapter 4 Conceptos básicos de Elixir(2)
      • 4.1 Tipos de datos
      • 4.2 Números
      • 4.3 Átomos
      • 4.4 Strings
      • 4.5 Listas, listas de char, tuplas, listas de palabras clave, mapas
      • 4.6 Funciones
      • 4.7 Identificación de tipos
      • 4.8 Ejercicios
    • Chapter 5 Fundamentos de Elixir(3)
      • 5.1 Variables y concordancia de patrones
      • 5.2 Funciones, módulos y macros
      • 5.3 Ejercicios
    • Chapter 6 Conceptos básicos de Elixir(4)
      • 6.1 Operadores
      • 6.2 Sistema de archivos y entrada/salida
      • 6.3 if macros, for macros, estructura Range
      • 6.4 Ejercicios
  • Part 2
    • Chapter 7 Módulos
      • 7.1 Definición de un módulo
      • 7.2 Alias de módulos
      • 7.3 Atributos de los módulos
      • 7.4 Ejercicios
    • Chapter 8 Funciones(1)
      • 8.1 Funciones sin nombre
      • 8.2 Funciones con nombre
      • 8.3 Funciones y listas de palabras clave
      • 8.4 Ejercicios
    • Chapter 9 Funciones(2)
      • 9.1 Clasificación de las llamadas a funciones y visibilidad de las funciones
      • 9.2 Operadores de captura
      • 9.3 Directivas de importación
      • 9.4 Ejercicios
    • Chapter 10 Fundamentos de las macros y rama condicional
      • 10.1 Introducción a las macros
      • 10.2 if macros
      • 10.3 cond macros
      • 10.4 Ejercicios
  • Part 3
    • Chapter 11 Átomos
      • 11.1 ¿Qué son los átomos?
      • 11.2 Funciones que trabajan con átomos
      • 11.3 El papel de los átomos
      • 11.4 Ejercicios
    • Chapter 12 Listas
      • 12.1 Creación de una lista
      • 12.2 Uso de las listas
      • 12.3 Conversión de una lista en otra lista
      • 12.4 Estructura de datos de las listas
      • 12.5 Operadores de Cabeza, Cola y Cons
      • 12.6 Ejercicios
    • Chapter 13 uplas y listas de palabras clave
      • 13.1 Tuplas
      • 13.2 Listas de palabras clave
      • 13.3 Ejercicios
    • Chapter 14 Mapas
      • 14.1 Fundamentos de los mapas
      • 14.2 Uso de los mapas
      • 14.3 Operaciones básicas con mapas
      • 14.4 Estructuras de datos de los mapas
      • 14.5 Ejercicios
    • Chapter 15 Strings de bits, binarios, string y listas de cha
      • 15.1 Strings de bits
      • 15.2 Binarios
      • 15.3 Strings(1)
      • 15.4 Strings(2)
      • 15.5 Funciones para strings
      • 15.6 Estructuras de datos de binarios
      • 15.7 Listas de char
      • 15.8 Ejercicios
  • Part 4
    • Chapter 16 Comparación de patrones
      • 16.1 ¿Qué es la concordancia de patrones?
      • 16.2 Correspondencia de patrones para listas
      • 16.3 Correspondencia de patrones para tuplas
      • 16.4 Correspondencia de patrones para mapas
      • 16.5 Comparación de patrones para strings binarias
      • 16.6 Comparación de patrones para strings de bits
      • 16.7 Operadores de pines
      • 16.8 Comparación de patrones para argumentos de funciones
      • 16.9 Ejercicios
    • Chapter 17 Módulo Enum
      • 17.1 Enumerables
      • 17.2 Funciones que convierten un Enumerable en una lista con el mismo número de elementos
      • 17.3 Funciones que convierten todo o parte de un Enumerable en una Lista y la devuelven
      • 17.4 Funciones que devuelven un único elemento perteneciente a un Enumerable
      • 17.5 Funciones que devuelven valores verdadero/falso
      • 17.6 Otras funciones
      • 17.7 Ejercicios
    • Chapter 18 for macros
      • 18.1 Fundamentos de las for macros
      • 18.2 Uso de generadores y filtros
      • 18.3 La opción :into
      • 18.4 Generadores de strings de bits
      • 18.5 Ejercicios
    • Chapter 19 case macros y with Macros
      • 19.1 Uso básico de la case macros
      • 19.2 Ejemplos de uso de la case macros
      • 19.3 with macros
      • 19.4 Ejercicios
    • Chapter 20 Funciones con cláusulas múltiples
      • 20.1 Creación de una función sin nombre con múltiples cláusulas
      • 20.2 Funciones con nombre y cláusulas múltiples
      • 20.3 Protección de las funciones con nombre contra las cláusulas
      • 20.4 Ejercicios
    • Chapter 21 reduce functions
      • 21.1 Acumulador
      • 21.2 Ejemplo de uso de la reduce función
      • 21.3 Ejercicios
    • Chapter 22 Manejo de errores
      • 22.1 Excepciones
      • 22.2 Lanzamientos
      • 22.3 Ejercicios
  • Part 5
    • Chapter 23 ExUnit
      • 23.1 Introducción a ExUnit
      • 23.2 Escribir pruebas
      • 23.3 Ejercicios
    • Chapter 24 Mix
      • 24.1 proyecto Mix
      • 24.2 La primera implementación
      • 24.3 Extensiones
      • 24.4 Ejercicios
    • Chapter 25 Agentes y GenServer
      • 25.1 Agentes
      • 25.2 GenServer
      • 25.3 Ejercicios
    • Chapter 26 Tic-tac-toe(1)
      • 26.1 Especificación de la aplicación creada en el ejercicio de desarrollo
      • 26.2 Creación del marco de la aplicación
      • 26.3 Agentes para gestionar el estado del juego
      • 26.4 Consola
      • 26.5 Definición de la tarea de juego
    • Chapter 27 Tic-tac-toe(2)
      • 27.1 Visualización del estado del juego
      • 27.2 Gestionar el turno
      • 27.3 Actualizar la parrilla
      • 27.4 Refrescar la pantalla
    • Chapter 28 Tic-tac-toe(3)
      • 28.1 Juzgar el resultado
      • 28.2 Dejar que el ordenador elija una jugada
  • Apéndice A. Respuestas a los ejercicios
Lista de temas