कंप्यूटर 0 और 1 को शब्दों और तस्वीरों में कैसे बदलते हैं

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

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

एक स्विच में एक बिट की जानकारी रखी जा सकती है

बत्ती का स्विच सोचिए। अभी हमारे लिए उसकी दो स्थितियाँ हैं: बंद और चालू। हम उनके नाम कुछ भी रख सकते हैं, लेकिन 0 और 1 कहना आसान है। दो संभावनाओं में से एक को चुनना एक बिट है, जो बाइनरी डिजिट का छोटा नाम है। एक बिट दो स्थितियों में फ़र्क बता सकता है, लेकिन अकेले किसी व्यक्ति का नाम नहीं बता सकता और न ही किसी तस्वीर का वर्णन कर सकता है।

कंप्यूटर के भीतर बहुत छोटे इलेक्ट्रॉनिक पुर्ज़े स्विच की तरह काम करते हैं। ऐसे अनेक दो-स्थिति वाले स्विचों को जोड़कर कंप्यूटर सिर्फ़ चालू और बंद से कहीं अधिक जानकारी दर्शा सकता है।

चार बिट से गिनती की जा सकती है

मान लीजिए, चार स्विच एक कतार में रखे हैं। बाएँ से दाएँ उन्हें 8, 4, 2 और 1 का मान दीजिए। स्विच चालू हो तो उसका मान गिना जाएगा; बंद हो तो वह कुछ नहीं जोड़ेगा। अब उन्हें 0 1 0 1 पर रखिए: बंद, चालू, बंद, चालू। दूसरे स्विच का मान 4 है और चौथे का 1। दोनों मिलकर 4 + 1 = 5 देते हैं।

दूसरा मेल आज़माइए। पैटर्न 0111 का मतलब 7 है और 1111 का मतलब 15। यही बाइनरी है: सिर्फ़ 0 और 1 से संख्याएँ लिखने का तरीका। यह रोज़ इस्तेमाल होने वाली दशमलव प्रणाली जैसी ही बुनियादी सोच पर चलता है, लेकिन बाईं ओर जाने पर हर जगह का मान दस गुना नहीं, बल्कि दोगुना होता है।

हर बिट की दो संभावित स्थितियाँ होती हैं, 0 या 1। इसलिए चार बिट से 2 × 2 × 2 × 2 = 16 अलग पैटर्न बनते हैं। आठ बिट, जिन्हें आम तौर पर एक बाइट में रखा जाता है, 256 पैटर्न दे सकते हैं। और बिट जोड़कर हम बड़ी संख्याएँ दर्शा सकते हैं; इसके लिए इलेक्ट्रॉनिक पुर्ज़ों को कोई नई स्थिति पहचानना नहीं सीखना पड़ता। गिनती इन पैटर्न का सिर्फ़ पहला उपयोग है।

एक संख्या किसी अक्षर का मतलब भी दे सकती है

स्क्रीन पर दिख रहे X के पास लौटते हैं। अगर किसी अक्षर को स्टोर करना है, तो ऐसी तय व्यवस्था चाहिए जो उस अक्षर को एक संख्या से जोड़े। ASCII नाम का एक पुराना टेक्स्ट स्टैंडर्ड इसका सीधा उदाहरण देता है: इसमें बड़े अंग्रेज़ी अक्षर X को संख्या 88 दी गई है।

बाइनरी में 88 को 01011000 लिखा जा सकता है। शुरू का शून्य केवल सात-बिट ASCII कोड को आठ जगहों में दिखाने के लिए जोड़ा गया है। इसमें 1 उन जगहों पर हैं जिनका मान 64, 16 और 8 है। इन्हें जोड़ने पर 88 मिलता है। अगर कोई प्रोग्राम इन बिट को संख्या माने, तो मान अट्ठासी होगा। अगर वह ASCII के हिसाब से इन्हें समझे, तो ये X अक्षर को दर्शाएँगे।

इस पैटर्न की शक्ल X जैसी बिल्कुल नहीं है। इनके बीच का संबंध उस तय नियम से आता है जिसके अनुसार पैटर्न को पढ़ा जाता है।

