लिटिल मैन कंप्यूटर

From Vigyanwiki
Revision as of 20:14, 8 August 2023 by alpha>Ashutoshyadav

लिटिल मैन कंप्यूटर (एलएमसी) कंप्यूटर का एक निर्देशात्मक मॉडल है, जिसे 1965 में डॉ. स्टुअर्ट मैडनिक द्वारा बनाया गया था।[1] एलएमसी का उपयोग आम तौर पर छात्रों को पढ़ाने के लिए किया जाता है, क्योंकि यह एक साधारण वॉन न्यूमैन आर्किटेक्चर कंप्यूटर का मॉडल बनाता है - जिसमें आधुनिक कंप्यूटर की सभी बुनियादी विशेषताएं हैं। इसे मशीन कोड (यद्यपि बाइनरी के बजाय दशमलव में) या असेंबली कोड में प्रोग्राम किया जा सकता है।[2][3][4]

एलएमसी मॉडल एक बंद मेल रूम में बंद एक छोटे आदमी की अवधारणा पर आधारित है (इस परिदृश्य में कंप्यूटर के अनुरूप)। कमरे के एक छोर पर, 100 मेलबॉक्स (मेमोरी) हैं, जिनकी संख्या 0 से 99 है, जिनमें से प्रत्येक में 3 अंकों का निर्देश या डेटा (000 से 999 तक) हो सकता है। इसके अलावा, दूसरे छोर पर इनबॉक्स और आउटबॉक्स लेबल वाले दो मेलबॉक्स हैं जिनका उपयोग डेटा प्राप्त करने और आउटपुट करने के लिए किया जाता है। कमरे के केंद्र में, एक कार्य क्षेत्र है जिसमें एक साधारण दो फ़ंक्शन (जोड़ और घटाव) कैलकुलेटर है जिसे एक्युमुलेटर के रूप में जाना जाता है और एक रीसेट करने योग्य काउंटर है जिसे प्रोग्राम काउंटर के रूप में जाना जाता है। प्रोग्राम काउंटर में लिटिल मैन द्वारा किए जाने वाले अगले निर्देश का पता होता है। प्रत्येक निर्देश के निष्पादित होने के बाद इस प्रोग्राम काउंटर को आम तौर पर 1 से बढ़ा दिया जाता है, जिससे लिटिल मैन को क्रमिक रूप से प्रोग्राम के माध्यम से काम करने की अनुमति मिलती है। शाखा निर्देश पुनरावृत्ति (लूप) और सशर्त प्रोग्रामिंग संरचनाओं को एक कार्यक्रम में शामिल करने की अनुमति देते हैं। यदि कोई विशेष शर्त पूरी हो जाती है (आमतौर पर संचायक में संग्रहीत मूल्य शून्य या सकारात्मक होता है) तो प्रोग्राम काउंटर को गैर-अनुक्रमिक मेमोरी पते पर सेट करके उत्तरार्द्ध प्राप्त किया जाता है।

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

निष्पादन चक्र

See also: Instruction cycle

किसी प्रोग्राम को निष्पादित करने के लिए, छोटा आदमी इन चरणों का पालन करता है:

  1. मेलबॉक्स नंबर के लिए प्रोग्राम काउंटर की जांच करें जिसमें प्रोग्राम निर्देश शामिल है (यानी प्रोग्राम की शुरुआत में शून्य)
  2. उस नंबर वाले मेलबॉक्स से निर्देश प्राप्त करें। प्रत्येक निर्देश में दो फ़ील्ड होते हैं एक ऑपकोड (संचालन करने के लिए ऑपरेशन को इंगित करता है) और पता फ़ील्ड (यह दर्शाता है कि ऑपरेशन करने के लिए डेटा कहां ढूंढना है)।
  3. प्रोग्राम काउंटर बढ़ाएँ (ताकि इसमें अगले निर्देश का मेलबॉक्स नंबर शामिल हो)
  4. निर्देश को डिकोड करें. यदि निर्देश किसी अन्य मेलबॉक्स में संग्रहीत डेटा का उपयोग करता है तो उस डेटा के लिए मेलबॉक्स नंबर ढूंढने के लिए पता फ़ील्ड का उपयोग करें जिस पर यह काम करेगा, उदाहरण के लिए 'मेलबॉक्स 42 से डेटा प्राप्त करें')
  5. डेटा प्राप्त करें (चरण 4 में निर्धारित पते के साथ इनपुट, संचायक, या मेलबॉक्स से)
  6. दिए गए ऑपकोड के आधार पर निर्देश निष्पादित करें
  7. परिणाम को ब्रांच या स्टोर करें (चरण 4 में निर्धारित पते के साथ आउटपुट, संचायक, या मेलबॉक्स में)
  8. चक्र या पड़ाव को दोहराने के लिए प्रोग्राम काउंटर पर लौटें

आदेश

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

निर्देश

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

नीचे दी गई तालिका एक विशिष्ट संख्यात्मक निर्देश सेट और समतुल्य स्मरणीय कोड दिखाती है।

निर्देश
न्यूमेरिक कोड मनेमोनिक कोड निर्देश विवरण
1xx ADD ADD मेलबॉक्स xx में संग्रहीत मान को वर्तमान में संचायक (कैलकुलेटर) पर जो भी मान है, उसमें जोड़ें।
ध्यान दें: मेलबॉक्स की सामग्री नहीं बदली जाती है, और संचायक (कैलकुलेटर) की गतिविधियों को उन निर्देशों को जोड़ने के लिए परिभाषित नहीं किया जाता है जो 3 अंकों से बड़े योग का कारण बनते हैं। सबट्रैक्ट के समान, कोई ओवरफ्लो पर नकारात्मक ध्वज सेट कर सकता है।
2xx SUB SUBTRACT संचायक (कैलकुलेटर) पर वर्तमान में जो भी मान है, उसमें से मेलबॉक्स xx में संग्रहीत मान घटाएँ।
ध्यान दें: मेलबॉक्स की सामग्री नहीं बदली गई है, और संचायक की क्रियाओं को नकारात्मक परिणामों का कारण बनने वाले घटाव निर्देशों के लिए परिभाषित नहीं किया गया है - हालांकि, एक नकारात्मक ध्वज सेट किया जाएगा ताकि 7xx (BRZ) और 8xx (BRP) का उपयोग किया जा सके अच्छी तरह से।
3xx STA STORE संचायक की सामग्री को मेलबॉक्स xx (विनाशकारी) में संग्रहीत करें।
ध्यान दें: संचायक (कैलकुलेटर) की सामग्री नहीं बदली जाती (गैर-विनाशकारी) लेकिन मेलबॉक्स की सामग्री बदल दी जाती है, चाहे उसमें कुछ भी हो (विनाशकारी)
5xx LDA LOAD मेलबॉक्स xx (गैर-विनाशकारी) से मान लोड करें और इसे संचायक (विनाशकारी) में दर्ज करें।
6xx BRA BRANCH (unconditional) प्रोग्राम काउंटर को दिए गए पते (मान xx) पर सेट करें। अर्थात्, मेलबॉक्स xx में मान अगला निष्पादित निर्देश होगा।
7xx BRZ BRANCH IF ZERO (conditional) यदि संचायक (कैलकुलेटर) में मान 000 है, तो प्रोग्राम काउंटर को मान xx पर सेट करें। अन्यथा, कुछ न करें. नकारात्मक ध्वज को ध्यान में रखा गया है या नहीं यह अपरिभाषित है। जब एक SUBTRACT संचायक को अंडरफ्लो करता है, तो यह ध्वज सेट किया जाता है, जिसके बाद संचायक अपरिभाषित होता है, संभावित रूप से शून्य होता है, जिससे अंडरफ्लो पर BRZ का व्यवहार अपरिभाषित हो जाता है। यदि संचायक शून्य है और नकारात्मक ध्वज सेट नहीं है तो सुझाया गया व्यवहार शाखा में होगा।
नोट: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है, इसलिए डेटा और प्रोग्राम निर्देशों का पता/स्थान प्रारूप समान होता है।
8xx BRP BRANCH IF POSITIVE (conditional) यदि संचायक (कैलकुलेटर) 0 या सकारात्मक है, तो प्रोग्राम काउंटर को मान xx पर सेट करें। अन्यथा, कुछ न करें. चूँकि LMC मेमोरी सेल केवल 0 और 999 के बीच मान रख सकते हैं, यह निर्देश पूरी तरह से SUBTRACT पर अंडरफ्लो द्वारा निर्धारित नकारात्मक ध्वज और संभावित रूप से ADD (अपरिभाषित) पर ओवरफ्लो पर निर्भर करता है।
नोट: चूंकि प्रोग्राम मेमोरी में संग्रहीत होता है, इसलिए डेटा और प्रोग्राम निर्देशों का पता/स्थान प्रारूप समान होता है।
901 INP INPUT इनबॉक्स पर जाएं, उपयोगकर्ता से मूल्य प्राप्त करें, और इसे संचायक (कैलकुलेटर) में डालें
नोट: यह संचायक में जो भी मूल्य था उसे अधिलेखित कर देगा (विनाशकारी)
902 OUT OUTPUT संचायक (कैलकुलेटर) से मान को आउटबॉक्स में कॉपी करें।
ध्यान दें: संचायक की सामग्री बदली नहीं जाती (गैर-विनाशकारी)।
000 HLT/COB HALT/COFFEE BREAK काम करना बंद करें/कार्यक्रम समाप्त करें।
DAT DATA यह एक असेंबलर निर्देश है जो बस मान को अगले उपलब्ध मेलबॉक्स में लोड करता है। वैरिएबल घोषित करने के लिए DAT का उपयोग लेबल के संयोजन में भी किया जा सकता है। उदाहरण के लिए, DAT 984 मान 984 को DAT निर्देश के पते पर एक मेलबॉक्स में संग्रहीत करेगा।

उदाहरण

संख्यात्मक निर्देश कोड का उपयोग करना

यह प्रोग्राम (निर्देश 901 से निर्देश 000 तक) केवल संख्यात्मक कोड का उपयोग करके लिखा गया है। प्रोग्राम इनपुट के रूप में दो नंबर लेता है और अंतर आउटपुट करता है। ध्यान दें कि निष्पादन मेलबॉक्स 00 पर शुरू होता है और मेलबॉक्स 07 पर समाप्त होता है। संख्यात्मक निर्देश कोड का उपयोग करके एलएमसी प्रोग्रामिंग के नुकसान पर नीचे चर्चा की गई है।

Mailbox Numeric code ऑपरेशन टिप्पणी
00 901 Accumulator = इनबॉक्स पहला नंबर दर्ज करें, कैलकुलेटर में दर्ज करें (वहां जो कुछ भी था उसे मिटा दें)
01 308 Mailbox 08 = Accumulator कैलकुलेटर का वर्तमान मान संग्रहीत करें (अगले चरण की तैयारी के लिए...)
02 901 Accumulator = इनबॉक्स दूसरा नंबर दर्ज करें, कैलकुलेटर में दर्ज करें (वहां जो कुछ भी था उसे मिटा दें)
03 309 Mailbox 09 = Accumulator कैलकुलेटर का वर्तमान मान संग्रहीत करें (फिर से, अगले चरण की तैयारी के लिए...)
04 508 Accumulator = Mailbox 08 (अब दोनों इनपुट मान मेलबॉक्स 08 और 09 में संग्रहीत हैं...)

पहले मान को वापस कैलकुलेटर में लोड करें (वहां जो कुछ भी था उसे मिटा दें)

05 209 Accumulator = Accumulator - Mailbox 09 कैलकुलेटर के वर्तमान मान से दूसरा नंबर घटाएं (जो कि पहले नंबर पर सेट किया गया था)
06 902 आउटबॉक्स = Accumulator कैलकुलेटर के परिणाम को आउटबॉक्स में आउटपुट करें
07 000 Halt एचएएलटी एलएमसी

स्मृति सहायक्स और लेबल का उपयोग करना

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

INP
STA FIRST
INP
STA SECOND
LDA FIRST
SUB SECOND
OUT
HLT
FIRST DAT
SECOND DAT

लेबल

लेबल के बिना प्रोग्रामर को मेलबॉक्स (मेमोरी) पतों की मैन्युअल रूप से गणना करने की आवश्यकता होती है। संख्यात्मक कोड उदाहरण में, यदि अंतिम एचएलटी निर्देश से पहले एक नया निर्देश डाला जाना था तो वह एचएलटी निर्देश पता 07 से पता 08 पर चला जाएगा (पता लेबलिंग पता स्थान 00 पर शुरू होता है)। मान लीजिए कि उपयोगकर्ता ने पहले इनपुट के रूप में 600 दर्ज किया। निर्देश 308 का अर्थ यह होगा कि यह मान पता स्थान 08 पर संग्रहीत किया जाएगा और 000 (एचएलटी) निर्देश को अधिलेखित कर दिया जाएगा। चूँकि 600 का अर्थ है "शाखा से मेलबॉक्स पता 00" प्रोग्राम रुकने के बजाय, एक अंतहीन लूप में फंस जाएगा।

इस कठिनाई को हल करने के लिए, अधिकांश असेंबली भाषाएँ (एलएमसी सहित) निमोनिक्स को लेबल (प्रोग्रामिंग भाषा) के साथ जोड़ती हैं। लेबल बस एक शब्द है जिसका उपयोग या तो एक मेमोरी एड्रेस को नाम देने के लिए किया जाता है जहां एक निर्देश या डेटा संग्रहीत किया जाता है, या एक निर्देश में उस पते को संदर्भित करने के लिए उपयोग किया जाता है।

जब कोई प्रोग्राम असेंबल किया जाता है:

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

असेंबली भाषा उदाहरण में जो निमोनिक्स और लेबल का उपयोग करता है, यदि अंतिम एचएलटी निर्देश से पहले एक नया निर्देश डाला गया था तो FIRST लेबल वाला पता स्थान अब 08 के बजाय मेमोरी स्थान 09 पर होगा और STA FIRST निर्देश 309 (STA) में परिवर्तित हो जाएगा 09) बजाय 308 (एसटीए 08) जब प्रोग्राम असेंबल किया गया था।

इसलिए लेबल का उपयोग किया जाता है:

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

उदाहरण

नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, और शून्य तक उल्टी गिनती करेगा। 

 INP
     OUT      // Initialize output 
LOOP BRZ QUIT // Label this memory address as LOOP. If the accumulator value is 0, jump to the memory address labeled QUIT
     SUB ONE  // Subtract the value stored at address ONE from the accumulator
     OUT
     BRA LOOP // Jump (unconditionally) to the memory address labeled LOOP
QUIT HLT      // Label this memory address as QUIT
ONE  DAT 1    // Store the value 1 in this memory address, and label it ONE (variable declaration)

नीचे दिया गया प्रोग्राम उपयोगकर्ता इनपुट लेगा, उसे वर्गित करेगा, उत्तर आउटपुट करेगा और फिर दोहराएगा। शून्य दर्ज करने से प्रोग्राम समाप्त हो जाएगा.

(ध्यान दें: जिस इनपुट का परिणाम 999 से अधिक है, उसका एलएमसी की 3 अंकों की संख्या सीमा के कारण अपरिभाषित व्यवहार होगा)। 

START   LDA ZERO     // Initialize for multiple program run
        STA RESULT
        STA COUNT
        INP          // User provided input
        BRZ END      // Branch to program END if input = 0
        STA VALUE    // Store input as VALUE
LOOP    LDA RESULT   // Load the RESULT
        ADD VALUE    // Add VALUE, the user provided input, to RESULT
        STA RESULT   // Store the new RESULT
        LDA COUNT    // Load the COUNT
        ADD ONE      // Add ONE to the COUNT
        STA COUNT    // Store the new COUNT
        SUB VALUE    // Subtract the user provided input VALUE from COUNT
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
        BRA LOOP     // Branch to LOOP to continue adding VALUE to RESULT
ENDLOOP LDA RESULT   // Load RESULT
        OUT          // Output RESULT
        BRA START    // Branch to the START to initialize and get another input VALUE
END     HLT          // HALT - a zero was entered so done!
RESULT  DAT          // Computed result (defaults to 0)
COUNT   DAT          // Counter (defaults to 0)
ONE     DAT 1        // Constant, value of 1
VALUE   DAT          // User provided input, the value to be squared (defaults to 0)
ZERO    DAT          // Constant, value of 0 (defaults to 0)

नोट: यदि DAT स्टेटमेंट के बाद कोई डेटा नहीं है तो डिफ़ॉल्ट मान 0 मेमोरी एड्रेस में संग्रहीत होता है।

उपरोक्त उदाहरण में, [BRZ ENDLOOP] अपरिभाषित व्यवहार पर निर्भर करता है, क्योंकि COUNT-VALUE नकारात्मक हो सकता है, जिसके बाद ACCUMULATOR मान अपरिभाषित होता है, जिसके परिणामस्वरूप BRZ या तो शाखाबद्ध हो जाता है या नहीं (ACCUMULATOR शून्य हो सकता है, या चारों ओर लपेटा जा सकता है)। कोड को विनिर्देश के अनुकूल बनाने के लिए, प्रतिस्थापित करें: 

   	...
        LDA COUNT    // Load the COUNT
        ADD ONE      // Add ONE to the COUNT
        STA COUNT    // Store the new COUNT
        SUB VALUE    // Subtract the user provided input VALUE from COUNT
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
        ...

निम्नलिखित संस्करण के साथ, जो COUNT-VALUE के बजाय VALUE-COUNT का मूल्यांकन करता है, यह सुनिश्चित करता है कि संचायक कभी भी कम प्रवाहित न हो: 

	...
        LDA COUNT    // Load the COUNT
        ADD ONE      // Add ONE to the COUNT
        STA COUNT    // Store the new COUNT
        LDA VALUE    // Load the VALUE
        SUB COUNT    // Subtract COUNT from the user provided input VALUE
        BRZ ENDLOOP  // If zero (VALUE has been added to RESULT by VALUE times), branch to ENDLOOP
        ...

एक अन्य उदाहरण एक क्विन (कंप्यूटिंग) है, जो अपने स्वयं के मशीन कोड को प्रिंट कर रहा है (मुद्रण स्रोत असंभव है क्योंकि अक्षरों को आउटपुट नहीं किया जा सकता है): 

LOAD LDA 0     // Load position 0 into the accumulator. This line will be modified on each loop to load the next lines into the accumulator
     OUT       // Output the accumulator's value. The accumulator's value will be the line that was just loaded
     SUB ONE   // Subtract 1 from the value in the accumulator. This is so we can do the BRZ in the next step to see if we are on the last line in the program
     BRZ ONE   // If the previous subtraction has made the accumulator 0 (which means we had the value 001 in the accumulator), then branch to position ONE
     LDA LOAD  // Load the LOAD position into the accumulator, this is in preparation to increment the address digits for this position
     ADD ONE   // Increment the position digits for the LOAD line. The value currently in the accumulator would, if read as an instruction, load the next line into the accumulator, compared to the last line loaded
     STA LOAD  // Store the newly incremented LOAD line back in the LOAD position
     BRA LOAD  // Return to the beginning of the loop
ONE  DAT 1     // The variable ONE. If read as an instruction, this will be interpreted as HLT/COB and will end the program

यह क्विन स्व-संशोधित कोड का उपयोग करके काम करता है। स्थिति 0 को प्रत्येक पुनरावृत्ति में एक से बढ़ाया जाता है, उस पंक्ति के कोड को आउटपुट किया जाता है, जब तक कि वह जो कोड आउटपुट कर रहा है वह 1 न हो, जिस बिंदु पर यह एक स्थिति में शाखा करता है। ONE स्थिति में मान ऑपकोड के रूप में 0 है, इसलिए इसे HALT/COB निर्देश के रूप में समझा जाता है।

यह भी देखें

संदर्भ

  1. ↑ "लिटिल मैन कंप्यूटर". Illinois State University. May 1, 2000. Archived from the original on February 27, 2009. Retrieved March 8, 2009.
  2. ↑ Yurcik, W.; Osborne, H. (2001). "A crowd of Little Man Computers: Visual computer simulator teaching tools". Proceedings of the 2001 Winter Simulation Conference (Cat. No.01CH37304). Vol. 2. p. 1632. doi:10.1109/WSC.2001.977496. ISBN 0-7803-7307-3. S2CID 18907923.
  3. ↑ Yurcik, W.; Brumbaugh, L. (2001). "A web-based little man computer simulator". कंप्यूटर विज्ञान शिक्षा पर बत्तीसवें SIGCSE तकनीकी संगोष्ठी की कार्यवाही - SIGCSE '01. p. 204. doi:10.1145/364447.364585. ISBN 1581133294. S2CID 14794750.
  4. ↑ Osborne, H.; Yurcik, W. (2002). "The educational range of visual simulations of the Little Man Computer architecture paradigm". 32nd Annual Frontiers in Education. pp. S4G–S19. doi:10.1109/FIE.2002.1158742. ISBN 0-7803-7444-4. S2CID 10324295.


बाहरी संबंध



सिमुलेटर

ऑनलाइन


श्रेणी:उदाहरण कोड वाले लेख श्रेणी:शैक्षिक सार मशीनें श्रेणी:1965 में कंप्यूटर से संबंधित परिचय

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=लिटिल_मैन_कंप्यूटर&oldid=251856’