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

पहला डिज़ाइनर डिक ब्रुना था, जो मिफ़ी (या मूल डच में "निजेंट्जे") का निर्माता था:

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

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

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

सन् 1958 की बात है। निज्न्त्जे की केवल दो पुस्तकें उपलब्ध थीं, और केवल डच में। मेरे माता-पिता पहली बार मिले (अंततः मेरा जन्म 1964 में हुआ)। अंतरिक्ष की दौड़ शुरू करते हुए रूसियों ने एक साल पहले स्पुतनिक उपग्रह लॉन्च किया था।

उस समय दुनिया का सबसे बड़ा कंप्यूटर IBM द्वारा निर्मित सैन्य प्रणाली AN/FSQ-7 था , जिसमें 24 मशीनें थीं। प्रत्येक मशीन का वजन 250 टन था, 3 मेगावाट बिजली का इस्तेमाल किया और प्रति सेकंड 75,000 ऑपरेशन किए। (तुलना के लिए, आपका फोन बैटरी पावर पर लगभग एक लाख गुना तेज है।)

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

नीदरलैंड में, अनुसंधान संस्थानों और फिलिप्स और फोकर जैसी उच्च तकनीक कंपनियों के स्वामित्व वाले कुछ ही कंप्यूटर थे।

विलेम वैन डेर पोएल ने दो साल पहले अपनी पीएचडी थीसिस "द लॉजिकल प्रिंसिपल्स ऑफ सम सिंपल कंप्यूटर्स" समाप्त की थी। उनकी थीसिस ने समझाया कि आप कम से कम संसाधनों के साथ एक कंप्यूटर कैसे बना सकते हैं।

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

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

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

विलेम वैन डेर पोल की मेरी यादें

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

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

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

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

ज़ेबरा कंप्यूटर का कार्य करना

ZEBRA कंप्यूटर के काम करने के अजीब तरीके को समझने के लिए, कंप्यूटर के काम करने के तरीके के बारे में आपने जो कुछ भी लिया था, उसे भूलने के लिए तैयार रहें। ZEBRA में कीबोर्ड, ROM, बाइट्स, पॉइंटर्स, स्टैक या प्रोग्राम काउंटर भी नहीं था।

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

हार्डवेयर

ZEBRA एक सीरियल मशीन है: इसका मतलब है कि बिट्स को एक-एक करके जोड़कर जोड़ा जाता है। सभी ऑपरेशन 33 बिट्स थे। हाँ, 33: यह कोई गलती नहीं है! बिट बाय बिट जोड़ के लिए इलेक्ट्रॉनिक सर्किट एक " सीरियल बाइनरी योजक " है, एक बहुत ही बुनियादी डिजिटल सर्किट। लेकिन चूंकि इसे वैक्यूम ट्यूबों का उपयोग करके लागू किया गया है, इसमें पहले से ही कुछ किलो इलेक्ट्रॉनिक्स लगे हैं। ZEBRA में कुल मिलाकर पांच सीरियल योजक शामिल थे, साथ ही एक "इंक्रीमेंटर", इस सर्किट का एक सरलीकृत संस्करण जो एक को एक संख्या में जोड़ता है।

निर्देश और डेटा दोनों का आकार समान था; वास्तव में, दोनों के बीच वास्तव में कोई अंतर नहीं था, जैसा कि आपको कभी-कभी निर्देशों के साथ गणना करने की आवश्यकता होती है।

याद

ZEBRA में 33 बिट्स मेमोरी के 8192 शब्द थे, जो एक चुंबकीय ड्रम पर 256 ट्रैक्स के रूप में व्यवस्थित थे। प्रत्येक ट्रैक में 32 शब्द थे, इसका मतलब है कि एक ड्रम एड्रेस में ट्रैक का निर्धारण करने वाले आठ बिट्स और ट्रैक पर स्थिति का निर्धारण करने वाले पांच बिट शामिल थे।