आज के कंप्यूटरों को ASCII से कहीं अधिक अक्षर और चिह्न दिखाने होते हैं। इनमें दुनिया भर की लिपियाँ और इमोजी जैसे प्रतीक भी शामिल हैं। इसलिए वे Unicode जैसे अधिक व्यापक मानकों और अक्षरों को बाइट में एनकोड करने के अलग-अलग तरीकों का इस्तेमाल करते हैं। विवरण बदल सकते हैं, लेकिन मूल बात वही है: स्टोर किए गए मानों को अर्थ तय नियमों से मिलता है। शब्द ऐसे ही दर्शाए गए अक्षरों का क्रम होता है। कोई प्रोग्राम B, O और X के कोड एक के बाद एक स्टोर और पढ़ सकता है; BOX शब्द के लिए अलग हार्डवेयर की ज़रूरत नहीं होती।

रंगों के लिए भी यही बात लागू होती है। स्क्रीन पर एक पिक्सेल बताने का आम तरीका है तीन संख्याओं से लाल, हरी और नीली रोशनी की मात्रा बताना। हर रंग के लिए आठ बिट वाले एक सामान्य उदाहरण में (255, 0, 0) लाल रंग दर्शाता है: लाल का मान सबसे अधिक है, जबकि हरे और नीले का शून्य। किसी दूसरे नियम के तहत इन्हीं संख्याओं का दूसरा अर्थ हो सकता है। इसलिए टेक्स्ट और तस्वीरें एक ही तरह की बुनियादी इलेक्ट्रॉनिक व्यवस्था से स्टोर की जा सकती हैं, लेकिन वे एक ही तरह की जानकारी नहीं हैं।

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

इलेक्ट्रॉनिक सर्किट काम कैसे करते हैं

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

कंप्यूटर बाइनरी संख्याओं को जोड़ सकता है। उदाहरण के लिए 0101 का मान 5 है और 0001 का 1। दोनों को जोड़ने पर 0110 मिलता है, जिसका मान 6 है।

निर्देश भी 0 और 1 के रूप में दर्शाए जाते हैं। कुछ बिट प्रोसेसर को बताते हैं कि कौन-सा काम करना है, और दूसरे बताते हैं कि किन मानों का इस्तेमाल होगा या वे कहाँ मिलेंगे, जैसे किसी रजिस्टर में (प्रोसेसर के भीतर छोटी-सी स्टोरेज जगह)। हम इन कामों को छोटे नाम देते हैं: MOVE मान की कॉपी करता है, ADD संख्याएँ जोड़ता है, COMPARE मानों की तुलना करता है और JUMP प्रोसेसर को दूसरे निर्देश पर ले जाता है। CALL निर्देशों का एक अलग क्रम शुरू करता है और RETURN उसके बाद वापस लौटाता है। निर्देशों के अनुसार चलते हुए, कभी कदम दोहराकर और कभी रास्ता बदलकर, प्रोसेसर प्रोग्राम चलाता है।

यहीं सॉफ़्टवेयर और हार्डवेयर मिलते हैं: निर्देश इलेक्ट्रॉनिक सर्किट को बताते हैं कि क्या काम करना है।

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

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

स्क्रीन पर X अक्षर कैसे आता है

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

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

फ़ॉन्ट बदलने पर X की शक्ल काफ़ी बदल सकती है। अक्षर की पहचान नहीं बदली; उसे बनाने वाली जानकारी और निर्देश बदल गए हैं। इसी तरह 88 अपने-आप X बनकर नहीं दिखेगा, केवल इसलिए कि ये बिट कहीं स्टोर हैं। प्रोग्राम को तय करना होगा कि उन्हें टेक्स्ट के रूप में समझा जाए, और फिर उन्हें दिखाने की व्यवस्था करनी होगी।

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

तस्वीरें और आवाज़ भी इसी तरह काम करती हैं

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

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

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

जब कुछ गड़बड़ हो जाए

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

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

आने वाले लेखों में हम देखेंगे कि ऐसी विफलताएँ कैसे होती हैं और इंजीनियर उन्हें रोकने या उनके असर को सीमित करने के लिए क्या करते हैं।

निचोड़

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

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