Ho iniziato a lavorare su un nuovo progetto recentemente correlato a Big Data per il mio stage. I miei manager consigliarono di iniziare ad apprendere la programmazione funzionale (altamente raccomandato Scala). Ho avuto un'esperienza umiliata usando F #, ma non ho potuto vedere l'importante di usare questo paradigma di programmazione in quanto è costoso in alcuni casi.
Dean ha tenuto un discorso interessante su questo argomento e ha condiviso i suoi pensieri sul perché "Big Data" qui: link Ma non era molto conveniente dato che Big Data non significa solo Hadoop.
Come BigData è un concetto molto vago. L'ho dimenticato per un po '. Ho cercato di trovare un semplice esempio per confrontare i diversi aspetti quando trattiamo i dati, per vedere se il modo funzionale è costoso o no. Se la programmazione funzionale è costosa e consuma la memoria per i piccoli dati, perché ne abbiamo bisogno per i Big Data?
Lontano da strumenti di fantasia, ho cercato di costruire una soluzione per un problema specifico e diffuso utilizzando tre approcci: modo imperativo e modo funzionale (ricorsione, utilizzo di collezioni). Ho confrontato il tempo e la complessità, per confrontare i tre approcci.
Ho usato Scala per scrivere queste funzioni in quanto è lo strumento migliore per scrivere un algoritmo usando tre paradigmi
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))
}
Modo funzionale:
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))(_ + _)
}
Modo ricorsivo:
def Fibonacci_R(n: Int): BigInt = n match {
case 1 | 2 = > 1
case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}
Modo imperativo:
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
}
Ho notato che la programmazione funzionale è pesante! richiede più tempo e consuma più spazio nella memoria. Sono confuso, ogni volta che leggo un articolo o guardo un discorso, dicono che dovremmo usare la programmazione funzionale nella scienza dei dati. È vero, è più facile e più produttivo, specialmente nel mondo dei dati. ma ci vuole più tempo e più spazio di memoria.
Quindi, perché è necessario utilizzare la programmazione funzionale nei Big Data? Quali sono le migliori pratiche per utilizzare la programmazione funzionale (Scala) per i Big Data?