اسکالا (Scala)، زبانی نوین و پول ساز

برنامه نویسی نمی شناسم که تا به حال، حداقل اسم زبان برنامه نویسی جاوا به گوشش نخورده باشد. این زبان شی گرا با شعار «Write Once, Run Anywhere» که در اواخر دهه 90 میلادی بسیار محبوب شده بود، به برنامه نویس ها اجازه میداد کد هایشان را در هر دستگاهی که یک Java Runtime برروی آن نصب شده باشد، اجرا کنند. همچنین، قابلیت های جالب دیگری هم داشت. مثلا مدیریت خودکار حافظه را دارا بود که برنامه نویس هارا از دغدغه هایی که زبان های C و C++ به وجود آورده بودند، راحت کرده بود.

اما همه چیز گل و بلبل نبود. زبان جاوا خیلی طولانی و به اصطلاح Verbose است. به این معنا که شما برای ساخت یک ماشین حساب ساده باید ساختاری را به اجبار رعایت کنید. منظور از ماشین حساب ساده، صرفاً الگوریتمی است که دو عدد را دریافت، آنهارا جمع و نتیجه را پرینت می کند. بعلاوه، شاید خطای مشهور «NullPointerException» به گوشتان خورده باشد. جاوا برخلاف زبان های نوین امروزی، دارای سیستم Null Safety نبود. بدین معنا که اگر متغیری مقدار null را در خود داشت و بعد تر از آن متغیر استفاده ای می شد، کامپایلر بدون اینکه جلوی این مورد را بگیرد؛ در هنگام اجرای کد، با خطای معروف NullPointerException مواجه می شد و برنامه ممکن بود کرش کند.

حدود 20 سال بعد، نسخه پایدار زبان جوانی به نام Kotlin منتشر شد. این زبان برنامه نویسی که برروی JVM اجرا می شود و با اکوسیستم جاوا سازگار است؛ به توسعه دهندگان اجازه می دهد کد های کوتاه تر و خواناتر را بنویسند. بعلاوه، دارای Null Safety و Type System بهتری است و برنامه نویسی را راحت تر می کند. برای اینکه متوجه تفاوت دو زبان بشوید، دو نمونه کد از این دو زبان را برایتان نوشته ام. هردوی این نمونه ها، یک ماشین حساب هستند. ماشین حسابی که جمع، تفریق، ضرب و تقسیم را داراست.

جاوا:

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter first number: ");
        double a = sc.nextDouble();

        System.out.print("Enter operator (+, -, *, /): ");
        String op = sc.next();

        System.out.print("Enter second number: ");
        double b = sc.nextDouble();

        double result;

        switch (op) {
            case "+":
                result = a + b;
                break;
            case "-":
                result = a - b;
                break;
            case "*":
                result = a * b;
                break;
            case "/":
                result = a / b;
                break;
            default:
                System.out.println("Invalid operator");
                return;
        }

        System.out.println("Result: " + result);
    }
}

کاتلین:

fun main() {
    print("Enter first number: ")
    val a = readLine()?.toDoubleOrNull() ?: return println("Invalid first number")

    print("Enter operator (+, -, *, /): ")
    val op = readLine() ?: return println("Invalid operator input")

    print("Enter second number: ")
    val b = readLine()?.toDoubleOrNull() ?: return println("Invalid second number")

    val result = when (op) {
        "+" -> a + b
        "-" -> a - b
        "*" -> a * b
        "/" -> if (b != 0.0) a / b else return println("Cannot divide by zero")
        else -> return println("Invalid operator")
    }

    println("Result: $result")
}

کاملا واضح است که کد نوشته شده با زبان کاتلین، خواناتر و زیباتر است. اما زبان کاتلین هم کامل و بی عیب نیست. برای مثال، سرعت کامپایل پایین تری به نسبت جاوا دارد و این مسئله به ویژه در بیلد پروژه های نسبتا بزرگ اندرویدی کاملا قابل مشاهده است. هرچند که در نسخه های جدیدتر زبان این مورد کمی بهبود یافته است. با این حال، همچنان برخی ویژگی هایش مانند Coroutine ها و یا Inline functions می توانند پیچیده شوند و اگر درست درک نشوند، برنامه نویسی را تلخ می کنند. در ضمن، به علت وابستگی شدید این زبان به اکوسیستم جاوا، در برخی تعاملات با یکسری از کتابخانه ها، ممکن است مشکلات ناسازگاری ظریف اتفاق بیافتد.

زبانی به نام Scala در سال 2004 توسط Martin Odersky منتشر شد. این زبان از ابتدا پیچیدگی های خاصی داشت و همین مسئله باعث فراری شدن خیلی از برنامه نویس ها شد. اما خود این زبان، برای حل محدودیت های جاوا پا به عرصه گذاشت. شاید مهم ترین ویژگی آن «Functional Programming» باشد. به این معنا که اسکالا تاکید بیشتری برروی برنامه نویسی تابعی دارد. بدین منظور، در زبان اسکالا، ما شاهد ویژگی هایی مثل Immutable collections، Pattern matching، Higher-order functions، Type inference، Algebraic Data Types و ... بودیم. یعنی اکنون می توانستید با این زبان، در عین دارا بودن قدرت های جاوا، به صورت تابعی برنامه نویسی کنید. در کنار تمامی این ویژگی ها، اسکالا توانست Type System بسیار پیشرفته تری به نسبت Kotlin ارائه کند. همچنین، کدهارا تا حد زیادی مختصر نمود. با این حال، این زبان با مسائلی مثل سختی در یادگیری و سادگی پایین مواجه است. برای درک این موارد، کد زیر را که به عنوان یک نمونه نوشته ام، بررسی کنید. این هم یک ماشین حساب مانند دو زبان دیگر است.

اسکالا:

object Calculator {
  def main(args: Array[String]): Unit = {
    print("Enter first number: ")
    val a = scala.io.StdIn.readDouble()

    print("Enter operator (+, -, *, /): ")
    val op = scala.io.StdIn.readLine()

    print("Enter second number: ")
    val b = scala.io.StdIn.readDouble()

    val result = op match {
      case "+" => a + b
      case "-" => a - b
      case "*" => a * b
      case "/" => a / b
      case _ =>
        println("Invalid operator")
        return
    }

    println(s"Result: $result")
  }
}

جالب است بدانید که این تفاوت ها حتی در بازار هم تا حدی دیده می شوند. در کنار ویژگی های برنامه نویسی تابعی، اسکالا امروزه بسیار پول ساز است. هرچند میزان درآمد توسعه‌دهندگان به عوامل زیادی مثل کشور، سابقه، حوزه کاری و نوع شرکت بستگی دارد، اما اسکالا معمولاً در بازارهای تخصصی تر، به ویژه در حوزه داده و سامانه های مقیاس پذیر، با فرصت های شغلی پردرآمدتری همراه است.

اسکالا می تواند پتانسیل بلند مدت داشته باشد، چرا که بیشتر در زمینه داده و هوش مصنوعی مورد استفاده قرار می گیرد. من که از نوشتن دیگه خسته شدم، شما با کدام یک از این سه زبان راحت تر هستید؟