डायनामिक टाइपिंग का अनुमानित उत्पादकता लाभ क्या है? [बन्द है]


82

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

तो: गतिशील टाइपिंग के साथ उत्पादकता के लिए क्या कहना है जो वास्तव में टाइप मॉडल का एक फायदा है?

स्पष्टता: मुझे त्वरित हैक की तुलना में बड़ी / मध्यम आकार की परियोजनाओं में अधिक रुचि है। :-)


10
क्या आप "स्थिर जोड़ी" से "गतिशील जोड़ी" की तुलना में तेज़ या अधिक उत्पादक होने की उम्मीद करेंगे?
स्टीव 314

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

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

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

जवाबों:


99

मुझे वास्तव में लगता है कि यह एक बहुत करीबी कॉल है। डायनेमिक टाइपिंग और स्टैटिक टाइपिंग दोनों के अपने फायदे हैं।

डायनामिक टाइपिंग के कारण अधिक उत्पादक हैं:

  • यह अधिक संक्षिप्त है - यदि सब कुछ गतिशील रूप से टाइप किया गया हो तो बहुत सारे बाहरी बायलरप्लेट कोड को हटाया जा सकता है - प्रकार की घोषणाएं, टाइपकास्टिंग तर्क आदि। अन्य सभी चीजें समान होने के कारण, छोटा कोड लिखने में थोड़ा तेज होता है, लेकिन इससे भी महत्वपूर्ण बात यह है कि यह पढ़ने में तेज हो सकता है और बनाए रखना (क्योंकि आपको क्या हो रहा है, इस पर पकड़ बनाने के लिए कोड के कई पन्नों से गुजरने की जरूरत नहीं है)
  • बतख टाइपिंग और बंदर पैचिंग जैसी तकनीकों को "हैक" करने के लिए आपको बहुत जल्दी परिणाम मिल सकते हैं (हालांकि बाद में आपको भ्रमित कर सकते हैं ...)
  • अधिक इंटरैक्टिव - डायनामिक टाइपिंग इंटरएक्टिव के लिए यकीनन अधिक उपयुक्त है, रैपिड प्रोटोटाइप के लिए आरईपीएल जैसी प्रोग्रामिंग, प्रोग्राम इंस्टेंस के रियल-टाइम डिबगिंग या यहां तक ​​कि लाइव कोडिंग भी।
  • परीक्षण के मामले रनटाइम त्रुटियों को पकड़ सकते हैं - यह मानते हुए कि आप TDD का उपयोग कर रहे हैं या बहुत कम से कम एक अच्छा परीक्षण सूट है, यह आपके कोड में किसी भी टाइपिंग मुद्दों को उठाना चाहिए।
  • बेहतर बहुरूपता - गतिशील भाषाओं में बहुरूपता कार्यों और सार के निर्माण को प्रोत्साहित करने की संभावना अधिक होती है, जो उत्पादकता और कोड को फिर से उपयोग को बढ़ावा दे सकता है। उदाहरण के लिए क्लोजर अपने कई सार में गतिशील बहुरूपता का महान उपयोग करता है
  • प्रोटोटाइप - प्रोटोटाइप आधारित डेटा / ऑब्जेक्ट मॉडल मेरे विचार में सांख्यिकीय रूप से टाइप किए गए उत्तराधिकारियों की तुलना में अधिक शक्तिशाली और लचीले हैं। प्रोटोटाइप-आधारित दृष्टिकोण की अनुमति देने या प्रोत्साहित करने के लिए गतिशील भाषाओं की अधिक संभावना है, जावास्क्रिप्ट एक महान उदाहरण है।

स्थैतिक टाइपिंग के कारण अधिक उत्पादक होने के कारण:

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

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

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


14
+1, बहुत विस्तृत जवाब। "बेहतर संकलन समय जाँच" बिंदु के मूल्य पर पर्याप्त जोर नहीं दिया जा सकता है।
NoChance 8

