Coffee break #37. Isang bagong hinaharap para sa Java. Mga prospect ng JVM, Kotlin at Java pagkatapos ng 2020

Pinagmulan: Pangunahing pinupuna ang Medium Java para sa dalawang bagay: verbosity at ang dami ng boilerplate code na nabuo sa maraming kaso nang walang malinaw na pangangailangan. Bagama't palagi kong gusto ang Java, hindi ko masasabi na mali ang mga pahayag na ito. Ito ay talagang totoo: ang labis na detalye sa Java ay maaaring minsan ay nakakainis. Gayunpaman, dapat nating aminin na hindi tayo nabubuhay sa isang perpektong mundo, at sa karamihan ng mga kaso kailangan nating piliin ang mas maliit sa dalawang kasamaan. Mula nang mabuo ito, ang Java ay hindi naging perpekto: alam nating lahat ito, ngunit ang tunay na tanong ay kung bakit walang ginawa bago upang malutas ang mga problemang ito. Sa palagay ko ang tanging dahilan kung bakit nagtagal ang mga pagbabago ay dahil ang wikang Java ay walang kumpetisyon at ang mga bagay ay tulad ng dati. Nangibabaw ang Java sa merkado, marahil dahil sa kakulangan ng mga seryosong kakumpitensya at ang mahusay na pagsisikap na ginawa muna ng Sun at pagkatapos ng Oracle. Ang mataas na antas ng kaligtasan ng uri na ibinibigay ng Java at ang mahusay na pagkakaayos ng wika ay naging napakasikat para sa malalaking proyekto. Bilang karagdagan, ito ay isang multi-platform na wika na tumatakbo sa sarili nitong virtual machine. Kasama ng awtomatikong pag-optimize ng pagganap sa pamamagitan ng JIT compiler, lahat ng ito ay pinapaliit ang epekto ng hindi magandang nakasulat na code. Sa kabuuan, ito ay isang medyo nakakahimok na hanay ng mga dahilan para gamitin ang Java. Ngunit ano ang sumunod na nangyari? Ang nangyari ay ang mga bagong wika ay dumating sa merkado na maaaring tumakbo sa parehong JVM bilang Java. Mga wikang nag-alis ng ilan sa mga pinakamalaking abala sa Java at, sa ilang mga kaso, nag-aalok sa mga developer ng isang mas kaaya-ayang kapaligiran na may mas mababang hadlang sa pagpasok. Bago tayo magpatuloy, tingnan natin ang kasaysayan ng mga wikang JVM.

Kasaysayan ng mga wikang JVM

