Rehat kopi #37. Masa depan baru bagi Jawa. Prospek JVM, Kotlin dan Java setelah tahun 2020

Sumber: Medium Java terutama dikritik karena dua hal: verbositas dan jumlah kode boilerplate yang dihasilkan dalam banyak kasus tanpa kebutuhan yang jelas. Meskipun saya selalu menyukai Java, saya tidak bisa mengatakan bahwa pernyataan ini salah. Memang benar: detail yang berlebihan di Java terkadang bisa sangat mengganggu. Namun, kita harus mengakui bahwa kita tidak hidup di dunia yang ideal, dan dalam banyak kasus kita harus memilih yang lebih kecil dari dua hal yang buruk. Sejak awal, Java belum sempurna: kita semua tahu hal ini, tapi pertanyaan sebenarnya adalah mengapa tidak ada yang dilakukan sebelumnya untuk memecahkan masalah ini. Saya pikir satu-satunya alasan perubahan memakan waktu lama adalah karena bahasa Java kurang bersaing dan semuanya berjalan sebagaimana adanya. Java mendominasi pasar, mungkin karena kurangnya pesaing yang serius dan upaya besar yang dilakukan pertama kali oleh Sun dan kemudian oleh Oracle. Tingkat keamanan tipe yang tinggi yang disediakan Java dan struktur bahasa yang baik menjadikannya sangat populer untuk proyek-proyek besar. Selain itu, ini adalah bahasa multi-platform yang berjalan pada mesin virtualnya sendiri. Dikombinasikan dengan optimalisasi kinerja otomatis melalui kompiler JIT, semua ini meminimalkan dampak kode yang ditulis dengan buruk. Secara keseluruhan, ini adalah serangkaian alasan yang cukup kuat untuk menggunakan Java. Tapi apa yang terjadi selanjutnya? Apa yang terjadi adalah bahasa-bahasa baru telah memasuki pasar yang dapat berjalan di JVM yang sama dengan Java. Bahasa yang menghilangkan beberapa ketidaknyamanan terbesar di Java dan, dalam beberapa kasus, menawarkan lingkungan yang lebih menyenangkan bagi pengembang dengan hambatan masuk yang lebih rendah. Sebelum melanjutkan, mari kita lihat dan melihat sekilas sejarah bahasa JVM.

Sejarah bahasa JVM

