(प्रति @mlubin , यह प्रासंगिक परिवर्तन है https://github.com/JuliaLang/julia/pull/19324)

स्टीफन ने यहां सुझाव let ब्लॉक में आरईपीएल प्रविष्टियों का स्वचालित रैपिंग है

लेकिन क्या यह भ्रमित करने वाला नहीं होगा कि आप ऐसा नहीं कर सकते?

a = 1

और उसके बाद a उपयोग करें? जब तक सभी टॉपलेवल असाइनमेंट के लिए global डाला जाता, मुझे लगता है?

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

तो आप a = 1 को a = let a; a = 1; end जैसी किसी चीज़ में बदल देंगे। और कुछ

for i in 1:2
    before = false
end

इसमें बदल दिया जाएगा:

before = let before = before
    for i in 1:2
        before = false
    end
end

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

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

यहां एक शुरुआत करने वाले को यह सिखाना थोड़ा मुश्किल हो जाता है कि कार्यों या वैश्विक चर को बताए बिना 1 से 10 तक की संख्याओं का योग कैसे किया जाए।

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

सच कहूं तो जूलिया 0.7 को 13 दिन पहले रिलीज किया गया था। अधिकांश जूलिया उपयोगकर्ताओं के लिए यह एक नया बदलाव है।

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

दुर्भाग्य से हम में से उन लोगों के लिए जो किनारे पर रहना नहीं संभाल सकते, यह हमारे दृष्टिकोण से बिल्कुल नया है।

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

और हममें से जिन्हें विकास शाखाओं से दूर रहने के लिए प्रोत्साहित किया गया है, "यह हमारे दृष्टिकोण से बिल्कुल नया है।"

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

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

यहां एक शुरुआत करने वाले को यह सिखाना थोड़ा मुश्किल हो जाता है कि कार्यों या वैश्विक चर को बताए बिना 1 से 10 तक की संख्याओं का योग कैसे किया जाए।

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

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

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

global x = 5
for i = 1:5
  println(x+i)
end

खोजकर्ता को रखने का एक अच्छा तरीका हो सकता है, और "ग्लोबल की वजह से आरईपीएल कोड धीमा है" और अधिक स्पष्ट हो जाएगा। नकारात्मक पक्ष यह है कि एक बार फिर चीजों को किसी फ़ंक्शन में फेंकने के लिए global मार्करों की आवश्यकता नहीं होगी।

लेकिन यह देखते हुए कि यह कैसे दिखाई देता है, यह वास्तव में गेमब्रेकिंग या शोस्टॉपर नहीं है। मैं इसे एक मस्से के रूप में वर्गीकृत करूंगा जिसका किसी भी कार्यशाला में उल्लेख होना चाहिए लेकिन ऐसा नहीं है कि v1.0 इसके कारण अनुपयोगी है। मुझे आशा है कि इस व्यवहार को बदलने को ब्रेकिंग के रूप में वर्गीकृत नहीं किया गया है और इसके लिए v2.0 की आवश्यकता है।

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

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

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

अगर हम "आरईपीएल एक समारोह के अंदर के समान है" के लिए जा रहे हैं तो हमें outer बारे में भी सोचना चाहिए:

julia> i = 1
1

julia> for outer i = 1:10
       end
ERROR: syntax: no outer variable declaration exists for "for outer"

बनाम:

julia> function f()
          i = 0
          for outer i = 1:10
          end
          return i
       end
f (generic function with 1 method)

julia> f()
10

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

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

(मैं उन कुछ लोगों में से एक था जिन्होंने #19324 में प्रतिक्रिया दी थी, हालांकि, जहां मैंने पुराने व्यवहार के लिए तर्क दिया था।)

इसका एक गैर-तोड़ने वाला तरीका पुराने व्यवहार में वापस बदलना होगा (आदर्श रूप से निहित let ब्लॉक या कुछ भी डालने से नहीं - बस पुराने कोड को julia-syntax.scm में एक विकल्प के रूप में पुनर्स्थापित करें) आरईपीएल। या इसके बजाय, इसे इजूलिया जैसे वातावरण में उपलब्ध कराने के लिए जो इसे चाहते हैं, soft_global_scope=false ध्वज को include , include_string , और Core.eval को पुनर्स्थापित करने के लिए जोड़ें पुराना व्यवहार।

(मैं उन कुछ लोगों में से एक था जिन्होंने #19324 में प्रतिक्रिया दी थी, हालांकि, जहां मैंने पुराने व्यवहार के लिए तर्क दिया था।)

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

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

पुराने व्यवहार और नए के बीच चयन करने का विकल्प दिलचस्प है लेकिन यह बहुत हैकी लगता है।

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

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

इसे Meta.globalize(m::Module, expr::Expr) रूप में किया जा सकता है जो मॉड्यूल में मौजूद किसी भी ग्लोबल्स को ग्लोबल के रूप में स्वचालित रूप से एनोटेट करके अभिव्यक्ति को बदल देता है यदि उन्हें किसी शीर्ष-स्तरीय गैर-फ़ंक्शन स्कोप के अंदर असाइन किया गया हो। बेशक, मुझे लगता है कि यह पुराने पार्सर के बराबर है, लेकिन थोड़ा अधिक पारदर्शी है क्योंकि आप स्वयं Meta.globalize कॉल कर सकते हैं और देख सकते हैं कि आरईपीएल क्या मूल्यांकन करेगा।

इसे Meta.globalize(m::Module, expr::Expr) रूप में किया जा सकता है जो मॉड्यूल में मौजूद किसी भी ग्लोबल्स को ग्लोबल के रूप में स्वचालित रूप से एनोटेट करके अभिव्यक्ति को बदल देता है यदि उन्हें किसी शीर्ष-स्तरीय गैर-फ़ंक्शन स्कोप के अंदर असाइन किया गया हो।

मैंने वास्तव में कुछ मिनट पहले ऐसा कुछ लागू करने की तलाश शुरू कर दी थी। हालांकि, ऐसा लगता है कि julia-syntax.jl में एक विकल्प के रूप में इसे लागू करना बहुत आसान होगा:

• एक बाहरी एएसटी परिवर्तन लिखना संभव है, लेकिन ऐसा लगता है कि बहुत सारे मुश्किल कोने के मामले हैं - आपको मूल रूप से स्कोपिंग नियमों को फिर से लागू करना होगा - जबकि हमारे पास पहले से ही इसे प्राप्त करने के लिए कोड था julia-syntax.scm ।
• यह IJulia जैसी किसी चीज़ के लिए और भी मुश्किल है जो वर्तमान में कोड के पूरे ब्लॉक का मूल्यांकन करने और अंतिम अभिव्यक्ति का मूल्य प्राप्त करने के लिए include_string का उपयोग करता है। न केवल हमें अभिव्यक्ति द्वारा पार्सिंग अभिव्यक्ति पर स्विच करना होगा, बल्कि मूल पंक्ति संख्याओं (त्रुटि संदेशों वगैरह के लिए) को संरक्षित करने के लिए कुछ हैकरी की आवश्यकता हो सकती है। (हालांकि मुझे इस तरह की चीज़ के लिए ChangePrecision.jl के लिए एक
• लोगों के मामले का उल्लेख नहीं है कि include बाहरी फाइलें, जो आपके एएसटी परिवर्तन से नहीं पकड़ी जाएंगी।

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

मुझे गंभीरता से संदेह है कि नए उपयोगकर्ताओं को यह कहना आसान होगा कि इंटरैक्टिव उपयोग के लिए नियम कम पसंद हैं या एक निश्चित ध्वज के साथ include के लिए।

यहां globalize(::Module, ast) कार्यान्वयन का एक मोटा मसौदा है: https://gist.github.com/stevengj/255cb778efcc72a84dbf97ecbbf221fe

ठीक है, मैंने globalize_include_string फ़ंक्शन को कार्यान्वित करने का तरीका निकाला है जो लाइन-नंबर जानकारी को संरक्षित करता है, और इसे मेरे gist में जोड़ा है।

आगे बढ़ने का एक संभावित (गैर-ब्रेकिंग) तरीका, अगर लोग इस दृष्टिकोण को पसंद करते हैं:

1. globalize आदि कार्यों के साथ एक SoftGlobalScope.jl पैकेज जारी करें।
2. IJulia (और संभवतः जूनो, बनामकोड, और ओहमायरेपीएल) में सॉफ्टग्लोबलस्कोप का उपयोग करें।
3. सॉफ्टग्लोबलस्कोप फ़ंक्शंस को आरईपीएल stdlib पैकेज के भविष्य के रिलीज में मोड़ो और इसे आरईपीएल में उपयोग करें।

या क्या इसे तुरंत REPL.jl में रोल करना व्यावहारिक है? मैं पूरी तरह से स्पष्ट नहीं हूं कि 1.0 में stdlib अपडेट कैसे काम करते हैं।

कृपया मेरे कार्यान्वयन पर एक नज़र डालें, अगर मुझे कुछ याद आ रहा है जो इसे नाजुक बना देगा।

क्या हम इसे 1.1 में आरईपीएल की गैर-डिफ़ॉल्ट विशेषता के रूप में नहीं रख सकते हैं?

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

इसके लिए आरईपीएल में एक गैर-डिफ़ॉल्ट सुविधा जोड़ना मेरे लिए ठीक लगता है।

@JeffBezanson , याद रखें कि हम में से कई जूलिया को रैखिक बीजगणित और सांख्यिकी जैसे तकनीकी पाठ्यक्रमों में मैटलैब वगैरह के विकल्प के रूप में उपयोग करना चाहेंगे। ये प्रोग्रामिंग पाठ्यक्रम नहीं हैं और छात्रों के पास अक्सर कोई प्रोग्रामिंग पृष्ठभूमि नहीं होती है। हम कभी भी संरचित प्रोग्रामिंग नहीं करते हैं - यह लगभग सभी छोटे स्निपेट और वैश्विक चर के साथ इंटरैक्टिव है।

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

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

हम में से कई जूलिया उपयोगकर्ताओं के पास बिल्कुल 0 सीएस पृष्ठभूमि (स्वयं सहित) है, लेकिन मुझे ऐसा लगता है कि उचित रवैया ( विशेष रूप से छात्रों के लिए) सीखने की इच्छा है, बजाय इसके कि हमारे भोलेपन को समायोजित करने के लिए बदतर चीजों को बदलने की मांग की जाए।

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

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

इसके लायक क्या है, मैं इस बात से सहमत हूं कि इसके संलग्न दायरे के आधार पर कोड अलग-अलग व्यवहार करता है, यह आम तौर पर अवांछनीय विशेषता है।

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

क्या हम इसे 1.1 में आरईपीएल की गैर-डिफ़ॉल्ट विशेषता के रूप में नहीं रख सकते हैं?

"अनब्रेक मी" विकल्प बनाना डिफ़ॉल्ट रूप से समझदार लगता है, विशेष रूप से एक ऐसा विकल्प जो शुरुआत में उपयोगकर्ताओं के लिए लक्षित है। यदि यह एक गैर-डिफ़ॉल्ट विकल्प है, तो ठीक वे लोग जिन्हें इसकी सबसे अधिक आवश्यकता है, वे होंगे जिन्होंने इसे सक्षम नहीं किया है (और यह नहीं जानते कि यह मौजूद है)।

प्रस्तावित आरईपीएल-मोड include एड स्क्रिप्ट के लिए क्या करेगा? क्या वैश्विक बयानों का मूल्यांकन इस बात पर निर्भर करेगा कि आरईपीएल मोड सक्रिय है या नहीं? यदि ऐसा है, तो IMO यह 1.0 स्थिरता के वादे के विपरीत होगा।

अगर हमने ऐसा कुछ किया है तो ऐसा लगता है कि यह मॉड्यूल के लिए यह निर्धारित करने के लिए समझ में आता है कि यह कैसे काम करता है। तो Main एक "सॉफ्ट स्कोप" मॉड्यूल होगा जबकि डिफ़ॉल्ट रूप से अन्य मॉड्यूल "हार्ड स्कोप" मॉड्यूल होंगे।

मुझे यह देखने में दिलचस्पी थी कि आरईपीएल को @stevengj के globalize फ़ंक्शन का उपयोग करने के लिए बंदर पैच करना संभव था और ऐसा प्रतीत होता है कि यह बहुत अधिक प्रयास के बिना है (हालांकि काफी हैकी)। सार देखें। यह जूनो (या कुछ और जो Core.eval सीधे कॉल करता है) के साथ काम नहीं करता है।

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

julia> a = 0                                                                
0                                                                           

julia> for i = 1:10                                                         
         a += i                                                             
       end                                                                  
ERROR: UndefVarError: a not defined                                         
Stacktrace:                                                                 
 [1] top-level scope at .\REPL[2]:2 [inlined]                               
 [2] top-level scope at .\none:0                                            

julia> using SoftGlobalScope                                                
[ Info: Precompiling SoftGlobalScope [363c7d7e-a618-11e8-01c4-4f22c151e122] 

julia> for i = 1:10                                                         
         a += i                                                             
       end                                                                  

julia> a                                                                    
55                                                                          

(बीटीडब्लू: उपर्युक्त जितना परीक्षण हुआ है उतना ही परीक्षण है!)

प्रस्तावित आरईपीएल-मोड स्क्रिप्ट को शामिल करने के लिए क्या करेगा?

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

फाइलों में ग्लोबल कोड के लिए प्रॉम्प्ट की तुलना में पिकियर स्कोपिंग नियम होना आदर्श नहीं है। लेकिन मुझे लगता है कि #19324 जूलिया 1.0 स्थिरता वादे के साथ संयुक्त हमारे पास कोई आदर्श विकल्प नहीं है।

@stevengj :

@JeffBezanson , याद रखें कि हम में से कई जूलिया को रैखिक बीजगणित और सांख्यिकी जैसे तकनीकी पाठ्यक्रमों में मैटलैब वगैरह के विकल्प के रूप में उपयोग करना चाहेंगे। ये प्रोग्रामिंग पाठ्यक्रम नहीं हैं और छात्रों के पास अक्सर कोई प्रोग्रामिंग पृष्ठभूमि नहीं होती है। हम कभी भी संरचित प्रोग्रामिंग नहीं करते हैं - यह लगभग सभी छोटे स्निपेट और वैश्विक चर के साथ इंटरैक्टिव है।

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

मुझे लगता है कि मुख्य मुद्दा मौन विफलता है; प्रति समस्या को समझना और ठीक करना आसान है। मैं नया व्यवहार रखने का सुझाव दूंगा, लेकिन Main में चेतावनी दे रहा हूं (डिफ़ॉल्ट रूप से; इसे अक्षम करना संभव होना चाहिए)।

मेरे लिए, बड़ा मुद्दा कथित असंगति है। यही है, मैं जूलिया के साथ चीजों को अलग तरीके से करने के लिए ठीक हूं, लेकिन:

• किसी फ़ंक्शन से चिपकाया गया कोड आरईपीएल में काम क्यों नहीं करना चाहिए?
• मेरे द्वारा उपयोग की गई किसी अन्य भाषा में यह व्यवहार नहीं है, और यह अपनाने में एक और बाधा है
• for ब्लॉक begin और if ब्लॉक से अलग व्यवहार क्यों करते हैं? ( if मैं समझता हूं, लेकिन एक ब्लॉक [होना चाहिए] एक ब्लॉक है।)

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

मेरी प्राथमिकता यह सुनिश्चित करने के लिए होगी कि किसी फ़ंक्शन से आरईपीएल में चिपकाया गया कोड फ़ंक्शन के समान व्यवहार करता है, और यह कि for लूप डेटा का अंतःक्रियात्मक विश्लेषण करने के लिए उनका उपयोग करते समय अपेक्षित काम करते हैं; अर्थात्, विशेष रूप से, कि वे बिना किसी विशेष खोजशब्द के निर्देशित होने पर बाहरी/वैश्विक चरों को बदलते हैं।

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

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

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

क्या आप कह रहे हैं कि मुझे अपने रैखिक-बीजगणित पाठ्यक्रम में जूलिया का उपयोग नहीं करना चाहिए? या कि मुझे इसका उपयोग केवल तभी करना चाहिए जब मैं कंप्यूटर विज्ञान के साथ-साथ रैखिक बीजगणित सिखाने के लिए तैयार हूं?

मैं समस्या पर @stevengj से सहमत हूं (गैर प्रोग्रामर को पढ़ाना बहुत कठिन हो जाता है) और समाधान पर (चीजों को आरईपीएल और विभिन्न आईडीई में काम करना)। एक स्क्रिप्ट सहित अभी भी जूलिया 1.0 स्कोपिंग नियम होंगे, लेकिन यह एक चिंता का विषय नहीं है, किसी को केवल "हम अपने लूप को एक फ़ंक्शन में रख सकते हैं और फिर फ़ंक्शन को कॉल कर सकते हैं" वर्ग "हम डाल सकते हैं" से पहले सावधान रहना होगा। एक फ़ाइल में हमारे लूप के लिए और फ़ाइल को शामिल करें" वर्ग।

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

क्या आप कह रहे हैं कि मुझे अपने रैखिक-बीजगणित पाठ्यक्रम में जूलिया का उपयोग नहीं करना चाहिए? या कि मुझे इसका उपयोग केवल तभी करना चाहिए जब मैं कंप्यूटर विज्ञान के साथ-साथ रैखिक बीजगणित सिखाने के लिए तैयार हूं?

हो सकता है कि आपने मेरी बात को गलत समझा हो (या मैंने इसे स्पष्ट रूप से व्यक्त नहीं किया)। मैं उन पाठ्यक्रमों के बारे में बात कर रहा था जो कुछ डोमेन-विशिष्ट सिखाने के लिए जूलिया का

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

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

मैंने (अपंजीकृत) पैकेज बनाया है https://github.com/stevengj/SoftGlobalScope.jl

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

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

जाहिर है। जब मैं कहता हूं "मैटलैब के बजाय जूलिया का उपयोग करें", मेरा मतलब यह नहीं है कि मैं उन्हें जूलिया में मैटलैब सिंटैक्स सिखाने की कोशिश कर रहा हूं, न ही मैं विशेष रूप से पूर्व मैटलैब उपयोगकर्ताओं को लक्षित कर रहा हूं।

मैं इन मुद्दों का जल्द से जल्द सामना करना पसंद करता हूं

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

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

एक अन्य फिक्स का उल्लेख यहां नहीं किया गया है, बस एक स्कोप-ब्लॉक को परिभाषित करने के लिए 'के लिए' बनाना बंद करना है (बस कार्य करें और नया दायरा बनाएं)

@vtjnash , मैं इस चर्चा को उन चीजों पर केंद्रित करना चाहूंगा जो हम जूलिया 2.0 से पहले कर सकते हैं। मैं मानता हूं कि इंटरेक्टिव मोड अलग व्यवहार करना केवल एक स्टॉपगैप है, और हमें कुछ वर्षों में स्कोपिंग नियमों को बदलने पर गंभीरता से विचार करना चाहिए।

अच्छी बात है, इसके लिए भी import Future.scope

(मुझे लगता है कि यह मॉड्यूल/नेमस्पेस/व्यवहार प्रभाव पहले से ही आरक्षित/मौजूद है)

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

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

व्यवहार में मैंने जो शिकायतें देखीं (शून्य) निश्चित रूप से वर्तमान व्यवहार के बारे में आप देखेंगे (और पहले से ही देख रहे हैं) शिकायतों और भ्रम की संख्या से बौना होना निश्चित है।

इस परिवर्तन से पहले, आप एक ही कोड को दो बार चलाकर पूरी तरह से अलग उत्तर प्राप्त कर सकते थे (विभिन्न स्कोप असाइनमेंट के परिणामस्वरूप)

क्या आपका मतलब है कि नीचे दिए गए कोड में, a पहले और दूसरे for लूप के बीच बदलता है? मेरे दिमाग में, यह अपेक्षित व्यवहार है, बग नहीं।

a = 0
for i = 1:5
  a += 1
end

for i = 1:5
  a += 1
end

प्रस्तावित आरईपीएल-मोड स्क्रिप्ट को शामिल करने के लिए क्या करेगा?

@mauro3 @stevengj मुझे लगता है कि एक फ़ंक्शन जोड़ना (कहना, exec("path/to/script.jl") ) केवल एक मामूली संस्करण टक्कर के साथ किया जा सकता है? हम exec ' exec 'ed script से किसी अन्य फ़ाइल में चेतावनी भी दे सकते हैं और फिर उन्हें include का उपयोग करने के लिए प्रेरित करने के लिए वहां कुछ शैक्षणिक संदेश डाल सकते हैं।

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

लोग भोलेपन से वैश्विक दायरे को स्थानीय दायरे को घेरने वाले एक अजीब तरह के रूप में देखते हैं। यही कारण है कि वैश्विक क्षेत्रों ने जूलिया 0.6 और पूर्व में जिस तरह से काम किया है:

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

हालाँकि, मुख्य अंतर यह है:

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

इसके अलावा, चूंकि वैश्विक दायरा अक्सर काफी लंबा होता है-कई फाइलों में अक्सर फैलता नहीं है-एक अभिव्यक्ति का अर्थ अन्य अभिव्यक्तियों पर निर्भर करता है, इससे एक मनमानी दूरी, "दूरी पर डरावनी कार्रवाई" प्रभाव होता है, और इस तरह, काफी अवांछित .

यह अंतिम अवलोकन दिखाता है कि वैश्विक दायरे में लूप के दो अलग-अलग संस्करणों का अलग-अलग व्यवहार करना समस्याग्रस्त क्यों है:

# file1.jl
for i = 1:5
  a += 1
end

# file2.jl
a = 1



md5-f03fb9fa19e36e95f6b80b96bac9811e



```jl
# main.jl
include("file1.jl")
include("file2.jl")
include("file3.jl")

यह भी ध्यान दें कि file1.jl और file3.jl की सामग्री समान हैं और हम हर बार अलग अर्थ और व्यवहार के साथ एक ही फ़ाइल को दो बार शामिल करके उदाहरण को सरल बना सकते हैं।

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

मेरा छोटा सुझाव, जो उत्तर समस्या से निपटता नहीं है, लेकिन भाषा को अंतःक्रियात्मक रूप से पढ़ाने के दौरान व्यावहारिक उद्देश्यों के लिए उपयोगी होगा, कम से कम: "प्रोग्राम" नामक एक मुख्य ब्लॉक को परिभाषित करें, जैसे कि फोरट्रान में किया जा सकता है (यह है ऊपर दिए गए "लेट ... एंड" के समान, बस एक अधिक प्राकृतिक संकेतन के साथ):

कार्यक्रम परीक्षण
...
समाप्त

कोई भी स्कोप विवरण में जाए बिना भाषा सिखा सकता है और केवल अंततः उस बिंदु पर चर्चा कर सकता है।

एक और समस्याग्रस्त मामला लंबे समय से चल रहा आरईपीएल सत्र है। ऑनलाइन कहीं से एक उदाहरण का प्रयास करें? यह विफल हो जाता है क्योंकि आपके पास उसी नाम से वैश्विक चर होता है जिसका उदाहरण स्थानीय चर के लिए लूप या समान निर्माण में उपयोग करता है।

परेशान उपयोगकर्ताओं द्वारा इस बारे में कितनी मेलिंग-सूची शिकायतें और जीथब मुद्दे दर्ज किए गए हैं? शून्य, मेरी गिनती से। क्यों? शायद इसलिए कि यह व्यवहार लोगों के लिए मौलिक रूप से

तो यह धारणा कि नया व्यवहार केवल वही है जो भ्रम पैदा कर सकता है, निश्चित रूप से सटीक नहीं है।

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

हमें कुछ वर्षों में दायरे के नियमों को बदलने पर गंभीरता से विचार करना चाहिए।

बिल्कुल नहीं। क्या आप गंभीरता से पूर्व-v0.2 दुनिया में वापस जाना चाहते हैं (देखें #1571 और #330) लूप स्कोप?

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

x = 0
f(y) = (x=y)

किसी फ़ंक्शन के अंदर, f पहली पंक्ति से x को बदल देगा। आरईपीएल में यह नहीं होगा। लेकिन SoftGlobalScope.jl में इस तरह के बदलाव के साथ यह काम कर सकता है। बेशक, हम शायद यह नहीं चाहेंगे कि डिफ़ॉल्ट रूप से तब से स्टैंड-अलोन फ़ंक्शन परिभाषाएँ चिपकाने से काम नहीं चलेगा। पहली बात जो दिमाग में आती है वह लाइन-बाय-लाइन फ़ंक्शन डिबगिंग के लिए एक आरईपीएल मोड है।

क्या आप गंभीरता से पूर्व-v0.2 दुनिया में वापस जाना चाहते हैं

नहीं, मैं 0.6 दुनिया में वापस जाना चाहता हूं। मैं

मुझे लगता है कि मैं और अधिक प्रतिक्रिया दे रहा था:

यहां एक अन्य फिक्स का उल्लेख नहीं किया गया है, जो कि एक स्कोप-ब्लॉक को परिभाषित करने के लिए 'के लिए' बनाना बंद करना है

हमने वास्तव में कभी भी फ़ंक्शन लाइन-बाय-लाइन से कोड को आरईपीएल में कॉपी और पेस्ट करने का पूरी तरह से समर्थन नहीं किया है। तो हम इसे उस काम को करने के अवसर के रूप में देख सकते हैं।

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

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

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

julia> b = a + 1

में तब्दील किया जा रहा है

let a = _vars[:a]::Float64 # extract the variables used from the backing store
    # Code from the REPL
    b = a + 1
    # Save assigned variables back to the backing store
   _vars[:b] = b
end

ठीक से किया गया (यानी, किसी ऐसे व्यक्ति द्वारा जो जानता है कि वे क्या कर रहे हैं), मुझे लगता है कि मौजूदा आरईपीएल पर इससे कई लाभ होंगे। 1. इंटरैक्टिव डेटा विश्लेषण/गणना के साथ पिछले वर्कफ़्लो बस काम करते हैं। 2. प्रवचन पर बहुत कम पोस्ट जहां मूल प्रतिक्रिया "वैश्विक चर के साथ बेंचमार्किंग बंद करो" है - सब कुछ स्थानीय होगा और इसलिए उम्मीद है कि तेज़! :) 3. किसी फंक्शन बॉडी से कॉपी-एंड-पेस्ट उम्मीद के मुताबिक काम करता है। 4. एक workspace() जैसे फ़ंक्शन तुच्छ है यदि बैकिंग स्टोर किसी प्रकार का डिक्ट है; बस इसे साफ़ करें। 5. ग्लोबल्स स्पष्ट हो जाते हैं - चीजें स्थानीय होती हैं जब तक कि आप उन्हें विशेष रूप से वैश्विक होने के लिए नहीं कहते; यह मेरे दृष्टिकोण से एक बड़ा फायदा है, मुझे परोक्ष रूप से ग्लोबल्स बनाना पसंद नहीं है। एक बहुत ही मामूली अंतिम बिंदु (और मैं इसे जोड़ने में संकोच करता हूं!), यह मैटलैब के व्यवहार से मेल खाता है जिससे लोगों को संक्रमण करना आसान हो जाता है - मैटलैब आरईपीएल में सभी चर स्थानीय प्रतीत होते हैं जब तक कि स्पष्ट रूप से वैश्विक के रूप में एनोटेट नहीं किया जाता है।

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

SoftGlobalScope.jl के आधे रास्ते के लिए जाना कम से कम भ्रमित समझौता हो सकता है लेकिन मेरी चिंता यह है कि यह याद रखने के लिए नियमों का एक और सेट है (कौन सी चीजें आरईपीएल में काम करती हैं लेकिन मेरे कार्य निकाय/वैश्विक दायरे में नहीं हैं और विपरीतता से)।

लंबी पोस्ट के लिए माफ़ी, लेकिन मुझे लगता है कि यह उपयोगिता के लिए महत्वपूर्ण है (और इससे मुझे इसे सोचने में मदद मिली!)

परेशान उपयोगकर्ताओं द्वारा इस बारे में कितनी मेलिंग-सूची शिकायतें और जीथब मुद्दे दर्ज किए गए हैं? शून्य, मेरी गिनती से। क्यों? शायद इसलिए कि यह व्यवहार लोगों के लिए मौलिक रूप से आश्चर्यजनक है - यदि आप वैश्विक दायरे में काम करते हैं, तो आप वैश्विक स्थिति पर निर्भर हैं।

हम्म, क्या आपने वास्तव में इसका व्यवस्थित अध्ययन किया है? मेरे से वह छूट गया होगा। फिर भी, इसका मतलब यह नहीं है कि यह व्यवहार बग या अप्रत्याशित परिणामों का स्रोत नहीं है; बस उपयोगकर्ता द्वारा इसका पता लगाने के बाद, इसे सही व्यवहार के रूप में पहचाना गया और इस प्रकार किसी समस्या/शिकायत का संकेत नहीं दिया।

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

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

ऐसा प्रतीत होता है कि यह दृष्टिकोण अब संभव नहीं है। लेकिन मुझे आश्चर्य है कि क्या यह वास्तव में इसे करने का सही तरीका था, और इस बीच विभिन्न चीजों में बहुत सुधार हुआ है (#265 तय किया गया था, Revise.jl और हाल ही में Rebugger.j ने वर्कफ़्लो/डीबगिंग में काफी सुधार किया है)।

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

बस एक छोटा नोट: आरईपीएल के वैश्विक दायरे में विशेष आवरण के दौरान, कॉपी-पेस्ट करने वाले कोड को कार्यों में और से अनुमति देगा, यह किसी अन्य मॉड्यूल के वैश्विक दायरे में/से कॉपी-पेस्ट करने की अनुमति नहीं देगा।

मुझे आश्चर्य है कि क्या हम इसके बजाय शिक्षण के लिए अपने दृष्टिकोण को अनुकूलित कर सकते हैं, उदाहरण के लिए लूप से पहले फ़ंक्शन पेश करें, वैश्विक दायरे में लूप से बचें।

यह उस कक्षा में पूरी तरह से अव्यावहारिक है जो प्रोग्रामिंग सिखाने पर केंद्रित नहीं है। अगर मैं इसे अंतःक्रियात्मक रूप से उपयोग नहीं कर सकता और/या पहले सब कुछ के लिए फ़ंक्शन लिखना चाहता हूं तो मैं अपनी कक्षाओं में जूलिया का भी उपयोग नहीं कर सकता।

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

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

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

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

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

@StefanKarpinski : मुझे लगता है कि पहले, नरम/कठिन दायरे के साथ भ्रम एक सैद्धांतिक प्रकृति (मैनुअल पढ़ने वाले लोगों के) के बजाय एक व्यावहारिक (अनपेक्षित परिणाम प्राप्त करने वाले लोगों) के बजाय अधिक था। यह निश्चित रूप से मेरे लिए कैसा था और क्या, उदाहरण के लिए, यहां खोज परिणाम इसका समर्थन करते हैं; मुझे यहां एक प्रति-उदाहरण मिला।

दूसरी ओर, यह नया व्यवहार मैनुअल पढ़ते समय लोगों को भ्रमित नहीं करेगा, लेकिन आरईपीएल का उपयोग करते समय। यकीनन बाद वाला बदतर है।

SoftGlobalScope.jl अब एक पंजीकृत पैकेज है। मेरा इरादा इसे कम से कम इस सेमेस्टर में डिफ़ॉल्ट रूप से (ऑप्ट-आउट) IJulia के लिए सक्षम करना है।

@ मौरो 3 , यहां तक ​​​​कि आपका "काउंटर-उदाहरण" किसी ऐसे व्यक्ति के बारे में है जो हार्ड स्कोप से भ्रमित है, सॉफ्ट स्कोप से नहीं। 0.7 में अधिक क्षेत्रों को "कठिन" बनाना निश्चित रूप से इस प्रकार के और अधिक भ्रम पैदा करेगा।

मैं यह बताना चाहूंगा कि IJulia में डिफ़ॉल्ट रूप से वेरिएबल को स्थानीय do ब्लॉक बनाने की दिलचस्प संभावना है। यानी अगर आप इसे एक ही ब्लॉक में करते हैं तो यह काम करता है:

t = 0
for i = 1:n
    t += i
end
t

... और t केवल इस मूल्यांकन खंड में दिखाई दे रहा है। यदि आप चाहते हैं कि यह बाहर दिखाई दे, तो आपको यह करना होगा:

global t = 0
for i = 1:n
    global t += i
end
t

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

IJulia में डिफ़ॉल्ट रूप से वेरिएबल को स्थानीय do ब्लॉक बनाने की दिलचस्प संभावना है

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

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

फिर हमारे पास आरईपीएल वैरिएबल को आरईपीएल के लिए किसी भी तरह स्थानीय बनाकर भेद को और अधिक उचित/स्पष्ट करने का विकल्प भी है --- यानी सामान्य वैश्विक चर नहीं, Main.x रूप में उपलब्ध नहीं है। यह बहुत कुछ वैसा ही है जैसा @StefanKarpinski ने अभी ऊपर प्रस्तावित किया है, लेकिन सभी इनपुट ब्लॉक/सेल के बीच साझा किया गया है।

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

@StefanKarpinski
एक भोले प्रोग्रामर के रूप में, मैं वास्तव में नहीं देखता कि देखने में क्या गलत है
एक अजीब तरह के रूप में वैश्विक दायरा स्थानीय दायरे को घेरता है, विशेष रूप से गतिशील में
भाषाएं। मैं समझता हूँ कि एक संकलक की दृष्टि से यह नहीं है
आवश्यक रूप से सही (जूलिया में), लेकिन यह एक अच्छा, आसान और उपयोगी मॉडल है
एक (बेवकूफ) प्रोग्रामर के लिए। (मुझे यह भी संदेह है कि इसे वास्तव में इस तरह लागू किया जा सकता है
कुछ भाषाएं)।
जूलिया भी इसे प्रोग्रामर को इस तरह प्रस्तुत करती है:
निम्न फ़ंक्शन फ़ंक्शन "एक परिभाषित नहीं" त्रुटि देगा, जो
यदि लूप के लिए a=1 को पहले रखा जाता है तो यह नहीं होगा।

कार्य परीक्षण()
मैं के लिए = 1:10
ए=ए+आई
समाप्त
ए = 1
@शो ए
समाप्त

जो, जब तक कि मैं पूरी तरह से गलत समझा नहीं जाता, "क्या कोई
बाहरी स्थानीय चर मौजूद है, डिजाइन द्वारा, के क्रम पर निर्भर नहीं करता है
बाहरी स्थानीय दायरे में अभिव्यक्तियों की उपस्थिति या निष्पादन"।

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

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

मुझे इस पर पहले ध्यान देना चाहिए था, लेकिन कुछ पल की चिंता के बाद सब कुछ ठीक लगता है।

हमने वास्तव में कभी भी फ़ंक्शन लाइन-बाय-लाइन से आरईपीएल में कोड कॉपी और पेस्ट करने का पूरी तरह से समर्थन नहीं किया है ... पहली बात जो दिमाग में आती है वह लाइन-बाय-लाइन फ़ंक्शन डीबगिंग के लिए एक आरईपीएल मोड है।

वास्तव में रीबगर (जो ठीक यही है) 1.0 पर ठीक से काम करता है क्योंकि इसमें 0.7 के दायरे से बहिष्करण का अभाव है, और इसे कभी भी 0.6 पर काम करने के लिए नहीं बनाया जा सकता है। हालांकि, मुझे यह सत्यापित करने में प्रसन्नता हो रही है कि SoftGlobalScope.jl इसे तोड़ता नहीं है। उदाहरण के लिए, यदि आप show([1,2,4]) में पर्याप्त गहराई से कदम रखते हैं तो आप यहां प्राप्त करते हैं:

show_delim_array(io::IO, itr::Union{SimpleVector, AbstractArray}, op, delim, cl, delim_one) in Base at show.jl:649
  io = IOContext(Base.TTY(RawFD(0x0000000d) open, 0 bytes waiting))
  itr = [1, 2, 4]
  op = [
  delim = ,
  cl = ]
  delim_one = false
  i1 = 1
  l = 3
rebug> eval(softscope(Main, :(<strong i="10">@eval</strong> Base let (io, itr, op, delim, cl, delim_one, i1, l) = Main.Rebugger.getstored("bbf69398-aac5-11e8-1427-0158b103a88c")
       begin
           print(io, op)
           if !(show_circular(io, itr))
               recur_io = IOContext(io, :SHOWN_SET => itr)
               if !(haskey(io, :compact))
                   recur_io = IOContext(recur_io, :compact => true)
               end
               first = true
               i = i1
               if l >= i1
                   while true
                       if !(isassigned(itr, i))
                           print(io, undef_ref_str)
                       else
                           x = itr[i]
                           show(recur_io, x)
                       end
                       i += 1
                       if i > l
                           delim_one && (first && print(io, delim))
                           break
                       end
                       first = false
                       print(io, delim)
                       print(io, ' ')
                   end
               end
           end
           print(io, cl)
       end
       end)))
[1, 2, 4]

तो यह 1.0 पर ठीक काम करता है ( softscope साथ या बिना)। 0.7 पर, इसका मूल्यांकन (साथ या बिना softscope ) प्राप्त करेगा

┌ Warning: Deprecated syntax `implicit assignment to global variable `first``.
│ Use `global first` instead.
└ @ none:0
┌ Warning: Deprecated syntax `implicit assignment to global variable `first``.
│ Use `global first` instead.
└ @ none:0
[ERROR: invalid redefinition of constant first
Stacktrace:
 [1] top-level scope at ./REBUG:9 [inlined]
 [2] top-level scope at ./none:0
 [3] eval(::Module, ::Any) at ./boot.jl:319
 [4] top-level scope at none:0
 [5] eval at ./boot.jl:319 [inlined]
 [6] eval(::Expr) at ./client.jl:399
 [7] top-level scope at none:0

तो 0.7/1.0 निश्चित रूप से एक कदम आगे है, और अगर softscope महत्वपूर्ण कार्यक्षमता को तोड़े बिना कुछ चीजों को आसान बनाता है तो यह बहुत अच्छा है।

इसलिए, सबसे बड़ी चिंता यह है कि अन्य पैकेजों को टैंक किए बिना इसे उचित तरीके से कैसे रोका जाए (https://github.com/stevengj/SoftGlobalScope.jl/issues/2)।

@timholy , सॉफ़्टस्कोप मैक्रो कॉल के तर्कों को नहीं छूता है (क्योंकि यह जानने का कोई तरीका नहीं है कि मैक्रो इसे कैसे फिर से लिखेगा), इसलिए :(<strong i="6">@eval</strong> ...) सुरक्षित है।

के साथ अजीब लगता है "क्या an
बाहरी स्थानीय चर मौजूद है, डिजाइन द्वारा, के क्रम पर निर्भर नहीं करता है
बाहरी स्थानीय दायरे में अभिव्यक्तियों की उपस्थिति या निष्पादन"।

(बाहरी) स्थानीय चर a मौजूद है, लेकिन अभी तक असाइन नहीं किया गया है। यदि लूप ने इसे पढ़ने से पहले a को असाइन करने का प्रयास किया, तो असाइनमेंट बाहर भी दिखाई देगा।

सामान्य तौर पर, एक वैरिएबल बाइंडिंग बनाना और उसे एक मान निर्दिष्ट करना अलग-अलग चरण हैं।

इस पर समय-रेखा क्या है? ऐसा लगता है कि यह उपयोगकर्ता की उपयोगिता में एक बड़ा सुधार होगा। और 1.0 के साथ जूलिया के इस "महत्वपूर्ण" समय पर, यह निश्चित asap (ऊपर जेफ द्वारा सुझाए गए तरीके से) प्राप्त करना और एक नया जूलिया संस्करण या आरईपीएल संस्करण टैग करना फायदेमंद प्रतीत होगा। (इस आर्म-चेयर टिप्पणी के लिए खेद है, क्योंकि मैं निश्चित रूप से इसे ठीक नहीं करूँगा!)

@JeffBezanson
मैं तर्क देने जा रहा था कि यह सच है (कार्यान्वयन/संकलक के लिए), बेवकूफ जूलिया प्रोग्रामर अपने सरल वैचारिक मॉडल से कोई अलग व्यवहार नहीं देख सकता है (एक चर परिभाषित होने पर एक चर शुरू होता है)। दुर्भाग्य से आप सही हैं, निम्न कोड त्रुटि नहीं देगा, जबकि यदि आप अंत में a=2 छोड़ देते हैं तो यह एक त्रुटि देगा
कार्य परीक्षण()
मैं के लिए = 1:10
ए = 1
समाप्त
प्रिंट्लन (ए)
ए = 2
समाप्त
मैं दुर्भाग्य से समझाऊंगा: मैं व्यवहार को समझ सकता हूं (क्योंकि मैंने पहले संकलित भाषाओं के साथ काम किया है) लेकिन फिर भी इसे भ्रमित और अप्रत्याशित लगता है। केवल स्क्रिप्टिंग अनुभव वाले या प्रोग्रामिंग के लिए नए व्यक्ति के लिए यह कितना बुरा होना चाहिए। साथ ही, मुझे कुछ कोड मिला जो व्यवहार दिखाता है, मुझे एक उपयोगी एप्लिकेशन नहीं दिख रहा है (शायद आप वहां मेरी मदद कर सकते हैं)

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

@jeffbezanson और मैं दोनों लंबे समय से प्रतीक्षित छुट्टियों पर हैं (मुझे इसे नहीं पढ़ना चाहिए)। हम यह पता लगा सकते हैं कि एक-एक सप्ताह में क्या करना है।

@derijkp , जबकि प्रतिक्रिया की सराहना की जाती है, व्यापक बहस या संशोधन के लिए स्कोपिंग नियम नहीं हैं। मेज पर केवल एक चीज विशेष-आवरण इंटरैक्टिव eval है। सॉफ्टग्लोबलस्कोप पैकेज पहले से ही एक उत्कृष्ट प्रयोगात्मक कार्यान्वयन है और यह केवल आधार के उस हिस्से को बनाने और आरईपीएल में इसका उपयोग करने की बात हो सकती है।

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

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

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

मैं सहमत हूं... और यह भी सोचता हूं कि स्कोपिंग नियमों को जरूरी नहीं बदलना चाहिए, बस सभी इंटरैक्टिव इंटरफेस (यानी आरईपीएल, जुपिटर, और जूनो नियंत्रण दर्ज करें)

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

बेशक, मैं अन्य पोस्टरों से भी सहमत हूं ... शुरुआती लोगों के साथ वे कोड के टुकड़े लेने जा रहे हैं जो वे कार्यों के भीतर देखते हैं, I को स्क्रिप्ट में कॉपी करते हैं, और पूरी तरह से भ्रमित हो जाते हैं जब किसी फ़ंक्शन के अंदर कॉपी किए जाने पर इसका समान व्यवहार नहीं होता है , जूनो में, प्रतिलिपि, और ज्यूपिटर। 100 स्टैक एक्सचेंज प्रश्न होंगे जो एक ही मुद्दे पर आते हैं। इंटरमीडिएट प्रोग्रामर के पास let ब्लॉक आदि में रैपिंग के साथ सभी प्रकार के घरेलू समाधान होंगे, जो चीजों को और भ्रमित करेंगे

100 स्टैक एक्सचेंज प्रश्न होंगे जो एक ही मुद्दे पर आते हैं। इंटरमीडिएट प्रोग्रामर के पास let ब्लॉक आदि में रैपिंग के साथ सभी प्रकार के घरेलू समाधान होंगे, जो चीजों को और भ्रमित करेंगे

संभवतः, लेकिन इस स्तर पर यह काल्पनिक है (लिंक किए गए प्रश्न का ओपी भी स्कोपिंग नियम के औचित्य के बारे में पूछ रहा है, इसके बारे में भ्रमित होने के विपरीत)।

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

ऐसा लगता है कि प्रश्नकर्ता इससे भ्रमित हो गया है: "मुझे आश्चर्य है कि यह जूलिया उपयोगकर्ताओं को शुरू करने के लिए सहज है। यह मेरे लिए सहज नहीं था ..."

ऐसा लगता है कि प्रश्नकर्ता इससे भ्रमित हो गया है:

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

शायद, लेकिन इस स्तर पर यह काल्पनिक है

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

100 स्टैक एक्सचेंज प्रश्न होंगे जो एक ही मुद्दे पर आते हैं।

अपने "खाली समय" में, मैं SE प्रश्नों में scope , scoping , और global-variables टैग जोड़ रहा हूं। मैं केवल समय की कमी के कारण रुकता हूं, इसलिए नहीं कि और नहीं हैं।

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

ये दो कथन मुझे थोड़ा भ्रमित करते हैं क्योंकि वे थोड़े विरोधाभासी लगते हैं:

और इसे आरईपीएल और अन्य सभी इंटरैक्टिव मूल्यांकन संदर्भों में उपयोग करें

[...] लिपियों में कोई गुंजाइश व्यवहार नहीं है, केवल आरईपीएल जैसे संदर्भों में।

क्या इसका मतलब यह है कि मॉड्यूल Main में कभी-कभी एक नरम दायरा होता है (आरईपीएल प्रॉम्प्ट पर कहें) और कभी-कभी एक कठिन दायरा (कहें जब julia -L script.jl )? क्या यह कहने का कोई मतलब नहीं होगा कि Main हमेशा सॉफ्ट स्कोप होता है? और एक मॉड्यूल using SoftGlobalScope द्वारा सॉफ्ट स्कोप में ऑप्ट-इन कर सकता है?

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

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

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

कृपया, कृपया, कृपया इसे एक बगफिक्स के रूप में मानने और स्क्रिप्ट के साथ-साथ आरईपीएल के साथ इसे बाहर करने के बारे में सोचें - भले ही "पुराने" व्यवहार पर जाने के लिए कोई स्विच हो - और इसे 1.0.1 में जितनी जल्दी हो सके।

एक सहकर्मी जिसे मैं जूलिया सीखने की कोशिश कर रहा था, वह भी इसमें भाग गया। पहले चरणों में संपूर्ण वैश्विक बनाम स्थानीय परिवर्तनशील चीज़ों की व्याख्या करना आदर्श नहीं है...

मुझे नहीं लगता कि इसे "बगफिक्स" के रूप में व्यवहार करना कार्ड में है, क्योंकि यह 1.0 स्थिरता अनुबंध को तोड़ देगा। हालांकि, julia -i (यानी "इंटरैक्टिव" मोड) के साथ चलने वाली स्क्रिप्ट के लिए सॉफ़्टस्कोप का उपयोग करना मेरे लिए उचित लगता है।

(अर्थात, एक ध्वज --softscope={yes|no} होगा और यह isinteractive के मान पर डिफ़ॉल्ट होगा।)

हमें स्क्रिप्ट मोड विकल्प पर विचार करना होगा।

उस मामले के लिए, किसी भी "स्क्रिप्ट" के लिए --softscope=yes लिए डिफ़ॉल्ट रूप से मेरे लिए पागल नहीं है, यानी julia foo.jl , और केवल मॉड्यूल के लिए "हार्ड" स्कोपिंग नियम चालू करें और include (जिस बिंदु पर आपको वास्तव में अधिकांश कोड को फ़ंक्शन में डालना चाहिए)।

उस मामले के लिए, यह मेरे लिए किसी भी "स्क्रिप्ट" के लिए --softscope=yes डिफ़ॉल्ट करने के लिए पागल नहीं है,

उस। गंभीरता से विचार करने वाला दूसरा जूनो है। याद रखें कि लोग इंटरैक्टिव विकास करने के लिए अपने कोड के माध्यम से <shift-enter> करेंगे (विशेषकर जब प्रतिगमन परीक्षणों के साथ काम कर रहे हों) और फिर बाद में उसी फ़ाइल को चलाने में सक्षम होने की उम्मीद करेंगे। क्या इससे कोई फर्क पड़ता है कि कोड @testset या नहीं (जो मुझे लगता है कि एक दायरा पेश कर सकता है)? यह उपयोगकर्ता के लिए बहुत भ्रमित करने वाला होगा यदि एक ही पाठ @testset बनाम एटम के एकीकरण का उपयोग करते समय नहीं बदलता है, और साथ ही ] test करने के साथ असंगत है।

यह निश्चित रूप से मुझे लगता है कि सबसे अच्छा समाधान यह है कि हार्ड-स्कोप केवल एक ऑप्ट-इन चीज है, जहां यदि हर दूसरे उपयोग (स्क्रिप्ट के भीतर include सहित) softscope का उपयोग करता है जब तक कि आप अन्यथा न कहें .

पृथ्वी पर हर दूसरी भाषा से अलग

क्या आप प्रत्येक चर का परिचय देने के लिए var x = 0 लिखना चाहते हैं? यह इसे "ठीक" भी करेगा, और अन्य भाषाओं की तरह अधिक होगा।

हम यह नहीं कह रहे हैं कि हर बग को हमेशा के लिए पुन: पेश किया जाएगा हम हैं

ऐसा नहीं है कि यह कैसे काम करता है। केवल वर्तमान व्यवहार को एक बग कहकर आप अपनी इच्छित भाषा में कोई परिवर्तन नहीं कर सकते।

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

मुझे इसका एक स्पष्टीकरण प्रदान करने के लिए फिर से प्रयास करना चाहिए जो कि उन्माद, हिस्टीरिया और नरसंहार से बचने के लिए उपयोगी हो सकता है जो लोग कक्षा में देख रहे हैं:

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

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

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

मैं सहमत हूं। मेरे लिए एक शिक्षण और संचार सिरदर्द की तरह लगता है।

उदाहरण के लिए, मॉड्यूल के अंदर कठिन दायरा केवल समझ में आता है।

बस इतना ही मैं समझता हूं: अगर मेरे पास .jl फ़ाइल में एक छोटी स्क्रिप्ट (मॉड्यूल में नहीं!) थी जिसे मैंने IJulia नोटबुक से कॉपी किया था, तो अगर मैंने उस कोड को सीधे आरईपीएल में चलाया या शिफ्ट- जूनो में प्रवेश करें, तो यह लगातार सॉफ्ट-स्कोप के रूप में व्यवहार करेगा ... लेकिन अगर मैंने इसे module ब्लॉक के बजाय कॉपी किया तो यह मुझ पर ग्लोबल्स के बारे में चिल्लाएगा? लेकिन अगर मैंने उस कोड को मॉड्यूल के अंदर फ़ंक्शंस के अंदर कॉपी किया है, तो उसे काम करना चाहिए।

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

क्या आप प्रत्येक चर का परिचय देने के लिए var x = 0 लिखना चाहते हैं? यह इसे "ठीक" भी करेगा, और अन्य भाषाओं की तरह अधिक होगा।

नहीं, मैं नहीं बल्कि! लेकिन आरईपीएल वाली स्क्रिप्टिंग भाषाएं शायद ही कभी ऐसा करती हैं (जैसे रूबी, पायथन, आर, ...), वे जूलिया v0.6 की तरह व्यवहार करती हैं।

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

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

यह भी ध्यान दें कि यह केवल "_वेरिएबल्स जो आप आरईपीएल में या शीर्ष स्तर पर पेश करते हैं, किसी और चीज के बाहर, वैश्विक हैं_" और "_वैरिएबल्स के अंदर पेश किए गए फ़ंक्शन और लूप स्थानीय हैं_", यह भी है कि आरईपीएल में या पर बयान में चर शीर्ष स्तर वैश्विक हैं लेकिन @testset में चर स्थानीय हैं। हम "बस इसे आज़माएं और अपने लिए काम करें चाहे वह स्थानीय हो या वैश्विक, सौभाग्य" के एक खरगोश-छेद को समाप्त करते हैं।

हालांकि, मैं @jlperla से सहमत

हम लोगों पर थोपने की गुंजाइश के रूप में दूर से कुछ भी जटिल नहीं चाहते हैं ...
शीर्ष स्तर पर वैश्विक हैं लेकिन @testset में चर स्थानीय हैं

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

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

और वैश्विक बनाम स्थानीय पर एक सरल रेखा पर्याप्त होनी चाहिए।

एक ऐसी दुनिया में जहां सभी ने अपना सारा कोड एकदम से लिखना शुरू कर दिया है, मैं पूरी तरह सहमत हूं।

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

और फिर छात्र पूछना शुरू करते हैं कि for क्यों ऐसा दायरा बनाते हैं जिसके बारे में उन्हें चिंता करने की आवश्यकता है लेकिन अन्य चीजों की नहीं ....

हम "बस इसे आज़माएं और अपने लिए काम करें चाहे वह स्थानीय हो या वैश्विक, सौभाग्य" के एक खरगोश-छेद को समाप्त करते हैं।

पॉप क्विज़: जूलिया 0.6 में, x वैश्विक या स्थानीय है:

for i = 1:10
    x = i
end

इसका उत्तर यह है कि जानने का कोई तरीका नहीं है, क्योंकि यह इस बात पर निर्भर करता है कि वैश्विक x को पहले परिभाषित किया गया है या नहीं। अब, आप निश्चित रूप से कह सकते हैं कि यह स्थानीय है।

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

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

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

वैसे, मैं अभी तक जूलिया में नौसिखिया हूं, मैंने इसे कुछ हाई-स्कूल और स्नातक छात्रों को भौतिक प्रणालियों के सिमुलेशन की कुछ मूल बातें सिखाने के लिए चुना है। और मैं पहले से ही इस मुद्दे को पिछले संस्करणों के 'सामान्य' व्यवहार पर लौटने की उम्मीद कर रहा हूं, क्योंकि यह हमें काफी सिरदर्द देता है।

यह बातचीत अभी बंद है और केवल जूलिया कमिटर्स ही टिप्पणी कर सकती हैं।

@JeffBezanson , इस प्रवचन सूत्र में आपके द्वारा सुझाए गए शब्दार्थ को लागू करने की योजना क्या होगी, शुरुआत में केवल आरईपीएल में और कहीं और ऑप्ट-इन?

ऐसा लगता है कि आप इसे सीधे निचले कोड ( julia-syntax.scm ) में डालने की योजना बना रहे हैं, बजाय इसके कि सॉफ्टस्कोप.जेएल को फिर से लिखने वाले सिंटैक्स के रूप में? या आप इसे पहले सिंटैक्स पुनर्लेखन के रूप में रखेंगे (प्रस्तावित नियम में सॉफ्टस्कोप को संशोधित करना और इसे एक stdlib में परिवर्तित करना), और बाद में जूलिया रिलीज के लिए इसे कम कोड में डालना स्थगित करें?