Una, nais kong linawin ang isang bagay: Hindi ko binanggit ang ilan sa mga umiiral na wika ng JVM dahil hindi sila nagkaroon ng sapat na suporta upang ituring na mga kandidato para sa malawakang paggamit sa ating industriya. Simulan natin ngayon ang aming maikling pangkalahatang-ideya ng kasaysayan ng mga wika ng JVM. Una, magkakaroon tayo ng Java, ang pinakaluma at pinakasikat na wika sa mundo ng JVM. Ang Java ay opisyal na inilabas noong Enero 1996, kaya ang wika ay nasa loob ng 24 na taon. Hindi masama, tama? Ang Java ay orihinal na isang purong imperative na wika na sumunod sa isang object-oriented programming style; ito rin ay isang malakas na uri ng wika. Ang syntax ng Java ay medyo katulad ng C++ at C na mga wika, ngunit ito ay itinuturing na isang pinahusay na bersyon dahil ang pagsulat ng code sa Java ay mas madali kaysa sa C o C++. Sa kabilang banda, mayroon tayong pinakamalaking argumento sa kanyang mga detractors - verbosity. Ang pangalawang wika ng JVM ay Groovy. Ito ay mula noong 2003, kahit na ang unang standardized na bersyon nito, 1.0, ay lumitaw lamang noong Enero 2007. Ang bentahe ng Groovy ay maaari itong magamit bilang isang scripting language. Ang Groovy ay isang dynamic na na-type na wika, kaya ang pagsuri ng uri ay ginagawa sa runtime. Isa ito sa mga dahilan kung bakit hindi gusto ng ilang developer ang Groovy. Isinulat mo ang iyong code sa Groovy at mukhang tama ito sa oras ng pag-compile, ngunit pagkatapos ay sa runtime napagtanto mong may mali. Pagkatapos ay lumitaw ang isa pang tanyag na wika: pinag-uusapan natin ang tungkol sa Scala. Ito ay inilabas noong 2004. Nagdala siya ng bagong modelo ng trabaho sa mundo ng JVM: functional programming at isang declarative na diskarte. Karaniwan, ang Scala ang unang wika na nagpakilala ng konsepto ng immutability, na ginamit noon para mapahusay ang Java. Sa kabilang banda, hindi gusto ng mga detractors ang Scala dahil sa kumplikadong grammar nito at medyo mababa ang pagiging madaling mabasa. Ang susunod na wikang lumabas mula sa mundo ng JVM ay ang Clojure, isang purong functional na wika. Ito ay naging medyo sikat kamakailan, kahit na ito ay lumitaw noong 2007. Ang Clojure ay isang LISP-based na wika na nailalarawan sa pagiging simple nito at paggamit ng mga simpleng function. Kabilang sa mga disadvantage nito ay ang dynamic na pag-type nito (tulad ng Groovy) at ang learning curve ay mas matarik dahil ang syntax nito ay ganap na naiiba sa iba pang mga JVM na wika. At sa wakas, mayroon kaming Kotlin. Unang lumitaw ang Kotlin noong Pebrero 2016, at mula noon ang katanyagan nito ay hindi tumigil sa paglaki. Ito ay binuo ng JetBrains na may pangunahing layunin: upang ayusin ang pinakasikat na mga problema sa Java. Sa pamamagitan ng disenyo, pinanatili ni Kotlin ang lahat ng mga pakinabang ng Java, ngunit sa parehong oras ay nalutas ang maraming mga problema. Ito ang pinakamahalagang wika ng JVM. Tulad ng sinabi ko, napalampas namin ang ilang iba pang mga wika na hindi gaanong sikat: Jython, JRuby, Ceylon, Fantom, atbp. Kung nais mo, maaari mong malaman ang buong listahan ng mga umiiral na wika ng JVMsa Wikipedia. Marahil ay napagtanto mo na ang Java ay walang gaanong kumpetisyon sa unang walo o sampung taon pagkatapos nitong malikha, ngunit nagbago ang mga bagay mula noon. Kaya, ang kumpetisyon ba ay mabuti o masama?

Mga Benepisyo ng Pagtaas ng Kumpetisyon

Hindi gaanong nagbago ang Java sa mga unang taon nito. Marahil dahil hindi ito kailangan. Ang wikang ito ay malawakang ginagamit at noon pa man ay napakapopular, sa kabila ng katotohanang ito ay malayo sa perpekto. Ngunit pagkatapos ay lumitaw ang mga kakumpitensya, mas modernong mga wika na nag-aalok ng mga bagong tampok at nalutas ang ilan sa mga problema na nagpahirap sa mga developer ng Java sa loob ng mahabang panahon. Halimbawa, tingnan natin ang wikang Scala. Ang katanyagan ng Scala ay lumalaki mula noong 2009. Tinanggap ng mga developer ang bagong functional na istilo na ito, na nagbigay sa kanila ng higit na kakayahang umangkop pati na rin ang kakayahang magsulat ng parallel code nang ligtas at madali. Paano tumugon ang Oracle sa bagong kalakaran na ito? Noong 2014, lumitaw ang Java Lambdas at Stream. Sa palagay ko lahat tayo ay maaaring sumang-ayon na ito ay noong ginawa ng Java ang pinakamalaking hakbang nito patungo sa pagkatalo sa Scala. Ngayon alam ng sinumang programmer na ang Scala ay hindi na uso. Ang isa pang benepisyo ng pagkakaroon ng higit pang mga kakumpitensya sa mundo ng JVM ay ang patuloy na pagpapahusay na ginagawa sa JIT compiler at JVM. Ngayon mas maraming tao ang interesado sa pag-optimize ng JVM at pagpapabuti ng pagganap. Kaya't ang kumpetisyon ay mabuti para sa lahat! Ang pinakahuling alternatibo sa Java ay ang wikang Kotlin. Ang hitsura nito ay napakahalaga para sa pag-unlad ng Java, dahil ang bagong wika, sa isang kahulugan, ay nagpakita sa Oracle ng daan pasulong. Ang halimbawa ng Kotlin ay nagpakita na posible na mapanatili ang mga pakinabang ng Java, ngunit lumikha ng isang mas compact na wika kung saan ito ay mas mabilis na magsulat ng code. Kung titingnan mo ang graph ng Google Trends, makikita mo na mula 2016 hanggang 2018, mabilis na lumago ang kasikatan ng Kotlin. Ngunit sa nakalipas na dalawang taon ay bumaba ang kaguluhan. Sinuri ng Oracle ang tugon ng industriya sa Kotlin. Kung titingnan mo ang mga tala sa paglabas ng JDK 15 , makikita mo na ang ilan sa mga bagong feature ng Java ay mga kopya ng kung ano ang dumating sa Kotlin. Ito ay mga bagong Java entry , bagong text block (multiline string na may triple quotes) at bagong operator switch, na mahalagang kopya ng operator whensa Kotlin. Lahat ng pinag-usapan namin ay tinatawag kong "Kotlinization of Java." Sa pamamagitan ng pagiging mas malakas na katunggali, ipinakita ni Kotlin sa Java ang landas na dapat sundin.

