क्या प्रोग्राम को मनमाने ढंग से कोड के लिए सुरक्षा का मूल्यांकन करना संभव है?


10

मैं हाल ही में सुरक्षित कोड के बारे में बहुत सोच रहा हूं। सुरक्षित धागा। मेमोरी सुरक्षित। नहीं-जाने-विस्फोट-में-आपका-चेहरा-ए-सेगफॉल्ट सुरक्षित। लेकिन सवाल में स्पष्टता के लिए, चलो हमारे चलते परिभाषा के रूप में रस्ट के सुरक्षा मॉडल का उपयोग करें।

अक्सर, सुरक्षा सुनिश्चित करना एक बड़ी-से-बड़ी समस्या है, क्योंकि रुस्त की आवश्यकता से सिद्ध होने पर unsafe, कुछ बहुत ही उचित प्रोग्रामिंग विचार हैं, जैसे कि संगामिति, जिसे कीवर्ड का उपयोग किए बिना Rust में लागू नहीं किया जा सकता है। unsafe। हालांकि संगामिति ताले, mutexes, चैनलों और स्मृति अलगाव या क्या आपके पास के साथ पूरी तरह सुरक्षित बनाया जा सकता है, इस काम कर की आवश्यकता के बाहर के साथ जंग की सुरक्षा के मॉडल की unsafe, और फिर मैन्युअल रूप से संकलक आश्वस्त है कि, हाँ, मैं जानता हूँ कि "मैं क्या कर रहा हूं यह असुरक्षित दिखता है, लेकिन मैंने गणितीय रूप से साबित कर दिया है कि यह पूरी तरह से सुरक्षित है। "

लेकिन आमतौर पर, यह मैन्युअल रूप से इन चीजों के मॉडल बनाने और साबित करने के लिए आता है कि वे प्रमेय साबित करने वाले के साथ सुरक्षित हैं । एक कंप्यूटर विज्ञान के दृष्टिकोण (यह संभव है) और एक व्यावहारिकता के दृष्टिकोण से (क्या यह ब्रह्मांड के जीवन को लेने जा रहा है), क्या किसी ऐसे कार्यक्रम की कल्पना करना उचित है जो एक मनमाने भाषा में कोड लेता है और मूल्यांकन करता है कि यह "है या नहीं" रस्ट सेफ ”?

कैविट्स :

  • इस पर एक आसान यह इंगित करना है कि कार्यक्रम अनहेल्दी हो सकता है और इसलिए हॉल्टिंग समस्या हमें विफल करती है। मान लीजिए कि पाठक को खिलाया गया कोई भी कार्यक्रम रुकने की गारंटी है
  • जबकि "एक मनमाने भाषा में कोड" लक्ष्य है, मैं निश्चित रूप से जानता हूं कि यह चुने हुए भाषा के साथ कार्यक्रम की परिचितता पर निर्भर करता है, जिसे हम एक के रूप में लेंगे।

2
मनमाना कोड? नहीं, मुझे लगता है कि आप I / O और हार्डवेयर अपवादों के कारण सबसे उपयोगी कोड की सुरक्षा भी साबित नहीं कर सकते ।
तेलस्तीन

7
आप हॉल्टिंग समस्या की अवहेलना क्यों कर रहे हैं? आपके द्वारा बताए गए उदाहरणों में से हर एक, और बहुत से, हाल्टिंग प्रॉब्लम, फंक्शन प्रॉब्लम, राइस के प्रमेय, या किसी भी अन्य कई अनछुए सिद्धांत को हल करने के बराबर साबित हुए हैं: पॉइंटर-सेफ्टी, मेमोरी-सेफ्टी, थ्रेड -सफाई, अपवाद-सुरक्षा, शुद्धता, I / O- सेफ्टी, लॉक-सेफ्टी, प्रोग्रेस गारंटी, आदि। Halting Problem सबसे सरल संभव स्थैतिक गुणों में से एक है जिसे आप संभवतः जानना चाहते हैं, बाकी सब चीजें जो आप सूचीबद्ध करते हैं, वह बहुत कठिन है
जॉर्ग डब्ल्यू मित्तग

3
यदि आप केवल झूठी सकारात्मकता की परवाह करते हैं, और झूठी नकारात्मक स्वीकार करने के लिए तैयार हैं, तो मेरे पास एक एल्गोरिथ्म है जो सब कुछ वर्गीकृत करता है: क्या यह सुरक्षित है? नहीं "
केलथ