Pertama, saya ingin memperjelas satu hal: Saya tidak menyebutkan beberapa bahasa JVM yang ada karena bahasa tersebut tidak pernah mendapat cukup dukungan untuk dianggap sebagai kandidat untuk digunakan secara luas di industri kita. Sekarang mari kita mulai tinjauan singkat kita tentang sejarah bahasa JVM. Pertama kita akan memiliki Java, bahasa tertua dan terpopuler di dunia JVM. Java secara resmi dirilis pada bulan Januari 1996, sehingga bahasa tersebut telah ada selama 24 tahun. Tidak buruk, bukan? Java awalnya merupakan bahasa imperatif murni yang mengikuti gaya pemrograman berorientasi objek; itu juga bahasa yang diketik dengan kuat. Sintaks Java agak mirip dengan bahasa C++ dan C, namun dianggap sebagai versi perbaikan karena menulis kode di Java jauh lebih mudah dibandingkan di C atau C++. Di sisi lain, kami memiliki argumen terbesar di antara para pengkritiknya – verbositas. Bahasa JVM kedua adalah Groovy. Sudah ada sejak tahun 2003, meskipun versi standar pertamanya, 1.0, baru muncul pada bulan Januari 2007. Kelebihan Groovy adalah dapat digunakan sebagai bahasa scripting. Groovy adalah bahasa yang diketik secara dinamis, jadi pengecekan tipe dilakukan saat runtime. Inilah salah satu alasan mengapa beberapa pengembang tidak menyukai Groovy. Anda menulis kode Anda di Groovy dan terlihat benar pada waktu kompilasi, tetapi kemudian pada saat runtime Anda menyadari ada sesuatu yang salah. Kemudian bahasa populer lainnya muncul: kita berbicara tentang Scala. Ini dirilis pada tahun 2004. Dia membawa model kerja baru ke dunia JVM: pemrograman fungsional dan pendekatan deklaratif. Pada dasarnya, Scala adalah bahasa pertama yang memperkenalkan konsep kekekalan, yang kemudian digunakan untuk menyempurnakan Java. Di sisi lain, para pencela tidak menyukai Scala karena tata bahasanya yang rumit dan keterbacaannya yang rendah. Bahasa berikutnya yang muncul dari dunia JVM adalah Clojure, bahasa yang sepenuhnya berfungsi. Ini menjadi cukup populer baru-baru ini, meskipun muncul kembali pada tahun 2007. Clojure adalah bahasa berbasis LISP yang dicirikan oleh kesederhanaan dan penggunaan fungsi sederhana. Di antara kelemahannya adalah ia diketik secara dinamis (seperti Groovy) dan kurva pembelajarannya jauh lebih curam karena sintaksisnya sangat berbeda dari bahasa JVM lainnya. Dan terakhir, kami memiliki Kotlin. Kotlin pertama kali muncul pada bulan Februari 2016, dan sejak itu popularitasnya terus meningkat. Ini dikembangkan oleh JetBrains dengan tujuan utama: untuk memperbaiki masalah Java yang paling terkenal. Secara desain, Kotlin mempertahankan semua keunggulan Java, namun pada saat yang sama memecahkan banyak masalah. Ini adalah bahasa JVM yang paling penting. Seperti yang saya katakan, kami melewatkan beberapa bahasa lain yang tidak begitu populer: Jython, JRuby, Ceylon, Fantom, dll. Jika mau, Anda bisa mengetahui seluruh daftar bahasa JVM yang adadi Wikipedia. Anda mungkin menyadari bahwa Java tidak memiliki banyak persaingan dalam delapan atau sepuluh tahun pertama setelah penciptaannya, namun banyak hal telah berubah sejak saat itu. Jadi, apakah persaingan itu baik atau buruk?

Manfaat Meningkatnya Persaingan

Java tidak banyak berubah pada tahun-tahun awalnya. Mungkin karena itu tidak diperlukan. Bahasa ini telah digunakan secara luas dan selalu sangat populer, meskipun masih jauh dari sempurna. Namun kemudian muncul pesaing, bahasa yang lebih modern yang menawarkan fitur-fitur baru dan memecahkan beberapa masalah yang telah lama menjangkiti pengembang Java. Misalnya, mari kita lihat bahasa Scala. Popularitas Scala semakin meningkat sejak 2009. Pengembang menyambut baik gaya fungsional baru ini, yang memberi mereka fleksibilitas lebih besar serta kemampuan untuk menulis kode paralel dengan aman dan mudah. Bagaimana Oracle menanggapi tren baru ini? Pada tahun 2014, Java Lambdas dan Streams muncul. Saya rasa kita semua sepakat bahwa inilah saatnya Java mengambil langkah terbesarnya untuk mengalahkan Scala. Sekarang programmer mana pun tahu bahwa Scala tidak lagi trendi. Manfaat lain dari memiliki lebih banyak pesaing di dunia JVM adalah perbaikan terus-menerus yang dilakukan pada kompiler JIT dan JVM. Sekarang semakin banyak orang yang tertarik untuk mengoptimalkan JVM dan meningkatkan kinerja. Jadi kompetisi itu baik untuk semua orang! Alternatif terbaru untuk Java adalah bahasa Kotlin. Kemunculannya sangat penting untuk pengembangan Java, karena bahasa baru, dalam arti tertentu, menunjukkan kepada Oracle jalan ke depan. Contoh Kotlin menunjukkan bahwa keunggulan Java dapat dipertahankan, tetapi menciptakan bahasa yang lebih ringkas sehingga menulis kode lebih cepat. Jika melihat grafik Google Trends, terlihat bahwa dari tahun 2016 hingga 2018, popularitas Kotlin berkembang pesat. Namun dalam dua tahun terakhir, antusiasme tersebut menurun. Oracle telah mencermati respons industri terhadap Kotlin. Jika Anda melihat catatan rilis JDK 15 , Anda akan melihat bahwa beberapa fitur Java baru adalah salinan dari apa yang ada di Kotlin. Ini adalah entri Java baru , blok teks baru (string multiline dengan tanda kutip tiga) dan operator baru switch, yang pada dasarnya adalah salinan operator whendi Kotlin. Semua yang kita bicarakan adalah apa yang saya sebut “Kotlinisasi Java.” Dengan menjadi pesaing yang lebih kuat, Kotlin menunjukkan kepada Java jalur yang harus diikuti.