8
टाइप इंफ़ेक्शन के साथ, हास्केल-स्टाइल ओवरलोडिंग, सी ++ टेम्प्लेट, जेनरिक और शायद कुछ अन्य भाषा सुविधाएँ भी हैं जो स्थैतिक-टाइपिंग ढांचे के भीतर डक-टाइपिंग के कुछ फायदे प्रदान करती हैं - जब तक कि ऑब्जेक्ट आवश्यक इंटरफ़ेस प्रदान करता है (यह "एक बतख की तरह नीम हकीमों") आप इसका इस्तेमाल कर सकते हैं, लगभग ध्यान दिए बिना की कि नाममात्र प्रकार वस्तुओं। "लगभग" इसलिए है क्योंकि कुछ दृष्टिकोणों को कुछ इस तरह के "इस प्रकार के बक्सों की आवश्यकता होती है जैसे प्रासंगिक प्रकार की बतख" घोषणा - जैसे हास्केल में "वर्ग" घोषणा।
स्टीव 314

45
मुझे आपके जोर से असहमत होना है कि "कम कोड ... पढ़ने और बनाए रखने के लिए तेज है।" एक मध्यवर्ती चरण है, कोड को समझना। मुझे डेल्फी और जावास्क्रिप्ट दोनों में अन्य लोगों के कोड को बनाए रखना है, और डेल्फी कोड को समझना आसान है क्योंकि यह अधिक क्रिया है। और सबसे विशेष रूप से क्योंकि डेल्फी कोड में प्रकार की घोषणाएं हैं और जावास्क्रिप्ट नहीं है। जब आदिमों की तुलना में अधिक जटिल कुछ भी व्यवहार करते हैं, तो प्रकार की घोषणाएं यह देखने के लिए तुच्छ बनाती हैं कि आपके चर क्या हैं और वे क्या कर सकते हैं, जो रखरखाव के काम के लिए आवश्यक ज्ञान है।
मेसन व्हीलर

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

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

56

डायनेमिक भाषाओं के साथ आप टाइप की गई भाषा का उपयोग करते समय तेजी से भद्दा कोड लिख सकते हैं।

एक बार जब आप जल्दी से गतिशील सामान का अपना विशाल ढेर बना लेते हैं, तो आप लंबे समय तक रखरखाव के बारे में परवाह किए बिना सुरक्षित रूप से किसी अन्य परियोजना में जा सकते हैं।

यह उत्पादकता लाभ है :)

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

इसलिए उत्पादकता लाभ अपने जीवनकाल में मध्यम / बड़ी परियोजना के लिए एक मिथक हो सकता है।


11
हां, मेरा अनुभव वही है। एक 100 लाइनें पर्ल स्क्रिप्ट ठीक है, और ऐसे महान टूल के बिना हम खो गए थे। लेकिन एक 100k लाइन पर्ल प्रोजेक्ट शायद सबसे बुरा सपना होगा।
इंगो

3
... और फिर आपके पास जावास्क्रिप्ट (न केवल गतिशील है, बल्कि कमजोर टाइप भी है)।
डेन

16

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

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

कुछ मामलों में जहां आप टाइप-चेकर को नोटिस कर सकते हैं कि जेनेरिक कंटेनर और तर्कों और रिटर्न प्रकारों में सह-विरोधाभास है।


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

5
यदि आप गलत करते हैं तो सामान्य कंटेनरों और स्पष्ट सह-अंतर्विरोध "आपके रास्ते में आने" के लिए हैं। कोड संकलन का क्या लाभ है जो रनटाइम में विफल हो जाएगा?
M.Stramm

आमतौर पर नौकरी को 0% माना जाता है जब तक कि वह सभी परीक्षणों को सफलतापूर्वक पूरा नहीं करती है। तभी आपकी प्रगति को कुछ नहीं से अधिक माना जा सकता है। इस बात को ध्यान में रखते हुए, मुझे नहीं लगता कि यह आपकी उत्पादकता को मापने के लायक है जो अभी तक समाप्त नहीं हुई है।
पीजूसन

