Ինչու պետք է ձեր ընկերությունը մտածի Java-ից Kotlin-ի անցնելու մասին
Այս բլոգ գրառումը քննարկում է պատճառները, թե ինչու ձեր ընկերությունը պետք է մտածի Kotlin-ի անցնելու մասին, հատկապես վեբ մշակման նախագծերի համար։
Kotlin-ի ժողովրդականությունը շարունակում է աճել։ Այն Android մշակման համար նախընտրելի լեզու է և հիմա մուտք է գործում նաև վեբ հավելվածների աշխարհ։ Նույնիսկ աստիճանաբար Java-ի տեղը զբաղեցնելով՝ Kotlin-ը ապավինում է Java-ի հասուն էկոհամակարգին։ Մշակված որպես ժամանակակից այլընտրանք՝ Kotlin-ը լուծում է այն թերություններից շատերը, որոնք բխում են Java-ի՝ հետամուտ համատեղելիության շեշտադրումից, թեև Java-ն ինքն էլ վերջին տարիներին ավելի արագ է զարգանում։ Այս բլոգ գրառումը քննարկում է պատճառները, թե ինչու ձեր ընկերությունը պետք է մտածի Kotlin-ի անցնելու մասին, հատկապես վեբ մշակման նախագծերի համար։
Java-ի գերիշխանությունը
Java-ն ծնվել է գրեթե 30 տարի առաջ։ Երկար ժամանակ այս հասուն լեզուն համարվում էր լավագույն ընտրությունը բազմաթիվ բարդ ձեռնարկատիրական համակարգչային համակարգերի համար։ Java-ն հեղինակություն ուներ որպես շատ կայուն լեզու՝ և՛ հուսալիությամբ, և՛ դանդաղ զարգանալով։ Այդ կայունությունը կարելի էր համարել առավելություն, հատկապես ձեռնարկատիրական սցենարներում, որտեղ Java-ն փայլում է. ի վերջո, նոր շքեղ հնարավորություններով փորձարկելը production համակարգերում, որոնք ընկերությանը միլիոններ են բերում, հավանաբար ամենախելացի գաղափարը չէ։
Սակայն ծրագրային ապահովման մշակման արագ փոփոխվող աշխարհում նույնիսկ վաղուց հաստատված լեզուները պետք է հարմարվեն։ Լեզուները, որոնք չեն զարգանում, կարող են մնալ հետևում։ Բարեբախտաբար, Java համայնքը դա նկատեց և ավելացրեց մի քանի հաճելի նոր հնարավորություններ, ինչպիսիք են անփոփոխ հավաքածուները (immutable collections) Java 9-ում , record-ները Java 16-ում և pattern matching-ը Java 21-ում։ Չնայած այս առաջընթացին՝ Java-ն դեռ հետ է մնում իր մրցակիցներից որոշների համեմատ։ Ավելին, այս նոր հնարավորությունները կառուցվել են հին հիմքերի վրա, որոնք իրականում չեն համապատասխանում դրանց, ուստի դրանք լիովին այնպես չեն վարվում, ինչպես պետք է։ Արդյունքը լեզու է, որը փորձում է քայլ պահել մրցակցության հետ, բայց զսպված է սահմանափակումներով, որոնք արմատավորված են դրա նախնական նախագծման ժամանակ ընդունված որոշ որոշումներում։
Լավ, ուրեմն Java-ն կարող է հետ մնալ և զուրկ լինել այդ բոլոր նորաձև նոր հնարավորություններից. արդյո՞ք դա կարևոր է։ Միթե դա պարզապես ծրագրավորողի նախասիրություն չէ, ինչպես կոշիկների գույնը՝ ոչ մի էական բան։ Բոլորովին ոչ։ Բիզնեսի տեսանկյունից դա շատ կարևոր է, և հոդվածի մնացած մասը բացատրում է՝ ինչու։
Միլիարդ դոլարանոց սխալ
Միլիարդ դոլարանոց սխալը տերմին է, որը ստեղծել է Tony Hoare-ը 2009 թվականին [5]։ Hoare-ը զղջաց null հղումը հայտնագործելու համար և հետագայում ընդունեց, որ դա սխալ էր, քանի որ պատճառ դարձավ անթիվ սխալների, վթարների և խոցելիությունների ծրագրային համակարգերում։ Java-ի ստեղծողները նույն սխալը ներդրեցին իրենց լեզվի մեջ։ Սա հիմնարար խնդիր է Java-ի համար, քանի որ լեզվում յուրաքանչյուր հղում լռելյայն կարող է լինել null։ Պետք է հասկանալ, որ սա լուրջ անվտանգության խնդիր է։ Հետազոտությունները ցույց են տալիս, որ NullPointerException-ները կազմում են production միջավայրերի բացառությունների 20-40%-ը։ Սա նշանակում է շատ փող, որը կորչում է լրացուցիչ դեբագինգի, սպասարկման ավելի բարձր ծախսերի և սերվիսի հնարավոր անջատումների վրա։
Փորձեր եղել են խնդիրը նվազեցնելու, բայց օգտագործվող յուրաքանչյուր լուծում անբավարար է։ Իրականում, մի փայլուն նոր գաղափար դրա դեմ պայքարելու համար հայտնվում է մի քանի տարին մեկ և սնում է բազմաթիվ վեճեր։ Ի վերջո, հստակ պատասխան չկա, թե ինչպես պետք է null-ները մշակվեն Java-ում. կան շատ եղանակներ, և ոչ մեկը լավը չէ՝
- Ենթադրել, որ տվյալ հղումը երբեք null չի լինի (թեև կարող է)։
- Ստուգել՝ արդյոք հղումը null է, ամեն օգտագործումից առաջ։
- Կիրառել Jakarta @Nonnull-ի նման անոտացիա որպես փաստաթղթավորում։
- Կիրառել Jakarta @NotNull-ի նման անոտացիա runtime ստուգումների համար։
- Օգտագործել Java 8-ի Optional տիպը։
- Մատները խաչել և սպասել Null-Restricted and Nullable Types-ին։
- Հորինել ևս մեկ մոտեցում և այս ցանկը էլ ավելի երկար դարձնել։
Առաջինը բնականաբար հանգեցնում է բազմաթիվ NullPointerException սխալների, քանի որ նման ենթադրությունները հազվադեպ են ճիշտ լինում։ Երկրորդը կոդը լցնում է անթիվ if հայտարարություններով, ինչը վնասում է ընթեռնելիությանն ու սպասարկելիությանը և որոշ իրավիճակներում նույնիսկ կարող է race condition-ներ առաջացնել։
Երրորդն ու չորրորդը ավելի լավ են երևում, բայց այս անոտացիաները ողջ կոդով մեկ ցանելը կատարյալ չէ։ Մշակողները հաճախ մոռանում են դրանք, իսկ նրանք, ովքեր հիշում են, հակված են դրանք դնել միայն հանրային ինտերֆեյսների կամ փաթեթի ֆասադների վրա։ Ներքին կոդը հաճախ դուրս է մնում, ուստի NullPointerException-ի ռիսկը մնում է։ Ավելին, երրորդ տարբերակը զուտ փաստաթղթավորման օժանդակ միջոց է. եթե null փոխանցեք @Nonnull պարամետրին, IDE-ն կարող է միայն զգուշացում ցուցադրել, և այն էլ միայն եթե բավական խելացի է։ Չորրորդը ավելի լավ է երևում, քանի որ բացառություն է նետում, երբ null անվտանգությունը խախտվում է։ Այնուամենայնիվ, դա միայն runtime ստուգում է, ուստի դրա հիմնական դերը խնդրի տարածումը կանխելն է՝ այն ավելի շուտ բռնելով։
Հինգերորդ մոտեցումը Java աշխարհ մտավ ֆունկցիոնալ ծրագրավորումից։ Դա պարզապես հղումը փաթաթող տիպ է, որը նախատեսված է բացահայտ նշելու, որ օբյեկտը երբեմն կարող է լինել empty (null-ի մեկ այլ անվանում)։ Այսպիսով, այն շարահյուսության մակարդակում ծրագրավորողին ոչինչ անել չի ստիպում. դա ընդամենը ևս մեկ ենթադրություն է։
Վեցերորդ մոտեցումը ավելի խոստումնալից է երևում։ Այն բերում է հղումային տիպերի null-ականության վերահսկում շարահյուսության մակարդակում ! և ? նշիչներով, ճիշտ ինչպես Kotlin-ն է անում (այս մասին՝ հաջորդ բաժնում)։ Այն ներկայումս preview հնարավորություն է, բայց դրա հիմնական սահմանափակումն այն է, որ չի փոխի գոյություն ունեցող գրադարանային կոդը, ուստի, իրականացվելուց հետո, այն կընդգրկի մեր կոդային բազայի միայն մի մասը։
Մի խոսքով՝ այո, Java-ն առաջարկում է null-անվտանգության գործիքներ, բայց ոչ մեկը կատարյալ չէ, և միասնական ստանդարտ եղանակ չկա։ Դե, խիստ ասած, կա մեկ standard եղանակ՝ null-ները դիտարկել որպես Java-ի մաս, քանի որ լեզուն կառուցվել է դրանց շուրջ։ Այսպիսով, ի՞նչը կլուծեր խնդիրն իրականում։ Մեկ հնարավորություն կլիներ լեզվի շարահյուսությունից ընդհանրապես հեռացնել անուղղակիորեն null-ային հղումային տիպերը։ Սակայն դա կնշանակեր Java-ում կոտրող փոփոխություններ մտցնել, ինչը գործնականում անհնար է։
Ինչպես է Kotlin-ը վարվում null-ների հետ
Kotlin-ի հիմնական ուժեղ կողմերից մեկն այն է, որ այն առաջին օրվանից լեզվի անվտանգությունը դրեց առաջին տեղում։ Սովորելով այլ լեզուների սխալներից՝ Kotlin-ը միլիարդ դոլարանոց սխալը դուրս թողեց իր նախագծից։ Kotlin-ն ընտրեց null-ականության մշակման ավելի պարզ և նրբագեղ եղանակ՝
- Kotlin-ում բոլոր հղումները լռելյայն non-nullable են։
- Մշակողները պետք է բացահայտ հայտարարեն nullable հղումները՝ հղման տիպին կցելով
?(հարցական նշան)։ - Նախքան nullable տիպի հղումը dereference անելը՝ պետք է կատարվի null ստուգում։
Այս նախագիծը արդարացված է, որովհետև՝
- Ստանդարտ (ոչ-null) հղումներին null-ականության ստուգումներ բոլորովին պետք չեն։
- Երբ null-ականություն է պետք, մշակողները գիտակցաբար ընտրում են դա՝ տիպին կցելով հարցական նշանի սիմվոլը (
?)։ - Օբյեկտի փոխարեն null-ին հղվելը հնարավոր է միայն շատ սահմանափակ եղանակով. ծրագրավորողը պետք է օգտագործի հատուկ (
!!) շարահյուսությունը, որը խրախուսելի չէ։
Այս մոտեցումն ավելի նրբագեղ, պարզ և անվտանգ է, քան Java-ի առաջարկածը։ Այս նախագծային որոշումը պաշտպանել է Kotlin-ի շատ հավելվածներ NullPointerException-ից՝ լեզուն դարձնելով ավելի անվտանգ և հավելվածները՝ ավելի ամուր։ Հետևաբար, Kotlin-ը դարձել է հիանալի տարբերակ ձեռնարկատիրական հավելվածների համար։
Անփոփոխություն (Immutability)
Անփոփոխ հավաքածուները կենտրոնական դեր են խաղում լեզվի ընդհանուր անվտանգության մեջ։ Շատ դեպքերում համակարգի մեկ մասից մյուսին փոխանցվող կամ այնտեղից վերադարձվող հավաքածուները նախատեսված չեն փոփոխվելու։ Դրանց փոփոխվել թույլ տալը կարող է կոտրել encapsulation-ը և նաև առաջացնում է անսպասելի վիճակի փոփոխություններ, որոնք սկզբնական հեղինակի կոդը հաշվի չէր առել։ Դա կարող է հանգեցնել բազմաթիվ դժվար հետագծվող սխալների։
Java 9-ը իրոք ավելացրեց անփոփոխ հավաքածուների աջակցություն, բայց դա արեց սովորական փոփոխելի հավաքածուների շուրջ պարզ փաթաթիչներով, որոնք գրելու գործողությունների ժամանակ բացառություն են նետում։ Դա կարող է բավական լինել encapsulation ապահովելու և անսպասելի վիճակի փոփոխություններից խուսափելու համար, բայց ստեղծում է նոր խնդիր՝ խախտելով Liskov Substitution Principle-ը։ Այլ կերպ ասած, այս մոտեցումը ներմուծում է տիպեր (անփոփոխ հավաքածուներ), որոնք ճիշտ չեն իրականացնում իրենց ծնող տիպի (փոփոխելի հավաքածուներ) մեթոդները (գրելու գործողություններ)։ Այս անհամապատասխանությունը կարող է առաջացնել ավելի շատ սխալներ և շփոթություն։ Ինչպես null անվտանգության դեպքում, այս անկատար (կամ նույնիսկ «կեղտոտ») մոտեցումն ընտրվել է, որպեսզի անվտանգության հնարավորությունը ավելացվի առանց կոտրող փոփոխությունների։
Kotlin-ը աջակցում է անփոփոխ հավաքածուներին «տուփից դուրս»։ Այն դա ապահովում է հավաքածուների հիերարխիան ճիշտ վերանախագծելով, որպեսզի փոփոխելի տիպերը ժառանգեն անփոփոխներից, ինչը պահպանում է Liskov Substitution Principle-ը։ Ավելին, հավաքածուները, ինչպես Kotlin-ի այլ բաներ, լռելյայն անփոփոխ են։ Սովորաբար փոփոխելի հավաքածուների հետ աշխատելու համար պետք է մի լրացուցիչ բառ (mutable) ավելացնել։ Սա մշակողներին էլ ավելի հեռու է մղում փոփոխելի հավաքածուներից, որոնք շատ դեպքերում անհրաժեշտ չեն։ Այն կոդը դարձնում է ավելի անվտանգ՝ կանխելով տվյալների պատահական փոփոխությունները, ինչը ի վերջո կրճատում է դեբագինգի ժամանակը և սպասարկման ծախսերը բիզնեսների համար։
Kotlin-ի շարահյուսությամբ ավելի շատ բան է արվում
Kotlin-ը հայտնի է իր սեղմ շարահյուսությամբ և բազմաթիվ ներկառուցված հնարավորություններով, որոնք հաճախ տալիս են Java համարժեքից 20-40%-ով ավելի կարճ կոդ։ Այս սեղմությունը լեզուն ավելի հեշտ է դարձնում գրելու և դրա շուրջ դատելու համար։ Այն նաև թույլ է տալիս որոշ տեսակի սխալներ ավելի շուտ բռնել։ Ավելին, Kotlin ծրագրավորողները կարող են նույն ֆունկցիոնալությունը մատակարարել զգալիորեն ավելի արագ, քան Java մշակողները։ Որոշ ընկերություններ հայտնում են մշակման արագության աճի մասին՝ մինչև 40%, բայց այդ թիվը հավանաբար լավատեսական է. ավելի իրատեսական գնահատականը 10%-ի և 30%-ի միջև է։
Kotlin-ը նաև հայտնի է ֆունկցիոնալ լեզուներից ոգեշնչված իր ներկառուցված ֆունկցիաներով (օր.՝ fold, reduce, associate, groupBy, zipWithNext)։ Դրանք թույլ են տալիս մշակողներին մի քանի տողով շատ բան անել, ինչը արդյունավետորեն արագացնում է ծրագրային ապահովման իրականացումը։ Դրանցից շատերը հասանելի են Java-ում կամ այնպիսի գրադարաններում, ինչպիսին Guava-ն է, բայց դրանք հաստատ այնքան սեղմ կամ հաճելի չեն օգտագործելու համար, որքան Kotlin-ում, ինչը որոշ չափով հետ է պահում ծրագրավորողներին դրանք օգտագործելուց։
Թեև Kotlin-ն ավելի սեղմ է, քան Java-ն, դրա շարահյուսությունը մի փոքր ավելի բարդ է և պահանջում է նոր հասկացությունների որոշակի իմացություն։ Առաջին հայացքից կոդը մաքուր է երևում, բայց հասկանալը, թե իրականում ինչ է անում յուրաքանչյուր մաս, ջանք է պահանջում։ Lambda receiver-ները և extension ֆունկցիաները կարող են Java մշակողներին բավականին էկզոտիկ թվալ։ Այս հնարավորությունները անշուշտ հիանալի են DSL-ներ կառուցելու համար (պարզապես տեսեք, թե ինչ է Gradle-ը անում դրանցով), բայց սկզբում կարող են ձեր կոդը հանելուկի զգացողություն տալ։ Սեղմությունը կարող է գայթակղիչ լինել, բայց չափազանց կոմպակտ շարահյուսությունը կարող է վնասել ընթեռնելիությանը. լավագույնն է խուսափել մեկ տողանոց հնարքներից՝ կոդը հստակ և հասկանալի պահելու համար։ Դրական կողմը՝ սկզբնական շփոթությունն անցնելուց հետո Kotlin-ի դյուրանցումները և ավելի հարուստ ստանդարտ գրադարանը կօգնեն ձեզ կոդը ավելի արագ մատակարարել։
Ֆունկցիոնալ ծրագրավորում
IT աշխարհը դանդաղ տեղաշարժվում է դեպի ֆունկցիոնալ ծրագրավորում (FP)՝ հեռանալով զուտ օբյեկտ-կողմնորոշված (OO) մոտեցումից։ FP պարադիգմը բերում է անփոփոխություն, կողմնակի էֆեկտների բացակայություն և կանխատեսելիություն, ինչը կոդը դարձնում է ավելի անվտանգ, դրա շուրջ դատելը՝ ավելի հեշտ և զուգահեռ կատարման համար ավելի հարմար։ Զուտ OO հավելվածները, հատկապես նրանք, որոնք մեծապես ապավինում են ժառանգմանը՝ ֆունկցիոնալությունն ընդլայնելու համար, ժամանակի ընթացքում հակված են բարդանալու և դժվար սպասարկվելու։ Մյուս կողմից, համակարգերը ամբողջությամբ FP պարադիգմով կառուցելը կարող է ավելի դժվար լինել, հատկապես որ մշակողների մեծ մասը վարժվել է հիմնականում OOP ոճով։ Դա հիբրիդային մոտեցումը, երկու պարադիգմներից լավագույնը վերցնելով, դարձնում է ավելի գրավիչ։ Kotlin-ը այս միտման մեջ գտնում է ոսկե միջինը՝ շարահյուսությամբ, որը թույլ է տալիս մշակողներին գրել FP ոճի կոդ OOP միջավայրում, կամ մնալ զուտ OOP-ում, որտեղ FP-ն չի համապատասխանում։
Kotlin-ը առաջարկում է և՛ OOP, և՛ FP կառուցվածքներ, ուստի կարող եք համադրել երկու ոճերը կամ ընտրել մեկը, եթե նախընտրում եք։ Ֆունկցիայի տիպերը, extension ֆունկցիաները, անփոփոխությունը և null-անվտանգությունը Kotlin-ը դարձնում են հիանալի ընտրություն FP ոճի ծրագրավորման համար։ Կարող եք ֆունկցիայի հաջողությունը կամ ձախողումը մոդելավորել sealed դասերով և pattern matching-ով, կամ պարզապես օգտագործել բացառություններ, եթե ցանկանում եք (թեև շատ դեպքերում ավելի լավ է չանել)։ Կարող եք ֆունկցիան կառուցել ֆունկցիաների շղթայից, կամ օգտագործել ցիկլեր, if-եր և փոփոխականներ, եթե դա կոդն ավելի հստակ է դարձնում (բայց հավանաբար չի դարձնի)։ Կարող եք օգտագործել բարձր կարգի ֆունկցիաներ, կամ մնալ strategy/command/template method կաղապարների հետ (թեև ձեր թիմակիցները կարող են հիացած չլինել)։ Հիմնականն այն է, որ Kotlin-ը ձեզ ընտրություն է տալիս, ինչը նաև կարող է անեծք լինել, քանի որ ձեր թիմը պետք է համաձայնի, թե որ մոտեցմանը հետևել։
Խոստովանենք՝ Java-ն այսօր սեքսի չէ։ Ընկերությունները դիմում են ֆունկցիոնալ ծրագրավորման ոչ միայն տեխնիկական առավելությունների համար. այն նաև օգնում է տաղանդավոր մշակողներին ներգրավել։ Այդ մշակողները իրական բիզնես արժեք են մատակարարում ավելի արագ մատակարարմամբ, կոդի ավելի բարձր որակով և ավելի նորարարական լուծումներով։ Օրինակ՝ երբ Amazon Prime-ը ընդունեց Kotlin-ը, տեսավ և՛ մշակողների ավելի մեծ գոհունակություն, և՛ ավելի լավ արտադրողականություն։
Kotlin-ը աշխատում է Java-ի հետ
Kotlin-ը աշխատում է Java Virtual Machine-ի (JVM) վրա, ուստի կարող եք օգտագործել Java գործիքների և գրադարանների լայն շրջանակ, ներառյալ Spring-ը։ Սա նաև նշանակում է, որ Kotlin ֆայլերը և Java դասերը կարող են կողք կողքի ապրել մեկ նախագծում։ Սա շատ նախագծերի և թիմերի համար Kotlin-ի անցումը հեշտացնում է։ JetBrains-ը նաև առաջարկում է IDE գործիքակազմ Java կոդը Kotlin-ի փոխարկելու համար, ուստի Kotlin ծրագրավորողները դեռ կարող են հեշտությամբ StackOverflow-ից կոդի հատվածներ տեղադրել իրենց նախագծերում 😉։ Ավտոմատ փոխարկումը իսկապես պահանջում է որոշ ձեռքով հղկում, հատկապես Kotlin-ի հնարավորություններից, ինչպիսին null-ականության մշակումն է, լիարժեք օգտվելու համար, բայց այն լավ մեկնակետ է տալիս միգրացիայի համար։ Հիմնականն այն է, որ Kotlin-ը ձեր Java թիմին ներմուծելը հեղափոխություն չէ. էկոհամակարգը մնում է նույնը, և ձեր թիմը կարող է շարունակել օգտագործել բոլոր առկա գործիքները, ուստի անցումը և՛ անվտանգ է, և՛ սահուն։
Որքանո՞վ է Kotlin-ը ժողովրդական
Ընկերությունների մեծ մասն արդեն իրենց Android նախագծերը Java-ից տեղափոխել է Kotlin, հիմնականում վերը տրված պատճառներով, բայց նաև որովհետև Google-ը ուժեղ աջակցեց այս տեղաշարժին։ Kotlin-ը հիանալի ընտրություն է նաև backend վեբ հավելվածների մշակման համար, բայց այնտեղ այդքան տեղ չի ձեռք բերել։ Այնուամենայնիվ, այնպիսի ընկերությունների դեպքերի ուսումնասիրությունները, ինչպիսիք են Amazon, Zalando, DoorDash և Revolut, ցույց են տալիս, որ Kotlin-ը հիանալի տարբերակ է նաև backend մշակման համար։
Kotlin-ի ներկայիս ժողովրդականությունը աշխատաշուկայի տվյալներից գնահատելը դժվար է, քանի որ Kotlin-ի թափուր աշխատատեղերը սովորաբար համակցված են Java-ի հետ։ Գործնականում Kotlin backend սերվիսներից շատերը կառուցվում են մշակողների կողմից, որոնք նախկինում աշխատել են Java-ով։ Դա լավ նորություն է, որովհետև եթե ձեր ընկերությունը ընտրի Kotlin, դեռ կարող է օգտվել աշխատաշուկայի ծրագրային ինժեներների ամենամեծ ֆոնդերից մեկից։ Այդ Java մշակողներին, սակայն, հավանաբար որոշ վերապատրաստում կպահանջվի՝ նախքան Kotlin-ի մեջ խորանալը, հատկապես եթե նրանք ֆունկցիոնալ ծրագրավորման փորձ չունեն։ Բարեբախտաբար, լավ Java մշակողների մեծ մասը իսկապես ունի այդպիսի փորձ FP պարադիգմի հետ։
Ինչու ոչ
Kotlin-ն ունի մի շարք առավելություններ, բայց ինչպես ցանկացած ծրագրավորման լեզու, ունի նաև իր թերությունները։ Դրա հիմնական բիզնեսի հետ կապված թերությունն այն է, որ այն ավելի քիչ հայտնի է, քան Java-ն, հատկապես վեբ մշակման մեջ։ Kotlin-ը տարածված է հիմնականում բջջային հավելվածներում։ Բջջայինը Kotlin-ի միակ տարածքը համարելը, սակայն, սխալ է։ Այնուամենայնիվ՝ ավելի քիչ տարածված լինելը նշանակում է աշխատաշուկայում ավելի քիչ հասանելի ծրագրավորողներ։ Այն նաև հարց է առաջացնում լեզվի երկարաժամկետ կենսունակության մասին. արդյո՞ք անվտանգ է ավելի քիչ օգտագործվող լեզու ընտրել այն նախագծերի համար, որոնք պետք է սպասարկվեն տասնամյակներ։ Այսինքն՝ Kotlin-ին աջակցում են JetBrains-ը և Google-ը, ուստի ոչ ոք չի սպասում, որ այն հանկարծ լքվի. գոնե ոչ JetBrains-ի պատճառով 😉
Տեխնիկապես Kotlin-ը հիանալի, բայց ոչ անթերի լեզու է, քանի որ մի քանի հնարավորություն բացակայում է։ Kotlin-ն ունի pattern matching, բայց ոչ լիարժեք. pattern matching-ը չի աջակցում destructuring կամ բարդ արտահայտություններ։ Նույնիսկ Java-ն՝ Java 21-ում ներմուծված շարահյուսությամբ, առաջարկում է ավելի առաջադեմ pattern matching։ Երկրորդ՝ Kotlin-ի լռելյայն հասանելիությունը public է. նշանակում է՝ յուրաքանչյուր դաս, ֆունկցիա կամ հատկություն public է, եթե այլ բան նշված չէ, ինչը կարող է վատ պրակտիկաներ խրախուսել, քանի որ հասանելիությունը լռելյայն պետք է սահմանափակվի և բացվի միայն անհրաժեշտության դեպքում։ Kotlin-ը նաև չունի Java-ի package-private-ի նման որևէ բան, ուստի Kotlin-ի շարահյուսությունը չի աջակցում հանրային ֆասադներ կառուցելուն, որոնք թաքցնում են փաթեթի ներքին մասերը։ Կան նաև մի քանի այլ փոքր թերություններ, բայց դրանք արժանի են առանձին բլոգ գրառման. մնացեք մեզ հետ, նախատեսում ենք հրապարակել այն ավելի ուշ։ Եզրակացությունն այն է, որ մենք Kotlin-ը կատարյալ լեզու չենք համարում (ոչ մի լեզու կատարյալ չէ), բայց այն շատ լավ է, հավանաբար բազմաթիվ կիրառության դեպքերի համար լավագույն ընտրություններից մեկը։
Եզրակացություն
Kotlin-ն ունի մի շարք առավելություններ Java-ի նկատմամբ, ինչպիսիք են լեզվի ավելի ուժեղ անվտանգությունը, մշակման ավելի կարճ ժամանակը և ժամանակակից ծրագրավորման պարադիգմներին ավելի լավ համապատասխանությունը։ Java-ից Kotlin-ի անցումը թիմի լայնածավալ վերապատրաստում չի պահանջում, որովհետև Kotlin-ը դեռ Java էկոհամակարգի մաս է։ Այս ամենը Kotlin-ը դարձնում է գրավիչ տարբերակ և՛ նոր նախագծերի, և՛ այն թիմերի համար, որոնք ուզում են արդիականացնել իրենց առկա Java կոդային բազաները։ Այնուամենայնիվ, Kotlin-ի՝ Java-ից պակաս հասուն լինելը որոշ ռիսկ է բերում, հատկապես երբ թիմը վերապատրաստված Kotlin մշակողներ չունի կամ մտադիր է հիմնվել Kotlin-ին հատուկ գործիքների վրա, որոնք դեռ փորձարկված չեն մարտական պայմաններում, փոխարենը հաստատված Java գրադարանների։
Մեր ընկերությունում մեր փորձը մեզ ասում է, որ Kotlin-ը բավական հասուն է՝ նույնիսկ խոշոր backend նախագծերում հաջողությամբ օգտագործվելու համար։ Մենք գիտենք, թե որքան է ճիշտ գործիքների ընտրությունը ազդում բիզնեսի վրա։ Մենք նաև լավ հայտնի ենք մեր Scala փորձառությամբ. Scala-ն մեկ այլ JVM-ի վրա հիմնված լեզու է, որն առաջարկում է այս հոդվածում նկարագրված առավելություններից շատերը։
Այսպես՝ կմնա՞ք Java-ի հետ և կվտանգե՞ք միլիարդ դոլարանոց սխալով 😉
🎵Կառուցեք ավելի անվտանգ ապագա՝ Kotlin-ով։ 🎵