¿Qué son Futures en Scala?

Los futures en Scala son una serie de alternativas de comandos que se emplean como parte de este lenguaje de programación tan popular y demandado dentro del mundo Big Data. De hecho, los futures en Scala se presentan según diversas categorías de los macrodatos y el interés del tratamiento de los macrodatos.

El desarrollo Big Data requiere de estas dinámicas y procesos que optimizan el desenvolvimiento de un estudio ágil y eficaz de los macrodatos. Por ello, si lo que buscas es saber identificar cuál es la mejor herramienta para un análisis de datos específico, contar con este saber es de suma importancia. Así, debido a su relevancia, en este post te explicamos qué son los futures en Scala y cuáles son sus categorías.

¿Qué es Scala?

Antes de entrar en materia con los futures en Scala, te recordamos qué significa este lenguaje de programación dentro del mundo Big Data. Actualmente, Scala es uno de los lenguaje de programación más usados para el manejo y desarrollo del Big Data, de manera que también lo utilizan grandes empresas, como Twitter, LinkedIn, Coursera, Telefónica, The Guardian, Disney, Netflix, etc.

A continuación, te exponemos algunas de sus principales características, que debes tener en cuenta si planeas aplicarlo en tu procesamiento de macrodatos:

• Lo creó en 2003 Martin Odersky en la EPFL (Escuela Politécnica Federal de Lausana).
• Se ejecuta en la JVM (Máquina virtual Java o Java Virtual Machine) y es un lenguaje de propósito general.
• Es multiparadigma y está orientado a objetos.
• Se usa en proyectos DSL (Digital Subscriber Line o Línea de Abonado Digital) y Big Data.

¿Qué son futures en Scala?

Los futures en Scala hacen referencia a la aglomeración de comandos y alternativas de un future, es decir, de un valor que puede o no encontrarse en el momento de establecer el comando, pero que, sin embargo, se sabe que en algún momento estará disponible.

De ahí viene su nombre de futuro o futures en Scala, puesto que cuenta con un valor a futuro y no en la actualidad. En suma, esta estrategia ofrece una amplia serie de posibilidades que podrás emplear de forma paralela o separada, según tus intereses.

A continuación, te compartimos cómo se comportan cada una de esas posibilidades de futures en Scala:

Future [T]

Por defecto, las operaciones sin bloqueo tendrán un valor T en algún momento. De manera que te podrás encontrar con que los futures en Scala pueden estar incompletos, es decir, que todavía no tiene valor. O, por el contrario, también puedes hallar un future completo.
Por otra parte, la finalización se tratará como un valor scala.util.Try., lo que quiere decir que tendrá dos valores posibles, que son:

• Success(t: T)
• Failure(t: Throwable)

Future [T] I

import scala.concurrent._
import ExecutionContext.Implicits.global
val firstPrimeNumbers: Future[List[Int]] = Future {
List(1, 2, 3, 4, 7, 11, 13)
// what if ‘calculateFirstPrimeNumbers(100000000000)’
}
val thisWillFail: Future[Int] = Future(2 / 0)

Execution context

Un futuro, una vez que se completa, nunca cambia de valor.

• Se desarrolla en un contexto de ejecución.
• Está diseñado para ejecutar las tareas que se les envían.
• Estos se pueden ver como grupos de subprocesos.
• La mayoría de las operaciones futuras requieren un ExecutionContext implícito.

Future: Catch results

En Catch results o resultados esperados podrás encontrar dos posibilidades:

• Modo bloqueador (discutido, pero a veces obligatorio).
• Manera sin bloqueo: se genera al usar devoluciones de llamada de los datos.

Future: Blocking – Await

import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
val f: Future[Int] = Future {
Thread.sleep(10000)
2
}
println(Await.result(f, 12 seconds))

import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
val f: Future[Int] = Future {
Thread.sleep(10000)
2
}
println(Await.result(f, 5 seconds)) =>
java.util.concurrent.TimeoutException

Future: Callbacks

import scala.concurrent._
import ExecutionContext.Implicits.global
val f: Future[Int] = Future {
Thread.sleep(1000)
2
}
f.onComplete(n => println(n))

Future: Callbacks I

• onComplete

• onSuccess/foreach

• onFailure

Future: map & flatMap

def getFirstMillionOfPrimes(): Future[List[Int]] = ???
getFirstMillionOfPrimes().map(
(list: List[Int]) => list.head
) //Future[Int]
def concatenate(l: List[Int]): Future[String] = ???
getFirstMillionOfPrimes().flatMap(
(list: List[Int]) => concatenate(list))
) //Future[String]

Recover & RecoverWith

val f: Future[Int] = Future {
1 / 0
}.recover {
case e: ArithmeticException => 0
}
val f2: Future[Int] = Future {
1 / 0
}.recoverWith {
case e: ArithmeticException => Future(0)
}

Futures: For Comprehension

getFirstMillionOfPrimes().flatMap(
(list: List[Int]) => concatenate(list))
) //Future[String]
is equal to:
for {
primes <- getFirstMillionOfPrimes()
primeString <- concatenate(primes)
} yield primeString

¿Cuál es el siguiente paso en Big Data?

Por medio de este post, te has podido familiarizar con qué son y cómo funcionan los futures en Scala. Sin embargo, debes tener en cuenta que todas estas funciones o comandos que puedes emplear requieren de una gran disciplina para llevarlos a la práctica. Este es, sin duda, el factor más importante para manejar este lenguaje de programación, de manera que ¡debes dar el siguiente paso en Big Data con Scala!

Por este motivo, desde KeepCoding te ofrecemos nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning. Por medio de este bootcamp, podrás aprender más acerca de cómo configurar un Hive y del Big Data en general con módulos como el de Big Data Architecture, en el que verás una pintura completa del proceso de ingesta, clasificación, resguardo, procesamiento y presentación de los datos utilizando diferentes herramientas, sistemas y lenguajes. Además, podrás instruirte tanto de forma teórica como práctica y en remoto desde cualquier sitio. ¡No esperes más y apúntate ahora mismo!