Comparison between Scala and Haskell

1. Giới thiệu

• ####Scala:

Scala (phát âm /ˈskɑːlə/ SKAH-lə) là một ngôn ngữ lập trình đa mẫu hình, được thiết kế để tích hợp các tính năng của lập trình hướng đối tượng với lập trình hàm. Tên Scala xuất phát từ chữ tiếng Anh scalable, có nghĩa là "ngôn ngữ có khả năng mở rộng", được phát triển dựa trên nhu cầu sử dụng các tính năng mở rộng của nó.

• ####Haskell:

Haskell (phát âm/ˈhæskəl/) là một ngôn ngữ lập trình tiêu chuẩn, với mục đích lập trình hóa hoàn toàn chức năng với ngữ nghĩa không chặt chẽ. Nó được đặt tên là Haskell sau khi nhà lý luận học Haskell Curry mất.

2. So sánh

• ####Lịch sử phát triển

  • version đầu tiên của Haskell được đưa ra năm 1990 và phiên bản mới nhất là Haskell 2010
  • version đầu tiên của Scala được đưa ra vào năm 2003 và phiên bản mới nhất là Scala 2.11.6 (5/3/2015)
    

• ####So sánh về cú pháp của Haskell và Scala:

• Hello world!

module Main where
main :: IO ()
main = putStrLn " Hello , World !"

object HelloWorld {
            def main ( args : Array [ String ]) {
            	println (" Hello , World !")
            }
}

• Chi tiết hơn về cú pháp của 2 ngôn ngữ trên, mọi người có thể đọc từ: Haskell và Scala