आप बिल्कुल समवर्ती कोड लिखने के लिए जंग का उपयोग करने की आवश्यकता नहीं है unsafe। वे कई अलग-अलग तंत्र उपलब्ध हैं, जिसमें सिंक्रोनाइज़ेशन प्राइमेटिव से लेकर अभिनेता से प्रेरित चैनल शामिल हैं।
रबरडक

जवाबों:


8

आखिरकार हम यहां जिस बारे में बात कर रहे हैं वह संकलन समय बनाम रनटाइम है।

संकलित समय त्रुटियां, यदि आप इसके बारे में सोचते हैं, तो अंत में संकलक को यह निर्धारित करने में सक्षम होना चाहिए कि आपके प्रोग्राम में क्या समस्याएं हैं, इससे पहले कि आप इसे चलाएं। यह स्पष्ट रूप से "मनमानी भाषा" संकलक नहीं है, लेकिन मैं जल्द ही उस पर वापस आऊंगा। संकलक, अपने सभी अनंत ज्ञान में, हालांकि हर समस्या को सूचीबद्ध नहीं करता है जो संकलक द्वारा निर्धारित किया जा सकता है। यह आंशिक रूप से इस बात पर निर्भर करता है कि कंपाइलर कितना अच्छा लिखा गया है, लेकिन इसका प्राथमिक कारण यह है कि रनटाइम के दौरान कई अच्छी चीजें निर्धारित की जाती हैं ।

रनटाइम त्रुटियों, जैसा कि आप अच्छी तरह से परिचित हैं कि मैं निश्चित रूप से मैं हूं, किसी भी प्रकार की त्रुटि है जो प्रोग्राम के निष्पादन के दौरान होती है। इसमें शून्य, अशक्त सूचक अपवाद, हार्डवेयर समस्याएँ, और कई अन्य कारकों को विभाजित करना शामिल है।

रनटाइम त्रुटियों की प्रकृति का मतलब है कि आप संकलन समय पर त्रुटियों का अनुमान नहीं लगा सकते हैं। यदि आप कर सकते हैं, वे लगभग निश्चित रूप से संकलन समय पर जाँच की जाएगी। यदि आप यह संकलित कर सकते हैं कि संकलित समय में कोई संख्या शून्य है, तो आप कुछ तार्किक निष्कर्ष निकाल सकते हैं, जैसे कि किसी संख्या को उस संख्या से विभाजित करने के परिणामस्वरूप अंकगणितीय त्रुटि शून्य से विभाजित हो जाएगी।

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

एक और अच्छा उदाहरण नल को भाषा का हिस्सा होने की अनुमति दे सकता है, क्योंकि यदि आप नल की अनुमति देते हैं तो शून्य सूचक अपवाद हो सकते हैं। कुछ भाषाओं ने इस समस्या को पूरी तरह से रोक दिया है, चर को स्पष्ट रूप से घोषित नहीं करने के लिए शून्य मान रखने में सक्षम होने के बिना घोषित किया जा रहा है तुरंत एक मूल्य निर्दिष्ट किया जा रहा है (उदाहरण के लिए कोटलिन को लें)। जब आप एक शून्य पॉइंटर अपवाद रनटाइम त्रुटि को समाप्त नहीं कर सकते, तो आप इसे भाषा की गतिशील प्रकृति को हटाकर होने से रोक सकते हैं। कोटलिन में, आप निश्चित रूप से अशक्त मूल्यों को धारण करने की संभावना को बाध्य कर सकते हैं , लेकिन यह बिना कहे चला जाता है कि यह एक रूपक "खरीदारों से सावधान" है क्योंकि आपको इसे स्पष्ट रूप से इस तरह बताना होगा।

क्या आपके पास वैचारिक रूप से एक संकलक हो सकता है जो हर भाषा में त्रुटियों की जांच कर सकता है? हां, लेकिन यह संभवतः एक क्लूनी और अत्यधिक अस्थिर संकलक होगा, जिसमें आपको अनिवार्य रूप से पहले से तैयार की जा रही भाषा प्रदान करनी होगी। यह आपके कार्यक्रम के बारे में बहुत सी बातें भी नहीं जान सकता है, अब विशिष्ट भाषाओं के लिए संकलक इसके बारे में कुछ खास बातें जानते हैं, जैसे कि हॉल्टिंग समस्या जैसा कि आपने उल्लेख किया है। जैसा कि यह पता चला है, एक अच्छी जानकारी के कई टुकड़े जो किसी कार्यक्रम के बारे में जानने के लिए दिलचस्प हो सकते हैं, चमकना असंभव है। यह साबित हो गया है, इसलिए इसे जल्द ही कभी भी बदलने की संभावना नहीं है।

