क्या स्थैतिक टाइपिंग व्यापार-नापसंद है?


108

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

जावा और सी # शिविर जगह में टाइप सेफ्टी के बिना इसकी तरह आवाज करते हैं, ज्यादातर लोग हर तरह के भयानक कीड़े में चले जाते हैं जो एक दाईं ओर होता है और यह इसके लायक से अधिक परेशानी होगी।

यह एक भाषा तुलना नहीं है, इसलिए कृपया संकलित बनाम व्याख्या किए गए मुद्दों को संबोधित न करें। क्या विकास और flexibilty की गति के लिए सुरक्षा के प्रकार हिट हैं? क्यों?

उन लोगों के लिए जो इस राय का उदाहरण चाहते थे कि गतिशील टाइपिंग तेज है:

"विकास के दौरान एक गतिशील रूप से टाइप की गई भाषा का उपयोग करें। यह आपको तेज़ी से प्रतिक्रिया, बारी-बारी से समय और विकास की गति प्रदान करता है।" - http://blog.jayway.com/2010/04/14/static-typing-is-the-root-of-all-evil/



8
@ प्लम प्लम: क्या मुझे इस बात का प्रमाण चाहिए कि विकास और लचीलेपन की गति में कोई कमी है? चूंकि हम एक विशेष पहलू के बारे में बात कर रहे हैं , प्रकार सुरक्षा , का उपयोग करना Javaया C#अनिर्णायक होगा, यह प्रदान करने का उनका तरीका केवल एक ही नहीं है ...
मैथ्यू एम।

32
एक सख्त भाषा में परिश्रम के साथ, आप "सिरदर्द" को कम कर सकते हैं और फिर आपको आईडीई ऑटो-पूर्णता, कोड पीढ़ी और कोड संकेत के कारण गति में वृद्धि भी दिखाई दे सकती है ।
निकोल

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

5
@Prof प्लम, वह सब जो ब्लॉग पोस्ट को वास्तव में गति के बारे में कहना पड़ता है वह है गंजा जोर "किसी ने भी, जिसने रूबी या स्मॉलटाक जैसी आधुनिक गतिशील टाइप की भाषा के साथ गंभीरता से काम किया है, उन्हें पता है कि वे अधिक उत्पादक हैं।" व्यावहारिक रूप में कैसे, इसका कोई वास्तविक उदाहरण विकास को तेज नहीं बनाता है।
कार्सन 63000

जवाबों:


162

यह एक मिथक की तरह है कि प्रोग्रामर को गतिशील रूप से टाइप की जाने वाली भाषाओं के बारे में चिंता करने की ज़रूरत नहीं है।

गतिशील रूप से टाइप की गई भाषाओं में:

  • आपको अभी भी जानना है कि क्या आप किसी सरणी, पूर्णांक, स्ट्रिंग, हैश तालिका, फ़ंक्शन संदर्भ, शब्दकोश, ऑब्जेक्ट या जो कुछ भी काम कर रहे हैं।

  • यदि यह एक वस्तु है, तो आपको यह जानना होगा कि यह किस वर्ग का है।

  • इन प्रकारों में से किसी एक प्रकार को एक चर या फ़ंक्शन पैरामीटर के रूप में सौंपा जाना एक अन्य प्रकार होने की उम्मीद करना लगभग हमेशा एक त्रुटि है।

  • निचले स्तर पर, बिट्स की संख्या या हस्ताक्षरित बनाम अहस्ताक्षरित जैसी चीजें अभी भी खाते में होनी चाहिए यदि आप एक टीसीपी पैकेट को आबाद कर रहे हैं, उदाहरण के लिए।

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

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

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


10
मुझे इस तरह के बग्स बनाने / शुरू करने वाले अनुभवी प्रोग्रामर के बारे में थोड़ा संघर्ष करना होगा। अच्छे डेवलपर्स जो विनम्र होते हैं और उन्हें त्रुटियों की संभावना को स्वीकार करते हैं (और अनुभवी डेवलपर्स हमेशा ऐसे नहीं होते हैं) उन बगों को बनाने की संभावना कम होती है।
जे जय जय

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

