Inicio: instalación y primer programa

En esta lección vas a preparar tu entorno para programar en Scala. Primero vas a ver qué es Scala y qué versión usa el curso. Después vas a instalar Java, Scala, sbt y un editor, vas a escribir tu primer programa y vas a ver cómo se compila un proyecto con sbt y con Maven. Si querés empezar ya mismo, sin instalar nada, también hay una opción online.

¿Qué es Scala?

Scala es un lenguaje de programación de propósito general pensado para expresar patrones comunes de programación de forma concisa, legible y con tipos seguros. Apareció en 2003 y combina características de los lenguajes funcionales y de los orientados a objetos. Corre sobre la máquina virtual de Java y es compatible con las aplicaciones Java existentes. Sus rasgos principales:

1. Orientado a objetos. En Scala todo es un objeto. Podés definir tus propias clases y traits (rasgos) para crear tipos de datos y comportamientos, y armar programas estructurados y modulares.
2. Funcional. Las funciones son valores. Podés definir funciones anónimas y funciones de orden superior, y usar pattern matching para expresar la lógica de forma clara y concisa.
3. Fuertemente tipado. El sistema de tipos es estático: el compilador verifica la coherencia de los tipos antes de ejecutar, y eso previene errores. Además tiene inferencia de tipos, así que no hace falta anotar todo.
4. Extensible. Es sencillo crear librerías que se leen casi como un lenguaje propio (un DSL, Domain-Specific Language) sin extender la sintaxis del lenguaje.
5. Interoperable con Java. Podés usar cualquier librería o componente Java desde Scala. Lo que en Java son lambdas o clases genéricas tiene su equivalente en Scala.

Las versiones del curso

El material de este curso se armó en octubre de 2023, y usamos las versiones de ese momento, las mismas del proyecto final (lección 14):

Scala 3 aceptó casi toda la sintaxis de Scala 2, y en el curso usamos el estilo con llaves {}, que funciona en las dos versiones. Scala 3 también permite escribir bloques sin llaves, usando la indentación, como en Python; lo vas a ver en código moderno, pero acá nos quedamos con las llaves. Donde haya una diferencia entre Scala 2 y Scala 3 que te pueda morder (como el bucle do-while, que en Scala 3 ya no existe), la vas a ver marcada con una nota.

Opción 1: Scastie, sin instalar nada

Para tus primeras pruebas podés usar Scastie (scastie.scala-lang.org), un editor online que compila y ejecuta Scala en el navegador, sin ningún tipo de instalación.

1. Entrá a scastie.scala-lang.org.
2. En Build Settings, elegí Scala 3 y la versión 3.3.1 (o la 3.3 más cercana que ofrezca).
3. Escribí código en el editor y apretá Run.

Con Scastie alcanza para casi todo el curso. Las limitaciones son dos: no permite leer lo que escribe el usuario por teclado (lo vas a usar en la lección 4) ni trabajar con archivos de tu máquina (lección 11). Para eso necesitás la instalación local.

Opción 2: instalación local

Instalar Java

Scala se ejecuta sobre la JVM (Java Virtual Machine), así que antes de trabajar con Scala necesitás Java instalado. Instalá el JDK 11 (el kit de desarrollo, que incluye el entorno de ejecución y lo que hace falta para compilar):

# Linux (Debian/Ubuntu)
sudo apt-get update
sudo apt-get install openjdk-11-jdk

# macOS
brew install openjdk@11

# Windows: descargá el instalador del JDK 11 desde adoptium.net (Temurin 11)

Asegurate de elegir la versión que corresponde a tu sistema operativo y arquitectura. Después, verificá la instalación en una terminal:

java -version
# openjdk version "11.0.x" ...

Instalar Scala y sbt

En la página de descargas de scala-lang.org (sección Install), la opción recomendada es instalar con Coursier, el instalador oficial. Seguí las instrucciones de cs setup para tu sistema operativo: ese comando instala de una vez el compilador, el intérprete y sbt.

Para fijar exactamente la versión del curso:

cs install scala:3.3.1 scalac:3.3.1

Cuando termine, cerrá la terminal y abrí una nueva para que tome los cambios en el PATH. En algunos sistemas, sobre todo en Windows, conviene reiniciar la computadora. Verificá:

scala -version
# Scala code runner version 3.3.1 ...

sbt --version
# sbt runner version: 1.9.x

La versión de sbt que usa cada proyecto la fija el propio proyecto (en project/build.properties), así que no importa si el comando sbt que instalaste es un poco más nuevo.

Elegir un editor

Para escribir Scala te conviene un editor que entienda el lenguaje. Las dos opciones más usadas:

• IntelliJ IDEA Community Edition (gratuito) con el plugin Scala. Es la opción recomendada para el curso: autocompleta, marca errores mientras escribís y crea proyectos con un asistente. La edición Ultimate (paga) suma funciones avanzadas que acá no hacen falta.
• Visual Studio Code con la extensión Scala (Metals). Más liviano y muy configurable.