-1 वास्तविक प्रश्न ("उत्पादकता लाभ" को याद नहीं करता है?) इसके अलावा, आप शायद उन "वैध कार्यक्रमों को भी नहीं लिखना चाहते हैं जो सिस्टम को अस्वीकार करता है"। सिर्फ इसलिए कि आप का मतलब यह नहीं है कि आपको चाहिए। और आपके पास एक "वैध कार्यक्रम" भी क्यों होगा जो टाइपराइकर अस्वीकार करता है? क्या, आप एक जावास्क्रिप्ट प्रोग्राम को कोड कर रहे थे और अचानक इसे जावा में संकलित करने की कोशिश की?
एंड्रेस एफ।

वे मान्य प्रोग्राम जो टाइप सिस्टम को अस्वीकार करते हैं, आपके कोड को छोटा करने में मदद कर सकते हैं, जिससे कम त्रुटियां हो सकती हैं, जो टाइप सिस्टम का पता नहीं लगा सकता (कम कोड = कम त्रुटियां)। लाइन को हाइलाइट करने वाले कंपाइलर / आईडीई को डायनेमिक भाषाओं में टेस्ट वैल्यू (यानी REPL संचालित विकास) के साथ किया जा सकता है ताकि आप मध्यवर्ती मानों को देख सकें, और वे त्रुटियां उठा सकते हैं कि आपका टाइप सिस्टम त्रुटियों के साथ-साथ टाइप नहीं कर सकता। आप टाइपिंग चेतावनियाँ देने के लिए स्थैतिक प्रकार के अनुमान का भी उपयोग कर सकते हैं।
aoeu256

15

सबसे अधिक गतिशील भाषाओं के साथ मैंने जो लाभ उठाया है, वह यह है कि वे अधिक सामान्य कोड लिखना आसान बनाते हैं। जब आप ऐसा करने के लिए प्रकार प्रणाली से लड़ने की जरूरत नहीं है, तो अमूर्तता के उच्च स्तर पर लिखना बहुत आसान है।

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

हालाँकि, मैंने हाल ही में हास्केल का उपयोग शुरू किया है। हास्केल मुझे अमूर्त, जेनेरिक कोड जितनी आसानी से लिखी गई किसी भी गतिशील टाइप की भाषा का उपयोग करने देता है। ऊपर दिया गया मेरा जावा / जावास्क्रिप्ट उदाहरण हास्केल में कोई मतलब नहीं है क्योंकि इसमें ऑब्जेक्ट्स, तरीके, इवेंट या बहुत अधिक म्यूटेशन नहीं हैं, लेकिन अन्य प्रकार के जेनेरिक कोड वास्तव में लिखना आसान है।

वास्तव में, हास्केल कुछ सामान्य कोड लिख सकते हैं जो गतिशील रूप से टाइप की गई भाषाएं नहीं कर सकते हैं; एक आदर्श उदाहरण वह readकार्य है जो मूल रूप से इसके विपरीत है toString। आप एक Intया एक Doubleया जो भी प्रकार आप चाहते हैं (जब तक यह एक निश्चित प्रकार वर्ग में है) प्राप्त कर सकते हैं। तुम भी बहुरूपी हो सकता है स्थिरांक है, तो maxBoundअधिकतम हो सकता है Int, Double, Char... आदि।, सभी होना करने के लिए किस प्रकार यह अपेक्षा की जाती है पर निर्भर करता है।

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

हालाँकि यहां तक ​​कि हास्केल के प्रकार की प्रणाली में कुछ कष्टप्रद मुद्दे हैं जो आपको गतिशील रूप से टाइप की गई भाषा में नहीं होंगे। जिस तरह से मुझे सबसे ज्यादा परेशान किया गया है वह यह है कि नंबर किस तरह से हैंडल किए जाते हैं; उदाहरण के लिए, आपको lengthडबल के रूप में (किसी सूची का) उपयोग करने के लिए टाइप सिस्टम के साथ गड़बड़ करना होगा, कुछ ऐसा जो आपके पास बिना टाइप सिस्टम के कोई समस्या नहीं होगी। एक और कष्टप्रद बात जो मैंने चलायी है, वह Word8(एक अहस्ताक्षरित int प्रकार) और कार्यों के साथ काम कर रहा है जो उम्मीद करते हैं Int