अपने प्राथमिक बिंदु पर लौटना। विधियाँ स्वचालित रूप से थ्रेड सुरक्षित नहीं हैं। इसका एक व्यावहारिक कारण है, जो यह है कि थ्रेड सुरक्षित तरीके भी थ्रेड के उपयोग नहीं होने पर भी धीमे होते हैं। जंग तय करती है कि वे तरीकों को डिफ़ॉल्ट रूप से थ्रेड को सुरक्षित करके रनटाइम समस्याओं को समाप्त कर सकते हैं, और यह उनकी पसंद है। यह हालांकि एक लागत पर आता है।

यह एक कार्यक्रम की शुद्धता को गणितीय रूप से साबित करने के लिए संभव हो सकता है, लेकिन यह कैविएट के साथ होगा कि आपके पास भाषा में सचमुच शून्य रनटाइम विशेषताएं होंगी। आप इस भाषा को पढ़ सकेंगे और जान पाएंगे कि यह बिना किसी आश्चर्य के क्या करता है। भाषा शायद प्रकृति में बहुत गणितीय दिखेगी, और संभवत: वहाँ कोई संयोग नहीं है। दूसरा चेतावनी यह है कि रनटाइम त्रुटियां अभी भी होती हैं, जिसका कार्यक्रम से कोई लेना-देना नहीं है। इसलिए, प्रोग्राम को सही साबित किया जा सकता है, यह माना जा रहा है कि कंप्यूटर के बारे में मान्यताओं की एक श्रृंखला सही है और बदल नहीं है, जो निश्चित रूप से हमेशा किसी भी तरह और अक्सर होता है।


3

प्रकार प्रणाली शुद्धता के कुछ पहलुओं के स्वतः साक्ष्य प्रमाण हैं। उदाहरण के लिए, रस्ट का प्रकार सिस्टम यह साबित कर सकता है कि एक संदर्भ संदर्भित ऑब्जेक्ट को रेखांकित नहीं करता है, या यह कि संदर्भित ऑब्जेक्ट को किसी अन्य थ्रेड द्वारा संशोधित नहीं किया गया है।

लेकिन टाइप सिस्टम काफी प्रतिबंधित हैं:

  • वे जल्दी से गिरावट की समस्याओं में भाग जाते हैं। विशेष रूप से, टाइप सिस्टम ही निर्णायक होना चाहिए, फिर भी कई व्यावहारिक प्रकार की प्रणालियां गलती से ट्यूरिंग कम्प्लीट (सी + + सहित टेम्प्लेट्स और रूस्ट के कारण लक्षण) होती हैं। साथ ही, जिस प्रोग्राम को वे सत्यापित कर रहे हैं, उसके कुछ गुण सामान्य मामले में अनिर्दिष्ट हो सकते हैं, सबसे प्रसिद्ध यह कि क्या कुछ प्रोग्राम रुकता है (या डायवर्ज)।

  • इसके अतिरिक्त, टाइप सिस्टम जल्दी से चलना चाहिए, आदर्श रूप से रैखिक समय में। सभी प्रमाण जो संभव नहीं हैं, उन्हें टाइप सिस्टम में चित्रित किया जाना चाहिए। उदाहरण के लिए पूरे कार्यक्रम के विश्लेषण को आमतौर पर टाला जाता है, और साक्ष्यों को एकल मॉड्यूल या फ़ंक्शंस में स्कैन किया जाता है।