"Kotlinization" ng Java

Ang ilan sa mga paparating na tampok ng Java ay magiging makabuluhang pagpapabuti sa mga tuntunin ng pagiging madaling mabasa at tutugon sa isa sa mga pinakamalaking kahinaan ng wikang Java - ang verbosity nito. Maaaring magtaltalan ang isa na marami sa mga inihayag na feature ng Java ay kahina-hinalang katulad ng ilang feature ng Kotlin. Ngunit pakitandaan na karamihan sa mga ito ay mga pre-release na bersyon . Nangangahulugan ito na kung i-install mo ang JDK 14 o JDK 15 (kapag inilabas ito), hindi mo magagamit ang mga ito bilang default. Ang mga preview ng feature ng Java ay mga bagong feature na ipinakilala sa isang release ngunit hindi pinagana bilang default. Ang mga ito ay kasama sa bagong bersyon para lang mangalap ng feedback mula sa developer community, kaya maaari pa rin silang magbago. Ito ang dahilan kung bakit hindi inirerekomenda na gamitin ang mga ito sa production code. Upang paganahin ang mga ito sa oras ng pag-compile, kakailanganin mong gawin ang sumusunod:

javac --enable-preview --release 14

Kung gusto mong paganahin ang mga ito sa runtime, kakailanganin mong patakbuhin ang sumusunod:

java --enable-preview YourClass

Siyempre, maaari mo ring paganahin ang mga ito sa iyong IDE, ngunit mag-ingat na huwag paganahin ang preview bilang default sa lahat ng iyong mga bagong proyekto! Tingnan natin ang mga pagbabagong magkakaroon ng mas malaking epekto sa ating coding sa mga susunod na bersyon ng Java.

Mga Post sa Java

Ang Java Records ay isang feature na matagal nang hinihiling ng marami sa atin. Sa palagay ko ay natagpuan mo ang iyong sarili sa isang sitwasyon kung saan kailangan mong ipatupad toString , hashCode , equals , pati na rin ang mga getter para sa bawat umiiral na field. Ang Kotlin ay may mga klase ng data upang malutas ang problemang ito , at ang Java ay nagnanais na gawin ang parehong sa pamamagitan ng pagpapalabas ng mga klase ng record na mayroon na sa Scala sa anyo ng mga klase ng kaso . Ang pangunahing layunin ng mga klase na ito ay mag-imbak ng hindi nababagong data sa isang bagay. Kumuha tayo ng isang halimbawa upang makita kung gaano kahusay ang maaaring maging Java. Ito ay kung gaano karaming code ang kailangan naming isulat upang lumikha at maihambing ang aming klase 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 +
                '}';
    }
}

At din ang bagay na Addressnilalaman nito:

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 + '\'' +
                '}';
    }
}

Marahil ay masyadong maraming code para sa isang bagay na napakasimple, tama? Tingnan natin ngayon kung ano ang magiging hitsura nito sa mga bagong entry sa Java:

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

At huwag nating kalimutan ang klase ng Address:

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