ड्रम प्रति सेकंड 100 चक्कर लगाता था। ड्रम पर ट्रैक बदलने में कोई देरी नहीं हुई; आपको केवल दृश्य में घुमाने के लिए सही मान की प्रतीक्षा करनी है, जिसमें 10 मिलीसेकंड तक का समय लगता है। चालाकी से कार्यक्रम लिखे जाते थे ताकि ढोल (किसी भी ट्रैक पर) के आगे पता हो। इस तरह आपको ड्रम के लिए इंतजार नहीं करना पड़ा।

संक्षेप में, ZEBRA के तीन प्रकार के चक्र थे: 7.8 μs का बिट समय, जिसमें एक बिट को योजक द्वारा संसाधित किया गया था; 312 μs का निर्देश समय, जिसमें एक निर्देश निष्पादित किया गया था; और ड्रम रोटेशन का समय 10 एमएस।

रजिस्टर

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

कुछ छद्म रजिस्टर भी थे जो हार्डवेयर के विशेष टुकड़े थे जिन्हें एक रजिस्टर की तरह संबोधित किया गया था:

• 0 में मान 0 था
• 1 में मान 1 था
• 2 में A का मान निहित है (34 बिट को छोड़कर)
• 3 में B का मान निहित है
• 23 में "एक आधा", या 1 << 32 का मान होता है जैसा कि हम आज लिखते हैं
• 24 में A और B, या A और B का तार्किक AND निहित है जैसा कि हम आज लिखते हैं
• अन्य रजिस्टरों ने पढ़ने और लिखने के लिए टेप रीडर के पांच पंच छेदों का मान दिया
• एक रजिस्टर जो प्रिंटर को थोड़ा सा भेजता है।

रजिस्टर ए, बी, सी, डी

रजिस्टर ए और बी, जिन्हें संचायक भी कहा जाता है, दो (लगभग) समान रजिस्टर थे। वे कंप्यूटर के वर्कहॉर्स थे। प्रत्येक निर्देश दो संचायकों में से एक का उपयोग करेगा, या दोनों को दोहरे सटीक मान के रूप में उपयोग करेगा। रजिस्टर ए में अतिरिक्त 34 बिट था, जिसे केवल शिफ्ट ऑपरेशन का उपयोग करके पढ़ा जा सकता है। बी के लिए संबंधित मान "कैरी ट्रैप" में संग्रहीत किया गया था।

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

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

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

वहां इतने ही रजिस्टर थे।

संक्षेप में, ZEBRA कंप्यूटर हार्डवेयर में शामिल हैं:

• एक ड्रम जिसमें प्रोग्राम, डेटा और रजिस्टर होते हैं।
• रजिस्टर सी, हार्डवेयर में लागू किया गया, जिसे निर्देश के प्रारंभ में निर्देश रजिस्टर में कॉपी किया गया था।
• पांच योजक, रजिस्टर ए, बी, सी में फीडिंग
• कई इलेक्ट्रॉनिक स्विच जो सीरियल डेटा को विभिन्न योजक और रजिस्टरों में रूट करेंगे।
• ड्रम ट्रैक और स्थिति के लिए एक डेटा चयनकर्ता।
• अन्य सभी हार्डवेयर का उपयोग I/O सिस्टम (टेप रीडर, पंच और प्रिंटर) के लिए किया गया था।

सामान्य वास्तुकला

यहाँ बुनियादी बिल्डिंग ब्लॉक्स की एक तस्वीर है, सीधे मैनुअल से:

अंकगणितीय इकाई में ए और बी शामिल हैं; नियंत्रण इकाई में सी और डी और निर्देश रजिस्टर शामिल थे। रजिस्टर और मुख्य स्टोर प्रत्येक चक्र में एक शब्द को पढ़ या लिख ​​सकते थे। इकाइयों के बीच संबंध निर्देश पर निर्भर थे।

अनुदेश

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

33 निर्देश बिट्स निम्नानुसार गठित किए गए थे:

लिखने के लिए बाएं से आपके पास 15 "फ़ंक्शन अंक" थे जो नियंत्रण बिट्स थे जो स्वतंत्र रूप से निर्धारित करते थे कि निर्देश क्या करता है, पांच बिट रजिस्टर पता और 13 बिट मेमोरी पता। सभी ZEBRA उपयोगकर्ताओं ने AKQLRIBCDEV421W स्ट्रिंग को याद किया और इसे "डच वर्णमाला" कहा।

"मूल निर्देश"

आप फ़ंक्शन बिट्स को एक बुनियादी निर्देश के संशोधक के रूप में देख सकते हैं, जो:

• दिए गए रजिस्टर का मान A में जोड़ें।
• दिए गए स्मृति पते को रजिस्टर सी में लोड करें (प्रभावी रूप से उस पते पर कूदें)।
• रजिस्टर सी के मूल्य में 2 जोड़ें और इसे डी में कॉपी करें: यह सामान्य रूप से महत्वपूर्ण नहीं है, लेकिन ए निर्देशों के लिए आवश्यक है (नीचे देखें)।

कोडांतरक संकेतन: "सामान्य कोड"

"असेंबली लैंग्वेज" केवल 32 वर्णों (अंक, +, -, अवधि, और अधिकांश बड़े अक्षरों) वाली एक विशेष भाषा थी। कार्यक्रमों को 5 छेद चौड़े कागज टेप पर एन्कोड किया गया था।

एक निर्देश, जैसा कि असेंबली भाषा में लिखा गया है, इसमें शामिल हैं:

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

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

आइए पहले दो फ़ंक्शन बिट्स ए और के से शुरू करें, जो निर्धारित करते हैं कि अगला निर्देश क्या होगा:

• A, C रजिस्टर के बजाय ALU में जाने के लिए ड्रम के आउटपुट को रीरूट करता है। यह ड्रम से डेटा मानों को पढ़ने की अनुमति देता है (जो प्री-एडर के साथ रजिस्टर वैल्यू में जोड़े गए थे)। इसके बजाय सी रजिस्टर को डी रजिस्टर से फीड किया जाता है। रजिस्टर डी को रजिस्टर 4 से पढ़ा जाता है।
  याद रखें कि गैर-ए निर्देशों में, सी+2 डी को लिखा जाता है: इसलिए, ए निर्देश के बाद, निष्पादित अगला निर्देश पिछले निर्देश की तुलना में दो से अधिक होता है, जिसका अर्थ है कि यह आसानी से ड्रम पर अगला निर्देश, ताकि कोई देरी न हो। भ्रामक रूप से, इसका तात्पर्य है कि पिछला निर्देश फिर से किया जाता है। वैन डेर पोएल इन निहित निर्देशों को "निर्देशों के बाद" कहते हैं। अक्सर यह सुनिश्चित करने के लिए कि कोई आश्चर्य न हो, एक निर्देश के पहले एक डमी निर्देश रखा जाता है।
  ए निर्देशों का उपयोग कैसे करें, यह जानने में मुझे कुछ समय लगा।
• K एक रजिस्टर वैल्यू से रजिस्टर C को फीड करता है (A बिट के आधार पर मेमोरी वैल्यू या D रजिस्टर में जोड़ा जाता है)। इसका अर्थ है कि अगला निर्देश दो मानों का योग हो सकता है!

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

आधुनिक भाषा में आप लगभग कह सकते हैं: X का अर्थ है "जोड़ें और कूदें", A का अर्थ है "लोड करें और जोड़ें", K का अर्थ है "रजिस्टर निष्पादित करें", और KA का अर्थ है "पंजीकरण द्वारा अगला निर्देश ऑफसेट करें"।

(क्या आप अभी भी मेरे साथ हैं? यहाँ से यह थोड़ा आसान हो जाता है, मैं वादा करता हूँ।)

आइए शेष फ़ंक्शन बिट्स के साथ चलते हैं, जिनका पालन करना थोड़ा आसान है।

