Android Rust के बारे में जानकारी

Android प्लैटफ़ॉर्म, Rust में नेटिव ओएस कॉम्पोनेंट डेवलप करने की सुविधा देता है. यह एक आधुनिक सिस्टम-प्रोग्रामिंग भाषा है, जो C/C++ के बराबर परफ़ॉर्मेंस के साथ, मेमोरी की सुरक्षा की गारंटी देती है. Rust, कंपाइल के समय की जांचों के कॉम्बिनेशन का इस्तेमाल करती है, जो ऑब्जेक्ट के लाइफ़टाइम और मालिकाना हक को लागू करती हैं. साथ ही, रनटाइम की जांचों से यह पक्का किया जाता है कि मेमोरी का सही तरीके से ऐक्सेस किया जा रहा है. इससे, गै़रबेज कलेक्टर की ज़रूरत नहीं पड़ती.

Rust में, आधुनिक भाषा की कई सुविधाएं मिलती हैं. इनकी मदद से, डेवलपर अपने कोड को ज़्यादा बेहतर तरीके से लिख सकते हैं और उस पर भरोसा कर सकते हैं:

  • सुरक्षित कॉन्करंट प्रोग्रामिंग - इसकी मदद से, उपयोगकर्ता आसानी से बेहतर और थ्रेड-सेफ़ कोड लिख सकते हैं. इस वजह से, Rust का स्लोगन फ़ियरलेस कॉन्करेंसी है.
  • ज़्यादा जानकारी देने वाला टाइप सिस्टम - Rust, ज़्यादा जानकारी देने वाले टाइप (जैसे, Newtype रैपर और कॉन्टेंट वाले enum वैरिएंट) की अनुमति देकर, लॉजिकल प्रोग्रामिंग बग को रोकने में मदद करता है.
  • कम समय में बेहतर तरीके से जांच करना - कंपाइल करते समय जितनी ज़्यादा गड़बड़ियां पकड़ी जाती हैं, उनसे डेवलपर का यह भरोसा बढ़ता है कि जब कोड सही तरीके से कंपाइल हो जाता है, तो वह उम्मीद के मुताबिक काम करता है.
  • बिल्ट-इन टेस्टिंग फ़्रेमवर्क - Rust में एक बिल्ट-इन टेस्टिंग फ़्रेमवर्क होता है, जहां यूनिट टेस्ट को लागू करने के साथ-साथ रखा जा सकता है. इससे यूनिट टेस्ट को शामिल करना आसान हो जाता है.
  • गड़बड़ी ठीक करने का तरीका (एनफ़ोर्समेंट) - ऐसे फ़ंक्शन जिनके अपडेट नहीं हो पाते, वे नतीजे का टाइप दिखा सकते हैं, जो या तो सही वाला वैरिएंट या गड़बड़ी वाला वैरिएंट होगा. कंपाइलर के लिए ज़रूरी है कि कॉल करने वाले, फ़ंक्शन कॉल से मिले Result enum के गड़बड़ी वाले वैरिएंट की जांच करें और उसे मैनेज करें. इससे, गड़बड़ियों को मैनेज न किए जाने की वजह से होने वाली गड़बड़ियों की संभावना कम हो जाती है.
  • प्रोसेस शुरू करना - Rust का इस्तेमाल करने से पहले, हर वैरिएबल को उसके टाइप के कानूनी सदस्य के लिए शुरू करना ज़रूरी है. इससे, अनजाने में शुरू होने वाले असुरक्षित वैल्यू को शुरू होने से रोका जा सकता है.
  • इंटिजर को सुरक्षित तरीके से मैनेज करना - इंटिजर टाइप के सभी कन्वर्ज़न, साफ़ तौर पर कास्ट किए जाते हैं. डेवलपर, फ़ंक्शन कॉल के दौरान किसी वैरिएबल को असाइन करते समय या अन्य टाइप के साथ अंकगणितीय कार्रवाई करते समय, गलती से कास्ट नहीं कर सकते. Android for Rust में, ओवरफ़्लो की जांच करने की सुविधा डिफ़ॉल्ट रूप से चालू होती है. इसके लिए, ओवरफ़्लो ऑपरेशन साफ़ तौर पर होने चाहिए.

ज़्यादा जानकारी के लिए, Android Rust सहायता पर ब्लॉग पोस्ट की सीरीज़ देखें: