Scala vs. Java: Mengapa Saya Harus Mempelajari Scala?

Memang ada beberapa kebenaran untuk pernyataan bahwa "Scala itu sulit", tetapi kurva pembelajarannya sangat berharga untuk investasi. Beberapa fitur bahasa yang lebih kompleks (Tuple, Fungsi, Makro, untuk beberapa nama) pada akhirnya memudahkan pengembang untuk menulis kode yang lebih baik dan meningkatkan kinerja dengan memprogram di Scala. Terus terang, kami adalah programmer, dan jika kami tidak cukup pintar untuk mempelajari bahasa yang rumit, maka kami berada di bisnis yang salah.

Scala adalah bahasa JVM tipe-aman yang menggabungkan pemrograman berorientasi objek dan fungsional ke dalam bahasa yang sangat ringkas, logis, dan luar biasa kuat. Beberapa mungkin terkejut mengetahui bahwa Scala tidak sebaru yang mereka kira, pertama kali diperkenalkan pada tahun 2003. Namun, terutama dalam beberapa tahun terakhir Scala mulai mengembangkan pengikut yang signifikan. Yang menimbulkan pertanyaan "Mengapa Scala?".

Artikel ini membahas keunggulan Scala, terutama dibandingkan Java (karena Scala ditulis untuk dijalankan di JVM). Scala bukan satu-satunya upaya untuk menciptakan "Java yang lebih baik". Alternatif seperti Kotlin dan Ceylon juga telah menempuh jalan itu, tetapi mereka membuat keputusan mendasar untuk tetap sangat dekat dalam sintaksis dengan bahasa Java itu sendiri, untuk meminimalkan kurva pembelajaran. Ini mungkin tampak seperti ide yang bagus, tetapi pada akhirnya agak merugikan diri sendiri karena memaksa Anda untuk tetap berada dalam sejumlah paradigma Java yang sama yang menjadi alasan ingin menciptakan "Jawa yang lebih baik" di tempat pertama.

Sebaliknya, Scala dibuat secara khusus dengan tujuan menjadi bahasa yang lebih baik , menghilangkan aspek-aspek Java yang dianggap membatasi, terlalu membosankan, atau membuat frustrasi pengembang. Akibatnya, memang ada perbedaan kode dan perubahan paradigma yang dapat membuat pembelajaran awal pemrograman Scala sedikit lebih sulit, tetapi hasilnya adalah bahasa yang jauh lebih bersih dan terorganisir dengan baik yang pada akhirnya lebih mudah digunakan dan meningkatkan produktivitas.

Scala vs. Java: Mana yang Lebih Kompleks?

Sementara kesederhanaan bahasa Jawa telah menjadi bagian dari keberhasilannya, ironisnya, itu juga berkontribusi pada kerumitannya. Tentu, Anda dapat menulis hampir semua hal di Java, tetapi baris kode yang diperlukan untuk melakukannya dapat menjadi hal yang menakutkan. Pemrograman di Scala, di sisi lain, memiliki struktur yang sedikit lebih kompleks. Tetapi jika Anda dapat menulis satu baris kode yang sedikit lebih kompleks yang menggantikan 20 baris Java yang "lebih sederhana", mana yang benar-benar lebih kompleks?

Yang benar adalah bahwa Java seringkali terlalu bertele-tele. Di Scala, kompilernya sangat cerdas, jadi ini menghindari pengembang yang perlu menentukan secara eksplisit hal-hal yang dapat disimpulkan oleh kompiler. Bandingkan, misalnya, “Halo Dunia!” yang sederhana ini! program di Java vs. Scala:

Halo Dunia di Jawa:

 public class HelloJava { public static void main(String[] args) { System.out.println("Hello World!"); } }

Halo Dunia di Scala:

 object HelloScala { def main(args: Array[String]): Unit = { println("Hello World!") } }

Meskipun tidak ada perbedaan besar antara kedua bahasa di sini, Scala kurang bertele-tele bahkan dalam contoh sederhana ini.

Untuk contoh yang lebih praktis, mari kita lihat cara membuat daftar String sederhana:

Jawa:

 List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list.add("3");

skala:

 val list = List("1", "2", "3")

Tentu saja ada beberapa trik di Java untuk sedikit mempersingkat kode, tetapi tidak dalam penggunaan standar.

Sekarang pertimbangkan kasus di mana kami memiliki daftar string yang berupa angka, tetapi kami ingin mengonversi daftar itu menjadi daftar bilangan bulat:

Jawa:

 List<Integer> ints = new ArrayList<Integer>(); for (String s : list) { ints.add(Integer.parseInt(s)); }

skala:

 val ints = list.map(s => s.toInt)

Berkat sifat fungsional Scala, konversi ini menjadi sangat sederhana.

Contoh Kelas: Java vs. Scala

Mari kita melangkah lebih jauh dan membandingkan pembuatan standar bean / plain old Java object (POJO) di Java dan Scala.

