Saya mulai mengerjakan proyek baru belakangan ini yang berhubungan dengan Big Data untuk magang saya. Manajer saya merekomendasikan untuk mulai belajar pemrograman fungsional (Mereka sangat merekomendasikan Scala). Saya memiliki pengalaman yang rendah hati menggunakan F #, tetapi saya tidak bisa melihat pentingnya menggunakan paradigma pemrograman ini karena mahal dalam beberapa kasus.
Dean memberikan ceramah menarik tentang topik ini, dan berbagi pemikirannya tentang mengapa "Big Data" di sini: http://www.youtube.com/watch?v=DFAdLCqDbLQ Tapi itu tidak terlalu nyaman karena Big Data tidak berarti hanya Hadoop.
Seperti konsep BigData yang sangat kabur. Aku melupakannya sebentar. Saya mencoba membuat satu contoh sederhana untuk membandingkan antara berbagai aspek ketika kita berurusan dengan data, untuk melihat apakah cara fungsional mahal atau tidak. Jika pemrograman fungsional mahal dan memakan banyak data kecil, mengapa kita membutuhkannya untuk Big Data?
Jauh dari alat mewah, saya mencoba membangun solusi untuk satu masalah khusus dan populer menggunakan tiga pendekatan: cara imperatif dan cara fungsional (rekursi, menggunakan koleksi). Saya membandingkan waktu dan kompleksitas, untuk membandingkan antara tiga pendekatan.
Saya menggunakan Scala untuk menulis fungsi-fungsi ini karena ini adalah alat terbaik untuk menulis algoritma menggunakan tiga paradigma
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))
}
Cara fungsional:
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))(_ + _)
}
Cara rekursif:
def Fibonacci_R(n: Int): BigInt = n match {
case 1 | 2 = > 1
case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}
Cara imperatif:
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
}
Saya perhatikan bahwa pemrograman fungsional sangat berat! dibutuhkan waktu lebih lama dan lebih banyak ruang dalam memori. Saya bingung, setiap kali saya membaca artikel atau menonton ceramah, mereka mengatakan bahwa kita harus menggunakan pemrograman fungsional dalam ilmu data. Benar, ini lebih mudah dan lebih produktif, khususnya di dunia data. tetapi membutuhkan lebih banyak waktu dan lebih banyak ruang memori.
Jadi, mengapa kita perlu menggunakan pemrograman Fungsional dalam Big Data? Apa praktik terbaik untuk menggunakan pemrograman fungsional (Scala) untuk Big Data?