შესავალი

შენიშვნა: წიგნის ეს გამოცემა იგივეა, რაც The Rust Programming Language, რომელიც ხელმისაწვდომია ნაბეჭდი და ელექტრონული წიგნის ფორმატში No Starch Press-ისგან.

კეთილი იყოს თქვენი მობრძანება წიგნში The Rust Programming Language — შესავალ წიგნში Rust-ის შესახებ. Rust-ის პროგრამირების ენა ეხმარება უფრო სწრაფი და საიმედო პროგრამული უზრუნველყოფის დაწერაში. მაღალი დონის ერგონომიკა და დაბალი დონის კონტროლი ხშირად წინააღმდეგობაშია პროგრამირების ენების დიზაინში; Rust-ი ეჭვქვეშ აყენებს ამ კონფლიქტს. მძლავრი ტექნიკური შესაძლებლობებისა და დეველოპერის შესანიშნავი გამოცდილების ბალანსის მეშვეობით, Rust-ი გაძლევთ საშუალებას აკონტროლოთ დაბალი დონის დეტალები (მაგალითად, მეხსიერების გამოყენება) იმ პრობლემების გარეშე, რომლებიც ტრადიციულად ახლავს ასეთ კონტროლს.

ვისთვის არის განკუთვნილი Rust-ი

Rust-ი იდეალურია მრავალი ადამიანისთვის სხვადასხვა მიზეზის გამო. განვიხილოთ რამდენიმე ყველაზე მნიშვნელოვანი ჯგუფი.

დეველოპერთა გუნდები

Rust-ი მტკიცდება, როგორც პროდუქტიული ინსტრუმენტი დეველოპერთა დიდ გუნდებში თანამშრომლობისთვის, სადაც წევრებს სისტემური პროგრამირების ცოდნის განსხვავებული დონე აქვთ. დაბალი დონის კოდი მიდრეკილია სხვადასხვა ფარული ხარვეზისკენ (bugs), რომელთა დაჭერა ენების უმეტესობაში მხოლოდ ექსპერიმენტული ტესტირებითა და გამოცდილი დეველოპერების მიერ კოდის გულდასმით გადახედვით (code review) არის შესაძლებელი. Rust-ში კომპილატორი ასრულებს “გუშაგის” როლს და უარს ამბობს ასეთი ფარული შეცდომების (მათ შორის Concurrency შეცდომების) შემცველი კოდის კომპილაციაზე. კომპილატორთან ერთად მუშაობით, გუნდს შეუძლია დრო დაუთმოს პროგრამის ლოგიკაზე კონცენტრირებას, ნაცვლად შეცდომების დევნისა.

Rust-ს ასევე შეაქვს თანამედროვე დეველოპერული ინსტრუმენტები სისტემური პროგრამირების სამყაროში:

• Cargo — თანდართული დამოკიდებულებების მენეჯერი (dependency manager) და build ინსტრუმენტი, რომელიც დამოკიდებულებების დამატებას, კომპილაციასა და მართვას მარტივსა და თანმიმდევრულს ხდის მთელ Rust ეკოსისტემაში.
• rustfmt — ფორმატირების ინსტრუმენტი, რომელიც უზრუნველყოფს კოდის ერთიან სტილს დეველოპერებს შორის.
• Rust Language Server — უზრუნველყოფს ინტეგრირებული დეველოპერული გარემოს (IDE) ინტეგრაციას კოდის ავტო-შეავსებისთვის (code completion) და შეცდომების ინლაინ შეტყობინებებისთვის.

ამ და Rust ეკოსისტემის სხვა ინსტრუმენტების გამოყენებით, დეველოპერებს შეუძლიათ იყვნენ პროდუქტიულები სისტემური დონის კოდის წერისას.

სტუდენტები

Rust-ი განკუთვნილია სტუდენტებისთვის და მათთვის, ვინც დაინტერესებულია სისტემური კონცეფციების შესწავლით. Rust-ის გამოყენებით, ბევრმა ადამიანმა ისწავლა ისეთი თემები, როგორიცაა ოპერაციული სისტემების შემუშავება. საზოგადოება ძალიან მიმღებელია და სიამოვნებით პასუხობს სტუდენტების შეკითხვებს. ასეთი წიგნების მეშვეობით, Rust-ის გუნდებს სურთ სისტემური კონცეფციები უფრო ხელმისაწვდომი გახადონ მეტი ადამიანისთვის, განსაკუთრებით მათთვის, ვინც ახალია პროგრამირებაში.

კომპანიები

