कंपाइलर और इंटरप्रेटर में अंतर: आसान भाषा में समझिए
कंपाइलर पूरे प्रोग्राम का अनुवाद चलने से पहले करता है; इंटरप्रेटर एक-एक लाइन का अनुवाद करते-करते उसे चलाता भी जाता है। तुलना तालिका, ग़लतियाँ संभालना, और JIT दोनों को कैसे मिलाता है।
कंपाइलर और इंटरप्रेटर का फ़र्क़ इस बात का है कि अनुवाद कब होता है। कंपाइलर आपका पूरा सोर्स प्रोग्राम पढ़ता है, उसकी जाँच करता है, उसे मशीन कोड में बदलता है और आपको एक तैयार एक्ज़ीक्यूटेबल फ़ाइल थमा देता है — अनुवाद एक ही बार होता है, प्रोग्राम चलने से पहले। इंटरप्रेटर उसी सोर्स कोड को लेता है और प्रोग्राम चलते-चलते एक-एक कथन का अनुवाद करता जाता है, और हर टुकड़े को साथ-साथ चलाता भी जाता है।
दोनों एक ही बुनियादी समस्या सुलझाते हैं। प्रोसेसर सिर्फ़ अपना बाइनरी इंस्ट्रक्शन सेट समझता है; इंसान C, Python और Java जैसी भाषाओं में लिखते हैं। इस खाई को किसी को तो पाटना है। ये दोनों तरीक़े उसे अलग-अलग वक़्त पर पाटते हैं, और काम की लगभग हर बात — रफ़्तार, ग़लती के संदेश, मेमोरी का इस्तेमाल, एक जगह से दूसरी जगह चलना — इसी एक फ़ैसले से निकलती है।
कंपाइलर करता क्या है
कंपाइलर ख़ुद एक अनुवाद करने वाला प्रोग्राम है। आप उसे सोर्स कोड देते हैं; वह एक ऑब्जेक्ट फ़ाइल बनाता है, जिसे लिंकर एक्ज़ीक्यूटेबल में बदल देता है — और उसमें किसी एक ख़ास प्रोसेसर आर्किटेक्चर तथा ऑपरेटिंग सिस्टम के लिए मशीन निर्देश होते हैं। आप उसे चलाते हैं और प्रोसेसर उसे सीधे चला देता है। उस वक़्त कंपाइलर वहाँ होता ही नहीं — उसका काम आपके शुरू करने से पहले ख़त्म हो चुका था।
अनुवाद एक ही बार में नहीं होता। कंपाइलर पहचाने जा सकने वाले चरणों से गुज़रता है: लेक्सिकल विश्लेषण लिखे हुए को टोकन में तोड़ता है; सिंटैक्स विश्लेषण पार्स ट्री बनाता है; सिमेंटिक विश्लेषण देखता है कि टाइप और घोषणाएँ ठीक बैठ रही हैं या नहीं; एक बीच का रूप तैयार होता है; ऑप्टिमाइज़र उसे तेज़ या छोटा बनाने के लिए दोबारा लिखता है; और कोड जनरेटर मशीन निर्देश निकालता है।
कंपाइल किया कोड तेज़ इसी ऑप्टिमाइज़ेशन वाले चरण की वजह से चलता है। कंपाइलर को पूरा प्रोग्राम एक साथ दिखता है, इसलिए वह लूप खोल सकता है, बेकार पड़ा कोड हटा सकता है, बार-बार काम आने वाली क़ीमतें रजिस्टर में रख सकता है, प्रोसेसर की पाइपलाइन के हिसाब से निर्देशों का क्रम बदल सकता है, और छोटे फ़ंक्शन को वहीं घोल सकता है। जिस अनुवादक को हमेशा एक ही लाइन दिखती है, उसके पास इनमें से कुछ नहीं होता। GNU कंपाइलर कलेक्शन ऐसे दर्जनों ऑप्टिमाइज़ेशन चरणों का ब्योरा देता है।
क़ीमत भी उतनी ही साफ़ है। कंपाइल करने में वक़्त लगता है, और हर बदलाव पर यह वक़्त देना पड़ता है। जो निकलता है वह एक ही प्लेटफ़ॉर्म से बँधा होता है, इसलिए x86 प्रोसेसर पर Windows के लिए बनी बाइनरी ARM वाले फ़ोन पर नहीं चलेगी। और कंपाइलर को यह भरोसा होना चाहिए कि पूरा प्रोग्राम सही है, वरना वह कुछ भी नहीं बनाता।
इंटरप्रेटर करता क्या है
इंटरप्रेटर सोर्स कोड पढ़कर उसे सीधे चलाता है, बिना कोई अलग एक्ज़ीक्यूटेबल बनाए। वह एक कथन लेता है, उसका असर पूरा करता है, अगले पर जाता है, और यही दोहराता रहता है। प्रोग्राम जितनी देर चलता है, इंटरप्रेटर को उतनी देर मेमोरी में बने रहना पड़ता है।
इससे काम करने का पूरा अनुभव बदल जाता है। आप आधा-अधूरा प्रोग्राम भी चला सकते हैं, और वह टूटे हुए हिस्से तक पहुँचने तक ठीक चलेगा। इंटरैक्टिव प्रॉम्प्ट पर एक लाइन लिखकर तुरंत नतीजा देख सकते हैं। एक लाइन बदलकर बिना दोबारा बिल्ड का इंतज़ार किए फिर चला सकते हैं। इसीलिए स्क्रिप्टिंग, डेटा विश्लेषण, पढ़ाई और जल्दी-जल्दी प्रोटोटाइप बनाने में इंटरप्रेट होने वाली भाषाओं का ही राज है।
क़ीमत चलते वक़्त की रफ़्तार में चुकानी पड़ती है। लूप का शरीर जितनी बार चलता है, इंटरप्रेटर उतनी बार अनुवाद का काम दोहराता है — दस लाख बार चलने वाला लूप यह क़ीमत दस लाख बार देता है, जबकि कंपाइलर एक बार देकर निपट चुका था। इंटरप्रेट होने वाला कोड आम तौर पर वैसे ही कंपाइल किए कोड से कई गुना धीमा चलता है, और गणना वाले भारी काम में यह फ़ासला और बढ़ता है। इसीलिए इंटरप्रेट होने वाली भाषाओं की गणित लाइब्रेरियाँ ख़ुद आम तौर पर C में लिखी होती हैं और इंटरप्रेटर सिर्फ़ उन्हें बुलाता है।
कंपाइलर बनाम इंटरप्रेटर: तुलना तालिका
| आधार | कंपाइलर | इंटरप्रेटर |
|---|---|---|
| अनुवाद कब | एक बार, चलने से पहले | लगातार, चलते-चलते |
| एक बार में कितना अनुवाद | पूरा प्रोग्राम | एक बार में एक कथन या लाइन |
| क्या निकलता है | ऑब्जेक्ट फ़ाइल या अपने आप चलने वाली एक्ज़ीक्यूटेबल | कोई टिकाऊ फ़ाइल नहीं; नतीजे सीधे मिलते हैं |
| चलने की रफ़्तार | तेज़ — मशीन कोड सीधे प्रोसेसर पर चलता है | धीमी — अनुवाद का बोझ बार-बार उठाना पड़ता है |
| पहली बार चलने में लगने वाला समय | ज़्यादा; पूरा बिल्ड होने का इंतज़ार करना पड़ता है | कम; चलना फ़ौरन शुरू हो जाता है |
| ग़लतियाँ कैसे बताता है | पूरा प्रोग्राम देखकर सारी पकड़ी गई ग़लतियाँ एक साथ बताता है | चलते वक़्त जो पहली ग़लती मिली, वहीं रुक जाता है |
| ग़लती ढूँढ़ना | मुश्किल; ग़लतियाँ कंपाइल किए कोड की ओर इशारा करती हैं और पूरा प्रोग्राम दोबारा बनाना पड़ता है | आसान; ग़लती ठीक उसी लाइन पर सामने आती है, और प्रोग्राम की हालत भी सामने रहती है |
| चलते वक़्त मेमोरी | इंटरप्रेटर की मेमोरी में ज़रूरत नहीं; ऑब्जेक्ट कोड जगह लेता है | पूरे वक़्त इंटरप्रेटर को मेमोरी में बने रहना पड़ता है |
| ऑप्टिमाइज़ेशन का दायरा | पूरे प्रोग्राम को देखकर सुधार मुमकिन | सीमित; किसी भी पल बहुत कम संदर्भ सामने होता है |
| बनी हुई चीज़ कहाँ-कहाँ चलेगी | एक्ज़ीक्यूटेबल एक ही प्रोसेसर आर्किटेक्चर और ऑपरेटिंग सिस्टम से बँधी है | जहाँ भी उस भाषा का इंटरप्रेटर हो, वहाँ सोर्स चल जाता है |
| सोर्स कोड बाँटना | उपयोगकर्ता को बाइनरी मिलती है; सोर्स छिपाया जा सकता है | प्रोग्राम चलाने के लिए उपयोगकर्ता को आम तौर पर सोर्स चाहिए |
| आम भाषाएँ | C, C++, Rust, Go, Fortran | Python, Ruby, PHP, शेल स्क्रिप्ट, पुराना JavaScript |
| किसके लिए ठीक | ऑपरेटिंग सिस्टम, गेम, वैज्ञानिक गणना, एम्बेडेड फ़र्मवेयर | स्क्रिप्टिंग, ऑटोमेशन, डेटा विश्लेषण, पढ़ाई, प्रोटोटाइप |
ग़लतियाँ संभालना: फ़र्क़ सबसे पहले यहीं दिखता है
जब तक ग़लतियाँ बची हैं, कंपाइलर एक्ज़ीक्यूटेबल नहीं बनाएगा, और वह एक ही बार में जितनी ग़लतियाँ बता सकता है, बता देता है। पाँच सिंटैक्स ग़लतियों वाला C प्रोग्राम कंपाइल कीजिए तो आम तौर पर पाँचों संदेश मिलते हैं, और वह भी कुछ चलने से पहले। अनुशासन शुरू में ही चुकाना पड़ता है: पहले सब ठीक कीजिए, फिर चलाइए।
इंटरप्रेटर को ग़लतियाँ तभी मिलती हैं जब चलते-चलते वहाँ तक पहुँचे। लाइन 200 पर वर्तनी की ग़लती वाली Python स्क्रिप्ट पहली 199 लाइनें चला देगी, वे जो करती हैं वह सब कर देगी — फ़ाइलें लिखना या डेटा भेजना भी — और फिर रुक जाएगी। उसके आगे की ग़लतियाँ कभी बताई ही नहीं जातीं, क्योंकि प्रोग्राम वहाँ पहुँचा ही नहीं।
इसका असर सहूलियत से आगे जाता है। कंपाइल होने वाली भाषाएँ ग़लतियों की एक पूरी क़िस्म पकड़ लेती हैं — टाइप का मेल न खाना, बिना बताए इस्तेमाल हुए वेरिएबल, ग़लत गिनती में दिए गए आर्ग्युमेंट — और वह भी प्रोग्राम के असली डेटा को छूने से पहले। इंटरप्रेट होने वाली भाषाएँ यही ग़लतियाँ तभी पकड़ती हैं जब उस रास्ते का कोड चले, और यह मुमकिन है कि वह महीनों बाद, चालू सिस्टम पर हो। अब मर्ज़ी से लगाए जाने वाले टाइप एनोटेशन और जाँच करने वाले औज़ार कंपाइल के वक़्त जैसी जाँच वापस ले आते हैं, बिना यह बदले कि भाषा चलती कैसे है।
C और Python: एक ही काम, दो तरीक़े
C में प्रोग्राम लिखिए तो क्रम यह है: सोर्स फ़ाइल, कंपाइलर, ऑब्जेक्ट फ़ाइल, लिंकर, एक्ज़ीक्यूटेबल। एक्ज़ीक्यूटेबल चलाइए और प्रोसेसर सीधे आपके निर्देश चलाता है। किसी को देना हो तो उसे सिर्फ़ बाइनरी चाहिए। एक लाइन बदलिए और जाँचने से पहले दोबारा बिल्ड करना पड़ेगा।
वही प्रोग्राम Python में लिखिए तो क्रम यह है: सोर्स फ़ाइल, `python program.py`, नतीजा। पर्दे के पीछे CPython सोर्स को बाइटकोड नाम के एक बीच के रूप में कंपाइल करता है, उसे `.pyc` फ़ाइल में रख लेता है, और उस बाइटकोड को अपनी वर्चुअल मशीन पर चलाता है — यही प्रक्रिया Python के अपने एक्ज़ीक्यूशन मॉडल दस्तावेज़ में लिखी है। एक लाइन बदलिए और तुरंत दोबारा चलाइए। किसी को देना हो तो उसके पास Python इंस्टॉल होना चाहिए।
CPython वाली यही बात है जहाँ से किताबी बँटवारा रिसने लगता है। Python को इंटरप्रेट होने वाली भाषा कहा जाता है, फिर भी उसके भीतर कंपाइल करने का एक चरण है। बस वह किसी असली प्रोसेसर के बजाय एक वर्चुअल मशीन के लिए कंपाइल करता है।
बीच का रास्ता: बाइटकोड और जस्ट-इन-टाइम कंपाइलेशन
आज ज़्यादा चलने वाली अधिकतर भाषाएँ न पूरी तरह कंपाइल होती हैं, न पूरी तरह इंटरप्रेट।
Java ने इस मिले-जुले तरीक़े को मशहूर किया। `javac` कंपाइलर सोर्स को बाइटकोड में बदलता है — यानी उस काल्पनिक प्रोसेसर के निर्देश, जिसे Java Virtual Machine specification परिभाषित करता है। बाइटकोड किसी प्लेटफ़ॉर्म से बँधा नहीं होता, इसलिए वही `.class` फ़ाइल Windows, Linux या Android पर चल जाती है। चलते वक़्त JVM उस बाइटकोड को चलाता है, और उसका जस्ट-इन-टाइम कंपाइलर देखता रहता है कि कौन से मेथड सबसे ज़्यादा चल रहे हैं, और उन गरम रास्तों को चलते-चलते नेटिव मशीन कोड में बदल देता है। बाइटकोड से हर जगह चलने की सुविधा मिलती है, और जो कोड सचमुच मायने रखता है उसमें कंपाइल किए कोड के क़रीब की रफ़्तार।
आज के JavaScript इंजन इससे भी आगे जाते हैं। Google का V8 जल्दी शुरू होने के लिए पहले बाइटकोड इंटरप्रेट करता है, चल रहे कोड पर नज़र रखता है, और जो हिस्से बार-बार चलते हैं उन्हें एक ऑप्टिमाइज़ करने वाले कंपाइलर को सौंप देता है, जो नेटिव मशीन कोड बनाता है। किसी सुधार के पीछे लगाया गया अंदाज़ा ग़लत निकल जाए, तो इंजन उस सुधरे हुए रूप को फेंककर वापस इंटरप्रेटर पर आ जाता है।
अहेड-ऑफ़-टाइम कंपाइलेशन तस्वीर को दूसरी तरफ़ से पूरा करता है: Android ऐप के बाइटकोड को इंस्टॉल के वक़्त ही नेटिव कोड में बदल देता है, यानी शुरू होने की देर के बदले भरोसेमंद रफ़्तार।
तो “कंपाइल होने वाली” और “इंटरप्रेट होने वाली” बातें भाषा की नहीं, उसे लागू करने के तरीक़े की हैं। C के इंटरप्रेटर भी हैं और Python के कंपाइलर भी। किसी भाषा को आम तौर पर किस तरह चलाया जाता है, इससे उसके आम इस्तेमाल का पता चलता है, ख़ुद भाषा की किसी ख़ूबी का नहीं।
जहाँ बात ही चलने की रफ़्तार की हो, वहाँ कंपाइल करना आज भी साफ़ जीतता है। राष्ट्रीय सुपरकंप्यूटिंग मिशन के तहत बनी मशीनों पर वैज्ञानिक काम ठीक उसी प्रोसेसर के लिए, ज़ोरदार ऑप्टिमाइज़ेशन के साथ कंपाइल किया जाता है जिस पर वह चलेगा, और ग्राफ़िक्स प्रोसेसिंग यूनिट के लिए लिखा कोड उसी हार्डवेयर के हिसाब से कर्नेल में कंपाइल होता है — जैसे भारत के ऐरावत AI सुपरकंप्यूटर पर चलने वाले कामों में, जहाँ अनुवाद का दो-तीन फ़ीसदी बोझ भी गणना के कई घंटे खा जाएगा।
जहाँ लोग अक्सर उलझते हैं
“Python धीमा है क्योंकि वह इंटरप्रेट होता है।” कुछ हद तक। इंटरप्रेट करने का बोझ सचमुच है, और उसके साथ डायनैमिक टाइपिंग तथा ऑब्जेक्ट बनाने की क़ीमत भी। जो प्रोग्राम अपना ज़्यादातर वक़्त कंपाइल की हुई गणित लाइब्रेरियों के भीतर बिताते हैं, वे C के लगभग बराबर तेज़ हो सकते हैं, क्योंकि इंटरप्रेटर वहाँ सिर्फ़ तालमेल बिठा रहा होता है।
“Java कंपाइल होने वाली भाषा है।” Java बाइटकोड में कंपाइल होती है, मशीन कोड में नहीं, और फिर चलने के लिए उसे वर्चुअल मशीन चाहिए। उसे सीधे-सीधे कंपाइल होने वाली या इंटरप्रेट होने वाली कह देने से वही बात छूट जाती है जो उसमें दिलचस्प है।
“असेंबलर भी कंपाइलर ही है।” असेंबलर असेंबली भाषा को मशीन कोड में बदलता है, लेकिन वहाँ लगभग एक निर्देश के बदले एक निर्देश बनता है। कंपाइलर ऊँचे स्तर की भाषा का अनुवाद करता है, उसका ढाँचा बदलता है, और उसे बेहतर भी बनाता है।
“कंपाइल हुए प्रोग्राम में ग़लतियाँ नहीं होतीं, कंपाइलर जो जाँच लेता है।” कंपाइलर सिंटैक्स और टाइप की ग़लतियाँ पकड़ता है। तर्क की ग़लती वह नहीं पकड़ सकता — ऐसा प्रोग्राम जो साफ़-साफ़ कंपाइल हो जाए और जवाब ग़लत निकाले, मुमकिन भी है और सबसे आम बग भी यही है।
“इंटरप्रेटर सोर्स कोड को एक-एक लाइन करके मशीन कोड में बदलता है।” किताबों में यही लिखा मिलता है, और यह थोड़ा भ्रम पैदा करता है। आज के ज़्यादातर इंटरप्रेटर पहले सोर्स को अपने भीतरी बाइटकोड में बदलते हैं और फिर उसे चलाते हैं। सच बस इतना है कि यहाँ अनुवाद और चलना अलग-अलग नहीं, आपस में गुँथे हुए हैं।
सामान्य प्रश्न
तेज़ कौन है, कंपाइलर या इंटरप्रेटर?
कंपाइल हुआ प्रोग्राम तेज़ चलता है, क्योंकि अनुवाद और सुधार पहले ही एक बार में हो चुके होते हैं। इंटरप्रेटर चलना जल्दी शुरू कर देता है, क्योंकि वह पूरे बिल्ड का इंतज़ार नहीं करता। कौन सी बात ज़्यादा मायने रखती है, यह इस पर है कि आप चलने की रफ़्तार चाहते हैं या लिखो-और-जाँचो का तेज़ चक्र।
क्या एक ही भाषा कंपाइल भी हो सकती है और इंटरप्रेट भी?
हाँ। यह भाषा की नहीं, उसे लागू करने के तरीक़े की बात है। C के इंटरप्रेटर हैं, Python के कंपाइलर हैं, और Java एक ही बार चलने में दोनों तरीक़े इस्तेमाल करती है।
बाइटकोड क्या है?
असली प्रोसेसर के बजाय किसी वर्चुअल मशीन के लिए बने बीच के निर्देश। यह कच्चे सोर्स से ज़्यादा कसा हुआ होता है और तेज़ चलता है, और मशीन कोड के उलट वहाँ हर जगह चलता है जहाँ वह वर्चुअल मशीन मौजूद हो। Java का बाइटकोड और Python की `.pyc` फ़ाइलें, दोनों इसके उदाहरण हैं।
जस्ट-इन-टाइम कंपाइलेशन क्या है?
प्रोग्राम चलते-चलते उसके कुछ हिस्सों को नेटिव मशीन कोड में बदल देना, और वे हिस्से इस आधार पर चुने जाते हैं कि कौन सबसे ज़्यादा बार चल रहा है। इससे इंटरप्रेटर वाली तेज़ शुरुआत और कंपाइलर वाली टिकाऊ रफ़्तार, दोनों मिल जाती हैं — क़ीमत यह कि रनटाइम ज़्यादा पेचीदा हो जाता है और मेमोरी ज़्यादा लगती है।
अलग-अलग ऑपरेटिंग सिस्टम के लिए कंपाइल हुए प्रोग्राम दोबारा क्यों बनाने पड़ते हैं?
क्योंकि मशीन कोड किसी एक प्रोसेसर के इंस्ट्रक्शन सेट का होता है, और एक्ज़ीक्यूटेबल ऑपरेटिंग सिस्टम के फ़ाइल फ़ॉर्मेट तथा सिस्टम कॉल के तरीक़ों पर भी टिकी होती है। इनमें से कोई एक बदलिए और बाइनरी चलना बंद कर देगी, भले सोर्स कोड जस का तस हो।
क्या इंटरप्रेटर कंपाइलर से कम मेमोरी लेता है?
अनुवाद का काम ख़ुद आम तौर पर कम मेमोरी लेता है, क्योंकि कोई ऑब्जेक्ट कोड बनाकर रखना नहीं पड़ता। लेकिन प्रोग्राम जितनी देर चले, इंटरप्रेटर को उतनी देर मेमोरी में बने रहना पड़ता है, इसलिए चलते वक़्त कुल मेमोरी अक्सर ज़्यादा लगती है।
अभ्यास प्रश्न
1. कंपाइलर और इंटरप्रेटर के बीच मुख्य अंतर क्या है?
a) कंपाइलर सिर्फ़ ऊँचे स्तर की भाषाओं के साथ चलता है, जबकि इंटरप्रेटर सिर्फ़ असेंबली के साथ
b) कंपाइलर पूरे प्रोग्राम का अनुवाद चलने से पहले करता है, जबकि इंटरप्रेटर चलते वक़्त अनुवाद करता है
c) कंपाइलर कोई फ़ाइल नहीं बनाता, जबकि इंटरप्रेटर हमेशा बनाता है
d) कंपाइलर प्रोग्राम चलाता है, जबकि इंटरप्रेटर सिर्फ़ उसकी जाँच करता है
उत्तर: b) कंपाइलर पूरे प्रोग्राम का अनुवाद चलने से पहले करता है, जबकि इंटरप्रेटर चलते वक़्त अनुवाद करता है
2. सोर्स कोड को टोकन में तोड़ने का काम कंपाइल के किस चरण का है?
a) सिमेंटिक विश्लेषण
b) कोड जनरेशन
c) लेक्सिकल विश्लेषण
d) लिंकिंग
उत्तर: c) लेक्सिकल विश्लेषण
3. Java के चलने के तरीक़े में `javac` कंपाइलर से क्या निकलता है?
a) उसी प्रोसेसर के लिए बना मशीन कोड
b) Java Virtual Machine के लिए बना, प्लेटफ़ॉर्म से आज़ाद बाइटकोड
c) असेंबली भाषा की सूची
d) एक सुधरा हुआ बीच का रूप, जो कंपाइल के बाद फेंक दिया जाता है
उत्तर: b) Java Virtual Machine के लिए बना, प्लेटफ़ॉर्म से आज़ाद बाइटकोड
4. जस्ट-इन-टाइम कंपाइलेशन को सबसे सही तरीक़े से क्या कहा जा सकता है?
a) प्रोग्राम लिखते ही उसे तुरंत कंपाइल कर देना
b) प्रोग्राम चलते-चलते उसके बार-बार चलने वाले हिस्सों को नेटिव कोड में बदल देना
c) बिना किसी अनुवाद के प्रोग्राम को इंटरप्रेट करना
d) मशीन कोड को वापस सोर्स कोड में बदलना
उत्तर: b) प्रोग्राम चलते-चलते उसके बार-बार चलने वाले हिस्सों को नेटिव कोड में बदल देना
5. कंपाइल करने के मुक़ाबले इंटरप्रेट करने का फ़ायदा इनमें से कौन सा है?
a) गणना वाले भारी लूप तेज़ी से चलते हैं
b) फ़ंक्शन की सीमाओं के पार पूरे प्रोग्राम का सुधार मुमकिन होता है
c) चलते वक़्त ग़लती ठीक उसी लाइन पर बताई जाती है, जिससे उसे ढूँढ़ना आसान होता है
d) उपयोगकर्ताओं को सोर्स कोड देने की ज़रूरत नहीं पड़ती
उत्तर: c) चलते वक़्त ग़लती ठीक उसी लाइन पर बताई जाती है, जिससे उसे ढूँढ़ना आसान होता है
- कंपाइलर और इंटरप्रेटर में अंतर बताइए, और समझाइए कि अनुवाद कब होता है — इसी बात से रफ़्तार, ग़लतियाँ बताने के तरीक़े और कहाँ-कहाँ चल सकने का फ़र्क़ कैसे निकलता है।
- “कंपाइल होना और इंटरप्रेट होना, भाषा की नहीं, उसे लागू करने के तरीक़े की बात है।” Java, Python और JavaScript के संदर्भ में इस कथन की जाँच कीजिए।
- कंपाइल करने के चरणों पर चर्चा कीजिए और समझाइए कि पूरा प्रोग्राम सामने होने से ऐसे कौन से सुधार मुमकिन होते हैं जो इंटरप्रेटर नहीं कर सकता।
- जस्ट-इन-टाइम कंपाइलेशन दोनों तरीक़ों के फ़ायदे जोड़ने की कोशिश करता है। यह काम कैसे करता है और इसकी क़ीमत क्या है — विश्लेषण कीजिए।
- वैज्ञानिक और तेज़ रफ़्तार वाली गणना के कामों के लिए भाषा चुनते समय, बनाने की तेज़ी और चलने की तेज़ी के बीच के समझौते का मूल्यांकन कीजिए।