हम अपनी पाइथन शॉप के डॉक्यूमेंटिंग प्रकारों पर अधिक समय व्यतीत करते हैं, जैसे कि हम एक मौखिक रूप से टाइप की गई भाषा जैसे C # या Java में सेव करते हैं। यह भी ध्यान देने योग्य है कि नई पीढ़ी जैसे गो और रस्ट प्रकार का अनुमान लगाते हैं, इसलिए आप "ऑब्जेक्ट एक्स = नई वस्तु ()" के बजाय "x: = new (ऑब्जेक्ट)" टाइप कर रहे हैं।
weberc2

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

हाँ, चर के प्रकार देने के बजाय आप पायथन में डिफ़ॉल्ट मान या इकाई परीक्षण (इनलाइन सिद्धांत) का उपयोग कर सकते हैं। पायथन में भी कभी-कभी आपको मिस-स्पेलिंग के साथ अजीब त्रुटियां हो सकती हैं [यदि आप स्व-पूर्णता का उपयोग करते हैं तो कम होने की संभावना है, जिसका उपयोग अक्सर किया जा सकता है, हालांकि सभी समय गतिशील भाषाओं में नहीं होता] और यह पता लगाना है कि क्या self.bread = 5 का परिचय है। रोटी या इसे फिर से परिभाषित करना।
एओयू 25256

123

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


37
+1! "तर्क त्रुटियां रनटाइम क्रैश या बकवास परिणामों के बजाय संकलन-टाइम टाइप बेमेल बनने की अधिक संभावना है": वास्तव में अच्छा जवाब! जब मैं अपने प्रकारों को डिजाइन करने के लिए अधिक समय लेता हूं, तो कोड अधिक स्वाभाविक रूप से अनुसरण करता है और यह संकलन होते ही अक्सर सही होता है। एक प्रकार का डिजाइन करना एक डोमेन और इसके संचालन को समझने का मतलब है।
जियोर्जियो

78

अस्वीकरण: मैं एक प्रकार का प्रेमी हूं;)

आपके प्रश्न का उत्तर देना मुश्किल है: वे ट्रेड-ऑफ़ क्या हैं ?

मैं एक चरम उदाहरण लूंगा: हास्केल , यह सांख्यिकीय रूप से टाइप किया गया है। शायद सबसे जोरदार टाइप की गई भाषाओं में से एक, जो वास्तव में मौजूद है।

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

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

मैंने पाया है कि ज्यादातर लोग स्थैतिक टाइपिंग पर कठोर हैं, वास्तव में किसी और चीज़ के बारे में शिकायत कर रहे थे (क्रिया, एक प्रकार से दूसरे के पक्ष में स्विच करने का दर्द), लेकिन हस्केल उन मुद्दों में से कोई भी प्रदर्शित नहीं करता है, जबकि सांख्यिकीय रूप से टाइप किया जा रहा है ...


संक्षिप्तता का उदाहरण:

-- type
factorial :: Integer -> Integer

-- using recursion
factorial 0 = 1
factorial n = n * factorial (n - 1)

बिल्ट-इन सपोर्ट के अलावा, ब्रीफ़र मिलना मुश्किल है।

सामान्य प्रोग्रामिंग का उदाहरण:

> reverse "hell­o" -- Strings are list of Char in Haskell
=> "olleh"
> reverse [1, 2, 3, 4, 5]
=> [5,4,3,2,1]

प्रकार का उदाहरण

> :t rever­se "hell­o"
:: [Char]

जिसे बस गणना की जा सकती है:

  • "hello"Char(के रूप में व्यक्त [Char]) की एक सूची है
  • reverseएक प्रकार के लिए लागू एक प्रकार [A]देता है[A]