तो, आखिरकार, बिना किसी प्रकार की प्रणाली के बहुत अधिक सोचने के बिना सामान्य कोड लिखना आसान हो जाता है और टाइप सिस्टम के कष्टप्रद नुकसान से बचा जाता है। आपको डायनेमिक भाषा में टाइप सिस्टम से कभी नहीं लड़ना है, लेकिन आप इस पर भरोसा नहीं कर सकते हैं।


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

3
आपका जवाब अच्छी तरह से मतलब है, लेकिन गलतियाँ हैं। सबसे पहले, यह सच नहीं है कि गतिशील भाषाओं में "कोई प्रकार की प्रणाली नहीं है", इसलिए यह कारण नहीं हो सकता है कि वे "सामान्य कोड लिखना आसान बना दें"। वे इसे आसान नहीं बनाते हैं, जैसा कि हास्केल शो के साथ आपका अपना प्रतिरूप है (आप अपने स्वयं के दावे को हटाते हैं!)। "आपको कभी भी टाइप सिस्टम से लड़ने की ज़रूरत नहीं है" झूठा है: आप हर बार इसे लड़ते हैं जो आपको एक बग को ठीक करना होगा जो पर्याप्त स्थिर टाइपेकिटेकिंग के कारण नहीं था। अंत में, स्पष्ट रूप Intसे एक सूची के द्वारा लौटाया गया जबरदस्ती तुच्छ है; उदाहरण: 1.0 + fromIntegral (length myList)अर्थात बस उपयोग करें fromIntegral
एंड्रेस एफ।

2
अंत में, "कोड फास्ट लिखना"! = "अधिक उत्पादक होना"। आपका कोड काम करना है! यदि आप छोटी गाड़ी सॉफ्टवेयर लिखते हैं, जिसे आपको बाद में डिबगिंग और फिक्सिंग में खर्च करना होगा, तो आप उत्पादक नहीं हैं।
एंड्रेस एफ।

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

यदि प्रकार सिस्टम वास्तव में उत्पादकता में सुधार करते हैं तो हस्केल या इदरिस में सभी उपयोगी अनुप्रयोग कहां हैं? मुझे लगता है कि टाइप एरर को समझना कितना आसान है, "patchability" (अप्रत्याशित तरीकों से आपके आवेदन को संपादित करने की क्षमता) और सिद्धांतों और प्रकार के अनुमानों की 90% त्रुटि जाँच अधिक महत्वपूर्ण हो सकती है।
aoeu256 19

7

प्रश्न: मैंने अक्सर यह दावा सुना है कि गतिशील रूप से टाइप की गई भाषाएं, टाइप की गई भाषाओं की तुलना में अधिक उत्पादक होती हैं। इस दावे के कारण क्या हैं? "

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

यहाँ कुछ बिंदुओं पर विचार किया गया है:

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

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

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

बड़ा मानक पुस्तकालय। पायथन को बड़े मानक पुस्तकालय के कारण "बैटरी शामिल" के रूप में प्रसिद्ध किया गया था। सी के साथ तुलना में यह बहुत कम मानक पुस्तकालय है। लेकिन जावा और .net जैसे प्लेटफार्मों के साथ, एक विशाल मानक पुस्तकालय मानक बन रहा है, और स्काला और एफ # जैसी नई भाषाएं इस "मुफ्त में" विरासत में मिली हैं।

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

क्लोज़र और लैम्ब्डा सिंटैक्स - डायनेमिक भाषाओं में आमतौर पर यह शुरुआत से होता है, लेकिन स्थिर भाषाओं ने इसे अपनाया है, हाल ही में जावा।

अंत में कोड स्निपेट्स को जल्दी से परीक्षण करने की क्षमता को पुन: प्राप्त करना एक बहुत बड़ा वरदान है। लेकिन यद्यपि आईडीई उपकरण, विजुअल स्टूडियो में "तत्काल" विंडो की तरह, स्थिर भाषाएं कुछ हद तक इसका अनुकरण कर सकती हैं।

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

