De cero a "Hola mundo" en Scala

Spanish (Español) translation by Steven (you can also view the original English article)

Scala es uno de los lenguajes de programación más atractivos del momento. Hay mucha publicidad a su alrededor y los programadores de todo el mundo lo reconocen públicamente como la próxima gran novedad en la programación. Este es el por qué. Scala tiene que ver con la programación funcional en un contexto orientado a objetos. Intenta tomar lo mejor de ambos mundos y combinarlos en un lenguaje altamente eficiente, inteligente y relativamente fácil de entender. En este momento, es el líder en el renacimiento actual de los lenguajes de programación funcionales.

Recientemente terminé el curso Scala de Martin Odersky y me resultó muy difícil averiguar cómo empezar. Ya sabes, ese primer paso cuando deseas comenzar a programar, pero no sabes qué herramientas están a tu disposición, qué IDE usar o qué framework de pruebas unitarias elegir. Este tutorial se trata de ti, el recién llegado a Scala, preparando tu entorno de desarrollo para que puedas comenzar más fácilmente.

Las piezas del rompecabezas

Aquí están las piezas del rompecabezas de las que hablaremos en esta lección, siéntete libre de omitir las que ya conoces:

Herramientas de compilación simple (SBT): Esta es la herramienta que genera proyectos, dependencias, etc. para Scala
NetBeans con complementos de Scala: Cómo integrar Scala con NetBeans
Hola mundo: Crearemos nuestro primer archivo fuente en Scala
Scalatest: El framework de pruebas unitarias recomendado para Scala

Tomaremos cada tema de la lista y lo discutiremos a un nivel principiante y finalmente veremos cómo funcionan todas estas piezas juntas.

Requisitos del Software

Antes de comenzar, asegúrate de tener instalado en tu computadora el último SDK de Java. Dado que Scala se ejecuta en Java Virtual Machine (JVM), se requiere el SDK. El resto de los temas de nuestra lista pueden requerir el SDK de Java, ya sea directa o indirectamente, por lo que es bueno tenerlo.

No es necesario tener instalado Scala. Hablaremos de esto en el próximo capítulo.

Herramientas de compilación simple (SBT)

Si eres un desarrollador de PHP, probablemente estés familiarizado con Composer. Si eres un gurú de Ruby, conoces y amas a Bundler. Si programas en otro lenguaje, estoy seguro de que también hay un administrador de paquetes para eso.

SBT es similar a los administradores de paquetes anteriores, pero, mientras Composer requiere que tengas PHP preinstalado de la misma manera que Bundler necesita Ruby, Scala no necesita estar instalado en el sistema antes de que puedas usar SBT. De hecho, la versión específica de Scala que deseas usar para tu proyecto puede simplemente especificarse como una dependencia en SBT. Quizás te preguntes cómo es posible. Como mencioné antes, Scala se ejecuta en la JVM; básicamente, es solo una biblioteca de Java. Los paquetes de Scala también pueden ser simples archivos .jar. Entonces, SBT, en sí mismo, es solo un programa Java. Solo necesitas Java, que probablemente ya tengas de todos modos.

Hay muchas formas diferentes de abordar la instalación de SBT. Por razones multiplataforma entre Linux, Mac y Windows, mi forma preferida de instalar SBT es simplemente tomar el archivo, ponerlo en un directorio, extraerlo en mi directorio de inicio y agregar su ruta al sistema.

Una forma independiente de la plataforma para instalar SBT

Descarga el último SBT estable del repositorio oficial. Busca una carpeta sin "Beta", "R" o "M" al final. Esa será la versión estable. En el momento de escribir este tutorial, la última versión estable es 0.12.3.

El archivo contiene un directorio sbt dentro de él. Simplemente extrae esto en tu ubicación favorita. Prefiero que esté en algún lugar de mi directorio de inicio como home/csaba/Programming/Scala/sbt.

A continuación, agrega la ruta a tu directorio bin SBT, a tu variable PATH. En sistemas similares a UNIX, si usas Bash, agrega una línea como esta a tu archivo ~/.bash_profile o ~/.bashrc:

