Stajım için son zamanlarda Big Data ile ilgili yeni bir proje üzerinde çalışmaya başladım. Yöneticilerim fonksiyonel programlamayı öğrenmeye başlamalarını önerdiler (Scala'yı şiddetle tavsiye ettiler). F # kullanarak hileli bir deneyim yaşadım, ancak bazı durumlarda pahalı olduğu için bu programlama paradigmasını kullanmanın önemini göremedim.
Dean bu konu hakkında ilginç bir konuşma yaptı ve neden "Büyük Veri" ile ilgili düşüncelerini burada paylaştı: http://www.youtube.com/watch?v=DFAdLCqDbLQ Ama Büyük Veri demek çok uygun değildi sadece Hadoop.
BigData çok belirsiz bir kavram olduğu için. Bir süre unutuyorum. Verilerle uğraşırken farklı yönleri karşılaştırmak, fonksiyonel yolun pahalı olup olmadığını görmek için basit bir örnek bulmaya çalıştım. İşlevsel programlama küçük veriler için pahalı ve bellek tüketiyorsa, neden Büyük Veri için buna ihtiyacımız var?
Süslü araçlardan çok, üç yaklaşım kullanarak belirli ve popüler bir sorun için bir çözüm oluşturmaya çalıştım: Zorunlu yol ve fonksiyonel yol (özyineleme, koleksiyonları kullanma). Üç yaklaşımı karşılaştırmak için zaman ve karmaşıklığı karşılaştırdım.
Scala'yı üç paradigma kullanarak bir algoritma yazmak için en iyi araç olduğu için bu işlevleri yazmak için kullandım
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))
}
Fonksiyonel yolu:
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))(_ + _)
}
Özyinelemeli yol:
def Fibonacci_R(n: Int): BigInt = n match {
case 1 | 2 = > 1
case _ = > Fibonacci_R(n - 1) + Fibonacci_R(n - 2)
}
Zorunlu yol:
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
}
Fonksiyonel programlamanın ağır olduğunu fark ettim! daha uzun zaman alır ve bellekte daha fazla yer kaplar. Kafam karıştı, bir makale okuduğumda veya bir konuşma izlediğimde, veri biliminde fonksiyonel programlamayı kullanmamız gerektiğini söylüyorlar. Doğru, özellikle veri dünyasında daha kolay ve daha üretken. ancak daha fazla zaman ve daha fazla bellek alanı gerektirir.
Öyleyse neden Büyük Veri'de Fonksiyonel programlama kullanmamız gerekiyor? Büyük Veri için işlevsel programlamayı (Scala) kullanmak için en iyi uygulamalar nelerdir?