J'ai commencé à travailler sur un nouveau projet récemment lié au Big Data pour mon stage. Mes gestionnaires ont recommandé de commencer à apprendre la programmation fonctionnelle (ils ont fortement recommandé Scala). J'ai eu une expérience humble en utilisant F #, mais je ne voyais pas l'importance d'utiliser ce paradigme de programmation car il est cher dans certains cas.
Dean a donné une conférence intéressante sur ce sujet et a partagé ses réflexions sur la raison pour laquelle les "Big Data" ici: http://www.youtube.com/watch?v=DFAdLCqDbLQ Mais ce n'était pas très pratique car les Big Data ne signifient pas seulement Hadoop.
Comme BigData est un concept très vague. Je l'oublie un moment. J'ai essayé de trouver un exemple simple pour comparer les différents aspects lorsque nous traitons des données, pour voir si la méthode fonctionnelle est coûteuse ou non. Si la programmation fonctionnelle coûte cher et consomme beaucoup de mémoire pour les petites données, pourquoi en avons-nous besoin pour les Big Data?
Loin des outils sophistiqués, j'ai essayé de construire une solution pour un problème spécifique et populaire en utilisant trois approches: voie impérative et voie fonctionnelle (récursivité, utilisation de collections). J'ai comparé le temps et la complexité, pour comparer entre les trois approches.
J'ai utilisé Scala pour écrire ces fonctions car c'est le meilleur outil pour écrire un algorithme en utilisant trois paradigmes
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))
}Manière fonctionnelle:
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))(_ + _)
}Manière récursive:
def Fibonacci_R(n: Int): BigInt = n match {
case 1 | 2 = > 1
case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}Manière impérative:
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
}J'ai remarqué que la programmation fonctionnelle est lourde! cela prend plus de temps et consomme plus d'espace en mémoire. Je suis confus, chaque fois que je lis un article ou regarde une conférence, ils disent que nous devrions utiliser la programmation fonctionnelle en science des données. C'est vrai, c'est plus facile et plus productif, spécialement dans le monde des données. mais cela prend plus de temps et plus d'espace mémoire.
Alors, pourquoi avons-nous besoin d'utiliser la programmation fonctionnelle dans le Big Data? Quelles sont les meilleures pratiques pour utiliser la programmation fonctionnelle (Scala) pour le Big Data?