पहली उच्च स्तरीय प्रोग्रामिंग भाषा - प्लांकल्कुल

प्लैंकल्कल दुनिया की पहली उच्च स्तरीय प्रोग्रामिंग भाषा है जिसे जर्मन इंजीनियर कोनराड ज़ूस ने विकसित किया है
उनके Z4 कंप्यूटर के लिए 1942 और 1946 (नीचे चित्र में कंप्यूटर, विकिपीडिया से ली गई तस्वीर)।


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

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

केवल 1957 में (1954 में काम शुरू किया गया था) फोरट्रान दिखाई दिया - वह भाषा जो सबसे पहले उच्च-स्तरीय भाषा को मानती है।

"Z4" इलेक्ट्रोमैकेनिकल था, इसलिए प्लैंककलिल कंपाइलर या दुभाषिया मौजूद नहीं था, लेकिन 2000 में स्वोबोडनी में
बर्लिन विश्वविद्यालय (Freie Universität Berlin) ने उनकी व्याख्या की
बोली (ब्राउज़र में जावा एप्लेट के रूप में लॉन्च की गई)।

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

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

सभी चर को चार प्रकारों में विभाजित किया गया है।

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

तीन प्रकार के चर उपलब्ध हैं। इस तथ्य के बावजूद कि "Z4" फ्लोटिंग-पॉइंट नंबरों के साथ संचालित करने में सक्षम था, दुभाषिया को पता नहीं है कि कैसे।

• एक गैर-नकारात्मक पूर्णांक के लिए, बिट्स में आयाम इंगित किया गया है। "0" लिखने के दो रूप हैं - एक बिट, "n.0" - "एन" बिट्स, उदाहरण के लिए, 8.0 - एक बाइट (8 बिट)।
• टपल को कोष्ठक में इंगित किया गया है, उदाहरण के लिए (3.0, 4.0) - ये तीन और चार बिट्स के दो चर हैं, टपल में एक से अधिक तत्व होने चाहिए।
• एक बिंदु को एक बिंदु के माध्यम से लिखा जाता है, उदाहरण के लिए: 4.5.0 - पांच बिट्स के चार तत्वों की एक सरणी, 32. (0, 8.0, 16.0) - 32 ट्यूपल, जिनमें से प्रत्येक में तीन चर होते हैं: एक बिट, आठ और
  सोलह।

Plankalkyul को स्पष्ट रूप से वाक्यविन्यास द्वारा बहुत सरल किया जा सकता है, लेकिन आधुनिक बोली लगभग उस रिकॉर्ड की प्रतिलिपि बनाती है जिसका उपयोग Zuse ने किया है, मेरा मानना ​​है कि ऐसा वाक्यविन्यास पैदा होने के कारण हुआ था
कागज पर कार्यक्रम को "डिबग" करने की आवश्यकता है। हालाँकि, भाषा इतनी सरल है कि मैंने यह सब लगभग 15 मिनट में सीख लिया और यहां तक ​​कि कई संस्करणों में इस पर कुछ कार्यक्रम भी लिखे।

उनमें से एक संकेतित (क्रम में) फाइबोनैचि संख्या की गणना करता है:

P0 FactEvgenyStepanischev (V0[:4.0]) => (R0[:10.0]) (0, 1) => (Z0[:10.0], Z1[:10.0]) W1 (V0[:4.0]) [ i > 0 -> (Z0[:10.0] + Z1[:10.0], Z1[:10.0] - Z0[:10.0]) => (Z1[:10.0], Z0[:10.0]) ] Z1[:10.0] => R0[:10.0] END 

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


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

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

नीचे "लूप" (W1) के लिए नीचे दिया गया है, क्योंकि मैंने लूप वेरिएबल की संख्या को इंगित नहीं किया था (पहले वर्गाकार कोष्ठक जो यहां छोड़े गए हैं) को इंगित नहीं किया गया है, लूप वैरिएबल "i" का उपयोग किया जाता है, बिना नंबर के।
दोहराव की संख्या को कोष्ठक में दर्शाया गया है, और बाद के वर्ग कोष्ठक में चक्र का शरीर। विवरण कर सकते हैं
वर्णन में पाया गया।

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

मैंने यहां जटिल असाइनमेंट का इस्तेमाल किया, जो पर्ल, पायथन या पीसीपी का उपयोग करने वालों से परिचित है, लेकिन यह अलग तरह से काम करता है - प्रदर्शन किए जाते हैं
क्रमिक रूप से, बाएं से दाएं, इसलिए मैं अपने आप को "(Z0 [: 10.0] + Z1 [: 10.0], Z1 [: 10.0]) => (Z1 [: 10.0], Z0 [: 10.0])" तक सीमित नहीं कर सकता, परिणाम नहीं आएगा एक उम्मीद है कि

अंत में, मैं सबरूटीन के परिणामस्वरूप मूल्य के लिए एक मध्यवर्ती मान प्रदान करता हूं।

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