Scala Cookbook, 2ª Edición

Prefacio

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: [e-mail]

Éste es un libro de recetas para resolver problemas sobre Scala 3, el lenguaje de programación más interesante que he utilizado nunca. El libro contiene soluciones a más de doscientos cincuenta problemas comunes de programación en Scala, demostrados con más de mil ejemplos.

En comparación con otros recursos de aprendizaje de Scala 3, hay varias cosas únicas en este libro:

• Como libro de cocina, pretende ahorrarte tiempo proporcionándote soluciones a los problemas más comunes que te encontrarás.

• El libro abarca no sólo el lenguaje Scala, sino también recetas sobre herramientas y bibliotecas Scala, como sbt, Spark, Scala.js, actores Akka y procesamiento JSON con el Play Framework.

• El libro se sumerge a fondo en las clases de colecciones de Scala, utilizando cinco capítulos para demostrar su uso.

• La salida de los ejemplos se muestra en el intérprete Scala o en comentarios tras el código. Como resultado, tanto si estás sentado junto a un ordenador, en un avión o leyendo en tu sillón reclinable favorito, tienes la ventaja de ver su salida exacta. (Lo que a menudo lleva a decir: "Ah, así es como funciona").

El lenguaje Scala 3

En la primera edición de Scala Cookbook, describí Scala 2 como una combinación de Ruby y Java. Por aquel entonces escribí: "Mi (demasiado simplificado) discurso de ascensor de Scala es que es hijo de Ruby y Java: es ligero, conciso y legible como Ruby, pero se compila en archivos de clases que empaquetas como archivos JAR que se ejecutan en la máquina virtual Java (JVM); utiliza rasgos y mixins, y parece dinámico, pero está tipado estáticamente".

Desde entonces, las características del lenguaje Scala se han replanteado y debatido en un proceso abierto y público, y con el lanzamiento de Scala 3 en 2021, el lenguaje parece aún más ligero, y ahora parece una combinación de cuatro lenguajes estupendos: Ruby y Java, combinados con la sintaxis ligera y limpia de Python y Haskell.

Parte de esta sensación aún más ligera se debe a la nueva sintaxis opcional de llaves, que también se conoce como estilo de indentación significativa. Con este cambio, los bucles for que antes tenían este aspecto:

for (i <- 1 to 5) { println(i) }

ahora tienen este aspecto:

for i <- 1 to 5 do println(i)

Del mismo modo, las expresiones if y muchas otras expresiones también utilizan menos sintaxis repetitiva y son más fáciles de leer:

val y = if (x == 1) { true } else { false }   // Scala 2
val y = if x == 1 then true else false        // Scala 3

