Ich habe kürzlich angefangen, an einem neuen Projekt für Big Data für mein Praktikum zu arbeiten. Meine Manager empfahlen, mit dem Erlernen der funktionalen Programmierung zu beginnen (sie empfahlen Scala dringend). Ich hatte eine bescheidene Erfahrung mit F #, aber ich konnte nicht erkennen, wie wichtig es ist, dieses Paradigma der Programmierung zu verwenden, da es in einigen Fällen teuer ist.
Dean hielt einen interessanten Vortrag zu diesem Thema und teilte seine Gedanken darüber mit, warum "Big Data" hier ist: http://www.youtube.com/watch?v=DFAdLCqDbLQ Aber es war nicht sehr praktisch, da Big Data nicht bedeutet nur Hadoop.
Als BigData ist das Konzept sehr vage. Ich vergesse es für eine Weile. Ich habe versucht, ein einfaches Beispiel zu finden, um die verschiedenen Aspekte beim Umgang mit Daten zu vergleichen und festzustellen, ob funktionale Methoden teuer sind oder nicht. Wenn funktionale Programmierung für kleine Datenmengen teuer und speicherintensiv ist, warum benötigen wir sie für Big Data?
Weit entfernt von ausgefallenen Werkzeugen habe ich versucht, eine Lösung für ein bestimmtes und beliebtes Problem mit drei Ansätzen zu finden: Imperativer Weg und funktionaler Weg (Rekursion, Verwendung von Sammlungen). Ich habe Zeit und Komplexität verglichen, um die drei Ansätze zu vergleichen.
Ich habe Scala verwendet, um diese Funktionen zu schreiben, da es das beste Werkzeug ist, um einen Algorithmus unter Verwendung von drei Paradigmen zu schreiben
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))
}
Funktionsweise:
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))(_ + _)
}
Rekursiver Weg:
def Fibonacci_R(n: Int): BigInt = n match {
case 1 | 2 = > 1
case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}
Imperativer Weg:
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
}
Mir ist aufgefallen, dass die funktionale Programmierung schwer ist! Es dauert länger und verbraucht mehr Speicherplatz. Ich bin verwirrt, wenn ich einen Artikel lese oder einen Vortrag sehe, sagen sie, dass wir funktionale Programmierung in der Datenwissenschaft verwenden sollten. Es ist wahr, es ist einfacher und produktiver, insbesondere in der Datenwelt. Aber es braucht mehr Zeit und mehr Speicherplatz.
Warum müssen wir also die funktionale Programmierung in Big Data verwenden? Was sind die Best Practices für die Verwendung der funktionalen Programmierung (Scala) für Big Data?