इसे अपने ब्राउज़र में आज़माएं


4
शैतान के वकील की भूमिका निभाने के लिए, डायनेमिक भाषाओं (कम से कम प्रोटोटाइप के दौरान) के पक्ष में एक ट्रेड-ऑफ यह है कि प्रकार की घोषणाओं के रूप में इनोफ़र कुछ यूनिट परीक्षणों के समान उद्देश्य की सेवा कर सकता है, वे उसी तरह इंटरफेस को भी ठोस कर सकते हैं जैसे कि परीक्षण परीक्षण ( हालांकि निश्चित रूप से कम ओवरहेड के साथ)। इसके अलावा, सुरक्षित रूप से बिना किसी ज़ोर के भाषाएं टाइप की जाती हैं, जबकि सुरक्षित होने के लिए स्पष्ट प्रकार की कास्टिंग की आवश्यकता होती है (विशेषकर जब एक प्रकार पर्याप्त सामान्य नहीं हो), जो थकाऊपन से अलग हो सकता है।
TR

7
मुझे नहीं पता कि हास्केल लेकिन +1 के लिए "वास्तव में किसी और चीज़ के बारे में शिकायत कर रहे थे (क्रिया, एक प्रकार से दूसरे के पक्ष में स्विच करने का दर्द)"
निकोल

1
@ एडन: हास्केल एक विकसित भाषा है। हास्केल 98 हास्केल 1.4 पर एक सुधार था; हास्केल 2010 उस पर एक सुधार था। इस बीच, यह ध्यान देने योग्य है कि अपने जीवन के अधिकांश समय के लिए, हास्केल का रायसन डी'त्रे टाइप सिस्टमों का पता लगाने में मदद करने के लिए था ; मल्टी-पैरामीटर प्रकार की कक्षाएं एक उदाहरण हैं जहां यह एक उपयोगी प्रकार सिस्टम एक्सटेंशन को स्पष्ट करने में सफल रहा। (दूसरी तरफ, कार्यात्मक निर्भरता एक मृत अंत के कुछ लग रहे हैं।)
geekosaur

4
@Matthieu: WRT "। शायद सबसे प्रबलता से टाइप किये भाषाओं जो अस्तित्व में से एक है, वास्तव में", मैं अपने हास्केल देख सकते हैं और आप बढ़ा देंगे AGDA और Coq । (मैं अनुदान दूंगा कि यह संभवतः सबसे अधिक व्यावहारिक रूप से टाइप की जाने वाली उपयोगी भाषा है।)
गीकॉउसर

1
@ मैथ्यू: प्रूफ सहायक करी-हावर्ड पत्राचार का एक सीधा आवेदन है, इसलिए वे हृदय प्रोग्रामिंग भाषाओं में हैं (हालांकि सीमित मानक पुस्तकालयों के साथ)। वे निर्भर प्रकार के अनुसंधान में सबसे आगे हैं क्योंकि आपको "प्रकार प्रस्ताव हैं" पत्राचार का अच्छा उपयोग करने के लिए आश्रित प्रकार की आवश्यकता होती है।
गीकॉर्पोस

37

मुझे स्टेटिकली टाइप्ड और डायनामिकली टाइप्ड दोनों ही भाषाएं पसंद हैं। मुझे टाइप सुरक्षा के दो सबसे बड़े लाभ हैं:

1) आप अक्सर बहुत कम कर सकते हैं कि कोई फ़ंक्शन अपने प्रकार के हस्ताक्षर से विशुद्ध रूप से क्या करता है (यह विशेष रूप से कार्यात्मक भाषाओं जैसे हास्केल में सच है)।

2) जब आप महत्वपूर्ण रिफ्लेक्टर करते हैं, तो कंपाइलर स्वचालित रूप से आपको सब कुछ बताता है कि आपको सब कुछ काम करने के लिए करना है। जब मैं सी ++ में कुछ रिफ्लेक्टर करता हूं, तो मेरी प्रक्रिया अक्सर बस एक होती है) एक भाग को मैं जानता हूं कि मैं बदलना चाहता हूं, तो बी) हर संकलन त्रुटि को ठीक करें।