Aunque esta nueva sintaxis se considera opcional, se ha convertido en el estándar de facto y se utiliza en este libro, en el Libro de Scala 3 que coescribí para el sitio web de documentación de Scala, en las clases de formación oficiales de Scala 3 en Coursera, en los libros Programming in Scala de Martin Odersky et al. (Artima Press) y Programming Scala de Dean Wampler (O'Reilly), y en muchos más recursos de aprendizaje.

La nueva sintaxis no es el único cambio. Scala 3 tiene muchas características nuevas, entre ellas:

• Enumeraciones

• Tipos de unión e intersección

• Definiciones de alto nivel (para que tu código ya no tenga que estar contenido dentro de clases, rasgos y objetos)

• Uso simplificado de implícitos con la nueva sintaxis given y using

• Sintaxis muy simplificada para métodos de extensión y clases de tipos

Incluso la sintaxis de los rasgos y las clases se ha simplificado para que sea más legible que nunca:

trait Animal:
    def speak(): Unit

trait HasTail:
    def wagTail(): Unit

class Dog extends Animal, HasTail:
    def speak() = println("Woof")
    def wagTail() = println("⎞⎜⎛  ⎞⎜⎛")

Con la nueva sintaxis, se han eliminado todas las construcciones que crean "ruido" innecesario en tu código.

Características de Scala

Además de todo lo que acabamos de decir, Scala proporciona multitud de características que lo convierten en un lenguaje de programación único y verdaderamente moderno:

• Está creado por Martin Odersky -el "padre" de javac- e influenciado por Java, Ruby, Smalltalk, ML, Haskell, Python, Erlang y otros.

• Es un lenguaje de programación de alto nivel.

• Tiene una sintaxis concisa y legible: la llamamos expresiva.

• Está tipado estáticamente, por lo que puedes disfrutar de todas las ventajas de la seguridad tipográfica estática, pero parece un lenguaje de programación dinámico.

• Es un lenguaje puro de programación orientada a objetos (POO); cada variable es un objeto, y cada operador es un método.

• También es un lenguaje de programación funcional (PF), por lo que puedes pasar funciones como variables.

• De hecho, la esencia de Scala es, como dice el Sr. Odersky, que es una fusión de FP y OOP en un entorno tipado, con:

  • Funciones para la lógica

  • Objetos para la modularidad

• Se ejecuta en la JVM y, gracias al proyecto Scala.js, también es un sustituto de JavaScript de tipo seguro.

• Interactúa perfectamente con Java y otras bibliotecas JVM.

• Gracias a GraalVM y Scala Native, ahora puedes crear ejecutables nativos de inicio rápido a partir de tu código Scala.

• La innovadora biblioteca de colecciones de Scala tiene docenas de métodos funcionales preconstruidos que te ahorran tiempo y reducen enormemente la necesidad de escribir bucles y algoritmos personalizados en for.

• Las buenas prácticas de programación están integradas en Scala, que favorece la inmutabilidad, las funciones anónimas, las funciones de orden superior, la concordancia de patrones, las clases que no pueden ampliarse por defecto y mucho más.

• El ecosistema Scala ofrece las bibliotecas FP más modernas del mundo.

Una cosa que me encanta de Scala es que si estás familiarizado con Java, puedes ser productivo con Scala desde el primer día, pero el lenguaje es profundo, así que a medida que avances seguirás aprendiendo y encontrando nuevas y mejores formas de escribir código. Scala cambiará tu forma de pensar sobre la programación, y eso es bueno.

De todas las ventajas de Scala, la que más me gusta es que te permite escribir código conciso y legible. Se dice que el tiempo que un programador dedica a leer código comparado con el tiempo que dedica a escribirlo tiene una proporción de al menos 10:1, por lo que escribir código conciso y legible es algo muy importante.

Scala se siente ligera y dinámica

Más que ser expresivo, Scala se siente como un lenguaje de scripting ligero y dinámico. Por ejemplo, el sistema de inferencia de tipos de Scala elimina la necesidad de lo obvio. En lugar de tener que especificar siempre los tipos, simplemente asignas tus variables a sus datos:

val hello = "Hello, world"   // a String
val i = 1                    // an Int
val x = 1.0                  // a Double

Observa que no es necesario declarar que una variable es String, Int, o Double. Éste es el sistema de inferencia de tipos de Scala en funcionamiento.

Crear tus propios tipos personalizados funciona exactamente igual. Dada una clase Person:

class Person(val name: String)

puedes crear una sola persona:

val p = Person("Martin Odersky")

o varias personas en una lista, sin código repetitivo innecesario:

val scalaCenterFolks = List(
    Person("Darja Jovanovic"),
    Person("Julien Richard-Foy"),
    Person("Sébastien Doeraene")
)

Y aunque todavía no he introducido las expresiones for, sospecho que cualquier desarrollador con un poco de experiencia puede entender este código:

for
    person <- scalaCenterFolks
    if person.name.startsWith("D")
do
    println(person.name)

Y aunque todavía no he introducido los enums, es probable que el mismo desarrollador sepa lo que significa este código:

enum Topping:
    case Cheese, Pepperoni, Mushrooms, Olives

Observa de nuevo que aquí no hay código repetitivo innecesario; el código es lo más "minimalista" posible, pero sigue siendo fácilmente legible. Se ha puesto mucho cuidado en continuar la tradición de Scala de ser un lenguaje expresivo.

En todos estos ejemplos puedes ver la sintaxis ligera de Scala, y cómo se siente como un lenguaje de scripting dinámico.

Audiencia

Este libro está pensado para programadores que quieran encontrar rápidamente soluciones a los problemas que se les planteen al utilizar Scala y sus bibliotecas y herramientas. Espero que también sea una buena herramienta para los desarrolladores que quieran aprender Scala. Creo firmemente en el aprendizaje mediante el ejemplo, y este libro está repleto de ejemplos.

Generalmente asumo que tienes alguna experiencia con otro lenguaje de programación como C, C++, Java, Ruby, C#, PHP, Python, Haskell y similares. Mi propia experiencia es con esos lenguajes, así que estoy seguro de que mi escritura está influida por ese bagaje.

Otra forma de describir la audiencia de este libro consiste en considerar los distintos niveles de programadores informáticos. En este artículo sobre los niveles de Scala, Martin Odersky define los siguientes niveles de programadores informáticos:

• Nivel A1: Programador de aplicaciones principiante

• Nivel A2: Programador de aplicaciones intermedio

• Nivel A3: Programador experto en aplicaciones

• Nivel L1: Diseñador de bibliotecas junior

• Nivel L2: Diseñador de bibliotecas senior

• Nivel L3: Diseñador experto de bibliotecas

Este libro está dirigido principalmente a los desarrolladores de aplicaciones de las categorías A1, A2, A3 y L1. Aunque mi objetivo principal es ayudar a esos desarrolladores, espero que los desarrolladores L2 y L3 también puedan beneficiarse de los numerosos ejemplos de este libro, especialmente si no tienen experiencia previa con la programación funcional, o si quieren ponerse al día rápidamente con Scala y sus herramientas y bibliotecas.

Contenido de este libro

Este libro trata de soluciones, y el Capítulo 1, Tareas en la línea de comandos, contiene una colección de recetas centradas en el uso de Scala en la línea de comandos. Comienza mostrando consejos sobre cómo utilizar el REPL de Scala, así como el REPL Ammonite, repleto de funciones. A continuación, muestra cómo utilizar herramientas de línea de comandos como scalac y scala para compilar y ejecutar tu código, así como el comando javap para desensamblar tus archivos de clase Scala. Por último, muestra cómo ejecutar archivos JAR generados con Scala.

El Capítulo 2, Cadenas, proporciona recetas para trabajar con cadenas. Scala obtiene su funcionalidad básica String de Java, pero con la potencia de las conversiones implícitas, Scala añade una nueva funcionalidad a las cadenas, de modo que también puedes tratarlas como una secuencia de caracteres (Char values).

El capítulo 3, Números y fechas, proporciona recetas para trabajar con los tipos numéricos de Scala, así como con las clases de fecha que se introdujeron con Java 8. En las recetas numéricas, verás que no hay operadores ++ y -- para trabajar con números; este capítulo explica por qué y demuestra los otros métodos que puedes utilizar. También muestra cómo manejar números grandes, divisas y cómo comparar números de coma flotante. Las recetas de fecha utilizan las clases de fecha de Java 8 y también muestran cómo trabajar con fechas heredadas.

El capítulo 4, Estructuras de control, muestra las estructuras de control incorporadas en Scala, empezando por las sentencias if/then y los bucles básicos for, y luego proporciona soluciones para trabajar con bucles for/yield (for comprensiones), y expresiones for con sentencias if incrustadas (guardias). Dado que las expresiones match y la concordancia de patrones son tan importantes para Scala, varias recetas muestran cómo utilizarlas para resolver diversos problemas.

El Capítulo 5, Clases, proporciona ejemplos relacionados con clases, parámetros y campos Scala. Como los constructores Scala son muy diferentes de los constructores Java, varias recetas muestran los entresijos de escribir constructores primarios y auxiliares. Varias recetas muestran qué son las clases case y cómo utilizarlas.

El capítulo 6, Traits y Enums, proporciona ejemplos del importantísimo trait de Scala, así como del flamante enum. Las recetas de traits comienzan mostrando cómo utilizar un trait como una interfaz Java, y luego se sumergen en temas más avanzados, como la forma de utilizar traits como mixins, y cómo limitar en qué miembros se puede mezclar un trait utilizando diversos métodos. Las dos recetas finales demuestran cómo utilizar enums en el modelado de dominios, incluida la creación de tipos de datos algebraicos (ADT).

El Capítulo 7, Objetos, contiene recetas relacionadas con los objetos, incluido el significado de un objeto como instancia de una clase, así como todo lo relacionado con la palabra clave object.

El capítulo 8, Métodos, muestra cómo definir métodos que acepten parámetros, devuelvan valores, utilicen nombres de parámetros al llamar a métodos, establezcan valores por defecto para los parámetros de los métodos, creen campos varargs y escriban métodos que soporten un estilo de programación fluido. La última receta del capítulo muestra los nuevos métodos de extensión de Scala 3.

El capítulo 9, Empaquetado e importaciones, contiene ejemplos de las sentencias package y import de Scala, que proporcionan más capacidades que las mismas palabras clave de Java. Esto incluye cómo utilizar el estilo de llaves rizadas para el empaquetado, cómo ocultar y renombrar miembros cuando los importas, y mucho más.

Aunque gran parte del libro muestra técnicas de PF, el capítulo 10, Programación funcional, combina muchas recetas de PF en un solo lugar. Las soluciones muestran cómo definir funciones anónimas (literales de función) y utilizarlas en diversas situaciones. Las recetas demuestran cómo definir un método que acepte un argumento de función, funciones parcialmente aplicadas y cómo devolver una función desde una función.

La biblioteca de colecciones de Scala es rica y profunda, por lo que los capítulos 11 a 15 proporcionan cientos de ejemplos relacionados con las colecciones.

Las recetas del Capítulo 11, Colecciones: Introducción te ayudan a elegir clases de colecciones para necesidades específicas y luego te ayudan a elegir y utilizar métodos dentro de una colección para resolver problemas concretos, como transformar una colección en una nueva colección, filtrar una colección y crear subgrupos de una colección.

Capítulo 12, Colecciones: Clases comunes de secuencias muestra las clases de colecciones más comunes, como Vector, List, ArrayBuffer, Array y LazyList. Las recetas demuestran cómo crear cada tipo, así como añadir, actualizar y eliminar elementos.

El capítulo 13, Colecciones: Métodos comunes de secuencias, muestra cómo utilizar los métodos más comunes disponibles para las clases de secuencias de Scala. Las recetas muestran cómo iterar sobre secuencias, transformarlas, filtrarlas, ordenarlas y mucho más.

Del mismo modo que el capítulo anterior muestra métodos comunes de secuencias, el Capítulo 14, Colecciones: Uso de mapas, muestra muchas de las mismas técnicas para su uso con las clases Map de Scala.

Por último, el capítulo 15, Colecciones: Tuple, Range, Set,Stack y Queue (Tupla, Rango, Conjunto, P ila y Cola ) cubre las demás clases de colecciones de Scala, como tuplas, rangos, conjuntos, pilas y colas.

A continuación,el Capítulo 16, Archivos y procesos, muestra cómo trabajar con archivos y procesos. Las recetas muestran cómo leer y escribir archivos, obtener listados de directorios y trabajar con serialización. A continuación, varias recetas muestran cómo trabajar con procesos externos de forma independiente de la plataforma.

El capítulo 17, Construir proyectos con sbt, es una guía completa de la herramienta de construcción de facto para aplicaciones Scala. Comienza mostrando varias formas de crear una estructura de directorios de proyecto sbt, y luego muestra cómo incluir dependencias gestionadas y no gestionadas, construir tus proyectos, generar Scaladoc para tus proyectos, implementar tus proyectos, y mucho más.

El capítulo 18, Concurrencia con futuros de Scala y actores de Akka, proporciona soluciones para el maravilloso mundo de la creación de aplicaciones concurrentes (¡y de la utilización de esas CPU multinúcleo!) con futuros y la biblioteca de actores de Akka. Las recetas con futuros muestran cómo construir focos de concurrencia de una sola vez y de corta duración, mientras que las recetas con actores demuestran cómo crear procesos paralelos de larga duración que pueden responder a miles de millones de solicitudes durante su vida útil.

El capítulo 19, Play Framework y servicios web, muestra cómo utilizar Scala tanto en el lado cliente como en el lado servidor de los servicios web. En el lado del servidor, muestra cómo utilizar Play Framework para desarrollar servicios web RESTful. Tanto para el código del cliente como para el del servidor, muestra cómo serializar y deserializar JSON, y cómo trabajar con cabeceras HTTP.

El Capítulo 20, Apache Spark, muestra el framework Apache Spark. Spark es una de las aplicaciones que han hecho famoso a Scala, y las recetas demuestran cómo trabajar con grandes conjuntos de datos como un Conjunto de Datos Distribuido Resistente (RDD), y también cómo consultarlos mediante consultas SQL estándar del sector.

El Capítulo 21, Scala.js, GraalVM y jpackage proporciona varias recetas para bibliotecas y herramientas en los mundos de Scala y JVM. Las primeras recetas muestran cómo utilizar Scala.js como sustituto de JavaScript de tipo seguro. Las últimas recetas muestran cómo convertir tu código Scala en un ejecutable nativo utilizando GraalVM, y luego cómo empaquetar tu aplicación Scala como una aplicación nativa utilizando la utilidad jpackage de Java.

El capítulo 22, Integrar Scala con Java, muestra cómo resolver los pocos problemas que puedes encontrar al integrar código Scala y Java. Aunque el código Scala suele funcionar bien cuando interactúa con Java, hay algunas "gotchas". Este capítulo muestra cómo resolver los problemas relacionados con las diferencias en las bibliotecas de colecciones, así como los problemas que puedes encontrarte al llamar al código Scala desde Java.

El capítulo 23, Tipos, proporciona recetas para trabajar con el potente sistema de tipos de Scala. A partir de la introducción, se demuestran con ejemplos conceptos como la varianza de tipos, los límites y las restricciones. Las recetas muestran cómo declarar genéricos en definiciones de clases y métodos, implementar tipado de patos y controlar en qué tipos se pueden mezclar tus rasgos. A continuación, se demuestran varios conceptos totalmente nuevos de Scala 3 con tipos opacos, valores given`and `using como sustituto de implícitos, tipos de unión e intersección, y dos recetas relacionadas con el concepto de igualdad al comparar objetos.

El capítulo 24, Buenas prácticas, es único para un libro de recetas, pero como éste es un libro de soluciones, creo que es importante tener una sección dedicada a mostrar las buenas prácticas, es decir, cómo escribir código "a la manera Scala". Las recetas muestran cómo crear métodos sin efectos secundarios, cómo trabajar con objetos inmutables y tipos de colecciones, cómo pensar en términos de expresiones (en lugar de sentencias), cómo utilizar la concordancia de patrones y cómo eliminar los valores nulos en tu código.

Instalar Scala

Puedes instalar Scala 3 de varias formas diferentes, incluyendo Homebrew (en macOS), Coursier, SDKMAN, y descargando e instalando Scala manualmente. Coursier se considera el "instalador de Scala", y su uso se trata en esta página "Primeros pasos con Scala 3".

Si no quieres instalar Scala todavía, también puedes experimentar con él en tu navegador utilizando estas herramientas en línea:

• Scastie

• ScalaFiddle

Convenciones de este libro

Hay algunos puntos importantes que debes conocer sobre las convenciones que utilizo en este libro. En primer lugar, como ya he mencionado, utilizo el estilo de programación de llaves opcionales (indentación significativa), que elimina la mayor parte de la necesidad de paréntesis y llaves rizadas:

for i <- 1 to 5 do println(i)      // use this style
for (i <- 1 to 5) { println(i) }   // don’t use this style

Junto con este estilo, yo indento mi código con cuatro espacios. Actualmente no existe un estándar de indentación, y los desarrolladores parecen preferir de dos a cuatro espacios.

A continuación, cuando muestro ejemplos, suelo mostrar el resultado de mis ejemplos en comentarios después de los ejemplos. Por tanto, mis ejemplos tienen este aspecto:

(1 to 10 by 2).toList      // List(1, 3, 5, 7, 9)
(1 until 10 by 2).toList   // List(1, 3, 5, 7, 9)
('d' to 'h').toList        // List(d, e, f, g, h)
('d' until 'h').toList     // List(d, e, f, g)

Utilizar este estilo me ayuda a incluir en este libro muchos más ejemplos de los que cabían en la primera edición.

Otras normas de codificación utilizadas en este libro son:

• Siempre defino las variables como campos val (que son como final en Java), a menos que haya una razón por la que deban ser un var.

• Cuando un método no toma parámetros y tiene un efecto secundario (como imprimir en la consola), defino y llamo al método con paréntesis vacíos, como ().

• Aunque en muchas situaciones no es necesario definir tipos de datos, yo siempre declaro el tipo de retorno de los métodos públicos.

Como ejemplo de esta última norma, puedes definir un método sin declarar su tipo de retorno, así:

def double(i: Int) = i * 2

Sin embargo, la mayoría de los desarrolladores prefieren mostrar el tipo de retorno del método:

def double(i: Int): Int = i * 2

Por unos pocos caracteres más que teclees ahora, tu código será más fácil de leer después.

Ayuda

Muchos de los ejemplos de código fuente mostrados en este libro están disponibles en este repositorio de GitHub, que incluye muchos proyectos sbt completos:

• github.com/alvinj/ScalaCookbook2Ejemplos

El canal Gitter de Scala es una excelente fuente de ayuda, y de vez en cuando verás mis preguntas por ahí.

Si te interesan las propuestas y debates sobre las características de Scala, el sitio web "Scala Contributors " también es un recurso estupendo.

Por último, puedes encontrar las últimas entradas de mi blog en alvinalexander .com, y a menudo tuiteo sobre temas de Scala en twitter.com/alvinalexander.

Convenciones utilizadas en este libro

En este libro se utilizan las siguientes convenciones tipográficas:

Cursiva

Indica nuevos términos, URL, direcciones de correo electrónico, nombres de archivo y extensiones de archivo.

Constant width

Se utiliza en los listados de programas, así como dentro de los párrafos para referirse a elementos del programa como nombres de variables o funciones, bases de datos, tipos de datos, variables de entorno, sentencias y palabras clave.

Constant width italic

Muestra el texto que debe sustituirse por valores proporcionados por el usuario o por valores determinados por el contexto.

Consejo

Este elemento significa un consejo o sugerencia.

Nota

Este elemento significa una nota general.

Advertencia

Este elemento indica una advertencia o precaución.

Utilizar ejemplos de código

El material complementario (ejemplos de código, ejercicios, etc.) se puede descargar en https://github.com/alvinj/ScalaCookbook2Examples.

Si tienes una pregunta técnica o un problema al utilizar los ejemplos de código, envía un correo electrónico a [e-mail].

Este libro está aquí para ayudarte a hacer tu trabajo. En general, si se ofrece código de ejemplo con este libro, puedes utilizarlo en tus programas y documentación. No es necesario que te pongas en contacto con nosotros para pedirnos permiso, a menos que estés reproduciendo una parte importante del código. Por ejemplo, escribir un programa que utilice varios trozos de código de este libro no requiere permiso. Vender o distribuir ejemplos de los libros de O'Reilly sí requiere permiso. Responder a una pregunta citando este libro y el código de ejemplo no requiere permiso. Incorporar una cantidad significativa de código de ejemplo de este libro en la documentación de tu producto sí requierepermiso.

Agradecemos la atribución, pero en general no la exigimos. Una atribución suele incluir el título, el autor, la editorial y el ISBN. Por ejemplo "Scala Cookbook por Alvin Alexander (O'Reilly). Copyright 2021 Alvin Alexander, 978-1-492-05154-1".

Si crees que el uso que haces de los ejemplos de código no se ajusta al uso legítimo o al permiso concedido anteriormente, no dudes en ponerte en contacto con nosotros en [e-mail].

Aprendizaje en línea O'Reilly

Nota

Durante más de 40 años, O'Reilly Media ha proporcionado formación tecnológica y empresarial, conocimientos y perspectivas para ayudar a las empresas a alcanzar el éxito.

Nuestra red única de expertos e innovadores comparten sus conocimientos y experiencia a través de libros, artículos y nuestra plataforma de aprendizaje online. La plataforma de aprendizaje en línea de O'Reilly te ofrece acceso bajo demanda a cursos de formación en directo, rutas de aprendizaje en profundidad, entornos de codificación interactivos y una amplia colección de textos y vídeos de O'Reilly y de más de 200 editoriales. Para más información, visita http://oreilly.com.

Cómo contactar con nosotros

Dirige tus comentarios y preguntas sobre este libro a la editorial:

• O'Reilly Media, Inc.
• 1005 Gravenstein Highway Norte
• Sebastopol, CA 95472
• 800-998-9938 (en Estados Unidos o Canadá)
• 707-829-0515 (internacional o local)
• 707-829-0104 (fax)

Tenemos una página web para este libro, donde se enumeran erratas, ejemplos y cualquier información adicional. Puedes acceder a esta página en https://oreil.ly/scala-cookbook-2e.

Envía un correo electrónico a [e-mail] para comentar o hacer preguntas técnicas sobre este libro.

Para obtener noticias e información sobre nuestros libros y cursos, visita https://oreilly.com.

Encuéntranos en Facebook: https://facebook.com/oreilly

Síguenos en Twitter: https://twitter.com/oreillymedia

Míranos en YouTube: https://youtube.com/oreillymedia

Agradecimientos

Escribir un libro tan extenso requiere mucho trabajo, y me gustaría dar las gracias a mi editor, Jeff Bleiel, por su labor a lo largo de la creación de este libro. Empezamos a trabajar juntos en el libro en diciembre de 2018, y mientras Scala 3 seguía cambiando a través del proceso de la comunidad, seguimos trabajando juntos en él hasta la finalización del libro en 2021.

Cuando completé los borradores iniciales de los capítulos, Jeff me ofreció cientos de sugerencias sobre cómo mejorarlos. Este proceso continuó durante la pandemia de COVID-19, y a medida que el libro se hacía más claro, Jeff (correctamente) sugirió la reorganización de varios capítulos. Es increíblemente minucioso, y puedo decirte que cuando veas un libro que ha sido editado por Jeff Bleiel, puedes estar seguro de que está bien editado y pensado.

Para esta edición del libro, todos los revisores fueron útiles de diferentes maneras. Jason Swartz fue candidato a "revisor más valioso" en la primera edición de Scala Cookbook, e hizo otro trabajo estelar en esta edición con muchas sugerencias sólidas.

Philip Schwarz se unió a nosotros en esta edición y ofreció una serie de buenas ideas, especialmente sobre los primeros capítulos del libro.

Pero para esta edición, debo un enorme y especial agradecimiento a Hermann Hueck, que fue el revisor más valioso de esta edición. Hermann ofreció cientos de sugerencias, grandes y pequeñas, que abarcaban desde la más pequeña línea de código hasta la organización general del libro.

No puedo decir lo suficiente tanto de Jeff como de Hermann, pero quizá la mejor forma de decirlo es que este libro no habría sido lo mismo sin ellos: ¡gracias a los dos!

También me gustaría dar las gracias a Christopher Faucher, el editor de producción de este libro. Después de que Jeff y yo acordáramos que habíamos terminado con el proceso inicial de redacción y edición, Chris vino y nos ayudó a llevar el libro a la línea de meta, mientras trabajábamos en cientos de comentarios y problemas. Si sabes lo que es dar vida a una gran aplicación de software, conseguir que un gran libro como éste supere la línea de meta es exactamente lo mismo. ¡Gracias, Chris!

Por último, me gustaría dar las gracias a Martin Odersky y a su equipo por crear un lenguaje de programación tan interesante. Me enamoré de Scala por primera vez cuando encontré su libro Programming in Scala en una librería de Anchorage, Alaska, en 2010, y desde entonces ha sido un festival de amor que continúa hasta Scala 3 en 2021 y más allá.

Te deseo lo mejor,
Al