ทำไมต้องใช้ Scala มากกว่า Java

ฉันเป็นภาษาสกาล่าโดยสิ้นเชิง ... ฉันยังคงดิ้นรนกับเหตุผลที่ว่า บริษัท ใดควรเปลี่ยนจากชวาเป็นสคาลา Scala เป็นเพียงน้ำตาล syntatic ที่ด้านบนของ JVM หรือมีการปรับปรุงพื้นฐานใน Scala มากกว่า Java ที่จะปรับปรุงการใช้งานจริงหรือไม่?

ข้อจำกัดความรับผิดชอบ: ฉันไม่ใช่คุรุสกาล่า

Scala ทำสองสิ่งได้ดีมากซึ่ง Java (ในปัจจุบัน) ทำไม่ได้

แก้ปัญหาการทำงาน

• ในระดับพื้นฐานที่สุด Scala มีการปิดอย่างสมบูรณ์พร้อมการสนับสนุนคอลเลกชัน ซึ่งหมายความว่าคุณไม่จำเป็นต้องเขียนรหัสแผ่นหม้อไอน้ำอีกต่อไปเช่น (ฉีกออกจากโพสต์ DZone อย่างไร้ยางอาย)

  public List<Item> bought(User user)
  {
      List<Item> result = new ArrayList();
      for (Item item : currentItems)
      {
          if (user.bought(item))
          {
              result.add(item);
          }
      }
      return result;
  }

แต่แทนที่จะเขียนสิ่งที่ชอบ:

def bought(user: User) = items.filter(user bought _)

• มีความรักที่ใช้งานได้มากกว่า แต่ฉันไม่มีคุณสมบัติที่จะพูดคุยเกี่ยวกับมันตั้งแต่ฉันยังคงดูดที่การเขียนโปรแกรมการทำงาน :)

แก้ปัญหาการทำงานพร้อมกันในวิธีที่ปลอดภัยยิ่งขึ้น