"Kotlinisasi" di Jawa

Beberapa fitur Java yang akan datang akan menjadi peningkatan yang signifikan dalam hal keterbacaan dan akan mengatasi salah satu kelemahan terbesar bahasa Java – verbositasnya. Ada yang berpendapat bahwa banyak fitur Java yang diumumkan mirip dengan beberapa fitur Kotlin. Namun perlu diketahui bahwa sebagian besar adalah versi pra-rilis . Artinya jika Anda menginstal JDK 14 atau JDK 15 (saat dirilis), Anda tidak akan dapat menggunakannya secara default. Pratinjau fitur Java adalah fitur baru yang diperkenalkan dalam rilis tetapi dinonaktifkan secara default. Mereka disertakan dalam versi baru hanya untuk mengumpulkan masukan dari komunitas pengembang, jadi mereka mungkin masih dapat berubah. Inilah mengapa tidak disarankan untuk menggunakannya dalam kode produksi. Untuk mengaktifkannya pada waktu kompilasi, Anda perlu melakukan hal berikut:

javac --enable-preview --release 14

Jika Anda ingin mengaktifkannya saat runtime, Anda perlu menjalankan perintah berikut:

java --enable-preview YourClass

Tentu saja, Anda juga dapat mengaktifkannya di IDE Anda, namun berhati-hatilah untuk tidak mengaktifkan pratinjau secara default di semua proyek baru Anda! Mari kita lihat perubahan yang akan berdampak lebih besar pada pengkodean kita di versi Java mendatang.

Postingan Jawa

Java Records adalah fitur yang sudah lama ditunggu-tunggu oleh banyak dari kita. Saya kira Anda berada dalam situasi di mana Anda perlu menerapkan toString , hashCode , sama dengan , serta pengambil untuk setiap bidang yang ada. Kotlin memiliki kelas data untuk mengatasi masalah ini , dan Java bermaksud melakukan hal yang sama dengan merilis kelas rekaman yang sudah dimiliki Scala dalam bentuk kelas kasus . Tujuan utama dari kelas-kelas ini adalah untuk menyimpan data yang tidak dapat diubah dalam suatu objek. Mari kita ambil contoh untuk melihat seberapa jauh Java bisa menjadi lebih baik. Ini adalah berapa banyak kode yang harus kita tulis untuk membuat dan membandingkan kelas kita Employee:

package com.theboreddev.java14;

import java.util.Objects;

public class Employee {
    private final String firstName;
    private final String surname;
    private final int age;
    private final Address address;
    private final double salary;

    public Employee(String firstName, String surname, int age, Address address, double salary) {
        this.firstName = firstName;
        this.surname = surname;
        this.age = age;
        this.address = address;
        this.salary = salary;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getSurname() {
        return surname;
    }

    public int getAge() {
        return age;
    }

    public Address getAddress() {
        return address;
    }

    public double getSalary() {
        return salary;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(firstName, employee.firstName) &&
                Objects.equals(surname, employee.surname) &&
                Objects.equals(address, employee.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstName, surname, age, address, salary);
    }

    @Override
    public String toString() {
        return "Employee{" +
                "firstName='" + firstName + '\'' +
                ", surname='" + surname + '\'' +
                ", age=" + age +
                ", address=" + address +
                ", salary=" + salary +
                '}';
    }
}

Dan juga objek Addressyang dikandungnya:

import java.util.Objects;

public class Address {
    private final String firstLine;
    private final String secondLine;
    private final String postCode;