ასობით კომპანია, დიდი თუ მცირე, იყენებს Rust-ს წარმოებაში (production) სხვადასხვა ამოცანისთვის, მათ შორის Command Line ინსტრუმენტების, ვებ-სერვისების, DevOps ინსტრუმენტების, ჩაშენებული (embedded) მოწყობილობების, აუდიო და ვიდეო ანალიზისა და ტრანსკოდირების, კრიპტოვალუტების, ბიოინფორმატიკის, საძიებო სისტემების, ნივთების ინტერნეტის (IoT) აპლიკაციების, მანქანური სწავლების (machine learning) და Firefox ვებ-ბრაუზერის ძირითადი ნაწილების შესაქმნელად.

ღია კოდის (Open Source) დეველოპერები

Rust-ი არის მათთვის, ვისაც სურს Rust-ის პროგრამირების ენის, საზოგადოების, დეველოპერული ინსტრუმენტებისა და ბიბლიოთეკების შექმნა. ჩვენ ძალიან გაგვიხარდება, თუ თქვენც შეიტანთ წვლილს Rust-ის ენის განვითარებაში.

ადამიანები, რომლებიც აფასებენ სიჩქარესა და სტაბილურობას

Rust-ი არის მათთვის, ვისაც სურს სიჩქარე და სტაბილურობა ენაში. სიჩქარეში ვგულისხმობთ როგორც იმას, თუ რამდენად სწრაფად იშვება Rust-ის კოდი, ასევე იმ სიჩქარეს, რომლითაც Rust-ი გაძლევთ პროგრამების დაწერის საშუალებას. Rust-ის კომპილატორის შემოწმებები უზრუნველყოფს სტაბილურობას ახალი ფუნქციების დამატებისა და რეფაქტორინგის დროს. ეს კონტრასტშია იმ ენების მოწყვლად ძველ (legacy) კოდთან, რომელთაც არ აქვთ ეს შემოწმებები და რომელთა შეცვლაც დეველოპერებს ხშირად ეშინიათ. ნულოვანი ღირებულების აბსტრაქციებისაკენ (zero-cost abstractions) სწრაფვით — მაღალი დონის შესაძლებლობები, რომლებიც კომპილირდება დაბალი დონის კოდში ისე სწრაფად, როგორც ხელით დაწერილი კოდი — Rust-ი ცდილობს, რომ უსაფრთხო კოდი ამავდროულად სწრაფი კოდიც იყოს.

Rust-ის ენას იმედი აქვს, რომ მხარს დაუჭერს ბევრ სხვა მომხმარებელსაც; აქ ნახსენები მხარეები მხოლოდ ზოგიერთი უმსხვილესი დაინტერესებული მხარეა. მთლიანობაში, Rust-ის უდიდესი ამბიციაა აღმოფხვრას კომპრომისები, რომლებსაც პროგრამისტები ათწლეულების განმავლობაში ეგუებოდნენ, უსაფრთხოებისა და პროდუქტიულობის, სიჩქარისა და ერგონომიკის ერთდროულად უზრუნველყოფით. სცადეთ Rust-ი და ნახეთ, მუშაობს თუ არა მისი არჩევანი თქვენთვის.

ვისთვის არის განკუთვნილი ეს წიგნი

ეს წიგნი გულისხმობს, რომ თქვენ დაგიწერიათ კოდი სხვა პროგრამირების ენაზე, თუმცა არ აკეთებს არანაირ დაშვებას იმის შესახებ, თუ რომელ ენაზე. ჩვენ ვეცადეთ მასალა ფართოდ ხელმისაწვდომი გავხადოთ სხვადასხვა პროგრამირების გამოცდილების მქონე ადამიანებისთვის. ჩვენ არ ვხარჯავთ დიდ დროს იმაზე საუბარში, თუ რა არის პროგრამირება ან როგორ უნდა იაზროვნოთ. თუ სრულიად ახალი ხართ პროგრამირებაში, ჯობია წაიკითხოთ წიგნი, რომელიც სპეციალურად პროგრამირების შესავალს ეთმობა.

როგორ გამოვიყენოთ ეს წიგნი

ზოგადად, ეს წიგნი გულისხმობს, რომ მას კითხულობთ თანმიმდევრობით, დასაწყისიდან ბოლომდე. მომდევნო თავები ეფუძნება წინა თავებში განხილულ კონცეფციებს, ხოლო წინა თავები შეიძლება სიღრმისეულად არ განიხილავდნენ კონკრეტულ თემას, მაგრამ დაუბრუნდნენ მას შემდგომ თავში.