• Tổng hợp: cú pháp của Haskell là sự kết hợp của việc sử dụng khoảng trống cho các hàm và constructor, và currying làm cho mã vô cùng sạch sẽ, súc tích và dễ đọc. So với code Scala có rất nhiều loại ký tự gây xao nhãng, khó đọc như các loại dấu ngoặc nhọn, dấu ngoặc đơn, dấu phẩy, từ khóa...

   |                         | Haskell  | Scala  |
   |-------------------------|:--------:|:------:|
   | Semicollons             |optional  |optional|
   | Curly brackets          |optional  |yes***  |
   | Significant indentation |yes       |no      |
   | Type inference          |yes       |yes     |
   | Functions definitions   |whitespace|yes(*)  |
   | Functions call          |whitespace|yes(**) |
   | Point-free notation     |yes       |no      |
   * (*) optional for [arity](https://en.wikipedia.org/wiki/Arity)-0
   * (**) optional for [arity](https://en.wikipedia.org/wiki/Arity)-0 and [arity](https://en.wikipedia.org/wiki/Arity)-1
   * (***) optional for purely functional bodies (but without val definitions)
  

• ####Type Inference: Các loại suy luận trong Haskell hoạt động và làm việc một cách đáng tin cậy. Các loại suy luận trong Scala kém hơn so với Haskell, nhưng không quá xấu nếu xem xét sự phức tạp của hệ thống. Hầu hết thời gian nó hoạt động khá tốt, nhưng nếu chúng ta viết hơi phức tạp mã chúng ta sẽ chạy vào trường hợp xấu nhất là thất bại (fail). Scala cũng yêu cầu gõ chú thích trong khai báo chức năng/phương thức, trong khi Haskell không.

• ####Subtyping Scala có subtyping nhờ việc cách tương thích với Java, trong khi Haskell không có

• ####Modules vs Objects Hệ thống module của Haskell là rất thô sơ. Ngược lại hệ thống đối tượng / module của Scala là rất mạnh mẽ cho phép các đối tượng để thực hiện các nhiều tác vụ. Điều này cho phép cấu trúc mã code bằng những cách thức mới và mạnh mẽ.

• ####Typeclasses vs Implicit Parameters Typeclasses trong Haskell và các thông số ngầm định trong Scala được sử dụng để giải quyết cơ bản các vấn đề tương tự, và trong nhiều cách nó rất giống nhau. Scala có quy tắc lựa chọn tiên tiến hơn để xác định các trường hợp mà được coi là đặc biệt nhất. Điều này rất hữu ích trong nhiều trường hợp. GHC (Glasgow Haskell Compiler) không cho phép chồng chéo các trường (instances) trừ khi nhận được một cờ (flag) biên dịch, và thậm chí sau đó các quy tắc cho việc lựa chọn một trong những đặc trưng nhất được rất hạn chế.

• ####Lazy vs Strict Evaluation Haskell mặc định sử dụng Lazy Evaluation, còn Scala có sử dụng Strict Evaluation.

  • lazy evaluation - call-by-need: là một chiến lược đánh giá mà trì hoãn việc đánh giá một biểu thức cho đến khi giá trị của nó là cần thiết (đánh giá không nghiêm ngặt) và được đánh giá cũng tránh lặp đi lặp lại (chia sẻ). Các chia sẻ có thể làm giảm thời gian chạy của một số chức năng của một yếu tố theo cấp số nhân trong chiến lược đánh giá không nghiêm ngặt khác, chẳng hạn như cuộc call-by-name
  • strict evalution: là chiến lược đánh giá mà các đối số cho hàm được luôn được đánh giá hoàn toàn trước khi chức năng được áp dụng.

• ####Type Safety Trong Haskell tác dụng phụ (side effects) được điều khiển và kiểm tra bởi các trình biên dịch, và tất cả các chức năng này là thuần túy. Trong Scala bất kỳ chức năng/phương thức nào cũng có có thể có tác dụng phụ ẩn. Ngoài ra, để tương thích Java các giá trị null có thể được sử dụng cho bất kỳ người dùng để định nghĩa kiểu (mặc dù nó không khuyến khích), thường dẫn đến NullPointerException. Ngoài ra, trường hợp ngoại lệ (exceptions) được sử dụng khá thường xuyên trong các thư viện của Java và nó không được kiểm tra bởi trình biên dịch Scala và nó có thể dẫn đến lỗi unhandled. Haskell chắc chắn là an toàn hơn một ngôn ngữ lập trình trong

• ####Development Environment Môi trường phát triển cho Scala khá đẹp với Eclipse tốt và plugins IntelliJ hỗ trợ code completion, duyệt web, highlight lỗi ngay lập tức, API và debug. Trước đây Haskell không có ide hỗ trợ cho tới gần đây có bắt đầu xuất hiện nhiều hơn ide hỗ trợ cho Haskell (https://wiki.haskell.org/IDEs). Và hiện tại, cả Haskell và Scala có khác nhiều ide hỗ trợ cho việc phát triển và nó không có quá nhiều khác biệt.

• ####Performance

  • Các trình biên dịch cho Haskell (GHC) và Scala (scalac) là rất khác nhau. GHC thực hiện tối ưu hóa các đoạn mã phức tạp trong quá trình biên soạn, trong khi scalac chủ yếu chỉ là kết quả đầu ra Java bytecode (với một số tối ưu nhỏ) mà sau đó được biên dịch động và tối ưu hóa bằng Hotspot tại thời gian chạy.
  • Một điều Haskell và Scala có điểm chung là cả hai đều sử dụng garbage collection.

• ####Final Words Haskell và Scala là cả hai ngôn ngữ lập trình rất mạnh mẽ và thiết thực, nhưng với những điểm mạnh và điểm yếu khác nhau. Cả ngôn ngữ là hoàn hảo và tôi nghĩ rằng có chỗ cho cải tiến và bổ sung trong cả hai.

  	Haskell	Scala
  Strong static typing	yes	yes
  Type inference	yes	yes
  Higher order types	yes	yes
  Algebraic data types	yes	yes (verbose)
  Infinite streams	yes	yes
  Strict semantics	optional	default
  Lazy evaluation	default	optional
  Currying	default	optional
  Lambda expressions	yes	yes
  Immutability	enforced	not enforced
  Side effects isolation	yes	no
  Default implementations	yes	yes