También hay soporte para Scala en Eclipse y en Sublime Text, pero con mucha menos comunidad.

Tu primer programa

Creá un archivo HolaMundo.scala con este contenido:

object HolaMundo {
  def main(args: Array[String]): Unit = {
    println("Hola, mundo!")
    println("Estoy aprendiendo Scala")
  }
}

• object HolaMundo define un objeto: un contenedor único para tu código (lo vas a ver en detalle en la lección 8).
• def main(args: Array[String]): Unit es el punto de entrada: la función que se ejecuta al correr el programa. args trae los argumentos de la línea de comandos y Unit indica que no devuelve nada útil.
• println muestra un texto y salta de línea.

Compilalo y ejecutalo:

scalac HolaMundo.scala
scala HolaMundo

Hola, mundo!
Estoy aprendiendo Scala

scalac compila el archivo y genera los .class que entiende la JVM; scala HolaMundo ejecuta el objeto que tiene el main.

Scala 3 suma una forma más corta de declarar el punto de entrada: una función marcada con @main, sin object alrededor. Es la que usa el proyecto final.

@main def holaMundo(): Unit = {
  println("Hola, mundo!")
  println("Estoy aprendiendo Scala")
}

Las dos formas son válidas en Scala 3; la del object con main es la única que existe en Scala 2.

El intérprete (REPL)

El intérprete de Scala, también llamado REPL (Read-Eval-Print Loop), te deja ejecutar código de forma interactiva, sin crear un programa completo. Es ideal para probar cosas rápido.

1. Abrí una terminal.
2. Escribí scala y apretá Enter.
3. Escribí código y apretá Enter para ejecutarlo.
4. Para salir, escribí :q.

scala> 1 + 1
val res0: Int = 2

scala> val nombre = "Lucas"
val nombre: String = Lucas

scala> println(s"Hola, $nombre")
Hola, Lucas

El REPL te muestra el resultado de cada expresión junto con su tipo (Int, String). Los resultados sin nombre se guardan como res0, res1, etc., y los podés reusar.

Compilar un proyecto con sbt

Cuando un programa crece, deja de ser práctico compilarlo archivo por archivo con scalac. Para eso existen las herramientas de build, que compilan todo el proyecto, descargan las librerías que necesita, lo ejecutan y lo empaquetan. En Scala, la estándar es sbt. Un proyecto mínimo tiene esta forma:

mi-proyecto/
├── build.sbt
├── project/
│   └── build.properties
└── src/
    └── main/
        └── scala/
            └── Main.scala

// build.sbt
ThisBuild / version := "0.1.0-SNAPSHOT"
ThisBuild / scalaVersion := "3.3.1"

lazy val root = (project in file("."))
  .settings(
    name := "mi-proyecto"
  )

# project/build.properties
sbt.version = 1.9.6

• build.sbt describe el proyecto: su nombre, su versión y la versión de Scala.
• project/build.properties fija la versión de sbt.
• src/main/scala/ tiene el código. sbt sigue esta convención de carpetas: no hace falta configurarla.

Desde la carpeta del proyecto:

sbt run       # compila y ejecuta el main
sbt compile   # solo compila
sbt           # abre la consola de sbt, donde podés escribir run, compile, etc.

La primera vez tarda porque descarga sbt, Scala y lo que haga falta. IntelliJ IDEA (con el plugin Scala) y VS Code (con Metals) reconocen un proyecto sbt al abrir la carpeta. Es la misma estructura del proyecto final del curso.

Alternativa: compilar un proyecto con Maven

Muchos equipos que vienen de Java usan Maven en lugar de sbt. Para ese caso, el curso incluye un proyecto de ejemplo listo para compilar.

Descargá el proyecto de ejemplo (maven-scala.zip)

Ojo con la versión: este proyecto usa Scala 2.13.8 y compila para Java 8. El .jar resultante corre en Java 11 o posterior, pero para compilarlo usá un JDK entre 11 y 21: la versión del plugin de Scala para Maven de ese momento (scala-maven-plugin 4.5.2) falla con JDK más nuevos. Si mvn toma otro JDK por defecto, apuntá JAVA_HOME a uno de esos. Todo lo que ves en el curso funciona también en Scala 2.13, salvo los puntos marcados como propios de Scala 3, como @main. Si querés compilar con Maven código que use @main, cambiá la versión de Scala del pom.xml (y la dependencia de la librería de Scala 3) o usá un object con main.

Para usarlo necesitás tener Maven instalado (sudo apt-get install maven, brew install maven o el zip de maven.apache.org en Windows). Verificalo con mvn -version.

Estructura del proyecto

maven-scala/
├── pom.xml
└── src/
    ├── main/
    │   ├── resources/
    │   └── scala/
    │       └── Main.scala
    └── test/
        └── resources/