1	PATH=$PATH:$HOME/Programming/Scala/sbt/bin
2	export PATH

La variable $HOME generalmente apunta a tu directorio de inicio. Puedes reutilizarlo en tus archivos de configuración. Los usuarios de Windows pueden tener una variable diferente para esto. No olvides el comando export en la segunda línea; de lo contrario, tu variable PATH solo estará disponible dentro del archivo de configuración.

Ahora, prueba que la instalación de SBT fue exitosa. Abre una consola o herramienta de línea de comandos y escribe:

1	$ sbt --version
2	sbt launcher version 0.12.2

El signo $ es el indicador de Bash, el resto es el comando que ingresarás. Como puedes ver, tengo instalada la versión 0.12.2.

Para conocer otras formas de instalar SBT, puedes consultar la documentación oficial de instalación.

Crear un nuevo proyecto

Crea una carpeta donde desees que esté tu futuro código, abre una consola, cambia al directorio recién creado y simplemente ejecuta el comando sbt.

csaba@csaba ~/Personal/Programming/NetTuts/From Zero to Hello World in Scala/Sources $ sbt
[info] Loading global plugins from /home/csaba/.sbt/plugins
[info] Updating {file:/home/csaba/.sbt/plugins/}default-e430ed...
[info] Resolving org.scala-sbt#precompiled-2_10_0;0.12.2 ...
[info] downloading http://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/actions/0.12.2/jars/actions.jar ...
[info]  [SUCCESSFUL ] org.scala-sbt#actions;0.12.2!actions.jar (3648ms)

[...] Many more download here

[info]  [SUCCESSFUL ] org.scala-tools.testing#test-interface;0.5!test-interface.jar (239ms)
[info] Done updating.
[info] Set current project to default-f502c6 (in build file:/home/csaba/Personal/Programming/NetTuts/From%20Zero%20to%20Hello%20World%20in%20Scala/Sources/)
>

Ten en cuenta que el proyecto actual se configuró en la carpeta en la que te encuentras y que tu consola ha cambiado. Ahora estás dentro de la consola SBT. Puedes salir de esta consola presionando CTRL+D o CTRL+C o emitiendo el comando exit.

En esta consola, puedes decirle a SBT que haga muchas cosas. Simplemente presiona TAB dos veces y confirma con y para ver la lista completa de comandos disponibles.

Configuración de compilación basada en proyectos

Es posible que usar la configuración de todo el sistema o de todo el usuario para todos tus proyectos no sea la mejor opción. Cada proyecto es diferente, necesitas diferentes dependencias, tiene un nombre diferente, etc. Para decirle a SBT información como esta, tenemos que crear un archivo llamado build.sbt. Debe colocarse en la carpeta raíz del proyecto, que puedes encontrar en la última línea, en el ejemplo anterior.

El lenguaje utilizado en estos archivos es un DSL que se parece a la sintaxis de Scala, pero mucho menos complejo. Para mantenerlo simple, generalmente solo definirás algunos valores como el nombre y la versión de tu proyecto o las dependencias, como qué versiones de Scala o SBT usar. Los nombres de estos valores se denominan "claves". Trabajaremos solo con algunas de ellas. Consulta la página Keys.scala para obtener una lista completa de claves.

Para nuestro proyecto especificaremos solo cuatro claves. Sus nombres los hacen bastante autoexplicativos:

name := "Hellow World"

version := "1.0" 

scalaVersion := "2.10.1" 

sbtVersion := "0.12.3"

Ten mucho cuidado con las líneas vacías en el archivo de configuración. Cada definición de clave-valor debe estar separada por una línea vacía. Ahora ejecuta sbt update en el directorio de tu proyecto.

$ sbt update
[info] Loading global plugins from /home/csaba/.sbt/plugins
[info] Set current project to Hellow World (in build file:/home/csaba/Personal/Programming/NetTuts/From%20Zero%20to%20Hello%20World%20in%20Scala/Sources/)
[info] Updating {file:/home/csaba/Personal/Programming/NetTuts/From%20Zero%20to%20Hello%20World%20in%20Scala/Sources/}default-f502c6...
[info] Resolving org.scala-lang#scala-library;2.10.1 ...
[info] Done updating.
[success] Total time: 1 s, completed May 13, 2013 8:17:54 PM