• Q एक को B रजिस्टर में जोड़ता है, भले ही अन्य मान B में जोड़े गए हों।
• L, A और B की सामग्री को बाईं ओर शिफ्ट करता है। जोड़ने से पहले स्थानांतरण किया जाता है: चयनित रजिस्टर में स्थानांतरित मूल्य जोड़ा जाता है। बी के उच्च बिट को ए में स्थानांतरित कर दिया गया है, इसलिए एबी को 67 बिट डबल रजिस्टर के रूप में प्रभावी रूप से माना जाता है।
• R, A और B की सामग्री को दाईं ओर शिफ्ट करता है। ए का निम्न बिट बी में स्थानांतरित हो गया है, इसलिए एबी फिर से एक डबल रजिस्टर है। ए का उच्च बिट ए के अतिरिक्त 34 वें बिट से आता है। इस बिट तक पहुंचने का यही एकमात्र तरीका है, जो प्रभावी रूप से ए के लिए "अतिप्रवाह" ध्वज है।
• मैं जोड़ को घटाव में बदल देता हूं: रजिस्टर में जोड़े जाने के बजाय मूल्यों को घटा दिया जाता है। यह Q को B से 1 के घटाव में भी बदल देता है।
• B, A संचायक के बजाय B संचायक का उपयोग करता है। कैरी को "कैरी ट्रैप" में संग्रहित किया जाएगा।
• C उपयोग किए गए संचायक को साफ़ करता है (A या B): इसका मतलब है कि रजिस्टर से पढ़े गए मान को गणना में 0 से बदल दिया जाता है। स्थानांतरण के संयोजन में, केवल अन्य संचायक को स्थानांतरित किया जाता है और दोनों के बीच बिट्स का कोई परिवहन नहीं होता है।
• D पढ़ने के बजाय दिए गए स्थान पर A या B से ड्रम पर मान लिखता है। संचायक मान लिखने से रजिस्टर का मूल मान लिखा जाता है।
• E चयनित संचायक का मान दिए गए रजिस्टर में लिखता है। K के संयोजन में, इसके बजाय रजिस्टर D का मान लिखा जाता है।
• V कैरी ट्रैप वैल्यू को A रजिस्टर में जोड़ता है। अन्य वी झंडे के संयोजन में, निर्देश सशर्त हो जाता है।
• सशर्त निर्देशों के लिए V4, V2, V1 s अंक 1–7 बनाने के लिए संयोजित होते हैं। असेम्बलर में, आप उसके बाद एक अंक के साथ या उसके बिना V लिखते हैं। यदि वी ध्वज स्पष्ट है (यू के रूप में लिखा गया है), तो निर्देश सामने के पैनल पर संबंधित स्विच के आधार पर निष्पादित किया जाता है (और यदि मान शून्य है, तो कैरी ट्रैप का उपयोग किया जाता है, जैसा कि उल्लेख किया गया है)। यदि V सेट है और मान 1 से 4 है, तो निर्देश इन चार स्थितियों में से एक पर निष्पादित होता है: A ऋणात्मक है, B ऋणात्मक है, A शून्य है, या B विषम है, क्रमशः। यदि स्थिति सही नहीं है, तो निर्देश को A0W से बदल दिया जाता है।
• W ड्रम को निष्क्रिय कर देता है, ताकि अगला निर्देश तुरंत क्रियान्वित हो जाए। आपके द्वारा पढ़ा गया मान 0 हो जाता है। आम तौर पर आप इसे A या K के साथ जोड़ते हैं क्योंकि आपको निर्देश के रूप में शून्य मिलेगा। इसका उपयोग अन्य अक्षरों के संयोजन में दोहराए जाने वाले निर्देश बनाने के लिए किया जाता है, जैसे कि तेजी से गुणा (नीचे देखें), विभाजन, और ड्रम को साफ़ करना।

अक्षरों के कुछ संयोजन अतिरिक्त कार्यक्षमता प्रदान करते हैं।