• pom.xml describe el proyecto: su nombre, la versión de Scala, las dependencias y los plugins que se usan para compilar y empaquetar.
• src/main/scala/ tiene el código, con la misma convención de carpetas que sbt.
• src/test/ es el lugar para los tests, que en este ejemplo está vacío.

El programa es mínimo: pregunta tu nombre y te saluda.

object Main {
  def main(args: Array[String]): Unit = {
    val nombre = scala.io.StdIn.readLine("¿Cómo te llamás? ")
    println("Hola, " + nombre)
  }
}

Qué dice el pom.xml

• Las propiedades. scala.version fija Scala 2.13.8, y maven.compiler.source y maven.compiler.target en 1.8 indican que el código se compila para Java 8.
• La dependencia scala-library. Es la librería estándar de Scala (colecciones, println, StdIn y demás) en la versión de scala.version.
• Los plugins de build:
  • scala-maven-plugin 4.5.2 le enseña a Maven a compilar Scala. Se engancha en las fases compile y testCompile, así que los archivos de src/main/scala y src/test/scala se compilan con el compilador de Scala.
  • maven-assembly-plugin 3.3.0 arma el jar final. Con el descriptor jar-with-dependencies mete adentro del jar tu código y todas sus dependencias, incluida la librería de Scala, para que se pueda ejecutar solo con java, sin tener Scala instalado. El mainClass configurado es Main: le dice al jar qué objeto tiene el main que se ejecuta al arrancar.

Compilar y ejecutar

Desde la carpeta del proyecto, compilá y empaquetá:

mvn clean compile assembly:single

• clean borra lo compilado antes.
• compile compila el código.
• assembly:single arma el jar con todas las dependencias.

La primera vez tarda un poco porque descarga los plugins y la librería de Scala. Al terminar, ejecutá el jar:

java -jar target/mi-proyecto-1.0-SNAPSHOT-jar-with-dependencies.jar

¿Cómo te llamás? Lucas
Hola, Lucas

En Windows, la ruta se escribe con barra invertida: java -jar .\target\mi-proyecto-1.0-SNAPSHOT-jar-with-dependencies.jar.

El nombre del jar sale del pom.xml: artifactId (mi-proyecto) más version (1.0-SNAPSHOT) más el sufijo del descriptor.

Practicá

1. En Scastie o en el REPL, mostrá tu nombre y tu ciudad en dos líneas distintas.
2. En el REPL, calculá cuántos minutos tiene una semana. ¿Qué tipo te informa?
3. Escribí un programa Presentacion.scala con un object y un main que muestre tres líneas: tu nombre, tu rol y qué querés aprender en este curso. Compilalo con scalac y ejecutalo con scala.
4. Armá un proyecto sbt con la estructura de esta lección y un Main.scala que pregunte tu nombre y te salude mostrando también la cantidad de letras del nombre (nombre.length). Ejecutalo con sbt run. Si preferís Maven, hacé lo mismo sobre el proyecto de ejemplo y ejecutá el jar.

Soluciones

// Ejercicio 1
println("Lucas")
println("Mendoza")

// Ejercicio 2, en el REPL
scala> 60 * 24 * 7
val res0: Int = 10080

// Ejercicio 3
object Presentacion {
  def main(args: Array[String]): Unit = {
    println("Nombre: Lucas")
    println("Rol: Data Engineer")
    println("Quiero aprender: Scala desde cero")
  }
}

// Ejercicio 4: src/main/scala/Main.scala
object Main {
  def main(args: Array[String]): Unit = {
    val nombre = scala.io.StdIn.readLine("¿Cómo te llamás? ")
    println(s"Hola, $nombre. Tu nombre tiene ${nombre.length} letras.")
  }
}

sbt run
# o, con el proyecto Maven:
mvn clean compile assembly:single
java -jar target/mi-proyecto-1.0-SNAPSHOT-jar-with-dependencies.jar

Usamos un object con main para que el mismo archivo compile tanto en el proyecto sbt (Scala 3) como en el de Maven (Scala 2.13).

Resumen

• Scala combina programación orientada a objetos y funcional, tiene tipos estáticos con inferencia y corre sobre la JVM, compatible con Java.
• El curso usa Scala 3.3.1, sbt 1.9.6 y Java 11, las versiones de octubre de 2023.
• Scastie te deja programar sin instalar nada; para trabajar en serio, instalá el JDK 11, Scala y sbt con Coursier, y un editor (IntelliJ IDEA con el plugin Scala o VS Code con Metals).
• Un programa arranca en el main de un object o, en Scala 3, en una función @main. El REPL (scala) sirve para probar código línea por línea.
• Un proyecto sbt se define con build.sbt y project/build.properties y se ejecuta con sbt run.
• Como alternativa, el proyecto Maven de ejemplo (Scala 2.13.8, target Java 8) compila con scala-maven-plugin y arma un jar ejecutable con maven-assembly-plugin.