Scala-ով հավելվածներ կառուցելու հիմնական սկզբունքները
Մի քանի սկզբունք, որոնք արժե հիշել Scala-ով և ֆունկցիոնալ ծրագրավորմամբ կոդ գրելիս։
Scala-ն՝ ստատիկ տիպավորմամբ ֆունկցիոնալ ծրագրավորման լեզու, գոյություն ունի գրեթե 20 տարի։ Այդ ժամանակահատվածում ձևավորվել են Scala կոդ գրելու մի քանի հիմնական ուղղություններ։ Դրանց թվում են էֆեկտների համակարգերի հետ աշխատանքը, կոդն ասինխրոն աշխատեցնելու տարբեր տեխնիկաները և գրադարանների ու ֆրեյմվորքերի լայն շրջանակի օգտագործումը։
Թեև այս մոտեցումները զգալիորեն տարբերվում են, դրանք բոլորը կիսում են սկզբունքների ընդհանուր շարք։ Այլ կերպ ասած՝ ինչ ստեկ էլ նախընտրեք Scala-ով հավելվածներ կառուցելիս, կան բաներ, որ սովորաբար անում եք, և բաներ, որ երբեք չեք անում։
Այս սկզբունքները բխում են երեք հենասյուներից՝ հենց լեզվից, ստանդարտ գրադարանից և համայնքից։ Եկեք ավելի մոտիկից դիտարկենք այդ պրակտիկաներից մի քանիսը՝ երբեմն Scala-ի մոտեցումը համեմատելով Java էկոհամակարգում հավելվածներ կառուցելու ձևի հետ։
Անփոփոխելի տվյալների կառուցվածքներ
Scala կոդի ամենահիմնական և հեռուն գնացող առանձնահատկություններից մեկն այն է, որ տվյալների կառուցվածքները լռելյայն անփոփոխելի են։ Այս մոտեցումը բերում է մի քանի առավելություն (մի քանի թերության հետ մեկտեղ)՝
- ոչ ոք «այլ տեղից» չի կարող փոխել տվյալները «ինչ-որ այլ տեղում»
- քանի որ ֆունկցիայից դուրս վիճակը չի կարող փոխվել, կոդը ավելի հեշտ է հետևել. սա հայտնի է նաև որպես լոկալ դատողություն (local reasoning)
- տվյալները պաշտպանված են կոռումպացիայից, քանի որ զուգահեռ փոփոխությունը անհնար է
- ավելի լավ թելային անվտանգություն (thread-safety) և, ընդհանուր առմամբ, ավելի պարզ զուգահեռ ծրագրավորում
Այլ ծրագրավորման հարթակներ նույնպես զուգահեռ ծրագրավորման համար նախընտրում են անփոփոխելի տվյալների կառուցվածքները։ Այն, որ Scala-ն դա դարձնում է լռելյայն, կարող է լինել պատճառներից մեկը, թե ինչու զուգահեռ ծրագրավորումը դարձավ նրա նիշաներից մեկը։
Scala-ն աջակցում է անփոփոխելի տվյալների կառուցվածքներին բազմաթիվ մակարդակներում։ Սկզբից՝ հենց լեզուն տրամադրում է այնպիսի կառուցվածքներ, ինչպիսիք են case class-երը, լռելյայն val (այլ ոչ var) եղող դասի դաշտերը, enum-ները (Scala 3-ում) և ADT-ները (փակ դասերի ընտանիքներ)։ Նույնքան կարևոր է այն, թե որքան հեշտ է տվյալների կառուցվածքների փոփոխված պատճեններ ստեղծել՝ ավտոմատ գեներացվող copy մեթոդների շնորհիվ։
Թերևս ավելի նշանակալի է այն, որ ստանդարտ գրադարանը նախագծված է անփոփոխելի տվյալների կառուցվածքների շուրջ. երբ օգտագործում եք Set, List կամ Map, լռելյայն ստանում եք անփոփոխելի տարբերակը։
Վերջապես, Scala գրադարանների մեծ մասը ընդունում և վերադարձնում է անփոփոխելի տվյալների կառուցվածքներ։ Scala-ում տվյալների հետ հենց այսպես են վարվում։ Բնականաբար, փոփոխելի տվյալների կառուցվածքները դեռ հասանելի են, երբ դրանք պետք են։ Բայց դա ավելի շատ բացառություն է, քան կանոն։
Ոչինչ չի խանգարում անփոփոխելի տվյալների կառուցվածքներ օգտագործել այլ հարթակներում, ինչպես node.js-ը, Java-ն կամ .NET-ը։ Այդ դեպքերում, սակայն, լեզուն տրամադրում է միայն սահմանափակ աջակցություն։ Ավելի կարևորն այն է, որ ստանդարտ գրադարանները և համայնքի հայտնի գրադարանները կառուցված են փոփոխելի տվյալների կառուցվածքների վրա։ Նույնիսկ այնտեղ, որտեղ անփոփոխելիությունը հասանելի է, այն կարող է շատ անպրակտիկ լինել։
Օրինակ՝ գրեթե յուրաքանչյուր Java գրադարան ապավինում է ստանդարտ գրադարանի փոփոխելի կոլեկցիաների ինտերֆեյսներին։ Ինչ Java գրադարան էլ օգտագործեք, այն համարյա անպայման կաշխատի ստանդարտ, փոփոխելի կոլեկցիաների հետ։ Սա գործնականում անհնար է փոխել. Java-ն կմնա լեզու, որը առաջնությունը տալիս է փոփոխելիությանը։
Արտահայտություններ և արժեքներ
Scala-ի մի առանձնահատկություն, որը սկզբում կարող է աչքի չընկնել, բայց շուտով դառնում է մի բան, առանց որի չես կարող ապրել, այն է, որ Scala-ում ամեն ինչ արտահայտություն (expression) է։ Սրան սովորելուց հետո այն լեզվով ծրագրավորելը, որը բաժանում է հրամանները (statements) և արտահայտությունները, անհարմար և անհարկի սահմանափակող է թվում։
Սա ցույց է տալիս, թե որքան ճկուն և բազմակողմանի է Scala-ի շարահյուսությունը։ Սկզբում նկարագրված երեք հենասյուներին նայելիս՝ արտահայտությունների վրա կողմնորոշված լինելը հատկանիշ է, որը զուտ լեզվին է պատկանում։
Դրա հետ կապված Scala-ի պրակտիկա է տարբեր հասկացություններ արժեքների տեսքով մոդելավորելը։ Նախ վերցնենք ֆունկցիաները. ֆունկցիա-արժեք սահմանելու համար պետք է շատ թեթև շարահյուսություն։ Scala-ում դա պարզապես բնական է ստացվում։ Ստանդարտ գրադարանը սա էլ ավելի է ամրապնդում՝ ապավինելով բարձր կարգի ֆունկցիաներին (այսինքն՝ ֆունկցիաներ, որոնք ընդունում են այլ ֆունկցիաներ որպես պարամետր կամ վերադարձնում են ֆունկցիաներ)։ Նույնը անում է ամբողջ էկոհամակարգը, որը հետևում է նույն մոտեցմանը։
Սակայն դա միայն ֆունկցիաներով չի սահմանափակվում։ Scala-ի մեծ առավելությունն այն է, թե որքան ճկուն կարող եք սահմանել աբստրակցիաներ։ Գործնականում դա հաճախ նշանակում է տարբեր հասկացություններ արժեքների տեսքով մոդելավորելու հնարավորություն։ Գուցե անսպասելիորեն, անուղղակիության այս լրացուցիչ շերտի ներդրումը բացում է հետաքրքիր նոր հնարավորություններ։
Առաջատար օրինակ են ֆունկցիոնալ էֆեկտների համակարգերը, ինչպիսիք են ZIO-ն կամ cats-effect-ը։ Դրանցում ամբողջ հաշվարկը մոդելավորվում է որպես արժեք։ Սա մեզ տալիս է էֆեկտներով կոդի ծույլ, վերահսկվող կատարում։ Սեփական runtime-ի հետ զուգակցված՝ դա հնարավոր է դարձնում դեկլարատիվ զուգահեռություն, ինչպես նաև թեթև թելեր, որոնք աջակցում են սկզբունքային ընդհատումներ, կամ անվախ ռեֆակտորինգ։
Մեկ այլ օրինակ գալիս է HTTP գրադարաններից, որտեղ հաճախ սկսում եք՝ ստեղծելով արժեք, որը նկարագրում է endpoint-ը կամ HTTP հարցումը։ Բնականաբար, այս արժեքը անփոփոխելի է, ինչը հնարավորություն է տալիս այն քայլ առ քայլ ճշգրտել և առանձնացնել մտահոգությունները՝ ցանցային շերտը՝ դոմենային շերտից։
Մակրոսներ, ոչ թե ռեֆլեքսիա
Երրորդ սկզբունքը ուղղակիորեն բխում է Scala-ի շեշտադրումից ստատիկ ստուգվող տիպերի միջոցով ճշտության վրա։ Կրկին հիմնականում կհամեմատենք «Scala-ի մոտեցումը» այն բանի հետ, ինչ տրամադրում է Java-ն։
Scala-ն ձեզ տալիս է մեծ ճկունություն աբստրակցիաներ սահմանելու համար, բայց դա միայն մինչև որոշակի սահման կարող է տանել։ Շուտով կամ ուշ ստիպված կլինեք կամ գրել boilerplate-ի մեծ բլոկներ, կամ գտնել կոդը ձեզ համար գեներացնելու որևէ եղանակ։ Տիպիկ դեպքեր են JSON-ի կոդավորիչների/ապակոդավորիչների գեներացումը, օբյեկտների գրաֆի միացումը dependency injection-ով կամ դասերի արտապատկերումը տվյալների բազայի աղյուսակներին։
Այսպիսով, հարցը դառնում է. ինչպե՞ս պետք է սահմանել կոդի գեներացման այս գործընթացը։ Ո՞ր լեզուն ենք օգտագործում, և ինչպե՞ս են օգտատերերը նշում, թե ինչ պետք է գեներացվի։
Java-ում սա սովորաբար արվում է անոտացիաներով, որոնք հետո որևէ ֆրեյմվորք, ինչպես Spring-ը, կարդում է run-time-ում ռեֆլեքսիայով։ Այդ դեպքում ֆրեյմվորքը հանդես է գալիս որպես ինտերպրետատոր՝ արտադրելով բայթկոդ կամ ստեղծելով նախապես սահմանված դասերի օրինակներ։ Ես վաղուց կարծիք ունեմ, որ Java-ն չարաշահում է անոտացիաները և որ դրանք փաստացի կազմում են զուգահեռ, սահմանափակ և անապահով ծրագրավորման լեզու՝ թերսահմանված, ad-hoc ինտերպրետատորներով։
Ուրեմն ո՞րն է այլընտրանքը։ Scala-ի պատասխանը կոդը կոմպիլյացիայի ժամանակ գեներացնելն է։ Դրա ամենատարածված ձևը՝ տիպով ղեկավարվող տերմինների ածանցումը, հայտնի է որպես implicit-ներ (Scala 2-ում) կամ given-ներ (Scala 3-ում)։ Ինչպես IDE-ն հաճախ կարող է կոդի մի կտորի տիպերը ածանցել, Scala կոմպիլյատորը կարող է կոդ ածանցել տիպից։ Scala 3-ը բարելավել է այս հնարավորության «մշակողի փորձառությունը»։
Scala-ն, սակայն, էլ ավելի հեռու է գնում. inline-ները և մակրոսները ուղղակիորեն փոխարինում են անոտացիաների վրա հիմնված կոդի գեներացմանը։ Դրանք հնարավորություն են տալիս Scala կոդ գեներացնել կոմպիլյացիայի ժամանակ տիպային անվտանգ եղանակով՝ գործընթացը նկարագրելու համար օգտագործելով Scala լեզուն ամբողջությամբ և անթերի համընկնելով Scala-ի մնացած հնարավորությունների հետ։
Անոտացիաները դեռ կարող են ուղղորդել մակրոսը և տրամադրել լրացուցիչ մետատվյալներ, բայց դա ընդամենը մեկ հնարավորություն է. մյուսը մակրոսին փոխանցված տիպերի և տերմինների քննությունն է։ Scala-ն առաջարկում է մակրոսների կիրառման բազմաթիվ օրինակներ, ինչպես jsoniter-scala գրադարանը կամ macwire-ը՝ կոմպիլյացիայի ժամանակ dependency injection-ի համար։
Մակրոսները հաճախ նկարագրվում են որպես դժվար ըմբռնելի։ Եվ թեև մակրոս գրելը իսկապես կարող է հեռու լինել պարզից, նույնը ճիշտ է (ես կպնդեի՝ նույնիսկ ավելի մեծ չափով) անոտացիաների պրոցեսորներ կամ բայթկոդի գեներատորներ գրելու համար։
Մակրոսներ օգտագործելը բոլորովին այլ հարց է. սովորաբար դա ոչնչով չի տարբերվում մեթոդ կանչելուց։ Սխալի հաղորդագրությունների ոչ միշտ կատարյալ լինելը խնդիր է, բայց այն բխում է էկոհամակարգի հասունացումից, այլ ոչ թե ամբողջ մոտեցման հիմնարար թերությունից։
Թեև անոտացիաներով ղեկավարվող և ռեֆլեքսիայի վրա հիմնված կոդի գեներացումը դեռ գերիշխում է Java էկոհամակարգում, կան նշաններ, որ այն նույնպես տեղաշարժվում է դեպի կոմպիլյացիայի ժամանակ գեներացում։ Մի օրինակ է Hibernate-ի metamodel-ը (որը ապավինում է անոտացիաների պրոցեսորներին)։ Այդուհանդերձ, անոտացիաների՝ որպես ենթալեզվի սահմանափակ արտահայտչականությունը շարունակում է խնդիր լինել։ Kotlin-ի սերիալիզացիայի plugin-ը (https://github.com/Kotlin/kotlinx.serialization) մեկ այլ օրինակ է։
Բացահայտ, երբ անհրաժեշտ է, անուղղակի, երբ ոչ
Վերջին սկզբունքը ուղղակի արդյունք չէ Scala-ի կամ նրա ստանդարտ գրադարանի նախագծման, այլ ամբողջ ֆունկցիոնալ ծրագրավորման և մասնավորապես Scala համայնքի «մշակույթի»։
Գրեթե ցանկացած հարթակում գայթակղություն կա ավելացնել որևէ «կախարդանք»։ Մոտիվացիան լավ է. ուզում ենք, որ բաները ավտոմատացված լինեն և իրենք իրենցով տեղի ունենան։ Խնդիրները, սակայն, սկսվում են, երբ այս «կախարդանքի» օգտատերերս չենք կարողանում որոշել և ըմբռնել, թե ինչ է տեղի ունենալու, երբ և ինչ պատճառով։ Դա հակասում է մեր կոդային բազաների կանխատեսելիությանը և ուսումնասիրելիությանը, որոնք մեծ դեր են խաղում պահպանելի ծրագրակազմ մատակարարելու մեջ։
Նման «կախարդանքի» դասական օրինակ է classpath-ի սկանավորումը և «ավտոմատ հայտնաբերումը», որը որոշ բաղադրիչներ պայմանականորեն միացնում է միայն այն պատճառով, որ դրանք պատահաբար classpath-ում են։ Scala կոդում սա գրեթե ամբողջովին բացակայում է։
Կուզենայի՞ք, որ ձեր օպերացիոն համակարգը փոխի իր վարքը պարզապես այն պատճառով, որ ինտերնետից ինչ-որ բան ներբեռնել եք։ Բայց classpath-ի սկանավորման և ավտոմատ ինստրումենտացիայի կախարդանքը հենց դա է անում։ Scala-ն նախընտրում է, որ հնարավորությունները միացվեն բացահայտ՝ նույնիսկ երեք լրացուցիչ տող կոդի գնով։
Մեկ այլ օրինակ այն է, որ Scala հավելվածները իրենց main մեթոդները միշտ սահմանում են բացահայտ։ Ինչ-ինչ պատճառով Java կոդում հաճախ նման հստակ մուտքի կետ չկա, փոխարենը ապավինում են մեր հավատարիմ հին ընկերներին՝ անոտացիաներին և ռեֆլեքսիային։ Գուցե Java-ն այստեղ բացառություն է, կամ գուցե Scala-ն մի քիչ խելք է մտցնում գործի մեջ. չեմ կարող ասել։ Հստակ է միայն այն, որ main-ից վախենալու կարիք չկա։
Ո՞րն է սրա ակունքը։ Երբ գրում ենք Scala կոդ կամ ընդհանրապես հետևում ենք «ֆունկցիոնալ» ոճին, գործ ունենք ֆունկցիաների հետ, որոնք կարող են որպես պարամետր վերցնել այլ ֆունկցիաներ և վերադարձնել արժեքներ, որոնք հետո փոխանցում ենք այլ ֆունկցիաներին։ Դա, ի վերջո, ֆունկցիոնալ ծրագրավորման էությունն է. ֆունկցիաները դիտարկվում են որպես առաջին կարգի արժեքներ։
Արդյունքում կարող ենք կոդի ուղիները հետևել ուղղակիորեն՝ օգտագործելով մեր IDE-ների պարզ, բայց չափազանց արդյունավետ «go-to definition» հնարավորությունը։
Ամփոփում
Վերը նշված հատկանիշներից ոչ մեկը ընդհանրապես բացառապես Scala-ին բնորոշ չէ։ Ինչը այդքան լավ խառնուրդ է ստեղծում, դրանց համադրվելու ձևն է։ Լեզվի նախագծումը ամեն ինչ չէ. լռելյայն արժեքները նույնպես կարևոր են, ինչպես ցույց են տալիս անփոփոխելի տվյալների կառուցվածքները և ստանդարտ գրադարանի անփոփոխելի կոլեկցիաները։
Կանոնավոր, զարմանալիորեն փոքր քերականությունը արտահայտությունների վրա կողմնորոշված լեզվում նոր հնարավորություններ է բերում. օրինակ՝ հասկացությունների սեղմ ներկայացումը որպես արժեքներ։
Կոմպիլյացիան տիպային անվտանգ կոդի գեներացմամբ ընդլայնելը ավելի արդյունավետ, ավելի անվտանգ և ավելի կանխատեսելի է, քան run-time-ում անոտացիաներ մշակելը։
Վերջապես, բացահայտ լինելը այն հարցում, թե ինչ է տեղի ունենում ձեր կոդում, երբ և ինչու, մեր կոդային բազաները դարձնում է ավելի հեշտ ուսումնասիրելի և հասկանալի, նույնիսկ երբ պետք է կողմնորոշվենք գրադարանների տրամադրած ինֆրաստրուկտուրային կոդի մեջ։
Այս ամենը հիմնված է երեք հենասյուների վրա՝ Scala լեզվի, նրա ստանդարտ գրադարանի և համայնքի տրամադրած գրադարանների ու ֆրեյմվորքերի։ Ի՞նչ սկզբունքներ կավելացնեիք այս ցանկին՝ ֆունկցիոնալ ծրագրավորմամբ և Scala-ով կոդ մշակելիս։