Ito ang parehong bagay na isinulat namin kanina na may napakaraming code. Sumang-ayon: ito ay kamangha-manghang. At ang halaga ng code na aming i-save, at ang kadalian ng pagsulat! Tingnan natin ngayon kung ano ang mga pagkakaiba sa bagong operator switch.

Pinahusay na Operatorswitch

Ang bagong operator switchsa Java ay malulutas ang ilan sa mga lumang problema, kabilang ang ilang mga bug at pagdoble ng code. Sa bagong operator, switchmalulutas ang problemang ito. Upang ipaliwanag ito sa isang halimbawa, gagawa kami ng isang enum DayOfTheWeeksa Java:

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

Pagkatapos nito, switchsasabihin sa amin kung aling posisyon sa linggo ang tumutugma sa araw na iyon. Tingnan muna natin kung paano natin ito magagawa sa kasalukuyan gamit ang 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");

Gamit ang kasalukuyang pahayag, switchkakailanganin naming gumamit ng variable, at kung makaligtaan namin ang isa sa mga araw ng linggo, ang aming code ay mag-compile nang maayos. Ito ay isa sa mga problema sa mga operator switch: sila ay masyadong madaling kapitan ng error. Kaya paano pinapabuti ng Java 14 ang mga bagay? Tingnan natin:

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");

Tulad ng nakikita mo, ang mga bagong operator switchay maaaring gamitin bilang isang expression, hindi lamang bilang isang pahayag. Ang resulta ay mas maigsi at nagpapahayag. switchSapat na ito para kumbinsihin ang marami sa atin na gamitin ang mga ito, ngunit ang isa sa mga pangunahing pagpapahusay ay hindi na magsasama-sama ang mga pahayag maliban kung saklawin natin ang lahat ng kaso sa ating switch. Ipapakita nito sa amin ang error na ito, halimbawa:

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

Mula ngayon, imposibleng laktawan ang kaso sa aming mga operator switch. Ito ay halos kapareho sa mga operator whensa Kotlin, na mababasa mo sa dokumentasyon . Tingnan din natin ang mga bagong bloke ng teksto.

Mga bloke ng teksto

Nagreklamo ka na ba tungkol sa kung gaano kahirap magtalaga ng JSON blob sa isang variable sa Java? Ang Java ay may mga multiline na sequence na maaari mong ilarawan sa pamamagitan ng paglalagay ng mga ito sa triple quotes. Sa sandaling opisyal na inilabas ang feature na ito, magiging mas madaling ilarawan ang mahahabang sequence sa maraming linya. Tingnan natin ang mga pagkakaiba sa pagitan ng dalawang mga mode. Kung gusto naming gumamit ng naka-format na JSON sa isang variable, lumalabas na masama:

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" +
                "}} ";

Sa kabilang banda, kapag ang mga bagong bloke ng teksto ay inilabas, ang lahat ay magiging mas simple:

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;"
                    }
                }}
                """;

Tiyak na mas maganda ang hitsura nito. Ang lahat ng ito ay suportado na sa Kotlin, tulad ng makikita mo sa mga kahulugan ng uri nito . Kaya't nakita namin na ang Java ay "nagmana" ng maraming solusyon sa sarili nitong mga problema mula sa isa sa mga katunggali nito: Kotlin. Hindi namin alam kung tumugon ang Oracle sa oras upang labanan ang pagtaas ng Kotlin o kung huli na ang lahat. Sa personal, naniniwala ako na ang Java ay gumagawa ng mga tamang hakbang pasulong, kahit na ang mga pagbabagong ito ay pinasimulan sa anumang paraan ng mga kakumpitensya nito at maaaring may ilang pagkaantala.

Konklusyon

Sa tingin ko ang kumpetisyon ay ang pinakamagandang bagay na nangyari sa wikang Java. Ang aking impresyon ay na kung hindi man ay mananatili ang Java sa mga tagumpay nito. Bukod pa rito, ipinakita ng mga kakumpitensya ng Java na posible ang ibang paraan ng programming, na nagpapakita kung paano sumulong at maiwasan ang mga luma at hindi mahusay na paraan ng pagsulat ng code. Ang mga pagbabago sa hinaharap ay gagawing mas makapangyarihan ang Java kaysa dati, isang wikang inangkop sa modernong panahon, isang wikang gustong umunlad.