Ho iniziato a lavorare su un nuovo progetto recentemente correlato ai Big Data per il mio tirocinio. I miei manager hanno raccomandato di iniziare ad apprendere la programmazione funzionale (hanno fortemente raccomandato Scala). Ho avuto un'esperienza umiliante con F #, ma non riuscivo a vedere l'importanza di utilizzare questo paradigma di programmazione in quanto è costoso in alcuni casi.
Dean ha tenuto un discorso interessante su questo argomento e ha condiviso le sue opinioni sul perché "Big Data" qui: http://www.youtube.com/watch?v=DFAdLCqDbLQ Ma non è stato molto conveniente poiché i Big Data non significano 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 richiede molta memoria per i piccoli dati, perché ne abbiamo bisogno per i Big Data?
Lungi dall'essere strumenti fantasiosi, ho cercato di costruire una soluzione per un problema specifico e popolare usando tre approcci: il modo imperativo e il modo funzionale (ricorsione, usando le raccolte). Ho confrontato tempo e complessità, per confrontare tra 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 in 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 richiede più tempo e più spazio di memoria.
Quindi, perché dobbiamo usare la programmazione funzionale nei Big Data? Quali sono le migliori pratiche per utilizzare la programmazione funzionale (Scala) per i Big Data?