$ sbt
[info] Loading global plugins from /home/csaba/.sbt/plugins
[info] Set current project to Hellow World (in build file:/home/csaba/Personal/Programming/NetTuts/From%20Zero%20to%20Hello%20World%20in%20Scala/Sources/)
> sbt-version
[info] 0.12.3
> scala-version
[info] 2.10.1
> exit

Como puedes ver, Scala 2.10.1 se seleccionó automáticamente y se descargó si era necesario. También actualizamos SBT a 0.12.3 sobre la marcha. Finalmente, notarás que llama a nuestro proyecto por su nombre al cargar: "Establecer el proyecto actual en Hellow World".

Convenciones de estructura de directorios en SBT

Aunque simplemente puedes poner todos tus archivos fuente en el directorio raíz del proyecto, SBT recomienda y usa, por convención, una estructura de directorio similar a Maven. Actualicemos nuestros directorios para que se vean como el árbol de abajo. Debes crear solo el directorio src y sus hijos, el resto se generó cuando jugamos con los comandos SBT. Si no fue así, no te preocupes, solo te interesa el directorio src.

├── project
│   └── target
│       └── config-classes
├── src
│   ├── main
│   │   ├── resources
│   │   └── scala
│   └── test
│       ├── resources
│       └── scala
└── target

Integrando Scala, SBT y NetBeans

Ahora que hemos aprendido los conceptos básicos de SBT, necesitamos un IDE para escribir nuestro código. Si prefieres usar editores simples, como Sublime Text, puedes hacerlo y omitir este paso.

NetBeans ha tenido soporte para Scala mucho antes que SBT. Hay un complemento llamado "nbscala" que puede crear proyectos Scala para NetBeans y usar el lenguaje Scala instalado en el sistema. Por el momento, este complemento está en transición hacia SBT y eventualmente tendrá la capacidad de crear y administrar proyectos SBT.

Actualmente, SBT y NetBeans se integran bastante bien. Lo único que tienes que crear manualmente en el momento de escribir este artículo es el proyecto SBT inicial. Posteriormente, NetBeans puede integrarse muy bien con él.

Instalación del soporte de Scala en NetBeans

Abramos NetBeans, vayamos a Herramientas/Complementos, selecciona la pestaña Complementos disponibles y desplázate hacia abajo hasta la letra S. Verifica todos los complementos relacionados con Scala, haz clic en Instalar y deja que instale los complementos con todas las dependencias necesarias.

Si tienes curiosidad sobre cómo está escrito este complemento, puedes consultar su repositorio de Github.

Instalación del soporte de NetBeans en SBT

Sí, lo has leído bien, SBT tiene su propio sistema de complementos que puede generar proyectos NetBeans para ti. Solo tienes que consultar un repositorio de git y publicarlo localmente. Cambia a un directorio donde te gustaría que tu complemento sea verificado e instalado, luego ejecuta los siguientes comandos:

1	git clone git@github.com:dcaoyuan/nbsbt.git
2	cd nbsbt
3	sbt clean compile publish-local

Bien, ya casi terminamos. Tenemos el complemento, ahora necesitamos decirle a SBT que lo use. Puedes hacer esto por proyecto si lo deseas, pero te recomiendo que lo agregues a la configuración SBT de tu usuario: ~/.sbt/plugins/plugins.sbt.

El ~ se refiere a tu directorio de inicio, ya deberías tener un directorio llamado .sbt (ten en cuenta el punto como primer carácter). Puedes o no tener un directorio plugins, si no lo tienes, simplemente créalo y luego crea el archivo plugins.sbt. Ahora agrega lo siguiente:

1	addSbtPlugin("org.netbeans.nbsbt" % "nbsbt-plugin" % "1.0.2")

