असामान्य पारंपरिक डिजाइन

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

बीटा

बीटा एक ऑब्जेक्ट-ओरिएंटेड भाषा है, जो सिमुला का उत्तराधिकारी है। इसमें कई अद्भुत विशेषताएं हैं जो मैं विचार करूंगा। कुछ भी हो, एक विकिपीडिया लेख है। तो, बीटा में केवल दो (!) नियंत्रण निर्माण हैं: यदि और के लिए। और यह जीवन के लिए पर्याप्त है। यदि निर्माण उल्लेखनीय है, क्योंकि यह प्रत्येक को अभिव्यक्ति के परिणाम को लिखने की अनुमति देता है जो यदि उसके बाद आता है। न केवल यह आपको अन्य शाखा से छुटकारा पाने की अनुमति देता है, बल्कि यह दृष्टिकोण मामले के निर्माण का अनुकरण करना संभव बनाता है:
(if x
// 17 then …
// 33 then …
// y+3 then …
else …
if);

(if (x>0) and (y<0)
// True then …
// False then …
if)
कहने की जरूरत नहीं, अद्भुत भाषा! सभी वाक्यविन्यास को एक पृष्ठ पर संक्षेप में वर्णित किया जा सकता है। BETA असाइनमेंट डिज़ाइन में भी दिलचस्प है। ऐसा लगता है -> और आपको कई असाइनमेंट करने की अनुमति देता है:
10->j -> k;
i + 3 * j->k ;
उसी सिंटैक्स का उपयोग करके, आप C ++ की तरह ऑब्जेक्ट्स को डेटा भेज सकते हैं:
'Hello, World!'->putline;
लेकिन सबसे दिलचस्प चक्र को लागू करने की संभावना है। उदाहरण के लिए, एक पूरी तरह से वैध लूप कुछ इस तरह दिखता है:
X -> Root;
L: (if (X-Root*Root -> fabs) > X / 10E6 then
0.5 * (Root + X div Root) -> Root;
restart L;
if);
और यह सब इस तथ्य के बावजूद कि हमारे लिए मौलिक रूप से नया कुछ भी नहीं है - एक ही लूप, असाइनमेंट ऑपरेटर, यदि कथन। कुछ प्रतिबंधों को हटा दिया गया और नए जोड़े गए।

एफिल

इस खूबसूरत प्रोग्रामिंग भाषा को इस तथ्य से याद किया गया था कि इसमें केवल एक लूप ऑपरेटर है, लेकिन यह बहुत कार्यात्मक और न्यूनतर है। यहाँ उसकी परिभाषा (विकिपीडिया से) है:
from

until

loop

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

चिह्न

आइकन को सुपर-उच्च स्तर की भाषा के रूप में तैनात किया गया है। मेरी टिप्पणियों के साथ निम्नलिखित उदाहरणों को देखने के बाद, इस कथन से असहमत होना मुश्किल है। पाथ आइकॉन - स्ट्रिंग्स के साथ काम करना, यह वास्तव में इस का एक उत्कृष्ट काम करता है। यहाँ क्या दिलचस्प है? हां, लगभग सब कुछ, मुझे यह भी पता नहीं है कि कहां से शुरू करना है।
आइकन में, स्ट्रिंग्स के साथ, आप तार्किक संचालन कर सकते हैं और आप कुछ ऐसा लिख ​​सकते हैं
S:="ab"
S:=S || "cd" # S == "abcd"
मेरे लिए, यह पास्कल या BASIC जैसी भाषाओं में + ऑपरेटर का उपयोग करने से अधिक तर्कसंगत है। वास्तव में, यहां तक ​​कि ऑपरेशन का नाम - संघनन, खुद के लिए बोलता है। इसके अलावा, एक और उपयोगी निर्माण है: यूनिरी ऑपरेटर *। यदि इसके बाद कोई रेखा होती है, तो वह पंक्ति में वर्णों की संख्या लौटाती है:
S:="abcd"
write(*S) # '4'
यह अन्य भाषाओं में लेन () फ़ंक्शन की तुलना में बहुत अधिक सुरुचिपूर्ण है (नाम भिन्न हो सकता है, लेकिन यह महत्वपूर्ण नहीं है)। अन्य प्रोग्रामिंग भाषाओं में इस दृष्टिकोण का उपयोग क्यों नहीं किया जाता है? उत्तर स्पष्ट है: पात्रों की अस्पष्टता। सी ++ या जावा जैसी भाषाएं पहले से ही अभिभूत हैं, और यहां समस्याओं का एक और पैकेज है: आपको यह पहचानने की आवश्यकता है कि चरित्र एक निश्चित स्थान पर वास्तव में क्या करता है: गुणन, या स्ट्रिंग की लंबाई वापस करना? या शायद मेरा मतलब कुछ भयानक है:
S:="abcd"
S[3:3]:="aaa"
S[*S+1:*S+1]:="y"
write(S) # , !
मुझे लगता है कि मुझे तुरंत कुछ और पारंपरिक करने की जरूरत है ...