• एन एक एक्स निर्देश के सामान्य मामले के लिए एक कोडांतरक संक्षिप्त नाम है जो अगले ड्रम पते पर कूदता है: अगले निर्देश को निष्पादित करें।
• LR दाईं ओर शिफ्ट हो जाता है, लेकिन यदि B विषम था तो R15 को A (B बिट से स्वतंत्र) में भी जोड़ता है। यह गुणन के लिए प्रयोग किया जाता है।
• XD विभाजन के लिए उपयोग किए जाने वाले A या B (B बिट पर निर्भर) में R15 जोड़ता है।
• एनकेके का उपयोग उन निर्देशों के लिए किया जाता है जो अगले पते का उपयोग करते हैं। (असल में यह असेंबलर के काम करने के तरीके का एक साइड इफेक्ट है।)

• केई ने एक रजिस्टर में डी लिखा (जो पिछला निर्देश + 2 है)। आप इसका उपयोग निर्देशों को वर्तमान पते पर निर्भर करने के लिए कर सकते हैं, उदाहरण के लिए कॉल करने वाले को सबरूटीन्स वापस करने के लिए: आप एक वापसी निर्देश की गणना कर सकते हैं जो कॉलर पर वापस जाता है।
• एके एक रजिस्टर से एक निर्देश को क्रियान्वित करते हुए, गणना के लिए ड्रम का उपयोग करता था। इसका उपयोग उदाहरण के लिए एक घुमाव में ड्रम से दो मानों को पढ़ने के लिए किया गया था।

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

• एन : कोई ऑपरेशन नहीं। सटीक होने के लिए: अगले निर्देश को C में पढ़ते समय A में 0 जोड़ें।
• NLBQ3: B को तीन से गुणा करें और एक जोड़ें; ए को 2 से गुणा करें।
• X100BC5: रजिस्टर 5 को B में कॉपी करें (क्लियर करें और जोड़ें), अगला निर्देश 100 पर है।
• X569LQK7: बाएं शिफ्ट एबी, एक 1 में स्थानांतरण। अगला निर्देश स्मृति स्थान 569 और रजिस्टर 7 का योग है।
• A2991.9: मेमोरी लोकेशन 2119 + रजिस्टर 9 को ए में जोड़ें। (यह एक उदाहरण है जब प्री-एडर का उपयोग किया जाता है।) अगला निर्देश एक निर्देश के बाद है।
• X1956LBC3V4: यदि B विषम है, तो संचायक A को बाईं ओर शिफ्ट करें और स्मृति स्थान 1956 पर निष्पादन जारी रखें। अन्यथा, पिछले निर्देश को दोहराएं (क्योंकि गलत स्थितियां निर्देश रजिस्टर को A0W से बदल देती हैं, जो ऐसा करता है)। किसी भी मामले में, बी वही रहता है, जैसा कि इसे साफ किया जाता है और इसके पुराने मूल्य से भर दिया जाता है।

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

बाकी के लिए यह छिद्रित टेप को पढ़ और लिख सकता था और प्रिंट कर सकता था (टेप की तुलना में बहुत धीमी गति से 7 अक्षर प्रति सेकंड; रीडिंग टेप 100 वर्ण प्रति सेकंड था)।

टेप में प्रति पंक्ति केवल 5 छेद थे, जिसका अर्थ था कि कार्यक्रमों के लिए केवल 32 प्रतीक उपलब्ध थे। असेम्बलर ने कम वर्ण सेट का उपयोग किया ताकि अंक और आवश्यक अक्षर उपलब्ध हो सकें; अन्य पत्र अभी नहीं थे। यहाँ तक कि अक्षर W भी गायब था: यही कारण है कि W निर्देश एक विशेष तरीके से एन्कोड किए गए हैं।

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

अंत में, कंसोल पर एक "दक्षता मीटर" था जो दिखाता था कि कितने प्रतिशत निर्देशों को बिना देरी के निष्पादित किया गया था। बेशक, ऐसा प्रोग्राम लिखना काफी कठिन था जो प्रतिशत को ऊंचा रखे। याद रखें कि 100% प्राप्त करने के लिए, आपको यह सुनिश्चित करना होगा कि प्रत्येक निर्देश के बाद ड्रम पर एक निर्देश, या एक डब्ल्यू निर्देश हो, जो निश्चित रूप से संभव नहीं है।

प्रोग्रामिंग उदाहरण: गुणन

आपको ZEBRA की प्रोग्रामिंग की भावना का एक विचार देने के लिए, यहाँ एक छोटा सा छह निर्देश कार्यक्रम है जो रजिस्टरों A और B का एक हस्ताक्षरित गुणा करने के लिए है। स्पष्टीकरण उद्देश्यों के लिए, मान लें कि कार्यक्रम को 100 पते पर रखा गया है।

• 100 NE5 (X101E5 के रूप में असेंबल किया हुआ): 5 को रजिस्टर करने के लिए A को कॉपी करें, 101 पर जाएं।
• 101 एनकेकेसीई15 (ए102सीई15 के रूप में इकट्ठा): ए को रजिस्टर 15 में लोड करें, लोड वैल्यू 102 इनटू ए
• 102 ALR (A0000LRW के रूप में अस्सेम्ब्ल किया हुआ): R5 में स्टोर करने के लिए निर्देश.
• 103 NKE6LRC (X104LRC6 के रूप में असेम्बल): पहला गुणन चरण।
• 104 X5K15LR (X8162KLR5W के रूप में असेम्बल किया गया): रिपीट इंस्ट्रक्शन।
• 105 NLRI (X106LRI के रूप में इकट्ठे): सुनिश्चित करें कि संकेतों को ठीक से संभाला जाता है।

• NE5 : यह निर्देश, जो A के मान को रजिस्टर 5 में संग्रहीत करता है, वास्तव में अभी तक महत्वपूर्ण नहीं है। जो महत्वपूर्ण है, वह यह है कि अगले निर्देश के दौरान रजिस्टर D इस निर्देश से दो अधिक से भरा होता है, जो कि X103E5 है।
• NKKCE15 : पहले ऑपरेंड को रजिस्टर ए से रजिस्टर 15 में ले जाएं। उसी समय, अगले निर्देश "एएलआर" को रजिस्टर ए में लोड करें।
• इस निर्देश के बाद, रजिस्टर डी निष्पादित किया जाता है क्योंकि यह एक निर्देश है। यह निर्देश "ALR" को रजिस्टर 5 में संग्रहीत करता है, A को साफ़ करता है, और 103 पर निर्देश पर निष्पादन फिर से शुरू करता है।
  (संक्षेप में, पहले तीन निर्देश बताते हैं कि एक रजिस्टर में एक स्थिरांक कैसे प्राप्त करें।)
• ALR : यह निर्देश निष्पादित नहीं किया गया है लेकिन गुणन के दौरान उपयोग के लिए रजिस्टर 5 में लोड किया गया है।
• NKE6LRC : विशेष LR क्रिया "AB को दाएँ शिफ्ट करें, और यदि B विषम था तो A में R15 जोड़ें", जो गुणन का पहला चरण करता है। रजिस्टर डी का प्रतिलिपि मूल्य (जो अब X105E5 तक बढ़ गया है) रजिस्टर 6 में।
• X5K15LR: निर्देश का दूसरा चरण निष्पादित करें। अगला निर्देश रजिस्टर 5 में है। ध्यान दें कि इस निर्देश को X8162KLRW5 के रूप में पढ़ा जाना चाहिए।
• अगला निर्देश रजिस्टर 5 में है: ALR। गुणा का तीसरा चरण करें। क्योंकि यह एक A निर्देश है, अगला वाला पिछले वाले से दो अधिक है: X5K14LR (या यह दिखाने के लिए कि यह पिछले वाले से दो अधिक है: X8164LRW5)।
• X5K14LR: गुणा का चौथा चरण करें
• …
• X5K1LR: 30वां चरण पूरा करें।
• ALR: गुणा का 31वां चरण। निर्देश पता 8190 रजिस्टर संख्या में बहता है, इसलिए निर्देश X000KLR6, या दूसरे शब्दों में X6KLR बन जाता है।
• X6KLR: गुणा का 32वां और अंतिम चरण। अगला निर्देश R6 है, जिसमें X105E5 शामिल है।
• X105E5: A को R5 में संग्रहित करें (गणना के लिए उपयोग नहीं किया गया)। 105 पर जारी रखें।
• एनएलआरआई: यदि बी का साइन बिट नकारात्मक परिणाम प्राप्त करने के लिए सेट किया गया था, तो ए से आर15 घटाएं; यह द्विवार्षिक पूरक परिपाटी के साथ ऋणात्मक संख्या गुणन को संभालता है।

ध्यान दें कि गुणन रूटीन के दूसरे से अंतिम चरण तक डब्ल्यू निर्देश हैं, जो ड्रम की प्रतीक्षा नहीं करते हैं। इसका मतलब यह है कि ड्रम के 31 पदों पर घूमने के दौरान उन्हें निष्पादित किया जाता है। तो ड्रम ने लगभग पूर्ण रोटेशन किया, 104 से शुरू हुआ, और R6 पर निर्देश कंप्यूटर को 106 की स्थिति में निष्पादित करने का कारण बनता है, जिसके कारण यह अगले निर्देश को लाने के लिए केवल दो निर्देशों की प्रतीक्षा करता है। इसलिए कार्यक्रम को चलने में 6 + 32 = 38 चक्र लगते हैं।

सरल कोड

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

ऑपरेटिंग सिस्टम

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

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

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

क्योंकि कोई स्टैक नहीं था, सबरूटीन्स ने ऊपर बताए गए KE निर्देश का उपयोग करते हुए, कॉलिंग स्थान को याद रखने के लिए एक रजिस्टर का उपयोग किया।

दुर्भाग्य से, मैं ऑपरेटिंग सिस्टम के सभी विवरण नहीं जानता; मुझे जो पता है वह रिवर्स इंजीनियरिंग से है, जो अजीब प्रोसेसर को देखते हुए काफी कठिन है।

प्रोग्रामिंग प्रतिभा

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

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

उपयोगकर्ता के लिए अनुकूलता

प्रौद्योगिकी की सीमाओं के कारण प्रोग्रामिंग काफी कठिन थी। यदि आपने अपने प्रोग्राम में कोई त्रुटि की, तो कंप्यूटर क्रैश हो जाएगा। कोई सिंटैक्स जाँच नहीं थी, कोई उपयोगकर्ता के अनुकूल डिबगर या कुछ भी नहीं था। आजकल "हैकिंग" कुछ कोड को बुरा अभ्यास माना जाता है; ZEBRA की प्रोग्रामिंग करते समय आपके पास कोई विकल्प नहीं था: यहां तक ​​कि सबसे सरल प्रोग्राम को भी सबसे सरल कार्यों को करने के लिए सभी प्रकार के अजीब निर्माणों की आवश्यकता थी।

But still, the programming languages LISP and ALGOL did run on it. I don’t think they would be fast, though.

A call for resources

This whole adventure has lead me to many interesting documents, but there are two I cannot get hold of. If you have (a PDF version of) either of them, let me know!

• Stantec Zebra Program Manual, by Standard Telephones and Cables (London, England).
• ZEBRA simple code and its interpretation, by R.J. Ord-Smith Ph.D.

Computer history museum

Computer conservation society

My collection at archive.org

My Bitbucket page, that needs to be updated. It contains a working ZEBRA emulator, but the GUI doesn’t work because Python’s standard tkinter library has been modified. A bit frustrating how hard it is to keep historic material usable!

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