निचला रेखा: ऐतिहासिक रूप से यह सच था, लेकिन आज जवाब कम स्पष्ट है।


प्रश्न: तो: गतिशील टाइपिंग के साथ उत्पादकता के लिए क्या कहना है जो वास्तव में स्वयं प्रकार के मॉडल का एक फायदा है?

डायनामिक टाइपिंग मॉडल को डायनेमिक भाषाओं से अलग करना थोड़ा कठिन है, लेकिन एक उदाहरण के रूप में C # ने समय के साथ अधिक गतिशील सुविधाओं को अपनाया है, भले ही यह एक मूल भाषा है। यह वास्तव में गतिशील प्रकार के मॉडल के लाभ का प्रमाण है। उदाहरण:

परावर्तन परावर्तन मौलिक रूप से एक गतिशील टाइपिंग सुविधा है। आप संकलन समय की तुलना में रनटाइम रैटर पर ऑब्जेक्ट प्रकारों का निरीक्षण करते हैं। जब इसे पेश किया गया था, तो यह एक प्रकार का था, लेकिन C # में प्रतिबिंब का उपयोग अधिक से अधिक सर्वव्यापी हो जाता है, उदाहरण के लिए ASP.Net MVC प्रतिबिंब का भारी उपयोग करता है।

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

Linq to SQL, EF mv। विभिन्न Linq ट्रांसफार्मर रनटाइम ऑब्जेक्ट के रूप में प्रश्नों का निरीक्षण करते हैं और मक्खी पर sql उत्पन्न करते हैं। यह रनटाइम पर कोड का निरीक्षण करने की तुलना में अधिक गतिशील नहीं है। कोडडॉम सिक्के का दूसरा पहलू है, जहां रनटाइम पर कोड उत्पन्न किया जा सकता है

रोसलिन रोसलिन मूल रूप से लागू होते हैं eval, जिसे कभी वास्तविक रूप से गतिशील भाषा की परिभाषित विशेषता माना जाता था।

डायनेमिक The dynamic-ype, C # में सबसे स्पष्ट रूप से गतिशील विशेषता है, और बाहरी वस्तुओं और भाषाओं के साथ बातचीत को सरल और अधिक उत्पादक बनाने के लिए विज्ञापित किया जाता है। लेकिन इसका इस्तेमाल Asp.net MVC में सुविधा के लिए भी किया जाता है।

उपरोक्त सभी विशेषताओं के लाभ से पता चलता है कि डायनामिक मॉडल में स्थिर भाषा में भी पैरामीटराइज्ड प्रकार, संरचनात्मक प्रकार और प्रकार के अनुमान के साथ निश्चित लाभ होते हैं।


मुझे वास्तव में यह उत्तर पसंद नहीं है, क्योंकि लगभग सभी बिंदु मूल प्रश्न को संबोधित नहीं करते हैं, "गतिशील टाइपिंग का उत्पादकता उत्पादकता क्या है ?" गतिशील भाषा नहीं
नानी

@nanny क्या आप गतिशील टाइप की गई भाषाओं और गतिशील भाषाओं के बीच अपने कथित अंतर के बारे में विस्तार से बता सकते हैं? (इसके उन फजी चीजों में से एक)। क्या आप एक गतिशील टाइप की गई भाषा का उदाहरण दे सकते हैं जो एक गतिशील भाषा नहीं है, साथ ही प्रत्येक की स्पष्ट परिभाषा?

@ ज्ञान: प्रश्न वास्तव में "गतिशील टाइपिंग" के बारे में पूछता है, न कि "गतिशील टाइपिंग"।
जैक्सबी

@MichaelT क्षमा करें, मैं स्पष्ट नहीं था। डायनेमिक टाइपिंग सभी डायनेमिक भाषाओं का एक पहलू है। यह उत्तर अन्य पहलुओं के बारे में बात कर रहा है, जो कि, ऐतिहासिक रूप से, गतिशील भाषाएं आती हैं, जो वास्तव में गतिशील टाइपिंग भाग को संबोधित किए बिना होती हैं।
नैनी