• Scala มีโมเดลนักแสดง (+ ความดีอื่น ๆ ) ซึ่งปลอดภัยกว่าโดยทั่วไปของ Java ที่ไม่สามารถเปลี่ยนแปลงได้ของข้อมูล + ล็อคในรูปแบบ Thread (ไม่ว่า libs นั้นจะดีแค่ไหน

ฉันไม่สามารถคิดอย่างอื่นได้มากจนเกินไปที่ทำให้สกาล่าเป็นผู้นำและหัวไหล่เหนือ Java กำไรและการปรับปรุงเล็ก ๆ น้อย ๆ มากมายใช่ แต่ก็ยังมีอีกมากมายที่คุณต้องลอง YMMV

HTH นิดหน่อย

ขึ้นอยู่กับนิยามของคำว่า "just syntactic sugar" ตัวอย่างเช่น Java ในทางใดที่มากกว่าเพียงแค่ประโยคน้ำตาลมากกว่ารหัสเครื่อง?

ภาษาใดสามารถทำได้น้อยกว่ารหัสเครื่อง แต่ไม่มีภาษาใดสามารถทำได้มากกว่านี้

สิ่งที่ภาษาระดับสูงนำมาสู่ตารางทำให้การอ่านและทำความเข้าใจกับรหัสง่ายขึ้นง่ายต่อการเขียนและจับข้อผิดพลาดได้มากขึ้น และในความคิดของฉันมันเป็นครั้งแรกของสิ่งเหล่านี้ที่สร้างความแตกต่างมากที่สุด - แม่นยำ "เพียงน้ำตาลประโยค"

แต่เมื่อพิจารณาจากอีกสองข้อนั้นยังคงมีข้อดีของ Scala มากกว่า Java

เพื่อไม่ให้เชื่อประเด็น แต่การมีการปิดทำให้การเขียนโค้ดเป็นไปได้ง่ายกว่าการไม่ปิด และในขณะที่ Java 7 จะเพิ่มสิ่งที่เรียกว่าการปิดพวกเขาจะไม่เป็นเช่นนั้น - พวกเขาจะเป็นแค่ฟังก์ชั่นนิรนาม

สำหรับการจับข้อผิดพลาดเพิ่มเติม Scala การจัดการความแปรปรวนที่เหนือกว่าเป็นข้อพิสูจน์ที่เพียงพอ นอกจากนี้การเน้นที่การเปลี่ยนแปลงไม่ได้ยังป้องกันข้อผิดพลาดทุกประเภท - ไม่ใช่ว่า Java ไม่สามารถเปลี่ยนรูปแบบไม่ได้ แต่มันไม่ได้มาพร้อมกับไลบรารีที่จะทำเช่นนั้น

ด้านบนของคำตอบของ Martijnฉันต้องการเพิ่มว่า Scala แสดงออกได้ดีกว่า Java และประโยชน์คือ (1) มันทำให้คุณมีประสิทธิผลมากขึ้น (2) เขียนโค้ดน้อยลงสำหรับการแก้ปัญหาเดียวกันหมายความว่าคุณสามารถลดข้อบกพร่องใน รหัส (รหัสปราศจากข้อผิดพลาด IMHO เป็นตำนาน)

ฉันใช้ Scala มาประมาณ 3 เดือนแล้วและยังหาอะไรไม่เจอใน Java สำหรับผมอย่างแท้จริงวรรณกรรมเกี่ยวกับสกาล่าทุกดูเหมือนว่าจะพูดถึงสิ่งเดียวกันสำเร็จรูป หากสิ่งที่คุณกำลังมองหาคือการลดboilerplateดังนั้น Scala สำหรับคุณ แต่ IMHO ตัวอย่างเช่นตัวอย่างตัวกรองที่ระบุด้านบนสามารถแก้ไขได้โดยใช้ apache collection

<T> CollectionUtils.filter(Predicate<T>...)

หรือใช้การปิดเช่นนี้

<T> CollectionUtils.forAllDo(..., Closure<T>)

แต่แน่นอนมากขึ้น verbose ฉันชอบอนุมานประเภทแม้ว่า ในขณะที่คุณเรียนรู้สกาล่าคุณจะรู้ว่านี่อาจเป็นสิ่งที่เกิดขึ้นภายใต้ประทุน ในความคิดของฉันแต่ละภาษามาพร้อมกับ + ve และ -ve

รายการความเข้าใจเพื่อความเข้าใจ

เช่นใน java คุณเขียน:

int myVar;
if (condition) {
  myVar = //some value
}
else {
 myVar = //some other value
}

ในสกาล่ารหัสเดียวกันเขียนอย่างหรูหรามากขึ้น (เหมือนงูหลาม) เป็น:

int myVar = (//some value) if (condition) else // other value;

และทำ

มีหลายสิ่งที่ Scala เสนอให้ Java ไม่ ไม่มีการเปรียบเทียบเลย ปัญหาเดียวคือผู้คนคุ้นเคยกับ Java (b / c มากขึ้นนั่นคือสิ่งที่พวกเขาสอนในชั้นเรียน CS) และยังไม่ชำนาญเท่าที่มีอยู่ในกระบวนทัศน์ Scala

Scala มีการเรียกซ้ำหางมันสามารถคืนสิ่งอันดับ (สิ่งที่อาจจะมาใน Java 8 ฉันคิดว่า)

มันไม่มีการเปรียบเทียบ Scala ได้รับการพัฒนาโดย Martin Ordersky ซึ่งทำงานในทีมหลักของ Java Generics

สกาล่าเป็นเพียงภาษาที่เหนือกว่า นั่นคือทั้งหมดที่มีให้มัน คนที่พูดอย่างอื่นก็ไม่ได้สำรวจสกาล่าเพียงพอที่จะรู้ดีกว่า

ด้านบนฉันหมายถึงการเพิ่มประสิทธิภาพการเรียกซ้ำหาง (ซึ่ง JVM ไม่สามารถทำวิธีที่คอมไพเลอร์ของ Scala สามารถทำได้)

Scala ยังรวบรวมและทำงานได้เร็วกว่าแอป JVM (ใช่เป็นจริง) ไม่ต้องพูดถึงกรอบ เราใช้ Tomcat เป็นตัวอย่างและปรับใช้ servelets เพื่อจัดการกับ REST

สิ่งหนึ่งที่ Tomcat ทำไม่ได้คือการทำงานแบบอะซิงโครนัสที่ต้องการการปิดกั้น I / O สำหรับสิ่งนี้ผู้พัฒนา JAVA มักจะคิดค้นวิธีแก้ปัญหาโดยใช้คิวข้อความ (ส่งข้อความไปยังคิวและกระบวนการหรือเธรดอื่นจะเลือกมันและทำทุกอย่างที่คุณต้องการในพื้นหลัง)

น่าเสียดายที่วิธีนี้คือ cr * p และแฮ็คผ่านข้อ จำกัด ของการปรับใช้ servlets Java บน Tomcat

ไปตรวจสอบ akka + สเปรย์ ใช้นักแสดงของสกาล่า (นักแสดงเป็นเหมือนเธรดยกเว้นวิธีเดียวที่พวกเขาสามารถสื่อสารได้คือผ่านข้อความ)

และเสร็จสิ้นการเรียกใช้ REST แบบอะซิงโครนัสทำได้ง่าย งานเบื้องหลังที่ยาวนาน ไม่มีปัญหา. เพียงแค่ยิงแล้วลืมและทำแบบสำรวจ REST เพื่อตรวจสอบสถานะจากส่วนหน้าทุก ๆ ครั้ง

หากคุณยังคงใช้ Java และคิดว่ามันดีกว่าสกาล่าคุณอาจหยุดใช้คอมพิวเตอร์ของคุณเพื่อพิมพ์และย้อนกลับไปในสมัยของปากกาขนนกและเขียนด้วยแสงเทียน Java นั้นเป็นคนยิวโดยทั่วไปเมื่อเทียบกับ Scala