ამ წიგნში შეხვდებით ორი ტიპის თავებს: კონცეფციის თავებს და პროექტის თავებს. კონცეფციის თავებში ისწავლით Rust-ის რომელიმე ასპექტს. პროექტის თავებში კი ერთად ავაგებთ მცირე პროგრამებს და გამოვიყენებთ იმას, რაც აქამდე ისწავლეთ. მე-2 თავი, მე-12 თავი და 21-ე თავი არის პროექტის თავები; დანარჩენი კი კონცეფციის თავებია.

პირველი თავი განმარტავს, როგორ დააინსტალიროთ Rust-ი, როგორ დაწეროთ “Hello, world!” პროგრამა და როგორ გამოიყენოთ Cargo — Rust-ის პაკეტების მენეჯერი (package manager) და build ინსტრუმენტი. მე-2 თავი არის პრაქტიკული შესავალი Rust-ში პროგრამის დასაწერად, სადაც ააგებთ რიცხვის გამოცნობის თამაშს. აქ კონცეფციებს განვიხილავთ მაღალ დონეზე, ხოლო შემდგომი თავები მოგაწვდით დამატებით დეტალებს. თუ გსურთ მაშინვე გადახვიდეთ პრაქტიკაზე, მე-2 თავი სწორედ ამისთვისაა. ხოლო თუ განსაკუთრებით პუნქტუალური შემსწავლელი ხართ და გირჩევნიათ ყოველი დეტალი შეისწავლოთ მომდევნო ეტაპზე გადასვლამდე, შეგიძლიათ გამოტოვოთ მე-2 თავი და პირდაპირ გადახვიდეთ მე-3 თავზე, რომელიც ფარავს Rust-ის ისეთ შესაძლებლობებს, რომლებიც წააგავს სხვა პროგრამირების ენების შესაძლებლობებს; შემდეგ კი შეგიძლიათ დაუბრუნდეთ მე-2 თავს, როცა მოგინდებათ იმუშაოთ პროექტზე და გამოიყენოთ შესწავლილი დეტალები.

მე-4 თავში ისწავლით Rust-ის Ownership სისტემას. მე-5 თავი განიხილავს Struct-ებსა და მეთოდებს. მე-6 თავი ფარავს Enum-ებს, match გამოსახულებებს და if let და let...else მართვის ნაკადის კონსტრუქციებს. თქვენ გამოიყენებთ Struct-ებსა და Enum-ებს ინდივიდუალური ტიპების (custom types) შესაქმნელად.

მე-7 თავში ისწავლით Rust-ის მოდულების სისტემას და ექსპორტის წესებს (privacy rules) თქვენი კოდისა და მისი საჯარო პროგრამული ინტერფეისის (API) ორგანიზებისთვის. მე-8 თავი განიხილავს კოლექციების ზოგად მონაცემთა სტრუქტურებს, რომლებსაც სტანდარტული ბიბლიოთეკა უზრუნველყოფს: Vector-ებს, String-ებს და Hash Map-ებს. მე-9 თავი იკვლევს Rust-ის შეცდომების დამუშავების (error-handling) ფილოსოფიასა და ტექნიკას.

მე-10 თავი ღრმად ჩადის Generic-ებში, Trait-ებსა და Lifetime-ებში, რომლებიც გაძლევთ საშუალებას განსაზღვროთ კოდი, რომელიც მიესადაგება მრავალ ტიპს. მე-11 თავი ეძღვნება ტესტირებას, რაც Rust-ის უსაფრთხოების გარანტიების მიუხედავადაც კი აუცილებელია იმის უზრუნველსაყოფად, რომ თქვენი პროგრამის ლოგიკა სწორია. მე-12 თავში ავაგებთ grep Command Line ინსტრუმენტის ფუნქციონალის ნაწილობრივ იმპლემენტაციას, რომელიც ეძებს ტექსტს ფაილებში. ამისთვის გამოვიყენებთ წინა თავებში განხილულ ბევრ კონცეფციას.

მე-13 თავი იკვლევს Closure-ებსა და Iterator-ებს: Rust-ის შესაძლებლობებს, რომლებიც ფუნქციონალური პროგრამირების ენებიდან მოდის. მე-14 თავში უფრო სიღრმისეულად განვიხილავთ Cargo-ს და ვისაუბრებთ საუკეთესო პრაქტიკაზე თქვენი ბიბლიოთეკების სხვებისთვის გასაზიარებლად. მე-15 თავი განიხილავს Smart Pointer-ებს, რომლებსაც სტანდარტული ბიბლიოთეკა უზრუნველყოფს, და Trait-ებს, რომლებიც უზრუნველყოფენ მათ ფუნქციონალს.

