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

From Vigyanwiki
Revision as of 13:27, 25 July 2023 by alpha>Indicwiki (Created page with "{{Short description|Instructional model of a computer}} {{Use mdy dates|date=March 2013}} लिटिल मैन कंप्यूटर (एलएमसी) कंप...")
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

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

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

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

See also: Instruction cycle

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

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

आदेश

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

निर्देश

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

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

Instructions
Numeric code Mnemonic code Instruction Description
1xx ADD ADD Add the value stored in mailbox xx to whatever value is currently on the accumulator (calculator).
Note: the contents of the mailbox are not changed, and the actions of the accumulator (calculator) are not defined for add instructions that cause sums larger than 3 digits. Similarly to SUBTRACT, one could set the negative flag on overflow.
2xx SUB SUBTRACT Subtract the value stored in mailbox xx from whatever value is currently on the accumulator (calculator).
Note: the contents of the mailbox are not changed, and the actions of the accumulator are not defined for subtract instructions that cause negative results - however, a negative flag will be set so that 7xx (BRZ) and 8xx (BRP) can be used properly.
3xx STA STORE Store the contents of the accumulator in mailbox xx (destructive).
Note: the contents of the accumulator (calculator) are not changed (non-destructive), but contents of mailbox are replaced regardless of what was in there (destructive)
5xx LDA LOAD Load the value from mailbox xx (non-destructive) and enter it in the accumulator (destructive).
6xx BRA BRANCH (unconditional) Set the program counter to the given address (value xx). That is, the value in mailbox xx will be the next instruction executed.
7xx BRZ BRANCH IF ZERO (conditional) If the accumulator (calculator) contains the value 000, set the program counter to the value xx. Otherwise, do nothing. Whether the negative flag is taken into account is undefined. When a SUBTRACT underflows the accumulator, this flag is set, after which the accumulator is undefined, potentially zero, causing behavior of BRZ to be undefined on underflow. Suggested behavior would be to branch if accumulator is zero and negative flag is not set.
Note: since the program is stored in memory, data and program instructions all have the same address/location format.
8xx BRP BRANCH IF POSITIVE (conditional) If the accumulator (calculator) is 0 or positive, set the program counter to the value xx. Otherwise, do nothing. As LMC memory cells can only hold values between 0 and 999, this instruction depends solely on the negative flag set by an underflow on SUBTRACT and potentially on an overflow on ADD (undefined).
Note: since the program is stored in memory, data and program instructions all have the same address/location format.
901 INP INPUT Go to the INBOX, fetch the value from the user, and put it in the accumulator (calculator)
Note: this will overwrite whatever value was in the accumulator (destructive)
902 OUT OUTPUT Copy the value from the accumulator (calculator) to the OUTBOX.
Note: the contents of the accumulator are not changed (non-destructive).
000 HLT/COB HALT/COFFEE BREAK Stop working/end the program.
DAT DATA This is an assembler instruction which simply loads the value into the next available mailbox. DAT can also be used in conjunction with labels to declare variables. For example, DAT 984 will store the value 984 into a mailbox at the address of the DAT instruction.


उदाहरण

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

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

Mailbox Numeric code Operation Comments
00 901 Accumulator = Inbox INPUT the first number, enter into calculator (erasing whatever was there)
01 308 Mailbox 08 = Accumulator STORE the calculator's current value (to prepare for the next step...)
02 901 Accumulator = Inbox INPUT the second number, enter into calculator (erasing whatever was there)
03 309 Mailbox 09 = Accumulator STORE the calculator's current value (again, to prepare for the next step...)
04 508 Accumulator = Mailbox 08 (Now that both INPUT values are STORED in Mailboxes 08 and 09...)

LOAD the first value back into the calculator (erasing whatever was there)

05 209 Accumulator = Accumulator - Mailbox 09 SUBTRACT the second number from the calculator's current value (which was just set to the first number)
06 902 Outbox = Accumulator OUTPUT the calculator's result to the OUTBOX
07 000 Halt HALT the LMC


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

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

आईएनपी
एसटीए प्रथम
आईएनपी
एसटीए सेकंड
एलडीए प्रथम
उप दूसरा
बाहर
एचएलटी
सबसे पहले DAT
दूसरा दिनांक

लेबल

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

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

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

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

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

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

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

उदाहरण

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

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

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

स्टार्ट एलडीए जीरो // मल्टीपल प्रोग्राम रन के लिए इनिशियलाइज़ करें
        एसटीए परिणाम
        एसटीए गिनती
        आईएनपी // उपयोगकर्ता द्वारा प्रदान किया गया इनपुट
        BRZ END // यदि इनपुट = 0 है तो प्रोग्राम END की शाखा
        एसटीए वैल्यू // इनपुट को वैल्यू के रूप में स्टोर करें
लूप एलडीए परिणाम // परिणाम लोड करें
        मान जोड़ें // परिणाम में उपयोगकर्ता द्वारा प्रदान किया गया इनपुट मान जोड़ें
        एसटीए परिणाम // नया परिणाम संग्रहीत करें
        एलडीए गिनती // गिनती लोड करें
        एक जोड़ें // गिनती में एक जोड़ें
        एसटीए काउंट // नई काउंट स्टोर करें
        उप मान // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान को COUNT से घटाएं
        BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
        BRA LOOP // परिणाम में मान जोड़ना जारी रखने के लिए LOOP पर शाखा करें
एंडलूप एलडीए परिणाम // लोड परिणाम
        आउट // आउटपुट परिणाम
        BRA START // प्रारंभ करने और दूसरा इनपुट मान प्राप्त करने के लिए START पर शाखा करें
END HLT // रुकें - एक शून्य दर्ज किया गया था इसलिए हो गया!
परिणाम दिनांक // परिकलित परिणाम (डिफ़ॉल्ट 0)
काउंट डेटा // काउंटर (डिफ़ॉल्ट 0)
एक दिनांक 1 // स्थिरांक, 1 का मान
VALUE DAT // उपयोगकर्ता द्वारा प्रदान किया गया इनपुट, मान का वर्ग किया जाना है (डिफ़ॉल्ट रूप से 0)
शून्य DAT // स्थिरांक, 0 का मान (0 पर डिफ़ॉल्ट)

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

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

        ...
        एलडीए गिनती // गिनती लोड करें
        एक जोड़ें // गिनती में एक जोड़ें
        एसटीए काउंट // नई काउंट स्टोर करें
        उप मान // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान को COUNT से घटाएं
        BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
        ...

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

        ...
        एलडीए गिनती // गिनती लोड करें
        एक जोड़ें // गिनती में एक जोड़ें
        एसटीए काउंट // नई काउंट स्टोर करें
        एलडीए वैल्यू // वैल्यू लोड करें
        SUB COUNT // उपयोगकर्ता द्वारा प्रदत्त इनपुट मान से COUNT घटाएं
        BRZ ENDLOOP // यदि शून्य (VALUE को परिणाम में VALUE गुना जोड़कर जोड़ा गया है), तो ENDLOOP पर शाखा करें
        ...

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

लोड एलडीए 0 // संचायक में स्थिति 0 लोड करें। अगली पंक्तियों को संचायक में लोड करने के लिए इस लाइन को प्रत्येक लूप पर संशोधित किया जाएगा
     OUT // संचायक का मान आउटपुट करें। संचायक का मान वह लाइन होगी जो अभी लोड की गई थी
     सब वन // संचायक में मान से 1 घटाएं। ऐसा इसलिए है ताकि हम अगले चरण में यह देखने के लिए बीआरजेड कर सकें कि क्या हमकार्यक्रम में अंतिम पंक्ति पर हैं
     बीआरजेड वन // यदि पिछले घटाव ने संचायक को 0 बना दिया है (जिसका अर्थ है कि हमारे पास संचायक में मान 001 था), तो स्थिति एक पर शाखा करें
     एलडीए लोड // लोड स्थिति को संचायक में लोड करें, यह इस स्थिति के लिए पता अंक बढ़ाने की तैयारी में है
     एक जोड़ें // लोड लाइन के लिए स्थिति अंक बढ़ाएँ। संचायक में वर्तमान में मान, यदि एक निर्देश के रूप में पढ़ा जाता है, तो लोड की गई अंतिम पंक्ति की तुलना में, अगली पंक्ति संचायक में लोड हो जाएगी
     एसटीए लोड // नई बढ़ी हुई लोड लाइन को वापस लोड स्थिति में स्टोर करें
     ब्रा लोड // लूप की शुरुआत पर लौटें
एक दिनांक 1 // चर एक। यदि इसे एक निर्देश के रूप में पढ़ा जाता है, तो इसे HLT/COB के रूप में समझा जाएगा और कार्यक्रम समाप्त हो जाएगा

यह क्विन स्व-संशोधित कोड का उपयोग करके काम करता है। स्थिति 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=251855’