1
@ ज्ञान: मैं मूल रूप से इसका उत्तर दे रहा हूं: "मैंने अक्सर यह दावा सुना है कि गतिशील टाइप की गई भाषाएं टाइप की गई भाषाओं की तुलना में अधिक उत्पादक हैं। इस दावे के कारण क्या हैं?" - मेरा मानना ​​है कि इस दावे के कारण ऐतिहासिक हैं और न केवल डायनेमिक टाइपिंग से संबंधित हैं बल्कि डायनेमिक भाषाओं की विशेषताओं में सुधार करने वाले अन्य उत्पादकता के लिए भी हैं।
जैक्सबी

6

सारी आधुनिक भाषा की विशेषताएं इतनी बड़ी हैं, कि स्थिर बनाम गतिशील टाइपिंग में अधिक भार नहीं होता है।

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

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

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

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

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

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


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

आप डिफ़ॉल्ट मान / कीवर्ड तर्क जैसी जानकारी के साथ डायनामिक टाइप किए गए कोड को पूरक कर सकते हैं, टाइप इंट्रैक्शन से प्राप्त कर सकते हैं, JIT कंपाइलर से डायनामिक टाइप इनेंस, या बस सभी फ़ंक्शन लॉगिंग कर सकते हैं [एक रनिंग प्रोग्राम में प्रत्येक फ़ंक्शन या क्लास से गुजरें और उन्हें बदलें फ़ंक्शन का संस्करण जो इसके तर्कों / परिणामों को लॉग करता है)। तब आप किसी फ़ंक्शन के पिछले रनों का लॉग देख सकते हैं। एक अन्य विचार कोड को अस्वीकार करना है जिसमें न तो टाइप एनोटेशन, रन-टाइम कॉन्ट्रैक्ट, या नमूना REPL सत्र परीक्षण हैं, लेकिन डेवलपर को तीनों में से किसी एक को चुनने का विकल्प दें।
एओयू 25256

3

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


0

मुझे लगता है कि सबसे पहले आपको "उत्पादकता" को परिभाषित करने की आवश्यकता है। "उत्पादकता" का क्या अर्थ और शामिल है?

यदि "अधिक उत्पादक" से आपका मतलब समान सुविधा को लागू करने के लिए कोड की कम पंक्तियों को लिखने से है, तो हाँ, डायनेमिक-टाइपिंग प्रोग्रामिंग भाषाएँ स्थिर-टाइपिंग भाषाओं की तुलना में अधिक "उत्पादक" हैं।

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


सामान्य तौर पर, यह सच नहीं है कि आप एक गतिशील भाषा का उपयोग करके कम लाइनों में एक विशेषता लिख ​​सकते हैं। वैसे भी आप किन भाषाओं की तुलना कर रहे हैं?
एंड्रेस एफ।

@AndresF। ओह, मैं मुख्य रूप से पायथन और सी ++ का उपयोग करता हूं।
योबिन

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

हाँ, लेकिन क्या होगा यदि आप अपने कार्यक्रम को संपादित करते हुए इसके चल रहे हैं? किसी भी रन समय समस्या बस हो जाएगा और आप उन्हें वहीं ठीक कर सकते हैं। लिस्प में, जब भी आपको कोई त्रुटि मिलती है तो आप अपने प्रोग्राम को ठीक कर सकते हैं और फिर इसे जारी रख सकते हैं ... हाँ और अधिक जटिल रास्तों के लिए टाइप एनोटेशन अच्छा होगा [शायद आप धीरे-धीरे टाइपिंग का उपयोग कर सकते हैं जैसे कि mypy & lisp], लेकिन उन अधिक जटिल पथ गैर-प्रकार की त्रुटियों की भी संभावना है इसलिए किसी भी भाषा में जटिल रास्तों से बचना एक अच्छा विचार हो सकता है।
aoeu256

-1

डायनामिक टाइपिंग का बड़ा फायदा उत्पादकता है।