    public Address(String firstLine, String secondLine, String postCode) {
        this.firstLine = firstLine;
        this.secondLine = secondLine;
        this.postCode = postCode;
    }

    public String getFirstLine() {
        return firstLine;
    }

    public String getSecondLine() {
        return secondLine;
    }

    public String getPostCode() {
        return postCode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(firstLine, address.firstLine) &&
                Objects.equals(secondLine, address.secondLine) &&
                Objects.equals(postCode, address.postCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstLine, secondLine, postCode);
    }

    @Override
    public String toString() {
        return "Address{" +
                "firstLine='" + firstLine + '\'' +
                ", secondLine='" + secondLine + '\'' +
                ", postCode='" + postCode + '\'' +
                '}';
    }
}

Mungkin ada terlalu banyak kode untuk sesuatu yang sederhana, bukan? Sekarang mari kita lihat tampilannya dengan entri Java baru:

public record EmployeeRecord(String firstName, String surname, int age, AddressRecord address, double salary) {
}

Dan jangan lupa kelas Address :

public record AddressRecord(String firstLine, String secondLine, String postCode) {
}

Ini adalah hal yang sama yang kami tulis sebelumnya dengan begitu banyak kode. Setuju: ini luar biasa. Dan jumlah kode yang akan kita simpan, serta kemudahan penulisannya! Sekarang mari kita lihat apa perbedaannya dengan operator baru switch.

Operator yang Ditingkatkanswitch

Operator baru switchdi Java akan menyelesaikan beberapa masalah lama, termasuk beberapa bug dan duplikasi kode. Dengan adanya operator baru switchmasalah ini akan teratasi. Untuk menjelaskan hal ini dengan sebuah contoh, kita akan membuat enum DayOfTheWeekdi Java:

public enum DayOfTheWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Setelah itu, posisi kita switchakan memberi tahu kita posisi mana dalam minggu yang sesuai dengan hari itu. Pertama mari kita lihat bagaimana kita dapat melakukan ini saat ini menggunakan Java 11.

final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;

        int position = 0;

        switch (dayOfTheWeek) {
            case MONDAY:
                position = 1;
                break;
            case TUESDAY:
                position = 2;
                break;
            case WEDNESDAY:
                position = 3;
                break;
            case THURSDAY:
                position = 4;
                break;
            case FRIDAY:
                position = 5;
                break;
            case SATURDAY:
                position = 6;
                break;
            case SUNDAY:
                position = 7;
                break;
        }

        System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

Dengan pernyataan saat ini, switchkita perlu menggunakan variabel, dan jika kita melewatkan salah satu hari dalam seminggu, kode kita akan dikompilasi dengan baik. Inilah salah satu masalah operator switch: mereka terlalu rawan kesalahan. Jadi bagaimana Java 14 memperbaiki keadaan? Mari kita lihat:

final DayOfTheWeek dayOfTheWeek = DayOfTheWeek.THURSDAY;

        int position = switch (dayOfTheWeek) {
            case MONDAY -> 1;
            case TUESDAY -> 2;
            case WEDNESDAY -> 3;
            case THURSDAY -> 4;
            case FRIDAY -> 5;
            case SATURDAY -> 6;
            case SUNDAY -> 7;
        };