मेरे साथ बिल्कुल वैसा ही, और जब भी मैं किसी चीज को रिफ्लेक्टर करना चाहता हूं (मैं ज्यादातर गोलंग / टाइपस्क्रिप्ट / जावा का उपयोग करता हूं), हां, उन 2 चरणों को किसी को भी आवश्यकता होगी। एक भाग को बदलें, फिर सभी संकलन त्रुटि को ठीक करें :) सही उत्तर।
निश्चल गौतम

29

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

मेरे लिए लब्बोलुआब यह है कि यद्यपि मैं कुछ लचीलापन खो देता हूं, मैं कुछ समय हासिल करता हूं जो अन्यथा प्रकार के मुद्दों को ट्रैक करने में खर्च किया जाएगा।


13

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

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

इस पर विचार करें: यदि किसी ने आपको बताया कि आपकी परियोजना में कीड़े को कम करने का एक सरल तरीका था रात भर में 15%, तो यह एक बिना दिमाग वाला होना चाहिए। 1 यह लगभग लौकिक चांदी की गोली है।

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

यह संक्षिप्त रूप से संक्षेप में बताना मुश्किल है कि लेखकों ने कितनी दृढ़ता से अपने विश्लेषण का प्रदर्शन किया है, लेकिन यहाँ (बहुत मोटा) रूपरेखा है:

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

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

शोधकर्ताओं ने यह सुनिश्चित करने के लिए कड़े कदम उठाए कि उनका विश्लेषण गैर-प्रकार से संबंधित बग को प्रकार से संबंधित नहीं माना जाएगा। 2

पिछले अध्ययनों की तुलना में, इस नए अध्ययन में विशेष ताकत है:

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

जब तक कागज में कोई मूलभूत दोष न हो जिसे किसी ने अभी तक नहीं खोजा है, तो कागज को लगभग किसी भी कीमत पर स्थैतिक टाइपिंग का एक बड़ा लाभ दिखाई देता है। 4


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

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

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

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


1 मूल पेपर के एक उद्धरण से प्रेरित।

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

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

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


3
मुझे पता है कि यह इस सवाल का देर से जवाब है लेकिन मेरा मानना ​​है कि नए सबूत (जो मैं यहां समझाता हूं) पूरी तरह स्थिर-बनाम-गतिशील बहस को बदल देता है।
कोनराड रुडोल्फ

2
यह निश्चित रूप से दिलचस्प है, लेकिन मुझे आश्चर्य है कि यह जावास्क्रिप्ट के विशेष प्रकार के सिस्टम से कितना संबंधित है। पायथन (विशेष रूप से पायथन 3) प्रकार की प्रणाली बहुत कम निहित रूपांतरणों के साथ बहुत सख्त है।
पीटर ग्रीन

@PeterGreen हाँ, यह एक शक के बिना सच है। शायद हम भाग्यशाली हैं, और पायथन के प्रकार संकेत सड़क के नीचे एक समान विश्लेषण का नेतृत्व करेंगे (हालांकि मुझे इस पर संदेह है, क्योंकि PEP484 और PEP526 में व्यक्त उद्देश्य स्थैतिक टाइपिंग को लागू नहीं करना है)।
कोनराड रुडोल्फ

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

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

12

क्या विकास और लचीलेपन की गति के लिए प्रकार की सुरक्षा हिट है?

तो वास्तव में यह नीचे आता है कि आप क्या कर रहे हैं। यदि आप प्रोग्रामिंग कह रहे हैं, तो हवाई जहाज के लिए बैकअप सिस्टम, टाइप सेफ्टी शायद जाने का रास्ता है।

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

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

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


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

7