पायथन, रूबी आदि के पास डायनामिक टाइपिंग (डिफ़ॉल्ट पैरामीटर, डिक्शनरी जैसे टाइप इत्यादि में बहुत से अन्य उत्पादकता बूस्टर हैं)। प्रोग्रामर उत्पादकता पर संचयी प्रभाव प्रभावशाली है।

गति (या कमी!) और संसाधन की खपत के मामले में दंड उतने बुरे नहीं हैं जितना आप उम्मीद करेंगे और ज्यादातर मामलों में विकास की गति और लचीलेपन के लिए मुआवजे से अधिक है।

यहां विषय पर एक (बहुत पुराना!) पेपर है। यह प्रोग्रामर उत्पादकता पर कुछ ठीक से किए गए अध्ययनों में से एक है और कई निष्कर्ष अभी भी मान्य हैं।

क्या (शायद) अलग होगा आज किए जाने वाले अध्ययन थे: -

  1. जावा जेवीएम ने मान्यता से परे सुधार किया है।
  2. आधुनिक आईडीई ने C ++ और जावा कोडर्स उत्पादकता में सुधार किया होगा, लेकिन, स्क्रिप्टिंग भाषाओं में बहुत कम अंतर आया।
  3. सी # को शामिल किया जाएगा और शायद जावा के समान बॉल पार्क में होगा लेकिन थोड़ा बेहतर होगा।

संदेश तब तक है जब तक कि प्रदर्शन वास्तव में गंभीर मुद्दा नहीं है गतिशील भाषाएं आपकी उत्पादकता को बढ़ावा देंगी।


2
मेरी अशुद्धता यह है कि वास्तव में यह है कि गतिशील टाइपिंग आपकी उत्पादकता को बढ़ावा देती है। कागज दिलचस्प है, हालांकि यह एक बहुत छोटे कार्यक्रम के बारे में है, और मुझे यकीन नहीं है कि यह अधिकांश कार्यक्रमों में कोड की हजारों लाइनों तक कैसे पहुंचता है।
हंस-पीटर स्टॉर

5
यह अध्ययन केवल सी, सी ++ और जावा को स्थिर भाषाओं के उदाहरण के रूप में उपयोग करता है, और फिर सामान्य रूप से पारंपरिक प्रोग्रामिंग भाषाओं में पाए गए निष्कर्षों को लागू करने का प्रयास करता है। सभी तीन भाषाएं एक ही मूल वाक्यविन्यास को समान अंतर्निहित, चालकता-घटती खामियों के साथ साझा करती हैं, जिससे तुलना अवैध हो जाती है। ऐसा नहीं है कि स्थिर भाषाएँ अनुत्पादक हैं, यह है कि C परिवार अनुत्पादक है। अगर वे अपने परीक्षणों में पास्कल बोली शामिल करते, तो वे कुछ अलग निष्कर्ष पर पहुँच सकते थे।
मेसन व्हीलर

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

2
-1 आप के बारे में ज्यादा नहीं कह रहे हैं क्या गतिशील टाइप भाषाओं और अधिक उत्पादक बनाता है। डिफ़ॉल्ट पैरामीटर और शब्दकोश स्थिर टाइप भाषाओं में जैसे स्कैला में पाए जा सकते हैं।
जोनास

1
@JamesAnderson इससे भी बदतर, आपके द्वारा लिंक किया गया पेपर भी आपकी बात का समर्थन नहीं करता है। यह "स्क्रिप्टिंग भाषाओं" (अक्सर गतिशील) की तुलना " पारंपरिक भाषाओं" (अक्सर स्थिर) से करता है। अब, मुझे बताओ, वास्तव में "पारंपरिक" भाषाएं क्या हैं? क्या आपको लगता है कि यह स्थिर टाइपिंग वाली भाषाओं के सेट के समान है? इससे भी बदतर, कागज उतना पुराना नहीं है । वर्ष 2000 तक, स्थिर टाइपिंग के साथ बहुत सी बेहतरीन भाषाएं जो पहले से मौजूद गतिशील भाषाओं की तुलना में अधिक उत्पादक थीं।
एंड्रेस एफ।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.