Rust-ի մի քանի գրավիչ հատկություններ JVM/C-ի աչքերով
Rust լեզուն շարունակում է մեծացնել իր popularity-ն։ Այս հոդվածում քննարկվում են Rust-ի մի քանի առանձնահատկություններ, որոնք անմիջապես աչքի են ընկնում։
Ներածություն
Rust լեզուն շարունակում է մեծացնել իր popularity-ն։ Այն կարելի է գտնել տարբեր գործիքներում, Linux միջուկում, Android-ում և այլ համակարգերում։
Rust-ը ստատիկ տիպավորմամբ լեզու է, որը բավական երիտասարդ է (համեմատած, ասենք, C-ի կամ Java-ի հետ)։ Սա և՛ հնարավորություններ է ստեղծում, և՛ դժվարություններ։ Թարմ էկոհամակարգ զրոյից կառուցելը նշանակում է, որ չկա հետընթաց համատեղելիություն պահպանելու կարիք։ Այն կարող է օգտվել այլ հարթակներում կուտակված փորձից և ավելի համարձակ փոփոխություններ անել։
Այս գրառման մեջ կդիտարկենք Rust-ի մի քանի առանձնահատկություններ, որոնք անմիջապես աչքի են ընկնում։
Ոչ մի null!
Շատ լեզուներում null-ները մղձավանջ են։ Java նախագծերում հաճախ դիմում են պաշտպանողական ծրագրավորման՝ ստուգելով յուրաքանչյուր մուտքային արժեք, որ այն անպայման null չէ։ Scala-ում լավագույն պրակտիկան ասում է null-եր չօգտագործել, բայց դրանք դեռ գոյություն ունեն լեզվի մակարդակում՝ JVM-ի և Java գրադարանների հետ փոխգործունակության պատճառով։ Tony Hoarse-ը ALGOL-ում null-ի ներմուծումն անվանել է իր «միլիարդ դոլարանոց սխալը»։ Գրեթե բոլորը, ովքեր աշխատել են Java-ով, գոնե մեկ անգամ հանդիպել են NullPointerException-ի։ Rust-ում դրանք պարզապես չկան։ Յուրաքանչյուր իրավիճակ, որը այլ լեզուները լուծում են null-ով, այստեղ ծածկվում է Option enum-ով։
Immutability՝ լռելյայն
Java-ում փոփոխականները mutable են։ Որոշ նախագծեր final հիմնաբառը ցանում են ամենուր՝ փորձելով դրանք immutable դարձնել, սակայն նույնիսկ դա հաստատուն երաշխիքներ չի տալիս (քանի որ final փոփոխականին վերագրված օբյեկտը դեռ կարող է ունենալ mutable դաշտեր)։ Scala-ում mutability-ն համարվում է վատ պրակտիկա։ Case class-երը և val-երը immutable են, թեև mutability-ն հասանելի է, երբ անհրաժեշտ է։ Rust-ը գնում է նույն ճանապարհով. յուրաքանչյուր փոփոխական immutable է, եթե այլ բան նշված չէ։ Ինչո՞ւ։ Պատասխանը տալիս է մի մեջբերում՝
Immutable օբյեկտը thread-safe է ցանկացած դեպքում։ – Brian Goetz
Երբ mutability-ն իսկապես պետք է, այն կարելի է ստանալ լրացուցիչ modifier-ների միջոցով։
Tooling – կոդի ֆորմատավորում
Rust-ի tooling-ը գալիս է ներկառուցված փաստաթղթերով (Rust book) և կոդի formatter-ով։ Որքան գիտեմ, Java-ում կոդի ֆորմատավորման ստանդարտ չկա։ Scala-ում կա լայնորեն օգտագործվող scalafmt գործիքը, սակայն ոչ բոլոր նախագծերն են այն ընդունում։ Rust-ում ֆորմատավորումը պարզապես toolchain-ի մաս է, ինչը կարող է զգալիորեն հեշտացնել դրա ընդունումը։ Cargo-ն դրանից բացի ներառում է Clippy-ը՝ հզոր Rust linter։
Concurrency հատկություններ
JVM-ի հիշողության մոդելը կախարդական աշխարհ է։ Բացահայտել, թե ինչ է այն և ինչպես է աշխատում, կարող է գլուխ պտտեցնող լինել։ volatile հիմնաբառով concurrent կոդ գրելը դժվար է, և գործողությունների իրական կատարման հերթականությունը հեռու է ակնհայտ լինելուց։ C-ն ևս գործը չի հեշտացնում. race condition-ները և նմանատիպ խնդիրները հաճախակի գլխացավանք են։
Rust-ը սա լուծում է բոլորովին այլ կերպ։ Այն ներմուծում է մի քանի հասկացություն (դրանցից շատերը նախկինում հայտնի էին, բայց բացակայում էին ամենահայտնի լեզուներում)՝ lifetime-ներ, borrowing և immutable reference-ներ։ Միասին վերցրած՝ դրանք թույլ են տալիս compiler-ին ստուգել, որ ձեր կոդը անվտանգ է։ Rust-ը խանգարում է անել այնպիսի բաներ, որոնք կարող են խնդիրներ առաջացնել runtime-ում։
Կախվածությունների մոդել
JVM-ում նախագծի յուրաքանչյուր կախվածություն հայտնվում է նախագծի classpath-ում, և նախագիծը հիմնվում է տվյալ գրադարանի միայն մեկ կոնկրետ տարբերակի վրա։ Կոնֆլիկտի դեպքում հաղթում է ավելի նոր տարբերակը։ Սակայն դա կարող է հանգեցնել runtime սխալների, որոնք հաղորդում են, որ որևէ class կամ մեթոդ չի գտնվել։
Rust-ում Cargo-ն տեղյակ է Semantic Versioning-ից։ Crate-երը, որոնց վրա հիմնվում է ձեր նախագիծը, իրենք կարող են հիմնվել մեկ գրադարանի տարբեր տարբերակների վրա, և compiler-ը դա ձեր փոխարեն լուծում է։ Ավելին, կախվածության rename հնարավորության շնորհիվ կարելի է նույնիսկ նույն գրադարանի երկու տարբերակ բացահայտ օգտագործել սեփական սկզբնական կոդում։
Արտադրողականության հատկություններ
Java-ն առաջարկում է ցիկլերի մի քանի տեսակ, օրինակ՝ դասական for և foreach։ Հիշում եմ հին վեճերը, թե foreach-ն ավելի դանդաղ է։ Բավական նման հոդվածներ հայտնվեցին Java 8-ի շրջանում, երբ եկան lambda-ները։ Rust-ը որոշ չափով այլ վիճակում է։ Նրա closure-ները և iterator-ները իրականացված են այնպես, որ runtime արտադրողականությունը անփոփոխ է մնում։ Rust-ը ձգտում է zero-cost abstraction-ների, որպեսզի ավելի բարդ հնարավորությունները runtime-ում ոչինչ չարժենան և փոխարենը մշակվեն compile ժամանակ։
Եզրակացություններ
Rust-ը հիասքանչ է։ Այն լուծում է JVM աշխարհում սովորաբար հանդիպող մի քանի ցավոտ կետեր, և նրա նախագծային որոշումները ակնհայտ առավելություններ են տալիս, օրինակ, C-ի կամ C++-ի համեմատ։ Այն ամենապարզ լեզուն չէ, բայց անկասկած հզոր է։ Այսօր այն իր տեղն է գտել որպես C-ի փոխարինող մի շարք գործիքներում և համակարգային մակարդակի իրականացումներում։ Rust-ը ծաղկում է, և դրա համար կան նաև բազմաթիվ web ֆրեյմվորքներ։ Այդուհանդերծ, Rust-ով հիմնական web հավելված կառուցելը կարող է ավելի դժվար լինել և ավելի շատ ժամանակ խլել, քան, ասենք, Java-ով։ Եթե ձեզ պետք չէ այն արտադրողականությունը, որը նա առաջարկում է, Java/Scala-ն կարող է միանգամայն բավարար լինել։