Pertama, versi Java:

 public class User { private String name; private List<Order> orders; public User() { orders = new ArrayList<Order>(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public List<Order> getOrders() { return orders; } public void setOrders(List<Order> orders) { this.orders = orders; } } public class Order { private int id; private List<Product> products; public Order() { products = new ArrayList<Product>(); } public int getId() { return id; } public void setId(int id) { this.id = id; } public List<Product> getProducts() { return products; } public void setProducts(List<Product> products) { this.products = products; } } public class Product { private int id; private String category; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getCategory() { return category; } public void setCategory(String category) { this.category = category; } }

Fiuh. Kode lot.

Sekarang versi Scala:

 class User { var name: String = _ var orders: List[Order] = Nil } class Order { var id: Int = _ var products: List[Product] = Nil } class Product { var id: Int = _ var category: String = _ }

Bahasa mana yang kami katakan lebih rumit?!

Apakah Kita Sudah Adil?

Jika Anda telah sampai sejauh ini, dan adalah seorang programmer Java, Anda mungkin pada titik ini berpikir bahwa saya membuat perbandingan kode yang tidak adil. Lagi pula, tidak ada yang menghentikan saya untuk membuat variabel publik di Java dan kemudian menyingkirkan getter dan setter.

Namun, jika Anda memikirkan kembali alasan di balik getter dan setter di Java, ini khusus untuk pemeriksaan di masa mendatang. Artinya, jika nanti Anda perlu menambahkan beberapa logika untuk mendapatkan atau mengatur variabel, Anda harus menulis ulang variabel publik tersebut untuk menggunakan metode sebagai gantinya (itulah sebabnya penggunaan getter dan setter untuk memulai dianjurkan di Java ). Namun, dalam pemrograman Scala ini tidak terjadi. Karena desain bahasa, abstraksi tetap utuh tanpa memerlukan getter dan setter. Pertimbangkan, misalnya, kelas User yang dimodifikasi ini di Scala yang menampilkan NullPointerException jika Anda mencoba menyetel nama ke nol:

 class User { private var _name: String = _ var orders: List[Order] = Nil def name = _name def name_=(name: String) = { if (name == null) { throw new NullPointerException("User.name cannot be null!") } _name = name }

Dan Anda masih dapat mengatur nama seperti ini:

 user.name = "John Doe"

Perhatikan bahwa ini sepenuhnya menghilangkan kebutuhan untuk melakukan pra-konfigurasi pengakses metode.

Selain itu, karena Scala lebih menyukai kekekalan, saya dapat menulis ini di Scala lebih ringkas dengan kelas kasus:

 case class User(name: String, orders: List[Order]) case class Order(id: Int, products: List[Product]) case class Product(id: Int, category: String)

Cukup gila apalagi kode yang harus saya tulis.

Mengambil Contoh sedikit Lebih Jauh

Sekarang pertimbangkan skenario dengan kelas di atas di mana saya ingin menambahkan metode kecil yang bagus di kelas User yang mengembalikan daftar semua Products yang telah dipesan User :

Di dunia verbose Jawa:

 public List<Product> getProducts() { List<Product> products = new ArrayList<Product>(); for (Order order : orders) { products.addAll(order.getProducts()); } return products; }

Untungnya, java.util.List memiliki metode addAll , atau getProducts() akan lebih lama lagi di Java.

Di Scala, di sisi lain, yang kita butuhkan hanyalah:

 def products = orders.flatMap(o => o.products)

Anda dapat melihat seberapa kecil implementasi bahasa Scala. Ya, ini mungkin tampak lebih rumit bagi pemula Scala, tetapi begitu Anda benar-benar memahami konsep di baliknya, kode Scala akan terlihat jauh lebih sederhana daripada kode Java.

Mari kita menjadi sedikit lebih rumit di sini. Bagaimana jika kita hanya ingin mendapatkan Products dalam Category tertentu?

Dalam hal ini kami tidak dapat memanfaatkan metode addAll di java.util.List , jadi semuanya menjadi lebih buruk di Java :

 public List<Product> getProductsByCategory(String category) { List<Product> products = new ArrayList<Product>(); for (Order order : orders) { for (Product product : order.getProducts()) { if (category.equals(product.getCategory())) { products.add(product); } } } return products; }

Di Scala , bagaimanapun, kodenya tetap cukup mudah. Kami hanya menggunakan flatMap untuk menggabungkan daftar produk dari setiap Order yang diratakan dalam satu daftar, lalu kami memfilter untuk hanya menyertakan yang cocok dengan kategori:

 def productsByCategory(category: String) = orders.flatMap(o => o.products).filter(p => p.category == category)

Dinamis vs. statis

Tentu saja tidak ada kekurangan bahasa baru selama beberapa tahun terakhir, tetapi sementara hampir semua bahasa lain yang baru-baru ini muncul bersifat dinamis, Scala diketik secara statis.

Sebagai pengembang profesional – meskipun saya tahu dan menggunakan banyak bahasa dinamis – menurut saya pemeriksaan waktu kompilasi sangat penting untuk menulis kode yang solid. Dalam bahasa yang dinamis, Anda tidak akan pernah bisa yakin bahwa kode Anda cukup bebas bug dan kuat sampai Anda benar-benar menjalankannya dalam berbagai skenario. Hal ini dapat menyebabkan potensi cacat serius pada kode yang tidak pernah direalisasikan sampai kode tersebut diproduksi.

Bungkus

Mudah-mudahan, artikel ini memuat Java vs. Scala cukup untuk memberi Anda gambaran awal tentang kekuatan dan kemampuan Scala dan membangkitkan selera Anda untuk mempelajari bahasa tersebut. Tidak hanya itu bahasa hebat yang dapat membuat pemrograman tidak terlalu membosankan dan lebih menyenangkan, tetapi juga digunakan oleh beberapa perusahaan terbesar di dunia (LinkedIn, Twitter, FourSquare, The Guardian, dan lain-lain).

Popularitas dan penggunaan Scala meningkat pesat, sebagaimana dibuktikan oleh jumlah posisi terbuka yang terus meningkat untuk pengembang Scala. Jika Anda belum melakukannya, sekarang adalah saat yang tepat untuk mulai menunggangi ombak dan berhenti bertanya “Mengapa belajar Scala?”