        System.out.println("Day " + dayOfTheWeek + " is in position " + position + " of the week");

Seperti yang Anda lihat, operator baru switchdapat digunakan sebagai ekspresi, bukan hanya sebagai pernyataan. Hasilnya lebih ringkas dan ekspresif. Ini akan cukup untuk meyakinkan banyak dari kita untuk menggunakannya, namun salah satu perbaikan besarnya adalah sekarang pernyataan tersebut switchtidak dapat dikompilasi kecuali kita mencakup semua kasus dalam switch. Ini akan menunjukkan kepada kita kesalahan ini, misalnya:

Error:(9, 24) java: the switch expression does not cover all possible input values

Mulai sekarang, tidak mungkin melewatkan kasus di operator kami switch. Ini sangat mirip dengan operator whendi Kotlin, yang dapat Anda baca di dokumentasi . Mari kita lihat juga blok teks baru.

Blok teks

Pernahkah Anda mengeluh betapa sulitnya menetapkan blob JSON ke variabel di Java? Java memiliki urutan multiline yang dapat Anda gambarkan dengan mengapitnya dalam tanda kutip tiga. Setelah fitur ini dirilis secara resmi, akan lebih mudah untuk mendeskripsikan rangkaian panjang dalam beberapa baris. Mari kita lihat perbedaan antara kedua mode tersebut. Jika kita ingin menggunakan JSON yang diformat dalam suatu variabel, hasilnya buruk:

final String text = "{\"widget\": {\n" +
                "    \"debug\": \"on\",\n" +
                "    \"window\": {\n" +
                "        \"title\": \"Sample Konfabulator Widget\",\n" +
                "        \"name\": \"main_window\",\n" +
                "        \"width\": 500,\n" +
                "        \"height\": 500\n" +
                "    },\n" +
                "    \"image\": { \n" +
                "        \"src\": \"Images/Sun.png\",\n" +
                "        \"name\": \"sun1\",\n" +
                "        \"hOffset\": 250,\n" +
                "        \"vOffset\": 250,\n" +
                "        \"alignment\": \"center\"\n" +
                "    },\n" +
                "    \"text\": {\n" +
                "        \"data\": \"Click Here\",\n" +
                "        \"size\": 36,\n" +
                "        \"style\": \"bold\",\n" +
                "        \"name\": \"text1\",\n" +
                "        \"hOffset\": 250,\n" +
                "        \"vOffset\": 100,\n" +
                "        \"alignment\": \"center\",\n" +
                "        \"onMouseUp\": \"sun1.opacity = (sun1.opacity / 100) * 90;\"\n" +
                "    }\n" +
                "}} ";

Di sisi lain, ketika blok teks baru dirilis, segalanya akan menjadi lebih sederhana:

final String multiLineText = """
                {"widget": {
                    "debug": "on",
                    "window": {
                        "title": "Sample Konfabulator Widget",
                        "name": "main_window",
                        "width": 500,
                        "height": 500
                    },
                    "image": {\s
                        "src": "Images/Sun.png",
                        "name": "sun1",
                        "hOffset": 250,
                        "vOffset": 250,
                        "alignment": "center"
                    },
                    "text": {
                        "data": "Click Here",
                        "size": 36,
                        "style": "bold",
                        "name": "text1",
                        "hOffset": 250,
                        "vOffset": 100,
                        "alignment": "center",
                        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
                    }
                }}
                """;

Ini jelas terlihat lebih baik. Semua ini sudah didukung di Kotlin, seperti yang Anda lihat di definisi tipenya . Jadi kita telah melihat bahwa Java "mewarisi" banyak solusi untuk masalahnya sendiri dari salah satu pesaingnya: Kotlin. Kami tidak tahu apakah Oracle merespons tepat waktu untuk melawan kebangkitan Kotlin atau terlambat. Secara pribadi, saya percaya bahwa Java telah mengambil langkah maju yang tepat, meskipun perubahan ini diprakarsai oleh pesaingnya dan mungkin terjadi dengan beberapa penundaan.

Kesimpulan

Saya pikir kompetisi adalah hal terbaik yang pernah terjadi pada bahasa Java. Kesan saya adalah jika tidak, Jawa akan berpuas diri. Selain itu, pesaing Java telah menunjukkan bahwa cara pemrograman yang berbeda mungkin dilakukan, menunjukkan bagaimana bergerak maju dan menghindari cara penulisan kode yang ketinggalan jaman dan tidak efisien. Perubahan di masa depan akan menjadikan Java lebih kuat dari sebelumnya, bahasa yang disesuaikan dengan era modern, bahasa yang ingin berkembang.