फ़ैक्टर

इससे पहले, मैंने मुख्य रूप से तटस्थ तरीके से वाक्य रचना के असामान्य रूपांतरों के बारे में लिखा था, पाठक खुद के लिए तय कर पाएंगे कि क्या एक अच्छा विचार भाषा में एम्बेडेड था या नहीं। लेकिन अब मैं इस बारे में लिखूंगा कि आपको सिंटैक्स को विकृत करने की आवश्यकता नहीं है। एक प्रमुख उदाहरण: एक सशर्त यदि कारक में बयान। फोर्ट की तरह फैक्टर की मुख्य बारीकियों, स्टैक के साथ जुड़े उलटा अंकन हैं। इसके कारण, यदि कथन कहा जाता है, तो स्थिति का मूल्यांकन किया जाता है। यदि आप ऑपरेटर को पारंपरिक रूप से लिखते हैं, तो कुछ पसंद है
IF THEN 1
ELSE 2
END IF
मेरी राय में, यह घृणित है। फोर्ट डेवलपर्स ने एक और समाधान पाया है, यह बहुत बेहतर है। अब IF स्थिति और फिर शाखा को अलग करता है। इस प्रकार,
IF
1
ELSE 2
END IF
लेकिन फैक्टर ने दूसरे रास्ते पर जाने का फैसला किया। मैं केवल तथ्य की गणना का एक उदाहरण देता हूं:
: tail-factorial
dup 0 =
[ drop ]
[ [ * ] [ 1 - ] bi tail-factorial ]
if ;
प्रश्न: क्या आप कुछ समझते हैं? मैं एक बार में केवल एक ही चीज़ को समझता था - तब कोई और नहीं होता है, और अगर वे दोनों शाखाओं के बाद छिपते हैं! मतलब? आप कोड पढ़ते हैं, पढ़ते हैं, पढ़ते हैं ... और अंत में आपको अचानक पता चलता है कि ये एक सशर्त बयान की शाखाएं हैं। किले में, यह तुरंत स्पष्ट है कि आपके सामने क्या है - एक चक्र, या स्थिति। इसके अलावा, फोर्ट में, कार्यक्रम की तार्किक संरचना बेहतर दिखाई देती है, जबकि फैक्टर में, केवल वर्ग कोष्ठक का एक सेट। वे बुद्धिमान थे, बुद्धिमान थे, वे खुद भी बहुत बुद्धिमान थे ...

एडीए