მე-16 თავში გავეცნობით კონკურენტული პროგრამირების (concurrent programming) სხვადასხვა მოდელს და ვისაუბრებთ იმაზე, თუ როგორ ეხმარება Rust-ი მრავალ ნაკადში (threads) უშიშრად პროგრამირებას. მე-17 თავში ამას განვავითარებთ Rust-ის Async და Await სინტაქსის, Task-ების, Future-ების და Stream-ების გამოკვლევით, იმ მსუბუქ კონკურენტულ მოდელთან ერთად, რომელსაც ისინი უზრუნველყოფენ.

მე-18 თავი განმარტავს, თუ როგორ შეედარება Rust-ის იდიომები ობიექტზე ორიენტირებული პროგრამირების პრინციპებს, რომლებსაც შეიძლება იცნობდეთ. მე-19 თავი არის ცნობარი Pattern-ებისა და Pattern Matching-ის შესახებ, რომლებიც Rust პროგრამებში იდეების გამოხატვის მძლავრი საშუალებებია. მე-20 თავი შეიცავს საინტერესო გაფართოებულ თემებს, მათ შორის Unsafe Rust-ს, მაკროსებს და მეტს Lifetime-ების, Trait-ების, ტიპების, ფუნქციებისა და Closure-ების შესახებ.

21-ე თავში დავასრულებთ პროექტს, რომელშიც განვახორციელებთ დაბალი დონის მრავალნაკადიანი (multithreaded) ვებ-სერვერის იმპლემენტაციას!

ბოლოს, რამდენიმე დანართი შეიცავს სასარგებლო ინფორმაციას ენის შესახებ უფრო ცნობარისებრ ფორმატში. დანართი A ფარავს Rust-ის საკვანძო სიტყვებს (keywords), დანართი B ფარავს Rust-ის ოპერატორებსა და სიმბოლოებს, დანართი C ფარავს სტანდარტული ბიბლიოთეკის მიერ უზრუნველყოფილ Derivable Trait-ებს, დანართი D ფარავს ზოგერთ სასარგებლო დეველოპერულ ინსტრუმენტს, ხოლო დანართი E განმარტავს Rust-ის გამოცემებს (editions). დანართ F-ში შეგიძლიათ იპოვოთ წიგნის თარგმანები, ხოლო დანართ G-ში განვიხილავთ, თუ როგორ იქმნება Rust-ი და რა არის Nightly Rust-ი.

ამ წიგნის წაკითხვის არასწორი გზა არ არსებობს: თუ გსურთ წინ გადახტომა, მიჰყევით მას! დაბნეულობის შემთხვევაში, შეიძლება მოგიწიოთ წინა თავებში დაბრუნება. მაგრამ გააკეთეთ ის, რაც თქვენთვის მუშაობს.

Rust-ის შესწავლის პროცესის მნიშვნელოვანი ნაწილია იმის სწავლა, თუ როგორ წაიკითხოთ კომპილატორის მიერ გამოტანილი შეცდომების შეტყობინებები: ისინი მიგითითებენ მომუშავე კოდისკენ. ამდენად, ჩვენ მოგაწვდით ბევრ მაგალითს, რომლებიც არ კომპილირდება, იმ შეცდომის შეტყობინებასთან ერთად, რომელსაც კომპილატორი გაჩვენებთ თითოეულ სიტუაციაში. იცოდეთ, რომ თუ შეიყვანთ და გაუშვებთ შემთხვევით მაგალითს, ის შეიძლება არ დაკომპილირდეს! დარწმუნდით, რომ წაიკითხეთ გარშემომყოფი ტექსტი, რათა ნახოთ, არის თუ არა მაგალითი, რომლის გაშვებასაც ცდილობთ, განკუთვნილი შეცდომის გამოსაწვევად. სიტუაციების უმეტესობაში, ჩვენ მიგიყვანთ ნებისმიერი არაკომპილირებადი კოდის სწორ ვერსიამდე. Ferris-იც დაგეხმარებათ იმ კოდის გარჩევაში, რომელიც არ არის განკუთვნილი სამუშაოდ:

Ferris	მნიშვნელობა
	ეს კოდი არ კომპილირდება!
	ეს კოდი იწვევს panic-ს!
	ეს კოდი არ იძლევა სასურველ ქცევას.

სიტუაციების უმეტესობაში, ჩვენ მიგიყვანთ ნებისმიერი არაკომპილირებადი კოდის სწორ ვერსიამდე.

საწყისი კოდი (Source Code)

საწყისი ფაილები, რომლებიდანაც ეს წიგნი გენერირდება, შეგიძლიათ იპოვოთ GitHub-ზე.