Eso es todo, ahora tu SBT puede generar proyectos NetBeans para ti cuando ejecutas el comando netbeans en la consola de SBT. Alternativamente, en NetBeans, puedes simplemente abrir (no un proyecto nuevo, sino abrir) cualquier proyecto SBT y automáticamente generará las cosas de NetBeans para ti.

Luego, todas las dependencias del proyecto se actualizarán y el comando netbeans se ejecutará en una consola SBT, dentro de NetBeans.

Ahora puedes ver más texto desplazándose en la pantalla dependiendo de las dependencias necesarias para ser instaladas, y deberías poder ver que el comando netbeans se ejecutó automáticamente para nosotros.

En el panel izquierdo, en la pestaña del buscador de proyectos, incluso puedes ejecutar comandos SBT básicos simplemente haciendo clic con el botón derecho en el proyecto y ejecutar Reload, Clean, Compile y así sucesivamente.

Hola mundo en Scala

Ahora bien, este no es un tutorial para aprender Scala. Solo escribiremos un código muy básico, un clásico Hello World. Por lo tanto, puedes continuar y expandir tu proyecto Scala y, en la entrada "Paquetes Scala", haz clic derecho en <default package> y selecciona Nuevo -> Objeto Scala. Dale un nombre, algo como "HelloWorld" funcionará bien. Luego, dentro de él, ingresa el siguiente código:

1	object HelloWorld {
2	def main(args: Array[String]) =
3	println("Hello World!")
4	}

Si no estás familiarizado con Scala, un objeto se ejecutará automáticamente y se buscará un método llamado main. La definición del método es solo una simple línea de impresión de Hello World.

Ve a tu consola de SBT para este proyecto; si lo cerraste por error, simplemente haz clic derecho en el proyecto Scala en el panel izquierdo y selecciona Abrir consola de sbt. Ahora, escribe run en la consola, para ejecutar el programa

Agregar pruebas

El primer paso es instalar Scalatest para que tengamos un framework de prueba. La forma más sencilla de hacer esto es editar nuestro archivo build.sbt y agregar la siguiente línea; recuerda que debes dejar una línea vacía entre cada línea.

1	libraryDependencies += "org.scalatest" %% "scalatest" % "1.9.1" % "test"

Ahora, en tu consola SBT puedes emitir una actualización (opcional) y ejecutar el comando test. Todavía no tenemos ninguna prueba, por lo que el comando no debería fallar.

Crear nuestra primera prueba será bastante fácil. Lo único que debes saber es que debes estar en la carpeta src/test/scala. O, si expandes Paquetes de prueba de Scala en el visor de tu proyecto y haces clic con el botón derecho en <default package>, puedes seleccionar Nuevo -> Clase de Scala y crear una con el nombre "ExampleSuite" y agregar el código a continuación:

import org.scalatest.FunSuite

class ExampleSuite extends FunSuite {

  test("test 2 expected values are equal") {
    assert(2 === 2)
  }

  test("test 2 values are different and fail") {
    assert(2 === 3)
  }
}

Ten en cuenta que NetBeans puede tener algunos problemas con la ejecución de tus pruebas, ya que el complemento Scala aún no está completo. Pero que no cunda el pánico, aún puedes ejecutar las pruebas desde la consola SBT.

La prueba simplemente importa la suite de pruebas Scalatest FunSuite (donde "Fun" viene de funcional) y ejecuta dos pruebas. Como puedes deducir del código, el primero pasará, el segundo fallará.

Si, por alguna razón, SBT se niega a compilar tus pruebas, simplemente cierra la consola en NetBeans, haz clic derecho en tu proyecto y selecciona Recargar proyecto de STB. Esto solucionará el problema y tus pruebas se ejecutarán como se esperaba.

Notas finales

¡Ahí tienes! Acabas de completar tus primeros pasos hacia el aprendizaje de Scala. Espero que este tutorial te haya ayudado a comprender mejor cómo empezar. Si, en lugar de usar Netbeans, que es mi IDE preferido, también puedes hacer una búsqueda en Google para encontrar documentación en línea bastante completa sobre cómo usar SBT y Scala con Eclipse, si eso es lo que prefieres.

Gracias por leer.