इस शक्तिशाली, लेकिन जटिल प्रोग्रामिंग भाषा में, मुझे पूरे सरणी असाइनमेंट और बेहतर शुरुआत ... एंड ब्रैकेट्स याद हैं। हम उनके साथ शुरू करेंगे। उन दिनों में जब मैंने पास्कल को पढ़ाया था, तो मैं बहुत नाराज़ था कि मैं जहाँ चाहता था, वहाँ चर घोषित नहीं कर सका। नर्क में, यह मुद्दा हल हो गया है। शुरू करने से पहले ... अंत में, मैं घोषणात्मक भाग सम्मिलित कर सकता हूं, जहां मैं उन सभी चर और डेटा को परिभाषित करूंगा जो केवल इस ब्लॉक में उपयोग किए जाते हैं। एक उदाहरण:
declare
i : integer;
begin
-- , i
end;
-- i !
दूसरा दिलचस्प बिंदु सरणियों का संपूर्ण असाइनमेंट है। मान लीजिए कि हमारे पास दो समान सरणियाँ हैं, ए और बी। हमें a से b तक के सभी डेटा को कॉपी करना होगा। Ada में, इस प्रक्रिया को b: = a लिखकर एक चरण में किया जा सकता है। लेकिन एक बात है लेकिन: संकलक को कैसे पता चलता है कि सरणियाँ समान हैं? ऐसा करने के लिए, हम आधार प्रकार बना सकते हैं, हम इसे Test_Array कहेंगे:
type Test_Array is array (1..50) of Integer;
अब इस प्रकार के उदाहरणों के रूप में a और b घोषित करें:
a, b : Test_Array;
संकलक याद रखता है कि सरणियाँ प्रकार के अर्थों में समान हैं और अब a: = b जैसे संचालन की अनुमति देती हैं। नर्क में, ओओपी अवधारणाओं का स्वाद बहुत महसूस होता है।
एक और बहुत दिलचस्प बात: समुच्चय। लेकिन कई भाषाओं में, समुच्चय में भी अनुमानित समरूपता नहीं होती है, और समुच्चय का वर्णन बहुत सरल नहीं है। इसलिए, मैं जिज्ञासु को संबंधित लेख भेज देता हूं।

खुद से

मैं अपने विचारों को जनता के सामने पेश करने का उपक्रम करूंगा। सबसे पहले, अगर बयान एक शर्त को स्वीकार नहीं करता है, लेकिन अल्पविराम द्वारा अलग की गई शर्तों की एक सूची क्यों नहीं?
if 1, 2, ... , N then
...
end if
यदि कम से कम एक स्थिति झूठी है, तो किसी अन्य शाखा को निष्पादित किया जाता है, यदि कोई हो। इसकी आवश्यकता क्यों है? मान लें कि हमारे पास कई शर्तें हैं जिन्हें निष्पादित करने के लिए तत्कालीन शाखा के लिए सही होना चाहिए। फिर हम कुछ ऐसा लिखेंगे
if (1) and (2) and (3) then ...
अब मान लीजिए कि प्रत्येक स्थिति बल्कि जटिल है, और उनके ऑपरेटरों के साथ अलग-अलग तार्किक ऑपरेटरों को अलग करना होगा ताकि अनुवादक उन्हें सही ढंग से लिख सके। परिणामस्वरूप, हमें कोष्ठक के पर्वत मिलते हैं और इससे अधिक कुछ नहीं। बेशक, ऐसी स्थितियां बहुत दुर्लभ हैं, और लगभग एक हजार मामलों में से एक में होती हैं, लेकिन जब वे उत्पन्न होती हैं ... मेरा प्रस्ताव हमें कोष्ठक पर भार कम करने की अनुमति देता है, तो यह हमें एक महीने में अपने स्वयं के कार्यक्रम को बेहतर ढंग से समझने की अनुमति देगा। सामान्य तौर पर, स्थिति की एक सूची के बाद अगर ऐसी भयावहता लिखने की संभावना कम हो जाएगी:
if (figureX > leftLimit && figureX < fightLimit && figureColor == GREEN)
भले ही स्थितियों को अलग-अलग रेखाओं पर रखा गया हो, अर्धविराम विकल्प अधिक सुरुचिपूर्ण दिखता है (हालाँकि ... यह स्वाद की बात है):
if (figureX > leftLimit,
figureX < fightLimit,
figureColor == GREEN) ...
मुझे नहीं लगता कि समुदाय इस विचार को सकारात्मक रूप से लेगा, मैं खुद इस पर जोर नहीं देता। लेकिन यह सभी नई चीजों और अवधारणाओं के साथ होता है। विचार पास्कल जैसी भाषाओं के लिए अच्छी तरह से काम करता है, जहां कभी-कभी दुर्भाग्यपूर्ण प्रोग्रामर शर्तों का वर्णन करते समय कोष्ठक में डूब जाता है।