गंज: Mozilla तज्ञांकडून नवीन प्रोग्रामिंग भाषेसह कार्य करणे सुरू करणे. रस्ट प्रोग्रामिंग भाषा: उपयुक्तता, दस्तऐवजीकरण, विचारधारा आणि वाक्यरचना रस्ट, प्रोग्रामिंग कोठे सुरू करावे

आत्तापर्यंत तुमच्या लक्षात आले असेल की प्रश्नातील प्रोग्रामिंग भाषेचा वाक्यरचना C/C++ सारख्या भाषांच्या वाक्यरचनेशी सारखाच आहे, कारण दोन्ही प्रकरणांमध्ये टिप्पण्या हायलाइट करण्यासाठी दोन स्लॅश वापरले जातात, कोड ब्लॉक्स कुरळे ब्रेसेसने वेढलेले असतात. , आणि फंक्शन वितर्क कंसांनी वेढलेले आहेत. आपण हे देखील लक्षात ठेवले पाहिजे की फंक्शन्स वापरून घोषित केले जातात कीवर्ड fn , आणि प्रत्येक प्रोग्राममध्ये main() फंक्शन असणे आवश्यक आहे. उद्गारवाचक चिन्हफंक्शनच्या नावानंतर, या प्रकरणात println हे सूचित करते की मॅक्रो वापरला जात आहे (मूलत: Rust रनटाइम लायब्ररीमधील प्रिंट फंक्शनभोवती एक सोयीस्कर रॅपर).

प्रोग्राम संकलित करण्यासाठी, फक्त कमांड चालवा:

Rustc hello.rs

परिणामी, hello नावाची बायनरी फाइल प्रोग्राम सोर्स कोड फाइलसह दिसली पाहिजे, ती कार्यान्वित करण्यासाठी, फक्त कमांड./hello चालवा; परंतु आपण या फाईलच्या आकाराकडे लक्ष दिल्यास, आपल्याला काहीसे धक्का बसेल: ते 800 KB पेक्षा जास्त असेल. आणि एवढ्या साध्या कार्यक्रमासाठी हे सर्व आवश्यक आहे का? बरं, डीफॉल्टनुसार, रस्ट कंपाइलर बहुतेक रनटाइम लायब्ररींना प्रोग्रामशी स्थिरपणे लिंक करतो, त्यामुळे तुम्ही बायनरी अशा सिस्टमवर कॉपी करू शकता ज्यामध्ये रस्ट रनटाइम लायब्ररी स्थापित नाहीत आणि कोणत्याही समस्यांशिवाय ते चालवू शकता. तथापि, तुम्ही कंपाइलरला ऑप्टिमायझेशन आणि डायनॅमिक लिंकिंग करण्यास सांगू शकता:

Rustc -O C prefer-dynamic hello.rs

तुम्हाला आता 8 KB चा अधिक आटोपशीर बायनरी आकार मिळेल, परंतु तुम्ही ldd वापरल्यास तुम्हाला ते सापडेल योग्य ऑपरेशनप्रोग्रामला सिस्टममध्ये डायनॅमिक लायब्ररी libstd- ची उपस्थिती आवश्यक आहे<версия>.तर .

प्रोग्रामिंग भाषा वाक्यरचना

आता आम्ही रस्टमध्ये प्रोग्राम संकलित आणि चालवू शकतो, मी या प्रोग्रामिंग भाषेचा वाक्यरचना समजून घेण्याचा आणि C, C++ आणि इतर तत्सम प्रोग्रामिंग भाषांच्या सिंटॅक्समधील फरक हायलाइट करण्याचा प्रस्ताव देतो:

Fn doubler (x: i32) -> i32 ( x * 2 ) fn main () ( let a: i32 = 5; let b; b = doubler(a); println!("a times 2 ()", b) ; मॅच b ( 1 ... 10 => println!("1 ते 10"), _ => println!("दुसरा क्रमांक"), ) )

तुम्हाला C/C++ भाषांमध्ये काम करण्याची सवय असल्यास, तुम्हाला असे वाटेल हा कोडहे काहीसे विचित्र आहे, परंतु ते अगदी तार्किक आहे. चला main() फंक्शनपासून सुरुवात करूया: पहिल्या ओळीवर आपण ३२-बिट इंटीजर व्हेरिएबल a घोषित करू आणि त्यास ५ चे प्रारंभिक मूल्य देऊ. व्हेरिएबलचा प्रकार निर्दिष्ट करणे आपण वगळू शकतो (i32 हा मानक व्हेरिएबल प्रकार आहे) आणि त्यास प्रारंभिक मूल्य देखील नियुक्त करू नका, आणि या प्रकरणात त्यात शून्य मूल्य असेल. लक्षात घ्या की जर तुम्ही व्हेरिएबल घोषित केले आणि उदाहरणामधील व्हेरिएबल a प्रमाणेच विशिष्ट मूल्य नियुक्त केले, तर तुम्ही त्याचे मूल्य नंतर बदलू शकणार नाही, त्यामुळे खालील कोड स्निपेट संकलित करताना एक त्रुटी संदेश तयार केला जाईल:

चला a: i32 = 5; a = 10;

डीफॉल्टनुसार, Rust मधील व्हेरिएबल्स अपरिवर्तनीय असतात, म्हणजे त्यांची मूल्ये सुरुवातीनंतर बदलू शकत नाहीत. तुम्ही अशाच प्रकारे म्युटेबल व्हेरिएबल्स स्पष्टपणे घोषित करणे आवश्यक आहे:

चला mut a: i32 = 5;

याची गरज का आहे? हे अतिरिक्त काम आहे, नाही का? बरं, थोडक्यात हे खरं आहे, पण दुसरीकडे, हे वैशिष्ट्यप्रोग्रामिंग भाषा विकसित होण्यास मदत होते सुरक्षित कार्यक्रम. तुम्ही फक्त व्हेरिएबल्स म्यूटेबल बनवायला हवे ज्यांची व्हॅल्यू बदलणे आवश्यक आहे. प्रोग्राम कसा कार्य करतो हे शक्य तितक्या अचूकपणे वर्णन करण्यासाठी रस्ट तुम्हाला आवश्यक तितके शब्दशः व्हायला भाग पाडते: वरील ओळ भविष्यात त्याचे मूल्य बदलण्याच्या शक्यतेसह, अगदी 32 बिट्सच्या आकाराचे चिन्हांकित पूर्णांक व्हेरिएबल घोषित करते.

पुढे, आपण व्हेरिएबल a सह दुप्पट फंक्शनला त्याचे आर्ग्युमेंट म्हणून कॉल करतो आणि रिटर्न व्हॅल्यू व्हेरिएबल b मध्ये संग्रहित करतो. प्रोग्राम कोडच्या सुरूवातीस असलेल्या डबलर फंक्शनच्या घोषणेकडे लक्ष द्या: ते फंक्शन पॅरामीटरचा प्रकार (i32) आणि -> चिन्हांनंतर रिटर्न व्हॅल्यू (i32) चा प्रकार दर्शवते. हे पाहणे देखील सोपे आहे की फंक्शन एकच ऑपरेशन करते, x * 2 , ज्याचे अनुसरण अर्धविरामाने देखील केले जात नाही, जसे की रस्ट कोडच्या सामान्य ब्लॉकप्रमाणे; काय चाललय तिकडे?

असे दिसून आले की तुम्ही फंक्शनचे मूल्य C मध्ये प्रमाणेच परत करू शकता किंवा फंक्शन कोडच्या शेवटच्या ओळीवर फक्त अभिव्यक्ती ठेवून, जसे या प्रकरणात केले होते. आणि, ही फक्त एक अभिव्यक्ती असल्याने, त्याच्या नंतर अर्धविराम लावण्याची गरज नाही.

चला मुख्य() फंक्शनवर परत जाऊ, जिथे आपण परिणाम प्रिंट करण्यासाठी println!() मॅक्रो वापरला; वर्ण क्रम () वापरून व्हेरिएबलचे मूल्य बदलण्याचे तंत्र लक्षात घ्या. शेवटी, उदाहरण Rust प्रोग्रामिंग भाषेचा अत्यंत उपयुक्त "जुळणारा" कीवर्ड दर्शवितो, जे तुम्हाला मोठ्या संख्येने if/else स्टेटमेंट्स करण्याची आवश्यकता असल्यास कोडचे प्रमाण लक्षणीयरीत्या कमी करू शकते. या प्रकरणात, 1...10 ही मूल्यांच्या श्रेणीची घोषणा आहे (1 ते 10 समावेशी), आणि अंडरस्कोर (_) वर्ण इतर सर्व मूल्यांशी जुळतो.

रस्टमध्ये, चार स्ट्रिंग प्रकार चार-बाइट वर्णांचा वापर करण्यास परवानगी देतो, म्हणजे, कोणतेही युनिकोड वर्ण, आणि याचा अर्थ प्रोग्रामिंग भाषा वेगवेगळ्या भाषांसह कार्य करण्यासाठी डिझाइन स्टेजवर स्वीकारली गेली होती आणि विशेष वर्ण. दुसरा उपयुक्त डेटा प्रकार म्हणजे ट्यूपल, जो विविध प्रकारच्या चलांचा संग्रह आहे:

चला x = (1, 2.0, "हॅलो");

या प्रकरणात, एक पूर्णांक मूल्य, एक फ्लोट मूल्य आणि एक स्ट्रिंग मूल्य समान ट्यूपलमध्ये ठेवले जाते. ही मूल्ये अपरिवर्तनीय आहेत आणि त्याच प्रकारे प्रवेश केला जाऊ शकतो:

Println!("()", x.2);

परिणामी, ट्युपल x च्या तिसऱ्या घटकाचे मूल्य आउटपुट असेल, म्हणजेच "हॅलो" स्ट्रिंग. रेग्युलर ॲरेजच्या बाबतीत, जे Rust मध्ये देखील समर्थित आहेत, tuples च्या घटकांची संख्या शून्य पासून सुरू होते. फंक्शनमधून एकाधिक मूल्ये परत करण्यासाठी तुम्ही ट्युपल्स वापरू शकता:

Fn स्विच(इनपुट: (i32, i32)) -> (i32, i32) ( (input.1, input.0) ) fn main() ( let x = (10, 50); let y = switch(x) ; println!("(), ()", y.0, y.1);

या प्रकरणात, switch() नावाचे फंक्शन दोन 32-बिट पूर्णांक मूल्ये घेते आणि इनपुट व्हेरिएबलमध्ये संग्रहित करते. हे दोन पूर्णांक मूल्यांसह एक ट्युपल देखील मिळवते. हे फंक्शन एक साधी अभिव्यक्ती वापरते जे तुम्हाला ट्यूपलचे घटक स्वॅप करण्यास आणि परिणामी ट्यूपल परत करण्यास अनुमती देते.

main() फंक्शन 10 आणि 50 व्हॅल्यू असलेले x नावाचे ट्युपल तयार करते आणि y नावाचे ट्युपल ज्यामध्ये कॉल टू स्विच() मधून परत आलेली व्हॅल्यू असतात. पुढे, ट्यूपलची मूल्ये फक्त स्क्रीनवर प्रदर्शित केली जातात (50, 10).

सल्ला:जर तुम्हाला रस्टची क्षमता स्वतः एक्सप्लोर करण्यासाठी खाज सुटत असेल, तर आम्ही https://doc.rust-lang.org/book येथे असलेले अधिकृत दस्तऐवज वाचून प्रारंभ करण्याची शिफारस करतो.

ते होते लहान वर्णनरस्ट प्रोग्रामिंग भाषेची वाक्यरचना आणि क्षमता; जर तुम्हाला अधिक जाणून घ्यायचे असेल दिलेली भाषालेखांच्या विशेष मालिकेतून प्रोग्रामिंग, आम्हाला त्याबद्दल कळवा!

rustc कंपाइलरसह खालील उपयुक्तता पुरवल्या जातात:
> rustdoc- Doxygen सारख्या स्त्रोत कोडमधून स्वयंचलितपणे दस्तऐवजीकरण तयार करण्यासाठी उपयुक्तता;
> rustpkg- सुलभ स्थापनेसाठी पॅकेज व्यवस्थापक अतिरिक्त पॅकेजेसआणि ग्रंथालये;
> रस्टी- तथाकथित REPL युटिलिटी (वाच-इव्हल-प्रिंट-लूप). हा मूलत: एक चाचणी दुभाषी आहे जो रस्ट अभिव्यक्ती स्वीकारतो कमांड लाइन, ते अंतर्गत LLVM प्रतिनिधित्वामध्ये संकलित करते, ते कार्यान्वित करते आणि परिणाम मुद्रित करते;
> गंज- एक सार्वत्रिक उपयुक्तता जी इतर उपयुक्तता किंवा पॅरामीटर्सवर अवलंबून कंपाइलर लाँच करते. हे माझ्यासाठी कधीही काम करत नाही.

भाषेवरील सर्व उपलब्ध दस्तऐवज अधिकृत वेबसाइट www.rust-lang.org वर गोळा केले जातात. उपलब्ध तपशीलवार मार्गदर्शक(http://static.rust-lang.org/doc/tutorial.html) - वाक्यरचना, मेमरी मॉडेल, रनटाइम सिस्टीम इ.च्या सर्व बारकाव्यांवरील व्यापक औपचारिक दस्तऐवजीकरण, तसेच अंगभूत कोरवरील दस्तऐवजीकरण ग्रंथालय आणि मानक ग्रंथालय इयत्ता. सर्व कागदपत्रे इंग्रजीत आहेत. रशियन भाषेत कोणतीही वर्तमान सामग्री नाही आणि विद्यमान पुनरावलोकन लेखांपैकी दोन आधीच खूप जुने आहेत.

विचारधारा आणि वाक्यरचना

रस्टचे मेमरी मॉडेल मूळतः शून्य किंवा लटकणारे पॉइंटर्स आणि बफर ओव्हरफ्लोस परवानगी देत ​​नाही. एक पर्यायी कचरा गोळा करणारा आहे जो कोडच्या एका थ्रेडमध्येच काम करतो. भाषेमध्ये लाइटवेट मल्टीटास्किंग आणि संदेशवहन वापरून थ्रेड्समधील संवादासाठी अंगभूत समर्थन आहे. सामायिक मेमरी रस्टमध्ये अजिबात अस्तित्वात नाही. सर्व व्हेरिएबल्स स्टॅक व्हेरिएबल्स, दिलेल्या थ्रेडसाठी हीप व्हेरिएबल्स आणि तथाकथित "एक्स्चेंज" हीप व्हेरिएबल्समध्ये विभागलेले आहेत, जे सर्व थ्रेडद्वारे वाचले जाऊ शकतात, परंतु त्यांच्याद्वारे बदलले जाऊ शकत नाहीत. हे आपोआप डेडलॉक दूर करते, ज्याला मल्टी-थ्रेडेड प्रोग्रामिंगचा त्रास मानला जातो. भाषेचा ABI C शी सुसंगत आहे, म्हणून रस्ट प्रोग्राम्स अतिरिक्त रॅपरशिवाय C मध्ये लिहिलेल्या लायब्ररींशी जोडले जाऊ शकतात. कमी पातळीच्या गरजांसाठी सिस्टम प्रोग्रामिंगआणि C सह सुसंगतता सुनिश्चित करण्यासाठी, पॉइंटरची शुद्धता तपासल्याशिवाय भाषेमध्ये एक विशेष "असुरक्षित" मोड आहे. त्याच्या विचारसरणीमध्ये, रस्ट गो भाषेच्या सर्वात जवळ आहे. गो प्रमाणेच, बहु-थ्रेडेड प्रोग्रामिंगच्या साधेपणावर आणि मोठ्या प्रमाणात ऍप्लिकेशन विकसित करण्याच्या गतीवर मुख्य भर आहे आणि वाक्यरचना देखील काही ठिकाणी असामान्य आणि काहीसे आश्चर्यकारक आहे. त्याच वेळी, रस्ट ही गो सारखी अत्यल्प नाही आणि सिस्टम भाषा असल्याचा दावा करते.

रस्टची वाक्यरचना मुख्यत्वे C आणि C++ कडून घेतली आहे, ज्यामध्ये Go, C#, Haskell, Python आणि Ruby मधील काही कल्पना मिसळल्या आहेत. मी भाषेच्या वाक्यरचनेचे संपूर्णपणे वर्णन करणार नाही, परंतु केवळ सर्वात मनोरंजक संकल्पनांवर लक्ष केंद्रित करेन.

मी रस्टसाठी नवीन आहे, परंतु ती पटकन माझी आवडती प्रोग्रामिंग भाषा बनत आहे. रस्टमध्ये लहान प्रकल्प लिहिताना सहसा कमी अर्गोनॉमिक असते आणि जास्त वेळ लागतो (कमीतकमी माझ्याबरोबर चाकावर), तो प्रोग्राम डिझाइनबद्दल माझ्या विचार करण्याच्या पद्धतीला आव्हान देतो. मी काहीतरी नवीन शिकल्यानंतर कंपाइलरशी माझी लढाई कमी होते.

गंज समुदाय अलीकडेटोकियो लायब्ररी म्हणून कार्यान्वित असिंक्रोनस I/O वर बरेच प्रयत्न केंद्रित केले आहेत. आणि ते छान आहे.

समुदायातील अनेक सदस्य, ज्यांनी वेब सर्व्हर आणि संबंधित गोष्टींसह काम केले नाही, ते आम्हाला काय साध्य करायचे आहे हे स्पष्ट नाही. 1.0 दिवसांत जेव्हा या गोष्टींवर चर्चा झाली तेव्हा मलाही त्याबद्दल अस्पष्ट कल्पना होती, मी यापूर्वी कधीही काम केले नव्हते.

• हे काय आहे - Async I/O?
• कोरुटिन्स म्हणजे काय? कोरुटिन )?
• हलके धागे काय आहेत ( हलके धागे )?

भविष्य काय आहेत?( भविष्य )?

• ते एकत्र कसे बसतात?

फीड डाउनलोड करणारा छोटा प्रोग्राम कसा लिहायचा ते मी तुम्हाला दाखवतो ( अन्न देणे) JSON फॉरमॅटमध्ये, फॉरमॅट केलेल्या स्वरूपात कन्सोलवर नोट्सची सूची पार्स आणि प्रदर्शित करते.

आमच्यासाठी, प्रत्येक गोष्टीचा परिणाम अतिशय संक्षिप्त कोडमध्ये झाला. कसे? कट अंतर्गत पहा.

असुरक्षित कीवर्ड हा रस्ट भाषेच्या डिझाइनचा अविभाज्य भाग आहे. ज्यांना ते परिचित नाही त्यांच्यासाठी, असुरक्षित हा एक कीवर्ड आहे जो, सोप्या भाषेत, टाइप चेकिंगला बायपास करण्याचा एक मार्ग आहे( प्रकार तपासणी) गंज.

असुरक्षित कीवर्डचे अस्तित्व प्रथम अनेकांना आश्चर्यचकित करणारे आहे. खरंच, मेमरी त्रुटींमुळे प्रोग्राम्स क्रॅश होत नाहीत हे रस्टचे वैशिष्ट्य नाही का? जर हे खरे असेल, तर टाईप सिस्टमला बायपास करण्याचा सोपा मार्ग का आहे? हे भाषेच्या रचनेतील त्रुटीसारखे वाटू शकते.

तरीही, माझ्या मते, असुरक्षित हा गैरसोय नाही. किंबहुना तो भाषेचा महत्त्वाचा भाग आहे. असुरक्षित हे एक प्रकारचे एस्केप व्हॉल्व्ह म्हणून कार्य करते - याचा अर्थ असा आहे की आम्ही टाइप सिस्टम सोप्या प्रकरणांमध्ये वापरू शकतो, परंतु तरीही तुम्हाला तुमच्या कोडमध्ये वापरू इच्छित असलेल्या सर्व प्रकारच्या चतुर युक्त्यांना अनुमती देतो. आम्हाला फक्त तुम्ही ही तंत्रे (असुरक्षित कोड) सुरक्षित बाह्य ॲब्स्ट्रॅक्शन्सच्या मागे लपवण्याची आवश्यकता आहे.

ही नोट असुरक्षित कीवर्ड आणि मर्यादित "असुरक्षितता" ची कल्पना सादर करते. खरं तर, ही एक टीप आहे जी मी थोड्या वेळाने लिहू इच्छितो. ती रस्टच्या मेमरी मॉडेलवर चर्चा करते, जे असुरक्षित कोडमध्ये काय केले जाऊ शकते आणि काय केले जाऊ शकत नाही हे निर्दिष्ट करते.

रस्ट नवीन असल्याने मी गोंधळून गेलो होतो विविध प्रकारेस्ट्रिंग प्रतिनिधित्व. रस्ट भाषेबद्दलच्या पुस्तकात संदर्भ आणि कर्ज घेणे नावाचा एक अध्याय आहे, जो तीन वापरतो विविध प्रकारउदाहरणांमध्ये स्ट्रिंग व्हेरिएबल्स: स्ट्रिंग, &स्ट्रिंग आणि &स्ट्रिंग.

चला str आणि String मधील फरकापासून सुरुवात करूया: स्ट्रिंग ही एक्स्टेंसिबल, हीप-अलोकेटेड डेटा स्ट्रक्चर आहे, तर str ही अपरिवर्तनीय, निश्चित-लांबीची स्ट्रिंग आहे. कुठेतरीमनात.

ऑब्जेक्ट ओरिएंटेड भाषांमध्ये प्रोग्राम कसा करायचा हे बऱ्याच प्रोग्रामरना आधीच माहित आहे. रस्ट ही क्लासिक ऑब्जेक्ट-ओरिएंटेड भाषा नाही, परंतु त्यात मूलभूत OOP साधने वापरली जाऊ शकतात.

या लेखात आपण ओओपी शैलीमध्ये रस्टमध्ये कसे प्रोग्राम करावे ते पाहू. आम्ही हे उदाहरण वापरून करू: आम्ही प्रशिक्षण कार्यात वर्गांची पदानुक्रम तयार करू.

आमचे कार्य भौमितिक आकारांसह कार्य करणे आहे. आम्ही त्यांना स्क्रीनवर मजकूर स्वरूपात प्रदर्शित करू आणि त्यांच्या क्षेत्राची गणना करू. आमचा आकार आयताकृती, चौरस, लंबवर्तुळ, वर्तुळ आहे.

गंज ही एक सुंदर भाषा आहे जी इतर अनेक लोकप्रिय भाषांपेक्षा थोडी वेगळी आहे. उदाहरणार्थ, वर्ग आणि वारसा वापरण्याऐवजी, रस्ट स्वतःची वैशिष्ट्य-आधारित प्रकार प्रणाली ऑफर करते. तथापि, माझा असा विश्वास आहे की रस्ट (माझ्यासारखे) सह परिचित असलेले बरेच प्रोग्रामर सामान्यतः स्वीकारल्या जाणाऱ्या डिझाइन पॅटर्नशी अपरिचित आहेत.

या लेखात, मला डिझाइन पॅटर्नवर चर्चा करायची आहे नवीन प्रकार(नवीन प्रकार), तसेच From आणि Into गुण, जे प्रकार रूपांतरणास मदत करतात.

मी अलीकडे डिझाइन पॅटर्न आणि प्रोग्रामिंगमध्ये वापरत असलेल्या तंत्रांबद्दल खूप विचार करत आहे. प्रोजेक्ट एक्सप्लोर करणे आणि परिचित नमुने आणि शैली पाहणे खरोखर छान आहे जे तुम्ही यापूर्वी अनेकदा पाहिले आहे. त्यामुळे प्रकल्प समजून घेणे सोपे होते आणि कामाला गती देणे शक्य होते.

काहीवेळा तुम्ही एका नवीन प्रकल्पावर काम करत आहात आणि तुम्हाला हे लक्षात येते की तुम्ही शेवटच्या प्रकल्पात जसे केले तसे काहीतरी करण्याची गरज आहे. हे कार्यक्षमतेचा भाग किंवा लायब्ररी असू शकत नाही, हे असे काहीतरी असू शकते जे व्यवस्थित मॅक्रो किंवा लहान कंटेनरमध्ये गुंडाळले जाऊ शकत नाही. ही फक्त एक डिझाइन पॅटर्न किंवा स्ट्रक्चरल संकल्पना असू शकते जी समस्या चांगल्या प्रकारे सोडवते.

अशा समस्यांवर अनेकदा लागू केलेला एक मनोरंजक नमुना म्हणजे "फिनाइट स्टेट मशीन". या वाक्यांशाचा नेमका अर्थ काय आहे आणि ते इतके मनोरंजक का आहे हे समजून घेण्यासाठी मी थोडा वेळ घालवण्याचा सल्ला देतो.

खाली रस्ट प्रोग्रामिंग भाषेत हलविणे, कॉपी करणे आणि कर्ज घेण्याचे ग्राफिकल वर्णन आहे. मूलभूतपणे, या संकल्पना रस्टसाठी विशिष्ट आहेत आणि बहुतेक वेळा नवशिक्यांसाठी अडखळत असतात.

गोंधळ टाळण्यासाठी, मी मजकूर कमीत कमी ठेवण्याचा प्रयत्न केला आहे. ही टीप विविध ट्यूटोरियल्सची बदली नाही आणि केवळ त्यांच्यासाठी बनवली आहे ज्यांना विश्वास आहे की दृश्य माहिती समजणे सोपे आहे. जर तुम्ही नुकतेच रस्ट शिकण्यास सुरुवात करत असाल आणि हे चार्ट उपयुक्त वाटले तर, संकल्पनांना बळकट करण्यात मदत करण्यासाठी मी तुमचा कोड समान चार्टसह चिन्हांकित करण्याची शिफारस करतो.

पीयानो संख्या वापरून नैसर्गिक संख्या अंकगणित लागू करणे हे प्रोग्रामिंग शिकवण्याचे एक लोकप्रिय कार्य आहे. त्यांना रस्टमध्ये अंमलात आणणे शक्य आहे की नाही याबद्दल मी विचार करत होतो.

अशा प्रकारे, माझे कार्य टाइप तपासणीसह नैसर्गिक संख्या लिहून जोडणे आहे.

विकिपीडियाच्या मते, "पियानोचे स्वयंसिद्ध नैसर्गिक संख्यांसाठी स्वयंसिद्ध प्रणालींपैकी एक आहेत, इटालियन गणितज्ञ ज्युसेप्पे पियानो यांनी 19 व्या शतकात सादर केले."

आम्हाला त्यापैकी दोनमध्ये स्वारस्य आहे - ज्यासह तुम्ही नैसर्गिक संख्या प्रविष्ट करू शकता आणि वापरू शकता:

• 1 आहे नैसर्गिक संख्या
• नैसर्गिक संख्येनंतर येणारी संख्या देखील नैसर्गिक संख्या आहे.

वापरून गंज मध्ये शब्दशः लिहू:

Nat एकतर शून्य किंवा पुढील नैसर्गिक संख्या आहे.

टिप्पणी: Futures-rs प्रकल्पाची पुनर्रचना करण्यात आली आहे आणि अनेक गोष्टींचे नाव बदलण्यात आले आहे. जेथे शक्य असेल तेथे दुवे अपडेट केले आहेत.

फ्युचर्ससह प्रारंभ करणे

हा दस्तऐवज तुम्हाला रस्टसाठी फ्युचर्स प्रोग्रामिंग भाषा कंटेनर एक्सप्लोर करण्यात मदत करेल, जो फ्यूचर्स आणि थ्रेड्सची शून्य-किंमत अंमलबजावणी प्रदान करतो. फ्युचर्स इतर अनेक प्रोग्रामिंग भाषांमध्ये उपलब्ध आहेत, जसे की C++, Java आणि Scala, आणि फ्यूचर्स कंटेनर या भाषांच्या लायब्ररीतून प्रेरणा घेतात. तथापि, हे अर्गोनॉमिक आहे आणि रस्टमध्ये अंतर्निहित शून्य-किंमत ॲबस्ट्रॅक्शन तत्त्वज्ञानाचे पालन करते, म्हणजे: फ्यूचर्स तयार करण्यासाठी आणि तयार करण्यासाठी कोणत्याही मेमरी वाटपाची आवश्यकता नाही आणि त्यांचे व्यवस्थापन करणाऱ्या कार्यासाठी फक्त एक वाटप आवश्यक आहे. फ्यूचर्स हे रस्टमध्ये असिंक्रोनस, कंपोजेबल, उच्च-कार्यक्षमता I/O साठी आधार बनवण्याच्या उद्देशाने आहेत आणि प्रारंभिक कार्यप्रदर्शन मोजमाप दर्शविते की फ्यूचर्सवर तयार केलेला एक साधा HTTP सर्व्हर खरोखर वेगवान आहे.

हे दस्तऐवजीकरण अनेक विभागांमध्ये विभागलेले आहे:

• "हॅलो, जग!";
• भविष्यातील प्रकार;
• प्रवाह टाइप करा;
• विशिष्ट फ्युचर्स आणि प्रवाह (प्रवाह);
• रिटर्न फ्युचर्स;
• कार्य आणि भविष्य;
• स्थानिक कार्य डेटा.

टिप्पणी: Futures-rs प्रकल्पाची पुनर्रचना करण्यात आली आहे आणि अनेक गोष्टींचे नाव बदलण्यात आले आहे. जेथे शक्य असेल तेथे दुवे अपडेट केले आहेत.

रस्ट इकोसिस्टममधील मुख्य अंतरांपैकी एक जलद आणि कार्यक्षम होता असिंक्रोनस I/O. आमच्याकडे mio लायब्ररीचा भक्कम पाया आहे, पण तो खूप खालच्या पातळीवर आहे: आम्हाला मॅन्युअली स्टेट मशिन्स बनवाव्या लागतात आणि कॉलबॅक जगल करावे लागतात.

आम्हाला अधिक उच्च दर्जाचे काहीतरी हवे आहे, ज्यामध्ये चांगले अर्गोनॉमिक्स आहे, परंतु ते चांगले आहे संमिश्रता, एकत्र काम करणाऱ्या असिंक्रोनस ॲबस्ट्रॅक्शन्सच्या इकोसिस्टमला समर्थन देत आहे. खूप परिचित वाटतं: अंमलबजावणीद्वारे त्याच ध्येयाचा पाठपुरावा केला गेला भविष्य(किंवा वचने) अनेक भाषांमध्ये जे फॉर्ममध्ये सिंटॅक्टिक शुगरला समर्थन देतात async/प्रतीक्षासगळ्यात वरती.

प्रोसेसरद्वारे समर्थित आदिम पूर्णांक प्रकार हे पूर्णांकांच्या अमर्याद संचाचे मर्यादित अंदाजे आहेत जे आपल्याला वास्तविक जीवनात कार्य करण्यासाठी वापरले जातात. हे मर्यादित प्रतिनिधित्व नेहमी "वास्तविक" संख्यांशी जुळत नाही, उदाहरणार्थ 255_u8 + 1 == 0. बर्याचदा प्रोग्रामर या फरकाबद्दल विसरतो, ज्यामुळे सहजपणे बग होऊ शकतात.

रस्ट ही एक प्रोग्रामिंग भाषा आहे जी बग-प्रूफ बनण्याचे उद्दिष्ट ठेवते, त्यातील सर्वात कपटी - मेमरी त्रुटी रोखण्यावर लक्ष केंद्रित करते - परंतु प्रोग्रामरला इतर समस्या टाळण्यास मदत करण्याचा देखील प्रयत्न करते: बग्सकडे दुर्लक्ष केले जात आहे आणि, जसे आपण पाहू, पूर्णांक ओव्हरफ्लो होतो.

लोह बद्दल थोडे

आयरन हे रस्ट प्रोग्रामिंग भाषेत लिहिलेले एक उच्च-स्तरीय वेब फ्रेमवर्क आहे आणि दुसऱ्या सुप्रसिद्ध लायब्ररी, हायपरच्या वर तयार केले आहे. लोह हे सर्व फायद्यांचा लाभ घेण्यासाठी डिझाइन केलेले आहे जे गंज आम्हाला प्रदान करते. लोह त्याच्या कर्नलमध्ये ब्लॉकिंग ऑपरेशन टाळण्याचा प्रयत्न करतो.

तत्वज्ञान

लोह शक्य तितक्या विस्तारण्यायोग्य असण्याच्या तत्त्वावर बांधले गेले आहे. तो स्वतःची कार्यक्षमता वाढवण्यासाठी संकल्पना सादर करतो:

• "मध्यवर्ती" वैशिष्ट्ये - विनंती प्रक्रियेमध्ये एंड-टू-एंड कार्यक्षमता लागू करण्यासाठी वापरली जाते;
• मॉडिफायर्स - सर्वात अर्गोनॉमिक पद्धतीने विनंत्या आणि प्रतिसाद सुधारण्यासाठी वापरले जातात.

लेखाच्या दरम्यान तुम्हाला मॉडिफायर्स आणि इंटरमीडिएट प्रकारांचा मूलभूत भाग परिचित होईल.

प्रकल्प तयार करणे

प्रथम, कमांड वापरून कार्गो वापरून एक प्रकल्प तयार करूया:

संकलित केल्यानंतर, आम्हाला संबंधित एक्झिक्युटेबल फाइल मिळते:

साध्या प्रिंटसाठी 632 किलोबाइट्स?! रस्ट ही सिस्टीम भाषा म्हणून स्थित आहे ज्यामध्ये C/C++ बदलण्याची क्षमता आहे, बरोबर? मग ते का तपासू नये समान कार्यक्रमतुमच्या जवळच्या स्पर्धकाकडे?

आपल्या वातावरणात असा एक व्यापक विश्वास आहे की कचरा गोळा करणाऱ्याचा एक फायदा म्हणजे उच्च-कार्यक्षमता लॉक-फ्री डेटा संरचना विकसित करणे सोपे आहे. मॅन्युअल मेमरी व्यवस्थापन त्यांच्यामध्ये करणे सोपे नाही, परंतु GC ही समस्या सहजपणे सोडवते.

हे पोस्ट दर्शवेल की, रस्ट वापरून, समवर्ती डेटा स्ट्रक्चर्ससाठी मेमरी व्यवस्थापन API तयार करणे शक्य आहे जे:

• GC प्रमाणे लॉक-फ्री डेटा संरचना लागू करणे शक्य करेल;
• मेमरी व्यवस्थापन योजनेच्या गैरवापरापासून स्थिर संरक्षण तयार करते;
• जीसीशी तुलना करण्यायोग्य ओव्हरहेड असेल (आणि अधिक अंदाज करण्यायोग्य).

मी खाली दाखवत असलेल्या चाचण्यांमध्ये, रस्ट सहजपणे लॉक-फ्री रांगांच्या Java अंमलबजावणीला मागे टाकते आणि रस्ट अंमलबजावणी स्वतःच लिहिणे सोपे आहे.

मी नवीन क्रॉसबीम लायब्ररीमध्ये एक युग-आधारित मेमरी पुनर्प्राप्ती योजना लागू केली आहे, जी आता तुमच्या डेटा स्ट्रक्चर्ससह वापरण्यासाठी तयार आहे. या पोस्टमध्ये मी लॉक-फ्री डेटा स्ट्रक्चर्स, युग अल्गोरिदम आणि अंतर्गत रस्ट API बद्दल बोलेन.

मेमरी ऍक्सेस एरर आणि मेमरी लीक या त्रुटींच्या दोन श्रेणी आहेत ज्यांना सर्वात जास्त लक्ष दिले जाते, त्यांच्या घटना रोखण्यासाठी किंवा कमीत कमी कमी करण्यासाठी खूप प्रयत्न केले जातात. जरी त्यांचे नाव समानतेचे सुचवत असले तरी, ते काही मार्गांनी विरोधाभासी आहेत आणि एक समस्या सोडवल्याने आपल्याला दुसरी समस्या सोडवत नाही. व्यवस्थापित भाषांचा व्यापक वापर या कल्पनेला समर्थन देतो: ते मेमरी मुक्त करण्याचे काम हाती घेऊन काही मेमरी प्रवेश त्रुटींना प्रतिबंधित करतात.

सरळ सांगा: मेमरी ऍक्सेस उल्लंघन ही चुकीच्या डेटासह एक प्रकारची कृती आहे आणि मेमरी लीक आहे अनुपस्थितीयोग्य डेटासह काही क्रिया. सारणी स्वरूपात:

प्रोग्रामिंग भाषा शिकण्याबद्दल माझे काही विचार आहेत.

सर्व प्रथम, आम्ही त्याबद्दल चुकीच्या मार्गाने जात आहोत. मला खात्री आहे की तुम्हालाही असेच वाटले असेल. तुम्ही अभ्यास करण्याचा प्रयत्न करत आहात नवीन भाषाआणि त्यामध्ये सर्वकाही कसे कार्य करते हे आपल्याला पूर्णपणे समजत नाही. एक वाक्यरचना एका ठिकाणी आणि दुसरी दुसऱ्या ठिकाणी का वापरली जाते? या सर्व विचित्रता त्रासदायक आहेत आणि शेवटी आपण आपल्या नेहमीच्या भाषेकडे परत येतो.

माझा विश्वास आहे की भाषांबद्दलची आपली धारणा आपल्यावर एक क्रूर विनोद करते. शेवटच्या वेळी तुम्ही नवीन भाषेवर चर्चा केली होती याचा विचार करा. कोणीतरी त्याचा उल्लेख केला आणि कोणीतरी त्याचा वेग, वाक्यरचना किंवा उपलब्ध वेब फ्रेमवर्कबद्दल विचारले.

हे कारवर चर्चा करण्यासारखेच आहे. आपण नवीन UAZ Rybak बद्दल ऐकले आहे? तो किती वेगवान आहे? मी ते तलावाच्या पलीकडे चालवू शकतो का?

जेव्हा आपण भाषांबद्दल अशाच प्रकारे बोलतो, तेव्हा आपला अर्थ असा होतो की त्या परस्पर बदलण्यायोग्य आहेत. गाड्यांप्रमाणे. जर मला लाडा सरांस्क कसे चालवायचे हे माहित असेल तर मी कोणत्याही अडचणीशिवाय UAZ Rybak चालवू शकतो. फरक फक्त वेग आणि डॅशबोर्डचा आहे, बरोबर?

पण PHP कार कशी दिसेल याची कल्पना करा. आता कल्पना करा की लिस्प कार किती वेगळी असेल. कोणते बटण हीटिंग नियंत्रित करते हे शिकण्यापेक्षा एक ते दुसऱ्यामध्ये बदलणे आवश्यक आहे.

टीप: हा लेख वाचक Rust FFI (अनुवाद), endianness आणि ioctl शी परिचित आहे असे गृहीत धरतो.

सी कोडसाठी बाइंडिंग्ज तयार करताना, आम्हाला अपरिहार्यपणे एक संरचनेचा सामना करावा लागेल ज्यामध्ये युनियन असेल. जॉइन्ससाठी रस्टमध्ये अंगभूत समर्थन नाही, म्हणून आम्हाला स्वतःच धोरण बनवावे लागेल. सी मध्ये, युनियन हा एक प्रकार आहे जो संग्रहित करतो वेगळे प्रकारएका मेमरी क्षेत्रातील डेटा. जोडणीला अनुकूल होण्याची अनेक कारणे आहेत, जसे की: पूर्णांक आणि फ्लोटिंग-पॉइंट संख्यांचे बायनरी प्रतिनिधित्व, स्यूडो-पॉलीमॉर्फिझमची अंमलबजावणी आणि बिट्समध्ये थेट प्रवेश. मी स्यूडो-पॉलीमॉर्फिझमवर लक्ष केंद्रित करेन.

गंज लोकप्रियता मिळवत आहे, परंतु अनेकांना अद्याप त्याचे मूल्य आणि कार्ये समजत नाहीत. आम्ही तुम्हाला रस्ट प्रोग्रामिंग भाषेच्या मुख्य फायद्यांबद्दल सांगू.

गंज आणि इतर भाषांमध्ये काय साम्य आहे?

वरील व्याख्यांवर विश्वास ठेवणे कठीण आहे; ते अवास्तव विधानासारखे दिसते, कारण पूर्वी सर्व भाषांनी एक बाजू निवडली: विश्वसनीयता किंवा कार्यप्रदर्शन.

उच्च गतीचा एक उल्लेखनीय प्रतिनिधी आहे, परंतु आपल्या सर्वांना माहित आहे की वाटप केलेल्या मेमरीमध्ये चुकीच्या प्रवेशामुळे किती वेळा त्रुटी दिसून येतात, रिमोट सर्व्हर, आणि कामाच्या परिणामांच्या अप्रत्याशित निष्कर्षांबद्दल सांगण्यासारखे काहीही नाही. एकाधिक लेखन थ्रेड्समुळे, निकालाचा अंदाज लावणे अनेकदा कठीण होते.

विश्वासार्हतेकडे असलेला पक्षपाती भाषेद्वारे उत्तम प्रकारे प्रदर्शित केला जातो हॅस्केल, जे निसर्गात संकलित केले आहे आणि उच्च सुरक्षा कार्यप्रदर्शन प्रदान करते. जे काही संकलित केले जाऊ शकते ते योग्यरित्या कार्य करेल. मुख्य गैरसोय - हे कमी कार्यप्रदर्शन आहे, अशा प्रकल्पाची कल्पना करणे कठीण आहे ज्यामध्ये उच्च गती लिहिणे आवश्यक आहे हॅस्केल.

बाकीचे देखील तटस्थ स्थान, एक विशिष्ट शिल्लक व्यापतात. ते व्यावहारिकतेवर लक्ष केंद्रित करतात.

गंजशोषून घेतले सर्वोत्तम वैशिष्ट्ये C++आणि हॅस्केल, आणि इतर प्रतिस्पर्ध्यांकडून पुरेशी व्यावहारिकता आणि कार्यक्षमता राखण्यात देखील सक्षम होते.

रस्ट भाषेचे सौंदर्य काय आहे?

रस्टची जादूची वैशिष्ट्ये संकलित मूलभूत गोष्टी आणि मालक घटक माहितीद्वारे उपलब्ध करून दिली आहेत ( मालक), एका प्रोग्रामरबद्दल जो फक्त तात्पुरते डीबग करत आहे किंवा त्याने प्रकल्प ताब्यात घेतला आहे ( परिवर्तनीय कर्ज), तसेच सामान्य दर्शकांबद्दल ( अपरिवर्तनीय कर्ज).

मध्ये प्रोग्रामिंग करताना जावाकिंवा C++, तुम्हाला ही माहिती मेमरीमध्ये ठेवावी लागेल, जरी डेटाचा प्रकार काहीसा वेगळा आहे. IN गंजहे भाषा रचना वापरून लागू केले जाते, ही माहितीकंपाइलरला ओळख स्थापित करणे आणि योग्य वर्तन मॉडेल निवडणे सोपे करते. कंपायलरसह, तुम्ही कोडच्या अंमलबजावणीदरम्यान संभाव्य आणि सामान्य समस्या दूर झाल्याची खात्री करू शकता.

या भाषेला थोडा वेगळा दृष्टिकोन आवश्यक आहे. असामान्यता असूनही, अल्गोरिदम अगदी स्पष्ट आणि प्रभावी आहे. आता आम्ही भाषेच्या मूलभूत गोष्टी परिभाषित करू, ज्यामुळे अभ्यास सुरू केल्यावर त्याचा अंत होऊ शकतो:

1. वारसा प्रणाली पूर्णपणे काढून टाकली गेली आहे आणि त्यास पुनर्स्थित करण्यासाठी क्षमता वापरली जातात, अधिक तपशील वैशिष्ट्ये.
2. पॉइंटर केवळ कोडमध्ये उपस्थित असतात ज्याच्या अधीन नाही अतिरिक्त संरक्षण, म्हणजे, unsafe() फंक्शनच्या आत. त्यांना पुनर्स्थित करण्यासाठी, सुरक्षित कोड संदर्भ वापरतात जे विद्यमान वस्तूंना योग्य पॉइंटर प्रदान करतात.
3. जर लिंक स्थिर असेल आणि विशिष्ट घटकाकडे निर्देश करत असेल, उदाहरणार्थ, अपरिवर्तनीय कर्ज = &ऑब्जेक्ट, तो दुवा मरत नाही तोपर्यंत कोणत्याही वापरकर्त्याद्वारे ते सुधारित केले जाऊ शकत नाही.
4. बदलण्यायोग्य कर्ज = &mut ऑब्जेक्ट लिंक असल्यास, लिंकच्या संपूर्ण आयुष्यभर सामग्री इतर कोणत्याही वापरकर्त्याद्वारे वाचली जाऊ शकत नाही.
5. डेव्हलपर मॅक आणि *निक्स प्लॅटफॉर्मवर लक्ष केंद्रित करतात, यामुळे ते सिस्टमवर कार्य करते खिडक्याकेवळ GNU वातावरण वापरून शक्य आहे.

अगदी महत्वाचे लक्ष्य प्रेक्षक, रस्ट भाषेमध्ये बऱ्यापैकी सक्रिय समुदाय आहे, संप्रेषण आणि शिक्षणाची विकसित प्रणाली आहे. आम्ही IRC चॅनल किंवा Reddit ला भेट देण्याची शिफारस करतो. आधी आजआधीच लिहिले गेले आहे, आणि त्यापैकी बहुतेक अजूनही सतत विकसित केले जात आहेत, त्यांचे प्रकल्प GitHub वर आढळू शकतात.

ग्राफिक्स आणि गेम तयार करण्याचा मार्ग स्वीकारलेल्या विकसकांमध्ये भाषा सर्वात लोकप्रिय आहे. एक पूर्ण विकसित ऑपरेटिंग सिस्टम तयार करण्यासाठी विकास देखील आहेत, परंतु ते अद्याप विकसित केले जात आहेत. नजीकच्या भविष्यात, क्लायंट प्रोग्राम आणि वेब सर्व्हर लिहिण्याची शक्यता आहे. वरील सर्व कार्ये पूर्णपणे रस्टच्या क्षमतेमध्ये आहेत.

मुख्य, आणि कदाचित एकमेव, कमतरता म्हणजे त्याचा अत्यधिक सक्रिय विकास. नवीन आवृत्त्या रिलीझ झाल्यामुळे, वाक्यरचना काही प्रमाणात बदलते आणि नवीन क्षमतांशी जुळवून घेण्यासाठी वेळोवेळी वर्तन आणि विकासाचे तर्क बदलण्याची आवश्यकता असते. रस्ट-1.0 रिलीज होईपर्यंत काही काळ परिस्थिती कायम राहील.

नियमित स्तंभ " गंज मध्ये या आठवड्यात", जी लिंकवर Rust "n Stuffs मध्ये आढळू शकते, तेथे नेहमी पूर्वीच्या आणि भूतकाळातील बदलांबद्दल तसेच भाषेच्या विकासाच्या संभाव्यतेबद्दल माहिती असते.

आम्हाला "गंज भाषेची टीका आणि का C/C++ कधीही मरणार नाही" हा लेख आवडला. आम्ही लेखाचे इंग्रजीत भाषांतर करून आमच्या ब्लॉगवर प्रकाशित करू असे लेखकाला सुचवले. त्याने सहमती दर्शविली आणि आम्हाला हा लेख रशियन भाषेत सादर करण्यात आनंद झाला इंग्रजी भाषा. मूळ लेख स्थित आहे.

मूळ लेख पोस्ट केला आहे (रशियन भाषेत मजकूर). लेख आमच्या ब्लॉगवर लेखकाच्या कराराने प्रकाशित झाला.

टीप: खालील मध्ये, मी असे गृहीत धरत आहे की रस्ट हा एक जलद आणि सुरक्षित भाषा बनवण्याचा प्रयत्न आहे. शेवटी, मोझीला लोकांनी ते ब्राउझर इंजिन डेव्हलपमेंट टूल म्हणून बनवले. जर ही दुसरी सुरक्षित भाषा असेल तर आपल्याला काहीतरी विचित्र मिळते. आधीच डझनभर वेगवेगळ्या सुरक्षित भाषा आहेत, प्रत्येकाला त्यांच्या आवडीनुसार काहीतरी सापडेल. आणि जर C++ बदलण्याचे ध्येय नसेल, तर (1) भाषेत असुरक्षित उपसंच का बनवले जाते? (२) भाषेतून हलके प्रवाह काढणे का आवश्यक होते ते सोयीचे नाही का? दुसऱ्या शब्दांत, या प्रकरणात, जे काही घडत आहे त्यास काहीच अर्थ नाही.

जर तुम्ही linux.org.ru फोरम वाचत असाल, तर मी लक्षात घेईन की ही 10 ची यादी नाही. तांत्रिक कारणेनापसंत गंज, ज्याची चर्चा या धाग्यात केली होती. सह स्काईपवरील चर्चेद्वारे दर्शविल्याप्रमाणे प्रिय कॉम्रेड @sum3rman, ही कारणे कशी "तांत्रिक" मानली जावीत याबद्दल एकापेक्षा जास्त मते आहेत. सर्वसाधारणपणे, मी एक विचित्र यादी तयार केली आहे, परंतु मी कदाचित त्यातील काही सर्वात मनोरंजक मुद्दे उद्धृत करण्याचा धोका पत्करेन. खरं तर, इथे बरीच साधी, गैर-तांत्रिक कारणे आहेत.

C/C++ नजीकच्या भविष्यात कोठेही जाणार नाही ही वस्तुस्थिती कोणत्याही शांत मनाच्या व्यक्तीसाठी स्पष्ट आहे. जवळजवळ सर्व डेस्कटॉप अनुप्रयोग, कर्नल कोणीही पुन्हा लिहिणार नाही ऑपरेटिंग सिस्टम, कंपाइलर, गेम आणि ब्राउझर इंजिन, आभासी मशीन, डेटाबेस, आर्काइव्हर्स, ऑडिओ आणि व्हिडिओ कोडेक, इतर अनेक C-लायब्ररी, आणि असेच. हा खूप, खूप वेगवान, डीबग केलेला, वेळ-चाचणी केलेला कोड आहे. ते पुन्हा लिहिणे खूप, खूप महाग, जोखमीचे आहे आणि खरे सांगायचे तर, हे केवळ सर्वात हट्टी रस्ट चाहत्यांच्या विकृत चेतनेमध्येच अर्थपूर्ण आहे.

ठीक आहे, नवीन कोड लिहिताना रस्ट वापरण्याबद्दल काय?

आपण लक्षात ठेवूया की C/C++ “अधिक योग्य” करण्याचा हा पहिला प्रयत्न नाही. चला, उदाहरणार्थ, भाषा डी. 2001 मध्ये दिसली, खूप चांगली भाषा. कोणतीही रिक्त पदे नाहीत, कोणतीही सामान्य विकास साधने नाहीत, विशेषत: उल्लेखनीय यशोगाथा नाहीत. OpenMW प्रकल्प मूळतः D मध्ये लिहिलेला होता, आणि नंतर अचानक त्यांनी C++ मध्ये संपूर्णपणे पुन्हा लिहिण्याचा निर्णय घेतला. विकासकांनी कबूल केल्याप्रमाणे, "महान प्रकल्प, आम्हाला त्यात योगदान देण्यात आनंद होईल, परंतु आम्हाला हा मूर्ख डी माहित नाही आणि आम्हाला जाणून घ्यायचे नाही." विकिपीडियाने अहवाल दिला आहे की डी व्यतिरिक्त, C++ ला एका किंवा दुसऱ्या अंशाने मारण्याचे बरेच प्रयत्न झाले, उदाहरणार्थ, वाला, चक्रीवादळ, लिंबो, बिटसी. अशा भाषा किती जणांनी ऐकल्या असतील?

मला वाटते की आपण इतिहासातून शिकण्याची वेळ आली आहे. जोपर्यंत तुम्ही त्याला सामान्य विकास साधने दाखवत नाही, त्याला काही यशोगाथा सांगता आणि जवळपास राहणारे या भाषेतील डझनभर प्रोग्रामर दाखवत नाही तोपर्यंत एकही समजूतदार व्यक्ती नवीन भाषा प्रोजेक्टमध्ये ड्रॅग करणार नाही. प्रोग्रामर, कदाचित, सर्वात तरुण वगळता, पुढील सर्वात योग्य भाषा शिकण्यात त्यांचा वेळ आणि आरोग्य कधीही वाया घालवणार नाहीत जोपर्यंत तुम्ही त्यांना सामान्य विकास साधने दाखवत नाहीत (रेसरसारखी हस्तकला नाही), काही हजारो तयार लायब्ररी ( "प्रायोगिक", "अस्थिर" आणि असेच नाही), काही यशोगाथा सांगू नका आणि त्यांच्या शहरातील डझनभर रिक्त जागा दाखवू नका. चिकन आणि अंडी समस्या. फार क्वचितच ही समस्या यशस्वीरित्या सोडवली जाऊ शकते (स्काला येथे उदाहरण म्हणून वापरले जाऊ शकते), मुख्यतः काही लोकांकडून वेळ आणि पैसा गुंतवल्यामुळे मोठी कंपनी(Google, Typesafe), काही कारणास्तव भाषा लोकप्रिय करण्यात स्वारस्य आहे.

मी आधीच नमूद केल्याप्रमाणे, केवळ तांत्रिक नसलेली कारणे पुरेसे आहेत. तथापि, पूर्णपणे कुतूहलाच्या बाहेर, ते तेथे नाहीत याची एक सेकंद कल्पना करण्याचा प्रयत्न करूया. मग रस्टमध्ये न लिहिण्याचे कारण नाही? हे देखील किमान एक फार मोठा प्रश्न आहे की बाहेर करते.

C/C++ वर विविध गोष्टींसाठी टीका केली जाते. तसे, ज्यांनी उत्पादनात C++ कोड दुरूनही पाहिलेला नाही अशा लोकांकडून अनेकदा टीका केली जाते. समस्येचे थोडक्यात आणि स्पष्टपणे खालीलप्रमाणे वर्णन केले जाऊ शकते: C++ खूप वेगवान आहे (आणि मेमरी, बॅटरी चार्ज इ.ची मागणी देखील करत नाही), परंतु या अर्थाने सुरक्षित नाही की ते तुम्हाला ॲरेच्या सीमांच्या पलीकडे जाण्याची परवानगी देते, चुकून प्रवेश करते स्मृती मुक्त तुकडे, आणि त्यामुळे पुढे. एका वेळी, या समस्येमुळे Java, C#, Python आणि इतर सारख्या सुरक्षित भाषांचा मोठ्या प्रमाणावर उदय झाला. परंतु असे दिसून आले की या भाषा, C++ च्या तुलनेत, खूप संसाधन-मागणी आहेत आणि त्यांचे इतर तोटे आहेत, उदाहरणार्थ, कचरा संकलनादरम्यान जग थांबणे अपरिहार्य आहे. म्हणून, लोक भाषा C++ प्रमाणे जलद, पण सुरक्षित बनवण्याच्या कार्यात धडपडत आहेत. अशीच एक भाषा म्हणजे रस्ट.

गंज खरोखर सुरक्षित आहे, परंतु दुर्दैवाने, ते वेगवान आहे. लेखनाच्या वेळी, जावा, गो आणि हॅस्केलच्या वेगाशी गंजाची तुलना करता येते:

मला प्रामाणिकपणे आशा आहे की कालांतराने ते कसे तरी ओव्हरक्लॉक केले जाईल, परंतु तोपर्यंत, वेग आणि सुरक्षितता व्यापार-ऑफच्या बाबतीत, ते स्काला किंवा गो पेक्षा जास्त मनोरंजक नाही. एखादी भाषा जलद आणि सुरक्षित करणे शक्य आहे का, किंवा ॲरे सीमा ओलांडल्याबद्दल सतत तपासण्या, सी-लायब्ररीच्या बंधनांभोवती सुरक्षित बंधने, आणि याप्रमाणे कोणतीही भाषा आपोआप C/ पेक्षा 2 पटीने हळू बनवते का, हा प्रश्न अजूनही खुला आहे. C++.

गंज नक्की कशामुळे सुरक्षित होतो? बोललो तर सोप्या शब्दात, तर ही अंगभूत स्थिर कोड विश्लेषक असलेली भाषा आहे. खरोखरच खूप छान स्टॅटिक विश्लेषक जे सर्व ठराविक C++ त्रुटी पकडते, केवळ मेमरी व्यवस्थापनाशी संबंधित नाही तर मल्टीथ्रेडिंग देखील. मी चॅनेलद्वारे दुसऱ्या थ्रेडवर परिवर्तनीय ऑब्जेक्टची लिंक दिली आणि नंतर ही लिंक स्वतः वापरण्याचा प्रयत्न केला - तो संकलित झाला नाही. खरंच मस्त आहे.

असा युक्तिवाद बऱ्याचदा केला जातो की केवळ 10% कोड 90% वेळेत कार्यान्वित केला जातो (ज्यापर्यंत मला समजले आहे, तो पूर्णपणे अंगठ्याचा नियम आहे - मला या विषयावर कोणतेही कठोर संशोधन पटकन सापडले नाही). म्हणून, बहुतेक प्रोग्राम सुरक्षित रस्टमध्ये लिहिले जाऊ शकतात, 10% हॉट कोड असुरक्षित सबसेटमध्ये लिहिलेले आहेत आणि सध्याच्या रस्ट अंमलबजावणीची मंदता ही खरोखर समस्या नाही. ठीक आहे, पण नंतर असे दिसून आले की रस्टची अजिबात गरज नाही, कारण मी Go मध्ये 90% कोड आणि C मध्ये 10% लिहू शकतो. केवळ सिल्व्हर बुलेट साधक आणि स्पर्श नसलेले सिद्धांतवादी केवळ रस्ट वापरतील कारण 100% प्रोग्राम एका भाषेत लिहिता येईल. जरी प्रत्यक्षात या एकाच भाषेच्या दोन बोली आहेत, ज्या जावा प्लस सी किंवा गो प्लस सी च्या संयोजनापेक्षा वेगळ्या नाहीत.

खरं तर, 10:90 नियम अजूनही खोटा आहे. या तर्कानुसार, तुम्ही Java मध्ये 90% WebKit, 90% VirtualBox किंवा 90% GCC पुन्हा लिहू शकता आणि समान परिणाम मिळवू शकता. साहजिकच असे नाही. मुद्दा हा नसला तरी अनेक कार्यक्रमांमध्ये ही वृत्ती खूप वेगळी असते, तर हात पाहा. समजा संपूर्ण प्रोग्राम असुरक्षित C/C++ मध्ये लिहिलेला आहे आणि त्याची अंमलबजावणी करण्याची वेळ, तुलनेने, ०.९*१ (हॉट कोडचा एक छोटा भाग) + ०.१*१ (खूप कोल्ड कोड) = १. आता चला. एका सुरक्षित भाषेतील प्रोग्रॅमशी तुलना करा Si: 0.9*1 + 0.1*2 = 1.1, अंदाजे 10% फरक. हे खूप आहे की थोडे? तुमच्या स्केलवर अवलंबून आहे. Google च्या बाबतीत, काही टक्के देखील लाखो डॉलर्स वाचवू शकतात (पेपरमधील मुद्दा 5 पहा, “उपयोग”). किंवा त्यासह कल्पना करा पुढील अपडेट JVM ला अचानक 10% अधिक संसाधने लागतील! व्याज अमेरिकन पैशात रूपांतरित केल्यावर मिळालेल्या आकृतीमध्ये किती शून्य असतील याचा अंदाज लावायलाही मला भीती वाटते! ज्या कामांमध्ये C आणि C++ वापरले जातात त्यामध्ये 10% भरपूर आहे.

आम्ही मंत्राप्रमाणे “अकाली अनुकूलीकरण हे सर्व वाईटाचे मूळ आहे” असे पुनरावृत्ती करतो. पण जर आपण ते शब्दशः घेतले तर सर्वत्र क्विकसॉर्टऐवजी बबल सॉर्ट वापरूया. आम्हाला निश्चितपणे माहित नाही की या विशिष्ट ठिकाणी कार्यक्रम कमी होईल! काही क्रियांचे सामान्य काउंटर ॲक्टर्स किंवा ट्रान्झॅक्शनल मेमरीमध्ये गुंडाळण्यात काय अर्थ आहे जर तुम्ही ताबडतोब अधिक कार्यक्षम अणू वापरू शकत असाल? आणि सर्वसाधारणपणे, क्षुल्लक प्रकरणांमध्ये, सर्व, सर्व, सर्व व्हेरिएबल्स जबरदस्तीने सुरू करण्यात, अतिरिक्त तपासण्यांचा एक समूह करण्यात काही अर्थ नाही. चला 10% प्रवेग नाही तर 2-5% सह समाप्त करूया. हे देखील अजिबात वाईट नाही, जर त्यासाठी फक्त दोन अतिरिक्त मिनिटे विचार करणे आवश्यक असेल. आणि आम्ही आधीच शोधल्याप्रमाणे, C/C++ मध्ये सोडवलेल्या समस्यांमध्ये, हा एक मोठा फरक असू शकतो! मग, कोण म्हणाले की हॉट स्पॉट शोधणे, कोड पुन्हा लिहिणे (शक्यतो बरेच कोड) आणि ते खरोखर वेगवान आहे हे सिद्ध करणे आगाऊ कामगिरीबद्दल विचार करण्यापेक्षा सोपे आहे?

जर आपण वेग-सुरक्षा ट्रेड-ऑफच्या मुद्द्याकडे दुर्लक्ष केले तर मला भाषेच्या डिझाइनबद्दल देखील प्रश्न आहेत. विशेषतः, पाच प्रकारच्या पॉइंटर्सच्या संदर्भात. एकीकडे, जेव्हा प्रोग्रामर विचार करतो की व्हेरिएबल्स कुठे आहेत, स्टॅकवर किंवा ढीगवर आणि अनेक थ्रेड्स त्यांच्यासोबत एकाच वेळी कार्य करू शकतात किंवा करू शकत नाहीत. पण दुसरीकडे, कल्पना करा की तुम्ही एक प्रोग्राम लिहित आहात, आणि असे दिसून आले की व्हेरिएबल स्टॅकवर नाही तर ढीगवर जगले पाहिजे. तुम्ही बॉक्स वापरण्यासाठी सर्वकाही पुन्हा लिहा. त्यामुळे तुम्हाला समजते की तुम्हाला खरोखर आरसी किंवा आर्कची गरज आहे. तुम्ही पुन्हा लिहा. आणि मग तुम्ही ते स्टॅकवरील नियमित व्हेरिएबलवर पुन्हा लिहा. हे सर्व - हातात सामान्य IDE शिवाय. आणि नियमित खेळ मदत करणार नाहीत. बरं, किंवा फक्त "Vec" च्या शैलीमध्ये >>>", हॅलो, जावा! पण सर्वात दुःखाची गोष्ट म्हणजे कंपायलरला सर्व व्हेरिएबल्सच्या आयुष्याविषयी आधीच माहिती आहे, तो या सर्व बॉक्स, आर्क वगैरे आपोआप आउटपुट करू शकतो. परंतु काही कारणास्तव कामाचा हा भाग हस्तांतरित केला जातो. प्रोग्रामरसाठी val (तिसऱ्या सहस्राब्दीमध्ये!) लिहिणे अधिक सोयीचे असेल, आणि जेथे आवश्यक असेल तेथे स्पष्टपणे बॉक्स किंवा आरसी दर्शवा.

यामुळे, विशेषतः, गंज लागू करण्याची व्याप्ती मोठ्या प्रमाणात संकुचित आहे. त्यांच्या योग्य मनातील कोणीही अशा भाषेत वेब आणि सर्व्हरसाइड लिहिणार नाही. विशेषत: हे लक्षात घेता की ते JVM अंतर्गत समान भाषांवर महत्त्वपूर्ण फायदे प्रदान करत नाही. आणि गो विथ नॉर्मल लाइटवेट थ्रेड्स (फ्युचर्स नाही) या कामांसाठी जास्त आकर्षक दिसतात. फ्युचर्ससह, स्वत: ला पायात गोळी लागू नये म्हणून, आपल्याला अद्याप कार्य कसे करावे हे शिकण्याची आवश्यकता आहे आणि आपण "सुरक्षित भाषा" म्हणता. होय, या भाषांची स्वतःची वैशिष्ट्ये आहेत, जगाला समान स्थान घ्या, परंतु ही समस्या मायक्रो सर्व्हिसेस आणि इतर तंत्रांमध्ये कापून दोन्ही सोडवता येते. आणि हो, कोणीही JavaScript मध्ये Rust चे भाषांतर करणार नाही, AWS मध्ये लेआउटसाठी त्यात स्क्रिप्ट लिहिणार नाही किंवा MongoDB साठी क्वेरी भाषा म्हणून वापरणार नाही. ते Android साठी लिहिण्याची शक्यता देखील नाही, परंतु वेगळ्या कारणास्तव - एकापेक्षा जास्त आर्किटेक्चर आहेत आणि JVM सह ते खूप सोपे आहे. जर तुम्हाला अचानक वाटले की गंज "सर्व कार्यांसाठी योग्य" आहे, तर मला तुमची निराशा करावी लागेल.

बरं, ढिगाऱ्यापर्यंत:

• मॅक्रो हे सामान्य अपवादांच्या अभावामुळे होणाऱ्या अत्याधिक वर्बोसिटीचा बॅकअप आहेत. मी मेटाप्रोग्रामिंगच्या समस्यांबद्दल आधीच लिहिले आहे, विशेषतः, आम्हाला गंजासाठी सामान्य IDE दिसण्याची शक्यता नाही. आणि मला खात्री नाही, परंतु असे दिसते की रस्टमधील मॅक्रोमध्ये नेमस्पेस देखील नाहीत.
• लोक मूर्ख आहेत, आणि कार्गो खरोखरच Crates.io ला बायपास करून थेट git रिपॉझिटरीजमधून पॅकेजेस खेचण्यास प्रोत्साहित करते. परिणामी, एरलांगच्या जगात त्याच्या रबरसह पॅकेजमध्ये समान गोंधळ होण्याची उच्च शक्यता आहे, तसे, गोच्या जगातही अशीच परिस्थिती आहे.
• अनेक नवीन भाषांप्रमाणे, रस्ट सरलीकरणाचा मार्ग घेते. सर्वसाधारणपणे, मला समजले आहे की त्यात सामान्य वारसा आणि अपवाद का नाहीत, परंतु कोणीतरी माझ्यासाठी अशा गोष्टी ठरवते ही वस्तुस्थिती एक अप्रिय नंतरची चव सोडते. C++ प्रोग्रामर काय वापरावे आणि काय वापरू नये या संदर्भात मर्यादा घालत नाही.
• जर आपण सरलीकरणाचा मार्ग अवलंबायचा असेल तर आपण हे सर्व भाषा विस्तार फेकून दिले पाहिजे. अन्यथा, हे दिसून येते की हास्केलच्या जगात प्रत्येक प्रोग्रामर त्याच्या स्वतःच्या बोलीमध्ये लिहितो.
• स्मार्ट पॉइंटर, जर काही असेल तर ते विनामूल्य नसतात आणि कचरा गोळा करण्याच्या वेळेचा अंदाज घेत नाहीत. काही थ्रेडला अचानक खूप खोल डेटा स्ट्रक्चर मुक्त करण्याचा मान मिळाला आहे. तो मृत दुव्यांच्या चक्रव्यूहातून चालत असताना, धीराने त्याच्यावर अवलंबून असलेले धागे मूर्ख बनतात. एरलांगमध्ये त्याच्या लहान गटांसह समान समस्या अस्तित्वात आहे, मी स्वतः एकापेक्षा जास्त वेळा त्याचे निरीक्षण केले आहे. स्मार्ट पॉइंटर्सची देखील स्वतःची समस्या आहे, त्याच मेमरी फ्रॅगमेंटेशन आणि लीक आहेत. मी चक्रीय संरचनेत विकपॉइंटर विसरलो, इतकेच. आणि हे सुरक्षित असल्याचा दावा करणाऱ्या भाषेत. तुम्हाला GC वेळेचा अंदाज हवा असल्यास, एकतर तुमच्या ॲप्लिकेशनच्या लोडखाली असलेल्या वर्तनाचा अभ्यास करा आणि GC वेळ तुम्हाला अनुकूल नसल्यास कारवाई करा (त्याच ऑब्जेक्ट पूल लक्षात ठेवा), किंवा मेमरी मॅन्युअली व्यवस्थापित करा.
• कोणी रस्ट सिमेंटिक्सचे कठोर वर्णन पाहिले आहे का? त्यात किमान मेमरी मॉडेल आहे का? माझ्यासाठी एक "सुरक्षित" भाषा, प्रोग्रामची "योग्यता सिद्ध करणे", जी प्रत्यक्षात अर्थ लावू शकते स्रोतदहा वेगळा मार्ग, हा!
• मी मदत करू शकत नाही पण तुम्हाला पुन्हा एकदा आठवण करून देतो समस्या जवळजवळ नेहमीच लोकांची असते, तंत्रज्ञानाची नाही.. जर तुमच्याकडे खराब C++ कोड आला किंवा Java अचानक मंदावला, तर ते तंत्रज्ञान खराब आहे म्हणून नाही तर ते योग्यरित्या कसे वापरायचे हे तुम्ही शिकलेले नाही. आपण रस्टवर देखील नाखूष असाल, परंतु भिन्न कारणांमुळे. अधिक लोकप्रिय साधने वापरणे आणि आवडते हे शिकणे सोपे होणार नाही का?

सर्वसाधारणपणे, पुढील 5 वर्षांत मी माझा वेळ रस्टपेक्षा C/C++ शिकण्यात घालवतो. C++ - हे एक उद्योग मानक आहे. 30 वर्षांहून अधिक काळ या भाषेत विविध प्रकारच्या समस्यांचे यशस्वीरित्या निराकरण केले गेले आहे. आणि गंज आणि त्यासारखे इतर अस्पष्ट भविष्यासह अनाकलनीय खेळणी आहेत. किमान 2000 च्या दशकापासून C++ च्या आसन्न मृत्यूबद्दल संभाषणे आहेत, परंतु या काळात C/C++ मध्ये लिहिणे कमी झाले नाही. बरेच विरोधी. आणि आम्ही पाहतो की भाषा विकसित होत आहे (C++11, C++14), त्यासाठी नवीन साधने दिसू लागली आहेत (चला CLion आणि Clang लक्षात ठेवूया), आणि फक्त संबंधित रिक्त जागा आहेत.

C++ प्रोग्रॅमर नेहमीच योग्य पगारासह नोकरी शोधू शकतो आणि आवश्यक असल्यास, रस्टमध्ये त्वरीत पुन्हा प्रशिक्षण देऊ शकतो. उलट खूप, खूप संशयास्पद आहे. तसे, नवीन कामाची जागा निवडताना भाषा, जर काही असेल तर, एकमेव आणि निर्णायक घटकापासून दूर आहे. याव्यतिरिक्त, एक अनुभवी C/C++ प्रोग्रामर सहजपणे PostgreSQL किंवा मध्ये शोधू शकतो लिनक्स कर्नल, शक्तिशाली आधुनिक विकास साधने वापरते, आणि त्यांच्याकडे अनेक पुस्तके आणि लेख देखील आहेत (उदाहरणार्थ, OpenGL वर).

तुमचा वेळ आणि आरोग्याची काळजी घ्या, तुम्हाला वाटते तितके तुमच्याकडे नाही!