हाल ही में पूछा गया एक ऐसा ही सवाल था: डायनेमिक बनाम स्टेटिकली टाइप्ड भाषाएँ वेबसाइटों के लिए

मेरे उत्तर के मूल को पुनर्स्थापित करने के लिए:

जैसे-जैसे सिस्टम बड़े होते हैं, सांख्यिकीय रूप से टाइप की जाने वाली भाषाएं घटक स्तर पर मजबूती सुनिश्चित करती हैं और इस प्रकार सिस्टम स्तर पर लचीलापन आता है।

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

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

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

मुझे लगता है कि दावा है, कि स्थैतिक प्रकार की प्रणालियां केवल स्थैतिक प्रकार की प्रणालियों के ज्ञान की कमी पर आधारित हैं। कई भाषाएँ हैं जो इसे सही करती हैं, उनमें से एक हैक्स, और यकीनन उस संबंध में सर्वश्रेष्ठ भी नहीं है।

उदाहरण haXe कोड:

class Car {
    public function new();
    public function wroom() trace('wroooooooom!')
}
class Duck {
    public function new();
    public function quack(at) trace('quackquack, ' + at + '!')
}

function letQuack(o) o.quack();
letQuack(new Car());
letQuack(new Duck());

यह एक संकलन समय त्रुटि उत्पन्न करेगा:

Car should be { quack : Void -> Unknown<0> }
Car has no field quack
For function argument 'o'
Duck should be { quack : Void -> Unknown<0> }
Invalid type for field quack :
to : String -> Void should be Void -> Unknown<0>
For function argument 'o'

आप वास्तव में यह दावा नहीं कर सकते कि मुझे टाइप सुरक्षा में बहुत प्रयास करने पड़े।

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

दिन के अंत में, आप पाएंगे कि कोई फर्क नहीं पड़ता कि ओवरहेड प्रकार की सुरक्षा ने आपको कितना खर्च किया, यह अंततः ammortized है (यहां तक ​​कि जावा में - हालांकि शायद इतनी जल्दी नहीं)।


अजगर सिद्धांतों में दस्तावेजीकरण और बाद में जाँच के स्रोत के रूप में, उत्तर / शेल से कॉपी और पेस्ट किया जाता है। docs.python.org/3/library/doctest.html
aoeu256

5

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

लेकिन यह कहना नहीं है कि सांख्यिकीय रूप से टाइप किए गए सिस्टम उनसे बेहतर नहीं हो सकते।

सांख्यिकीय रूप से टाइप की गई भाषाओं के भीतर, प्रकार प्रणाली वास्तव में बहुत मायने रखती है। एक उदाहरण के रूप में, कार्यात्मक भाषाओं में कुछ मोनाड की तरह कुछ के साथ (प्रकार <कुछ>: = हाँ x | नहीं), आप संकलन-समय की जांच प्राप्त करते हैं जो अनिवार्य रूप से सबसे प्रकार के सिस्टम में खूंखार NullReferenceException को रोकते हैं; जब पैटर्न मिलान कोड चलता है, तो आपको यह बताते हुए संकलित समय त्रुटियां मिलती हैं कि आप अशक्त स्थिति को संभालने में विफल रहे हैं (यदि आप उस प्रकार को घोषित करने के लिए उस तंत्र का उपयोग करते हैं)। जब आप F # में पाइपलाइन ऑपरेटर जैसे चीजों का उपयोग करते हैं तो आप भी इसी प्रकार की त्रुटियों को कम करते हैं।

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

जब यह विकल्प नहीं होता है, तो C # को डिज़ाइन एक्सटेंशन ऑफ़ कॉन्ट्रैक्ट एक्सटेंशन में एक और तंत्र जोड़ा जा सकता है जो स्थैतिक प्रकार प्रणाली के मूल्य को बढ़ाता है, लेकिन उन्हें अभी भी कुछ कार्यात्मक प्रतिमानों की तुलना में अधिक अनुशासन की आवश्यकता होती है।