इन सीमाओं के कारण, टाइप सिस्टम केवल काफी कमजोर गुणों को सत्यापित करते हैं जो साबित करना आसान है, जैसे कि एक फ़ंक्शन को सही प्रकार के मूल्यों के साथ कहा जाता है। फिर भी यह काफी हद तक स्पष्टता को सीमित करता है, इसलिए वर्कअराउंड होना आम है (जैसे interface{}कि गो में, dynamicसी # में, Objectजावा में, void*सी में) या यहां तक ​​कि ऐसी भाषाओं का उपयोग करने के लिए जो पूरी तरह से स्थैतिक टाइपिंग को दूर करती हैं।

हम जितने मजबूत गुणों की पुष्टि करते हैं, भाषा उतनी ही कम अभिव्यक्त होती है। यदि आपने रस्ट लिखा है, तो आप इन "कंपाइलर के साथ लड़ रहे हैं" क्षणों को जान पाएंगे, जहां कंपाइलर सही कोड को अस्वीकार करता है, क्योंकि यह शुद्धता साबित करने में सक्षम नहीं था। कुछ मामलों में, रूस्ट में एक निश्चित कार्यक्रम को व्यक्त करना संभव नहीं है , यहां तक ​​कि जब हम मानते हैं कि हम इसकी शुद्धता साबित कर सकते हैं। unsafeजंग या सी # में तंत्र आप प्रकार प्रणाली के दायरे से बचने के लिए अनुमति देता है। कुछ मामलों में, रनटाइम के लिए चेक डिफर करना एक और विकल्प हो सकता है - लेकिन इसका मतलब है कि हम कुछ अमान्य कार्यक्रमों को अस्वीकार नहीं कर सकते। यह परिभाषा का विषय है। एक जंग कार्यक्रम जो कि प्रकार प्रणाली का संबंध है, जहां तक ​​पैनिक सुरक्षित है, लेकिन जरूरी नहीं कि प्रोग्रामर या उपयोगकर्ता के दृष्टिकोण से।

भाषाओं को उनके प्रकार के सिस्टम के साथ डिजाइन किया गया है। यह दुर्लभ है कि एक मौजूदा भाषा पर एक नया प्रकार सिस्टम लगाया जाता है (लेकिन उदाहरण के लिए MyPy, Flow, या टाइपस्क्रिप्ट देखें)। भाषा उस कोड को लिखना आसान बनाने की कोशिश करेगी जो टाइप सिस्टम के अनुरूप हो, जैसे कि टाइप एनोटेशन देकर या नियंत्रण प्रवाह संरचनाओं को साबित करने के लिए आसान पेश करके। विभिन्न भाषाएं अलग-अलग समाधानों के साथ समाप्त हो सकती हैं। उदाहरण के लिए, जावा के finalवैरिएबल की अवधारणा है जो रुस्ट के नॉन- mutवैरिएबल्स के समान ही एक बार सौंपी गई है:

final int x;
if (...) { ... }
else     { ... }
doSomethingWith(x);

जावा के पास यह निर्धारित करने के लिए सिस्टम नियम हैं कि क्या सभी रास्ते चर को असाइन करते हैं या चर को एक्सेस करने से पहले फ़ंक्शन को समाप्त कर सकते हैं। इसके विपरीत, रूस्ट घोषित-लेकिन-अनिर्दिष्ट चर नहीं होने के कारण इस प्रमाण को सरल बनाता है, लेकिन आपको नियंत्रण प्रवाह बिंदुओं से मान वापस करने देता है:

let x = if ... { ... } else { ... };
do_something_with(x)

यह वास्तव में मामूली बिंदु की तरह दिखता है जब असाइनमेंट का पता चलता है, लेकिन आजीवन संबंधित सबूत के लिए स्पष्ट स्कूपिंग बेहद महत्वपूर्ण है।

अगर हम जावा में एक रस्ट-स्टाइल प्रकार प्रणाली लागू करने के लिए थे, तो हमें इसकी तुलना में बहुत बड़ी समस्याएं होंगी: जावा ऑब्जेक्ट को जीवनकाल के साथ एनोटेट नहीं किया जाता है, इसलिए हमें उनके साथ &'static SomeClassया जैसा व्यवहार करना होगा Arc<dyn SomeClass>। यह किसी भी परिणामी सबूत को कमजोर करेगा। जावा में अपरिवर्तनीयता की कोई भी प्रकार-स्तरीय अवधारणा नहीं है, इसलिए हम &और &mutप्रकारों के बीच अंतर नहीं कर सकते हैं । हमें सेल या म्यूटेक्स के रूप में किसी भी वस्तु का इलाज करना होगा, हालांकि यह जावा की तुलना में मजबूत गारंटी देता है जो वास्तव में प्रदान करता है (जावा क्षेत्र को बदलना जब तक कि सिंक्रनाइज़ और अस्थिर नहीं है)। अंत में, रस्ट को जावा-शैली कार्यान्वयन विरासत की कोई अवधारणा नहीं है।

टीएल; डीआर: टाइप सिस्टम प्रमेय सिद्ध करने वाले हैं। लेकिन वे निर्णायक समस्याओं और प्रदर्शन की चिंताओं से सीमित हैं। आप बस एक प्रकार की प्रणाली नहीं ले सकते हैं और इसे एक अलग भाषा में लागू कर सकते हैं, क्योंकि लक्ष्य की भाषा वाक्य रचना आवश्यक जानकारी प्रदान नहीं कर सकती है, और क्योंकि शब्दार्थ असंगत हो सकता है।


3

कितना सुरक्षित है?

हां, इस तरह के एक सत्यापनकर्ता को लिखना लगभग संभव है: आपके कार्यक्रम को निरंतर UNSAFE वापस करना होगा। आप समय का सही 99% होगा

क्योंकि यदि आप एक सुरक्षित जंग कार्यक्रम चलाते हैं, तो भी कोई इसके निष्पादन के दौरान प्लग खींच सकता है: इसलिए आपका कार्यक्रम भले ही सैद्धांतिक रूप से न माना जाए, तब भी रुक सकता है।

और यहां तक ​​कि अगर आपका सर्वर एक बंकर में फैराडे पिंजरे में चल रहा है, तो एक पड़ोसी प्रक्रिया एक पंक्तिबद्ध शोषण को अंजाम दे सकती है और आपके कथित सुरक्षित रस्ट कार्यक्रम में से एक में थोड़ा सा फ्लिप कर सकती है।

जो मैं कहने की कोशिश कर रहा हूं, वह यह है कि आपका सॉफ्टवेयर एक निर्धारक वातावरण में चलेगा और कई बाहरी कारक निष्पादन को प्रभावित कर सकते हैं।

मजाक अलग, स्वचालित सत्यापन

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

इस तरह का विश्लेषण अनुकूलन के लिए कुछ संकलक द्वारा किए गए तरीके से भी होता है।

यह निश्चित रूप से एक कदम आगे जाना संभव है, और संगामिति का विश्लेषण भी करता है, और कई थ्रेड्स, सिंक्रनाइज़ेशन और रेसिंग स्थितियों में बाधाओं के प्रसार के बारे में कटौती करता है। हालाँकि, बहुत जल्दी आप निष्पादन पथों के बीच दहनशील विस्फोट की समस्या में भाग लेंगे, और कई अज्ञात (I / O, OS शेड्यूलिंग, उपयोगकर्ता इनपुट, बाहरी कार्यक्रमों का व्यवहार, रुकावट, आदि) जो उनके नंगे करने के लिए ज्ञात बाधाओं को कम कर देंगे। न्यूनतम और मनमाने कोड पर किसी भी उपयोगी स्वचालित निष्कर्ष बनाना बहुत मुश्किल है।


1

ट्यूरिंग समस्या पर ट्यूरिंग ने अपने कागज के साथ 1936 में इसे वापस संबोधित किया। परिणामों में से एक यह है कि, बस यह कि एल्गोरिथ्म लिखना असंभव है कि समय का 100% कोड का विश्लेषण कर सकता है और सही ढंग से निर्धारित कर सकता है कि यह रुक जाएगा या नहीं, एल्गोरिथ्म लिखना असंभव है जो कि 100% समय सही ढंग से हो सकता है निर्धारित करें कि क्या कोड में कोई विशेष संपत्ति है या नहीं, जिसमें "सुरक्षा" शामिल है, हालांकि आप इसे परिभाषित करना चाहते हैं।

हालाँकि, ट्यूरिंग के परिणाम से ऐसे कार्यक्रम की संभावना नहीं रहती है जो 100% समय या तो (1) बिल्कुल निर्धारित कोड सुरक्षित हो, (2) बिल्कुल निर्धारित करता है कि कोड असुरक्षित है, या (3) मानवजनित रूप से अपने हाथों को फेंक दें और कहें "बिल्ली, मुझे नहीं पता।" आम तौर पर बोलना, रस्ट का संकलक इस श्रेणी में है।


तो जब तक आपके पास "सुनिश्चित नहीं" विकल्प है, हाँ?
theEnvironmentalist

1
Takeaway यह है कि कार्यक्रम-विश्लेषण कार्यक्रम को भ्रमित करने में सक्षम प्रोग्राम लिखना हमेशा संभव होता है। पूर्णता असंभव है। व्यावहारिकता संभव हो सकती है।
नोवाडेनिज़ेन

1

यदि कोई कार्यक्रम कुल है (एक कार्यक्रम के लिए तकनीकी नाम जो रुकने की गारंटी है), तो यह पर्याप्त संसाधनों को दिए गए कार्यक्रम पर किसी भी मनमानी संपत्ति को साबित करने के लिए सैद्धांतिक रूप से संभव है। आप बस हर संभावित स्थिति का पता लगा सकते हैं जो कार्यक्रम में प्रवेश कर सकता है, और जांच सकता है कि उनमें से कोई भी आपकी संपत्ति का उल्लंघन करता है। TLA + मॉडल जाँच भाषा, इस दृष्टिकोण का एक संस्करण का उपयोग करता है बल्कि सभी राज्यों की गणना की तुलना में, संभावित कार्यक्रम राज्यों के सेट के खिलाफ अपने गुण की जाँच करने के सिद्धांत सेट का उपयोग।

तकनीकी रूप से, किसी भी व्यावहारिक भौतिक हार्डवेयर पर निष्पादित कोई भी कार्यक्रम या तो कुल है, या एक सिद्ध लूप है, इस तथ्य के कारण कि आपके पास सीमित मात्रा में ही स्टोरेज उपलब्ध है, इसलिए केवल एक सीमित संख्या में राज्यों में कंप्यूटर हो सकता है (कोई भी व्यावहारिक) कंप्यूटर वास्तव में एक परिमित अवस्था मशीन है, ट्यूरिंग पूर्ण नहीं है, लेकिन राज्य का स्थान इतना बड़ा है कि यह दिखावा करना आसान है कि वे पूर्ण हो रहे हैं)।

