कंप्यूटर कैसे काम करते हैं: फ़ाइनमैन का बेहद तेज़ फ़ाइल क्लर्क

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

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

न तो यह व्याख्यान और न यह लेख कंप्यूटर के बारे में सब कुछ समझाते हैं। वे एक उपयोगी मूल बात जरूर समझाते हैं: जानकारी कहीं संग्रहीत होती है, निर्देश तय करते हैं कि आगे क्या होगा, संग्रहीत मान मशीन को दूसरी जगह भेज सकते हैं, और सरल क्रियाएँ मिलकर कहीं अधिक जटिल व्यवहार बना सकती हैं।

सुरक्षा के लिए भी यह महत्वपूर्ण है। कई गंभीर विफलताएँ इस तस्वीर तक घटा देने पर बहुत कम रहस्यमय लगती हैं। मशीन गलत जगह से पढ़ सकती है, गलत अगला कदम ले सकती है, किसी ऐसे मान पर भरोसा कर सकती है जिसका अर्थ किसी दूसरे हिस्से के लिए अलग हो, या उसे जानबूझकर कोई ऐसा व्यक्ति मोड़ सकता है जो किसी दराज़ में रखी चीज़ या क्लर्क की अगली नज़र की जगह को प्रभावित कर सके।

मशीन अपने निर्देशों का पूरी तरह पालन कर सकती है और फिर भी कुछ खतरनाक कर सकती है। इसे समझना उन बुनियादों में से एक है जिन पर हम बार-बार लौटेंगे।

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

इसलिए यह लेख जानबूझकर बुनियादी बातों से शुरू होता है। यह फ़ाइनमैन की सरल उपमाओं को इतना आगे ले जाता है कि कोई गैर-विशेषज्ञ भी यह मजबूत तस्वीर बना सके कि कंप्यूटर जानकारी कैसे ढूँढता है, निर्देशों का पालन कैसे करता है, दिशा कैसे बदलता है और सरल कदमों से जटिल व्यवहार कैसे पैदा करता है। आगे हमें इस तस्वीर की बार-बार जरूरत पड़ेगी।

एक क्लर्क और कुछ दराज़ों से शुरू करें

नंबर लगे दराज़ों से भरे कमरे में एक क्लर्क की कल्पना कीजिए। हर दराज़ में कोई संख्या या दूसरी सरल जानकारी रखी जा सकती है। क्लर्क दराज़ खोल सकता है, अंदर की चीज़ पढ़ सकता है, कोई मान कॉपी कर सकता है, कहीं और नया मान लिख सकता है, दो मानों की तुलना कर सकता है और ऐसा निर्देश मान सकता है जो बताए कि आगे क्या करना है।

यह जानबूझकर साधारण है। क्लर्क को यह जानने की जरूरत नहीं कि कोई संख्या पैसा दर्शाती है, रंग, अक्षर, तापमान, शतरंज की बिसात पर कोई स्थान, या किसी दूसरे दराज़ का पता। अर्थ उस रिप्रेज़ेंटेशन से आता है जो हम तय करते हैं। क्लर्क के लिए बस मान, स्थान और प्रक्रियाएँ हैं।

कंप्यूटर का रहस्य हटाने का यह सबसे उपयोगी तरीकों में से एक है। बाहर से मशीन का व्यवहार चकित करने वाला लग सकता है, जबकि वह ऐसी क्रियाओं से बनी होती है जो अलग-अलग देखें तो लगभग हास्यास्पद रूप से सरल हैं। जटिलता संगठन से आती है: क्या संग्रहीत है, उसे कैसे रिप्रेज़ेंट किया गया है, अगला कौन-सा निर्देश चलता है, और ऐसी कितनी क्रियाओं को एक के बाद एक जोड़ा जा सकता है।

प्रोग्राम का रास्ता भी संग्रहीत होता है

सबसे शक्तिशाली बात यह है कि फ़ाइलिंग सिस्टम केवल डेटा ही नहीं, काम के रास्ते को भी बयान कर सकता है। कहीं न कहीं क्लर्क यह दर्ज रखता है कि अगला निर्देश कौन-सा है। आधुनिक कंप्यूटर आर्किटेक्चर में स्टेट के इस छोटे हिस्से को आम तौर पर प्रोग्राम काउंटर कहा जाता है। नाम तकनीकी लग सकता है; असली विचार लगभग मज़ेदार रूप से सरल है। यह क्लर्क का वह नोट है जो मानो कहता है: “अगला निर्देश 101 पढ़ो।”