5

निर्भर करता है।

मानव विफलता मोड अक्सर सांख्यिकीय होते हैं। मजबूत प्रकार की जाँच कुछ निश्चित प्रकार की मानवीय विफलताओं (छोटी गाड़ी कोड के कारण) की संभावना को कम करती है। लेकिन सिर्फ इसलिए कि आप असफल हो सकते हैं इसका मतलब यह नहीं है कि आप (मर्फी गैर-समझ) करेंगे।

क्या यह संभावित विफलता बाधाओं में कमी लागत के लायक है निर्भर करता है।

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


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

2
द पेपर: हास्केल बनाम ..., सॉफ्टवेयर प्रोटोटाइपिंग उत्पादकता में एक प्रयोग - पॉल हुडक और मार्क पी। जोन्स । यह ARPA और अमेरिकी नौसेना द्वारा दिए गए एक प्रयोग के परिणामों का वर्णन करता है।
एंड्रेस एफ।

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

4

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

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


4

इंटरफेस पर प्रकार बाधाएं हैं, इसलिए वे एक उपसमुच्चय हैं जो आप इकाई परीक्षणों के साथ परीक्षण करना चाहते हैं, और इसलिए बहुत सारे ट्रेड-ऑफ समान हैं:

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

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


3

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


4
जावा और सी # जैसी मजबूत टाइप की गई भाषाएं परावर्तन के उपयोग के माध्यम से स्वचालित रूप से डीसेरिएलाइज़ेशन को संभालती हैं।
मैथ्यू एम।

3

मॉर्गन, मुझे कोशिश करने के लिए एक दिलचस्प विचार मिला: स्थिर + गतिशील टाइपिंग। आपने पायथन, सी # और जावा का उल्लेख किया। क्या आप जानते हैं कि .NET और Java दोनों के लिए पायथन के कुछ बहुत अच्छे पोर्ट हैं? दोनों ही मामलों में, पोर्ट आपको उन प्लेटफार्मों के पुस्तकालयों का उपयोग करने और / या मौजूदा कोड के साथ इंटरोपरेट करने की अनुमति देते हैं। यह आपको कई संभावनाएं देता है:

  1. स्थिर, अनम्य भाषा में विरासत कोड रखें। नए सामान के लिए पायथन का उपयोग करें।
  2. परिपक्व प्लेटफार्मों के शीर्ष पर नए सामान को प्रोटोटाइप करने के लिए पायथन का उपयोग करें। उन घटकों को पुन: कोड करें जिन्हें आप अधिक परिपक्व भाषा में रखना चाहते हैं।
  3. आपके द्वारा अक्सर बदले जाने वाले भागों के लिए गतिशील भाषा का उपयोग करें।
  4. संभवतः चल रहे कोड को संशोधित करने जैसे विचारों के साथ खेलने के लिए गतिशील भाषा का उपयोग करें।
  5. डायनेमिक भाषा में उन सभी महत्वपूर्ण भागों को छोड़कर जहां आप जोरदार टाइप की गई भाषा का उपयोग करते हैं।

मैंने इन दृष्टिकोणों का उपयोग 90 के दशक के अंत तक C / C ++ में विकसित होने के दर्द के आसपास करने के लिए किया था। मुझे देशी पुस्तकालयों और कभी-कभी प्रदर्शन की आवश्यकता थी। फिर भी, मैं बेहतर सिंटेक्स, लचीलापन, सुरक्षा आदि चाहता था। इसलिए, ट्रिक उन्हें सही ट्रेडऑफ़ प्राप्त करने के लिए सावधानीपूर्वक संयोजन कर रही थी। यह पूरी भाषा और विरासत कोड को किसी अन्य भाषा / मंच के लिए बाहर फेंकने की तुलना में अक्सर अभ्यास में बेहतर था।

