Meta: Scala, BlueEyes y MongoDB

En mi colación, leí un artículo que me dejó con cara de WTF !😯 (what the frak!) y dije: QUIERO HACER ESTO !

Pero solamente entendí menos de la mitad de todo lo que se dice en ese coso. Así que vamos a empezar por parte, ya que este tutorial lo hago para aprender yo mismo🙂

Instalar y hacer algo en Scala, BlueEyes, Heroku y lo de Mongo Sobra🙂

Empezamos por Scala. Se supone que Scala es una “evolución” de Java (por lo que entendí). Corre bajo la máquina virtual de Java, pero tiene mejoras🙂 y es más un lenguaje funcional.

Para instalarlo, desde Ubuntu es tan simple como un

sudo apt-get install scala

Y listo. En mi caso fueron casi 60 MB entre Scala y el JDK de java, y otras hierbas. Ya después hacen un scalac -version y si responde Scala compiler version 2.9.0.1 — Copyright 2002-2011, LAMP/EPFL Es porque quedo bien😉

Vamos con el primer código (Hello World) :

object HelloWorld {
	def main (args: Array [String]): Unit = {
		System.out.println ("Hola, Scala!")
	}
}

Lo compilamos con scalac nombre.scala y lo corremos con scala HelloWorld (nombre de object).

Hasta ahora no es nada nuevo cierto ? Ocupamos la misma forma de escribir por pantalla, podemos heredar cualquier componente de Java. Lo “raro” puede ser que no ocupamos ningún ;

Ahora veamos las diferencias. Al empezar, vemos que no es una clase como definiríamos en java. Es directamente un objeto. Y es que en Scala, todo es un objeto único. Son singleton, así que siempre nos aseguramos de tener una sola referencia.

Al ser único, el main no puede ser static😯 . Se evita el static cada vez que se puede, ya que no son necesarios.

Los arreglos siempre son instancias de Array y podemos aprecias que a diferencia de java que los tipos se declaraban como “<>” en Scala es “[]” .

Como es un lenguaje funcional tiene que devolver un valor. En este caso devolvemos nada, por lo que enviamos un Unit.

Ahora veamos cuando la cosa se pone rara…😯

Veamos una función simple:

object Timer {
	def oncePerSecond (): Unit = {
		while (true) {
			System.out.println ("El tiempo vuela cuando uno se divierte ...";)
			Thread.sleep(1000)
		}
	}

	def main (args: Array [String]): Unit = {
		oncePerSecond ()
	}
 }

No tenemos mucho para pensar. Simplemente se imprime algo cada 1 segundo. Esto desde una función, que se llama desde el main. Nada raro🙂 … Peeero esto no nos sirve… no es funcional, ni siquiera es útil😯

Qué pasa si quiero cambiar el mensaje ?? emm… podría mandarlo como parámetro en la función ! Puede ser… y qué pasa si quiero hacer otra tarea también cada segundo, por ejemplo un ping ? Tendría que hacer OTRA función que haga prácticamente lo mismo.

Estaríamos violando la regla de “No te repitas a ti mismo“. Esto en Scala lo podemos hacer así🙂

object Timer {
	def oncePerSecond(callback: => Unit): Unit = {
		while (true) {
			callback
			Thread.sleep(1000)
		}
	}
	def timeFlies(): Unit = {
		Console.println("El tiempo vuela cuando uno se divierte ...")
	}
	def main(args: Array[String]): Unit = {
		oncePerSecond(timeFlies)
	}
}

Y aquí ya se complica la cosa un poco. Vamos de abajo hacia arriba. Tenemos el main que llama a la función oncePerSecond y le envía un parámetro. Hasta ahora nada raro.

Luego tenemos la función timeFlies que devuelve nada. Su función es imprimir (esta vez es con Console.println) un mensaje. Console.println o System.out.println hacen lo mismo.

Aquí ya paramos un poco. En el main… a la función oncePerSecond le pasé una función como parámetro😯 ???? Si, eso hicimos :B

Por último, la función oncePerSecond. Recibe una función como parámetro en callback, que a su vez no devolverá nada (el => Unit indica eso). Y luego simplemente la ejecutamos en la función.

Pero momento ! La función timeFliesno hace nada más que imprimir… si lo pensamos, ¿sirve de algo crearla? No cierto? En estos casos, creamos funciones anónimas😀 Las definimos así:

object Timer {
	def oncePerSecond(callback: () => Unit): Unit = {
		while (true) {
			callback()
			Thread.sleep(1000)
		}
	}
	def main(args: Array[String]): Unit = {
		oncePerSecond(() =>
			Console.println("El tiempo vuela... oh, ya lo sabes😀 ."))
	}
}

Y como ven, al llamar la función enviamos el Console.println directo. Y en la función oncePerSecond la ejecutamos directamente, agregando los () que definen el “parámetro” de la función anónima.

Y qué pasaría si no quiero que sea cada segundo… podrían ser 2 o 5. Lo hacemos así:

object Timer {
	def periodicCall(seconds: Int, callback: () => Unit): Unit = {
		while (true) {
			callback()
			Thread.sleep(seconds * 1000)
		}
	}
	def main(args: Array[String]): Unit = {
		periodicCall(2, () =>
			Console.println("Time flies... oh, you get the idea."))
	}
} 

Como ven, sigue siendo igual de sencillo tanto en la llamada como en la ejecución.

Es la primera entrada a Scala en el blog. La verdad es que es muy interesante y me dejo babeando un rato… Y lo que más me gusta, es que es enredado :B

La prox. entrada es sobre BlueEyes, un servidor.

Fuentes:

Acerca de MaritoCares

Ingeniero Informático. Con tendencias a la programación en [C#, VB].NET, Java(Web principalmente...), PHP, JavaScript, algo mínimo de [ruby, python], y el clásico C.
Esta entrada fue publicada en Scala, Tutoriales y etiquetada . Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s