इस दृष्टिकोण के साथ समस्या यह है कि इसमें कार्यक्रम की भंडारण और आकार की मात्रा के लिए घातीय जटिलता है, इसे एल्गोरिदम के मूल के अलावा और कुछ के लिए अव्यावहारिक है, और संपूर्णता में महत्वपूर्ण कोड आधारों पर लागू करना असंभव है।

इसलिए शोध का अधिकांश हिस्सा प्रमाणों पर केंद्रित है। करी-हावर्ड पत्राचार बताता है कि शुद्धता का प्रमाण और एक प्रकार की प्रणाली एक और एक ही बात है, इसलिए अधिकांश व्यावहारिक अनुसंधान प्रकार प्रणालियों के नाम से जाते हैं। इस चर्चा के लिए विशेष रूप से प्रासंगिक Coq और Idriss हैं, जंग के अलावा जो आपने पहले ही उल्लेख किया है। Coq दूसरी दिशा से अंतर्निहित इंजीनियरिंग समस्या से संपर्क करता है। कोक भाषा में मनमाने कोड की शुद्धता का प्रमाण लेते हुए, यह कोड उत्पन्न कर सकता है जो सिद्ध किए गए कार्यक्रम को निष्पादित करता है। इस बीच इदरीस भाषा जैसे शुद्ध हास्केल में मनमाने कोड को साबित करने के लिए एक आश्रित प्रकार की प्रणाली का उपयोग करता है। ये दोनों भाषाएं लेखक पर एक व्यावहारिक प्रमाण उत्पन्न करने की कठिन समस्याओं को बढ़ाती हैं, जिससे टाइप-चेकर को प्रमाण की जांच करने पर ध्यान केंद्रित करने की अनुमति मिलती है। प्रमाण की जाँच एक बहुत सरल समस्या है, लेकिन इससे भाषाओं को काम करने में बहुत मुश्किल होती है।

ये दोनों भाषाएँ जहाँ विशेष रूप से साक्ष्यों को आसान बनाने के लिए डिज़ाइन की गई हैं, शुद्धता का उपयोग करके यह बताती हैं कि कार्यक्रम के कौन से हिस्से प्रासंगिक हैं। कई मुख्यधारा की भाषाओं के लिए, केवल यह साबित करना कि राज्य का एक टुकड़ा अप्रासंगिक है कार्यक्रम के हिस्से के साइड इफेक्ट और परस्पर मूल्यों की प्रकृति के कारण एक जटिल मुद्दा हो सकता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.