निर्देश 101 के बाद सामान्य नियम 102, फिर 103, फिर 104 पर जाना हो सकता है। लेकिन कोई निर्देश यह भी कह सकता है: अगली कार्ड पर मत जाओ; इसके बजाय निर्देश 250 पर जाओ। यह जंप है। कंडीशनल जंप एक परीक्षण जोड़ता है: अगर यह मान शून्य है तो 250 पर जाओ; नहीं तो 102 पर जारी रखो।

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

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

पॉइंटर बस लिखा हुआ एक स्थान है

पॉइंटर को भी उसी फ़ाइलिंग सिस्टम से समझा जा सकता है। मान लीजिए दराज़ 500 में संख्या 914 है। कभी 914 बस नौ सौ चौदह है। दूसरे संदर्भ में उसका अर्थ हो सकता है: जिस चीज़ की जरूरत है, वह दराज़ 914 में रखी है। जब किसी संख्या का इस तरह उपयोग होता है, तो वह पॉइंटर की तरह काम कर रही होती है, यानी किसी दूसरे स्थान (दूसरे दराज़) का पता।

फिर से, शक्ति व्याख्या में है। क्लर्क को मेमोरी में कोई चमकता हुआ तीर नहीं दिखता। वह एक मान पढ़ता है, मौजूदा निर्देश कहता है कि उस मान को स्थान की तरह समझो, और अगली क्रिया उससे दूसरा दराज़ चुनती है। इस तरह एक संग्रहीत संख्या बाद का काम कहाँ से पढ़ेगा या कहाँ लिखेगा, इसे बदल सकती है।

इसी वजह से फ़ाइल-क्लर्क मॉडल इतनी अच्छी तरह आगे बढ़ता है। डेटा दूसरे डेटा का नाम बन सकता है। निर्देश दूसरे निर्देशों की ओर मोड़ सकते हैं। स्थानों पर काम करने वाली कुछ सरल क्रियाएँ ऐसी संरचनाएँ बना सकती हैं जिनका व्यवहार उन क्रियाओं से कहीं अधिक समृद्ध हो।

सरल निर्देश, विशाल व्यवहार

एक दराज़ पढ़ो। एक दराज़ में लिखो। दो मान जोड़ो। उनकी तुलना करो। एक मान को दूसरे के स्थान की तरह इस्तेमाल करो। अगला निर्देश बदलो। दोहराओ। अलग-अलग देखें तो इनमें से कोई काम प्रभावशाली नहीं लगता।

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

यही इस व्याख्या की खूबी है। यह कंप्यूटर को मामूली नहीं बनाती। बल्कि उनकी शक्ति अधिक प्रभावशाली लगती है, क्योंकि वह इतनी साधारण चीज़ों से बनी है।

जब क्लर्क बुद्धिमान दिखाई देने लगे

फ़ाइनमैन अंततः फ़ाइल-क्लर्क मॉडल को एक कठिन सवाल की ओर ले जाते हैं: क्या मशीन सोच सकती है? उनकी रूपरेखा में कठिनाई यह नहीं है कि कंप्यूटर कभी सोचने की कोई प्रक्रिया चला ही नहीं सकता। कठिनाई यह है कि मानवीय सोच हमारे पास ऐसी ज्ञात, पूरी तरह निश्चित प्रक्रिया के रूप में नहीं आती जिसे हम बस क्लर्क को सौंप दें।

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

“वे अंकगणित किसी से भी बेहतर करते हैं, बहुत तेज़ और अलग तरीके से। … हम कभी उनके अंकगणित करने के तरीके को सिर्फ़ इंसानों जैसा दिखाने के लिए नहीं बदलेंगे; वह पीछे जाना होगा। क्योंकि इंसानों द्वारा किया गया अंकगणित धीमा, बोझिल, उलझा हुआ और गलतियों से भरा है।”

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

यहीं से कठिन सवाल आता है। अगर मशीन को अंकगणित मानवीय तरीके से करने की जरूरत नहीं, तो क्या बुद्धिमान व्यवहार भी मानवीय रास्ते से ही पैदा होना चाहिए?

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

कंप्यूटर उसी समस्या को अलग तरह से ले सकता है। वह किसी व्यक्ति से कहीं अधिक स्थितियाँ जाँच सकता है, स्पष्ट नियम और मूल्यांकन लागू कर सकता है, और ह्यूरिस्टिक इस्तेमाल करके हर जगह बराबर मेहनत लगाने से बच सकता है। उसे वह निजी रास्ता फिर से बनाना जरूरी नहीं जिससे कोई मानव विशेषज्ञ उसी चाल तक पहुँचा।

फ़ाइनमैन इस अंतर को खूबसूरती से कहते हैं: “हम उसे इंसान की तरह खेलता नहीं बना सकते, लेकिन हम उसे लगभग सभी इंसानों से बेहतर खेलवा सकते हैं।” (ज़ोर हमारा)

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

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

व्याख्यान का बाद का हिस्सा सोचने वाली मशीनों, बुद्धिमत्ता, ह्यूरिस्टिक और उनकी सीमाओं पर इस लेख से कहीं आगे जाता है। फिर भी फ़ाइनमैन की अंतिम पंक्ति इस संकुचन के बाद भी बचाए रखने लायक है: “मुझे लगता है कि हम बुद्धिमान मशीनों के करीब पहुँच रहे हैं, लेकिन वे बुद्धिमत्ता की आवश्यक कमजोरियाँ दिखा रही हैं।”

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

क्लर्क निर्देशों को शब्दशः मानता है

उसी बुद्धिमत्ता की एक तेज़ धार भी है: उसके नीचे का क्लर्क अब भी शब्दशः काम करता है। क्लर्क वही प्रक्रिया चलाता है जो वास्तव में मौजूद है और वही स्टेट इस्तेमाल करता है जो वास्तव में मौजूद है। वह हमारी मंशा को सुधार नहीं देता।

अगर कोई निर्देश गलत दराज़ की ओर इशारा करता है, तो क्लर्क किसी तरह यह नहीं जानता कि हमारा मतलब किस दराज़ से था। अगर दराज़ 500 में 914 की जगह 915 है, तो बाद का पॉइंटर कहीं और ले जा सकता है। अगर जंप की शर्त गलत लिखी गई है, तो क्लर्क गलत ब्रांच को बिल्कुल सही तरीके से ले सकता है। अगर सिस्टम का एक हिस्सा किसी मान को आकार समझता है और दूसरा हिस्सा उसे कुछ और समझता है, तो केवल इस वजह से क्लर्क नहीं रुकता कि असहमति संदिग्ध लगती है।

जब हम कहते हैं कि क्लर्क भ्रमित है, तो हमारा अर्थ यह नहीं कि कंप्यूटर मानवीय भ्रम महसूस करता है। हमारा मतलब है कि स्टेट, रिप्रेज़ेंटेशन या प्रक्रिया अब उस मॉडल से मेल नहीं खाती जिसे डिज़ाइनर लागू समझ रहा था। मशीन पूरी तरह आज्ञाकारी रह सकती है और फिर भी सिस्टम गलत हो सकता है।

वास्तविक सिस्टम में उन्हीं दराज़ों पर काम करने वाले एक से अधिक क्लर्क भी हो सकते हैं। एक क्लर्क कोई मान पढ़ रहा हो, उसी समय दूसरा उसे बदल सकता है, मिटा सकता है या उस दराज़ को किसी और काम में लगा सकता है। पहला क्लर्क फिर पुराने मान का उपयोग जारी रख सकता है, या नोट के अनुसार किसी ऐसे दराज़ तक जा सकता है जो अब उस वस्तु के लिए नहीं है जिसके लिए वह उसे समझ रहा था। जब कई क्लर्क एक ही दराज़ों तक पहुँच सकते हैं, तो कौन उन्हें कब पढ़ या बदल सकता है, यह भी प्रक्रिया के सही होने का हिस्सा बन जाता है।

यहीं इंजीनियरिंग दिलचस्प होने लगती है

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

बाहर से देखें तो ये विफलताएँ जटिल सॉफ़्टवेयर में हो सकती हैं। भीतर से बाहर देखें तो सवाल अक्सर बहुत ठोस होते हैं। क्लर्क ने कौन-सा मान पढ़ा? उस मान ने किस दराज़ का नाम दिया? अगला कौन-सा निर्देश चला? किस शर्त ने जंप कराया? अगले निर्देश ने कौन-सा स्टेट मिलने की उम्मीद की थी?

यह एक इंजीनियरिंग आदत है जिसे हम महत्वपूर्ण मानते हैं। जब सिस्टम-स्तरीय दावा धुंधला होने लगे, तब तक नीचे उतरें जब तक तंत्र फिर से शब्दशः समझ में आने न लगे।

और यहीं सुरक्षा प्रवेश करती है

सामान्य बग क्लर्क को गलती से भ्रमित कर सकता है। सुरक्षा समस्या तब संभव होती है जब कोई व्यक्ति जानबूझकर स्टेट या निर्देशों को इस तरह प्रभावित कर सके कि मशीन किसी उपयोगी नतीजे की ओर बढ़े।

हमलावर को कंप्यूटर को अवज्ञाकारी बनाने की जरूरत नहीं। उल्टा ही सही है। कुछ सबसे दिलचस्प विफलताएँ इसलिए होती हैं क्योंकि कंप्यूटर बहुत ईमानदारी से पालन करता है: वह हमलावर से प्रभावित पॉइंटर का अनुसरण करता है, भ्रामक रिप्रेज़ेंटेशन स्वीकार करता है, अनुमत जंप लेता है, अधिकृत क्रिया करता है या अगली कम्पोनेंट को बिल्कुल प्रक्रिया के अनुसार मान दे देता है।

नतीजा तब इस पर निर्भर करता है कि क्लर्क को क्या करने की अनुमति है। किसी फेंक देने योग्य अस्थायी हिस्से में भ्रम हानिरहित हो सकता है। वही भ्रम क्रेडेंशियल, टिकाऊ स्टेट, निजी डेटा, नेटवर्क पहुँच या किसी दूसरे विशेषाधिकारयुक्त कम्पोनेंट के पास हो तो उसका असर बहुत बड़ा हो सकता है।

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

एक मॉडल जिसे हम बार-बार इस्तेमाल करेंगे

हमें उम्मीद है कि फ़ाइल क्लर्क XMAKYNA की लिखाई में बार-बार लौटने वाली भाषा बनेगा, क्योंकि यह कठिन विचारों को आसान बनाता है, बिना उन्हें बच्चों जैसा बनाए। पॉइंटर लिखा हुआ स्थान बन जाता है। जंप “अगला निर्देश” वाले नोट में बदलाव बन जाता है। प्रोग्राम काउंटर क्लर्क का स्थान-चिह्न बन जाता है। मेमोरी दराज़ बन जाती है। एक्ज़ीक्यूशन उन दराज़ों पर होने वाली छोटी-छोटी क्रियाओं की श्रृंखला बन जाता है।

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

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

इसीलिए यह व्याख्यान कंप्यूटर की कोई आकर्षक पुरानी व्याख्या भर नहीं है। यह हमें लंबे समय तक उपयोगी रहने वाला सोचने का तरीका देता है।

व्याख्यान का मेटाडेटा और नामकरण संबंधी टिप्पणी

वक्ता: Richard P. Feynman। लिंक की गई रिकॉर्डिंग पर ही 26 सितंबर 1985 की तारीख दिखाई देती है और स्थान के रूप में कैलिफ़ोर्निया के बिग सुर स्थित Esalen Institute की Idiosyncratic Thinking वर्कशॉप दी गई है।

यह व्याख्यान अलग-अलग शीर्षकों से प्रचलित हुआ है, और कुछ प्रकाशित संदर्भ संबंधित Esalen सामग्री को अलग तारीख देते हैं। लिंक किए गए अपलोड का शीर्षक Hardware, Software and Heuristics है; Computers From the Inside Out और The Feynman Lecture on Heuristics भी अन्य जगह मिलते हैं। यहाँ हम इस व्याख्यान को Computers From the Inside Out कहते हैं।

व्याख्यान देखें: Richard Feynman, Computers From the Inside Out (YouTube).

निचोड़

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

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