Comencé a trabajar en un nuevo proyecto relacionado recientemente con Big Data para mi pasantía. Mis gerentes recomendaron comenzar a aprender programación funcional (recomendaron Scala). Tuve una experiencia humilde con F #, pero no pude ver la importancia de usar este paradigma de programación, ya que es costoso en algunos casos.
Dean dio una charla interesante sobre este tema y compartió sus pensamientos sobre por qué "Big Data" aquí: http://www.youtube.com/watch?v=DFAdLCqDbLQ Pero no fue muy conveniente ya que Big Data no significa solo Hadoop.
Como BigData es un concepto muy vago. Lo olvido por un tiempo. Traté de encontrar un ejemplo simple para comparar entre los diferentes aspectos cuando tratamos con datos, para ver si la forma funcional es costosa o no. Si la programación funcional es costosa y consume mucha memoria para datos pequeños, ¿por qué la necesitamos para Big Data?
Lejos de las herramientas sofisticadas, traté de construir una solución para un problema específico y popular usando tres enfoques: forma imperativa y forma funcional (recursividad, usando colecciones). Comparé tiempo y complejidad, para comparar entre los tres enfoques.
Usé Scala para escribir estas funciones, ya que es la mejor herramienta para escribir un algoritmo usando tres paradigmas
def main(args: Array[String]) {
val start = System.currentTimeMillis()
// Fibonacci_P
val s = Fibonacci_P(400000000)
val end = System.currentTimeMillis()
println("Functional way: \n the Fibonacci sequence whose values do not exceed four million : %d \n Time : %d ".format(s, end - start))
val start2 = System.currentTimeMillis()
// Fibonacci_I
val s2 = Fibonacci_I(40000000 0)
val end2 = System.currentTimeMillis();
println("Imperative way: \n the Fibonacci sequence whose values do not exceed four million : %d \n Time : %d ".format(s2, end2 - start2))
}
Forma funcional:
def Fibonacci_P(max: BigInt): BigInt = {
//http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Stream
//lazy val Fibonaccis: Stream[Long] = 0 #:: 1 #:: Fibonaccis.zip(Fibonaccis.tail).map { case (a, b) => a + b }
lazy val fibs: Stream[BigInt] = BigInt(0)#::BigInt(1)#::fibs.zip(fibs.tail).map {
n = > n._1 + n._2
}
// println(fibs.takeWhile(p => p < max).toList)
fibs.takeWhile(p = > p < max).foldLeft(BigInt(0))(_ + _)
}
Manera recursiva:
def Fibonacci_R(n: Int): BigInt = n match {
case 1 | 2 = > 1
case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}
Forma imperativa:
def Fibonacci_I(max: BigInt): BigInt = {
var first_element: BigInt = 0
var second_element: BigInt = 1
var sum: BigInt = 0
while (second_element < max) {
sum += second_element
second_element = first_element + second_element
first_element = second_element - first_element
}
//Return
sum
}
¡Noté que la programación funcional es pesada! lleva más tiempo y consume más espacio en la memoria. Estoy confundido, cada vez que leo un artículo o veo una charla, dicen que deberíamos usar programación funcional en ciencia de datos. Es cierto que es más fácil y más productivo, especialmente en el mundo de los datos. pero lleva más tiempo y más espacio de memoria.
Entonces, ¿por qué necesitamos usar la programación funcional en Big Data? ¿Cuáles son las mejores prácticas para usar la programación funcional (Scala) para Big Data?