(नोट: एक उत्तर पहले ही कहा था, लेकिन मैं उस डायनामिक टाइपिंग पर फिर से जोर देना चाहता हूं! एक चर प्रकार रनटाइम पर निर्धारित किया जाता है, एक प्रकार के एनोटेशन की आवश्यकता नहीं होती है, और / या रनटाइम में बदल सकता है।


2

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


यह एक व्यक्तिपरक क्यूए है इसलिए मैं इसके साथ ठीक हूं।
मॉर्गन हेरलॉकर

1
किसी को भी नीचे वोटों की व्याख्या करने की परवाह है?
पीडीआर

स्पष्टीकरण में आपकी मदद नहीं कर सकता, लेकिन मैंने आपको +1 दिया, मुझे लगता है कि यह एक उपयोगी योगदान है। डायनामिक टाइपिंग के साथ एक प्रमुख डर यह है कि आप कहीं न कहीं बदलाव करेंगे और मान्यताओं के कारण कुछ और तोड़ देंगे जो संकलित भाषा में संकलक द्वारा लागू किया गया होगा। हेवी यूनिट-टेस्ट कवरेज यहां आपकी रक्षा करेगा।
कार्सन 63000

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

@ कार्ल, कोई अपराध नहीं हुआ, यह एक वास्तविक प्रश्न था। मैं unapologetically समर्थक TDD हो सकता है, मैं मानता हूँ
pdr

2

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

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

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


2

क्या विकास और flexibilty की गति के लिए सुरक्षा के प्रकार के लायक है? क्यों?

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

सॉफ्टवेयर विकास में हमेशा कुछ सिरदर्द होंगे क्योंकि:

  • जो आप पूरा करने की कोशिश कर रहे हैं उसकी अंतर्निहित जटिलता

  • मनुष्यों की अंतर्निहित गिरावट, विशेष रूप से यह देखते हुए कि जब हम कुछ और अधिक जटिल करने की कोशिश करते हैं तो हम और अधिक गलतियाँ करते हैं

जल्दी या बाद में, आपको इन चुनौतियों का समाधान करने के लिए कुछ समय चाहिए। उस के आसपास कोई नहीं मिल रहा है। स्टेटिक टाइपिंग बाद में की बजाय जल्द ही इन चुनौतियों का समाधान करता है। जल्द ही बाद में बेहतर होता है, क्योंकि बाद में आपको एक गलती का पता चलता है ( यदि कोई सवाल नहीं है , लेकिन कब ), तो इस गलती को सुधारने में अधिक खर्च होता है।

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


1

यह सिर्फ मेरी अपनी राय है, लेकिन नहीं, मुझे नहीं लगता कि टाइप सुरक्षा इसके लायक है। एक सेकंड के लिए भी नहीं।

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

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

यहाँ एक उदाहरण है। मैं बस स्विफ्ट (Apple की नई भाषा) का उपयोग कर रहा था, यह उम्मीद कर रहा था कि यह वास्तव में एक दिन पहले अपने नाम पर जीवित रहेगा और ऐसा करने की कोशिश की: var n = 1/2 काम नहीं किया। मैं जैसा था, यहाँ क्या हो रहा है। और फिर दुख की बात है कि मुझे var n करना था: फ्लोट = 1/2। इसने मुझे याद दिलाया कि मैं टाइप सिस्टम से कितना नफरत करता हूं और वे कितने गैर-जरूरी हैं।

मैं यह भी कहना चाहता हूं कि मुझे उपयोगकर्ता परिभाषित प्रकार (जैसे कि कक्षाएं) भी नहीं चाहिए। मुझे टाइप बिल्कुल नहीं चाहिए। सभी मैं चाहता हूँ कि var और ऑब्जेक्ट्स हैं। जहां किसी भी वस्तु को किसी भी वस्तु के रूप में इस्तेमाल किया जा सकता है। और वस्तुएं गतिशील हैं और लगातार बदल रही हैं। जहां यह रनटाइम इशू बन जाता है कि क्या काम करता है और क्या नहीं।

डेवलपर्स यह कहना पसंद करते हैं कि बड़ी परियोजनाओं के लिए शिष्ट भाषाएं अच्छी नहीं हैं। लेकिन मैं कहूंगा कि यह विपरीत है। मजबूत टाइप की गई भाषाएं बड़ी परियोजनाओं के लिए भयावह हैं। और अगर आप कहते हैं कि जावास्क्रिप्ट बड़ी परियोजनाओं के लिए काम नहीं करता है, तो Uber से 40billion + की कंपनी के बारे में पूछें, जो कि सभी नोड पर चलने वाली है।

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


1
"मैं" का एक बहुत, तर्क का एक बहुत पदार्थ नहीं। और जिस तरह से एक त्रुटि "टूटती है" या नहीं, निर्माण का स्थैतिक बनाम गतिशील से कोई लेना-देना नहीं है। यदि आपके पास इकाई परीक्षण हैं और एक विफल रहता है "आपका निर्माण टूट गया है" और उम्मीद है कि उत्पादन को तब तक तैनात नहीं किया जाएगा जब तक कि इसे ठीक नहीं किया जाता है
nafg

आपको क्या लगा कि मैंने इस तरह की कोई बात की है?
नफ

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

1
@BrianYeh c ++ और c # भारी भाषाएं हैं क्योंकि वे प्रकारों के आसपास केंद्रित हैं। मैंने अभी-अभी अपनी नौकरी पर अभिकर्मकों का उपयोग करना शुरू किया है और मेरी उत्पादकता अभी तक फिर से खराब हो गई है क्योंकि यह प्रकार और घटकों पर लगातार उपयोग कर रहा है। यदि आप प्रकार और इकाई परीक्षण पसंद करते हैं, तो आपके लिए अच्छा है। हम सभी इस प्रोग्रामिंग शैली को साझा नहीं करते हैं।

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

0

हाँ।

मैंने PHP अनुप्रयोगों में काम किया है, जहां प्रकार जावा या सी # में "मजबूत" नहीं हैं। आमतौर पर मैंने "स्वचालित प्रकारों का अनुकरण" किया, क्योंकि खराब स्वचालित रूपांतरणों या डेटा को मान्य करने से बचने के लिए।

डायनामिक टाइप लैंग्वेज OS स्क्रिप्ट और क्विक स्मॉल ऐप्स के लिए अच्छी हैं। कॉम्प्लेक्स ऐप्स नहीं।

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


0

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

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

एक और अधिक सूक्ष्म समस्या हालांकि अपूर्ण प्रतिस्थापन है।

यदि एक प्रकार अभी पूरी तरह से गलत है, तो जब तक कि किसी विशेष कोड पथ का उपयोग नहीं किया जाता है, जो कि जल्दी से पता लगाया जा सकता है।

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

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

पायथन ने इस बात से परहेज किया कि विशेष समस्या, संख्या और तार एक दूसरे के लिए किसी भी तरह से विकल्प नहीं हैं और एक का उपयोग करने की कोशिश कर रहे हैं जहां दूसरे की उम्मीद है कि सामान्य रूप से तेजी से विफलता होगी।

हालांकि यह अपूर्ण susbstituibility समस्या से पूरी तरह से नहीं बचा था। विभिन्न प्रकार की संख्या एक दूसरे के लिए अपूर्ण विकल्प हो सकती है, इसलिए विभिन्न प्रकार के क्रम हो सकते हैं।


मुझे यहाँ क्या मिल रहा है, मुझे नहीं लगता कि स्थैतिक और गतिशील टाइपिंग के लाभों और लागतों की तुलना एक सामान्य तरीके से करना संभव है, क्योंकि मुझे लगता है कि लाभ और लागत दोनों एक भाषा के स्थिर या गतिशील टाइपिंग के विशेष रूप पर निर्भर करते हैं का उपयोग करता है।

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