C++ में प्रोग्रामिंग I: अध्ययन योजना

प्रयोजन

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

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

अधिक सरल भाषा के बजाय C++ क्यों

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

• प्रकार। हर डेटा एक प्रकार के साथ घोषित होता है, जो तय करता है कि वह कौन-से मान ले सकता है, कितनी जगह घेरता है और कौन-सी संक्रियाएँ स्वीकार करता है; कुछ भी चलाने से पहले ही कंपाइलर उसे अस्वीकार कर देता है जो मेल नहीं खाता।
• कंपाइलेशन। लिखना, कंपाइल करना, लिंक करना और चलाना अलग-अलग क्षण हैं, और हर त्रुटि इनमें से किसी एक की होती है; यह जानना कि किसकी है, उसे ठीक करने का आधा काम है।
• मेमोरी। चर एक नामित मेमोरी सेल है, जिसका जीवनकाल और स्कोप होता है; रेफ़रेंस उसी सेल का दूसरा नाम है, और ऐसी सेल का रेफ़रेंस जो अब मौजूद नहीं है, एक वास्तविक त्रुटि है।
• प्रतिलिपि की लागत। किसी वेक्टर को फ़ंक्शन को पास करने पर वह पूरा का पूरा कॉपी हो सकता है; मान और रेफ़रेंस के बीच चुनाव प्रोग्राम लिखने वाले का निर्णय है, मशीन का नहीं।
• संख्याओं की सीमाएँ। 32-बिट का पूर्णांक $2\,147\,483\,647$ से आगे नहीं जाता, और फ़्लोटिंग-पॉइंट संख्या $0.1$ को सटीक रूप से नहीं रख सकती।
• अपरिभाषित व्यवहार। जिसे मानक परिभाषित नहीं करता (किसी ऐरे की सीमा से बाहर जाना, किसी चिह्नित पूर्णांक का ओवरफ़्लो, किसी अन-इनिशियलाइज़्ड चर को पढ़ना) वह कोई निश्चित त्रुटि नहीं, बल्कि कुछ भी उत्पन्न करता है; इसीलिए पाठ्यक्रम हमेशा चेतावनियों और डिटेक्टरों (sanitizer) के साथ कंपाइल करता है।

नीचे दिया उदाहरण इसे छोटे पैमाने पर दिखाता है। प्रोग्राम $1$ से $15$ तक के क्रमगुणित int प्रकार के एक चर में निकालता है। Python में, जिसके पूर्णांक बिना सीमा के बढ़ते हैं, वही गणना बिना किसी शिकायत के $13! = 6\,227\,020\,800$ छाप देती; C++ में $12!$ और $13$ का गुणनफल int में नहीं समाता, और अपरिभाषित व्यवहार का डिटेक्टर, जिसके साथ पाठ्यक्रम अपने सभी उदाहरण कंपाइल करता है, प्रोग्राम को ठीक उसी पंक्ति पर रोक देता है:

#include <print>​int main(){    int factorial{1};    for (int n{1}; n <= 15; ++n) {        factorial = factorial * n;   // क्या गुणनफल int में समाता है?        std::println("{}! = {}", n, factorial);    }}

1! = 12! = 23! = 64! = 245! = 1206! = 7207! = 50408! = 403209! = 36288010! = 362880011! = 3991680012! = 479001600main.cpp:7:31: runtime error: signed integer overflow: 479001600 * 13 cannot be represented in type 'int'

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

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

फिर भी, C++ एक बड़ी भाषा है, और बुनियादी बातों के पाठ्यक्रम को उसे पूरा पढ़ाने के प्रलोभन से बचना चाहिए। यह पहला पाठ्यक्रम C++23 मानक में संरचित प्रोग्रामिंग (डेटा, व्यंजक, नियंत्रण प्रवाह, अनुक्रम, टेक्स्ट और फ़ंक्शन) तक सीमित है, उसके आधुनिक रूपों के साथ: std::println से आउटपुट, std::array और std::vector से अनुक्रम, std::string से टेक्स्ट, और लाइब्रेरी के एल्गोरिदम उनके रेंज वाले रूप में। जो कुछ इस नींव की माँग करता है, वह C++ में प्रोग्रामिंग II के लिए छोड़ दिया गया है: पॉइंटर और डायनेमिक मेमोरी, मेथड वाले क्लास, अपने टेम्पलेट, अनाम फ़ंक्शन और एक्सेप्शन।

लक्षित विद्यार्थी और पूर्व-ज्ञान

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

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

यह कहाँ ले जाता है

ऊपर कही बातों से साइट पर पाठ्यक्रम का स्थान निकलता है। इसकी कोई पूर्वापेक्षा नहीं है, और यह दो अध्ययन कार्यक्रमों, “सूचना विज्ञान और संगणन” और “अभियांत्रिकी”, का लक्ष्य है, क्योंकि दोनों में प्रोग्रामिंग एक साथ साधन भी है और विषय भी। इसलिए उचित है कि यह इन कार्यक्रमों के पहले पाठ्यक्रमों में से एक हो, शैक्षणिक लेखन के लिए LaTeX और गणितीय तर्कशास्त्र I: प्रस्तावात्मक तर्क के साथ।

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

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

समग्र अधिगम उद्देश्य

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

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

पाँच उद्देश्यों की अपनी इकाई है: उद्देश्य 2 की, डेटा और प्रकार की इकाई; उद्देश्य 3 की, व्यंजकों की; उद्देश्य 4 की, नियंत्रण प्रवाह की; उद्देश्य 5 की, फ़ंक्शनों की; और उद्देश्य 6 की, संयुक्त डेटा की, जो टेक्स्ट और फ़ाइलों की इकाई में आगे बढ़ती है, जहाँ उद्देश्य 2 UTF-8 एन्कोडिंग के साथ फिर प्रकट होता है। बाकी दो, इसके विपरीत, पूरे पाठ्यक्रम में व्याप्त हैं। उद्देश्य 1 की मुख्य इकाई पहली इकाई है, जो विनिर्दिष्ट करने, लिखने, कंपाइल करने और चलाने का कार्य-चक्र सिखाती है, और साथ में अंतिम इकाई का डिबगिंग वाला पाठ; पर इसका अभ्यास सभी इकाइयों में होता है, क्योंकि पाठ्यक्रम का हर प्रोग्राम कंपाइल होता है, चलता है और सुधारा जाता है। उद्देश्य 7 की मुख्य इकाई अंतिम इकाई, बड़े प्रोग्रामों की इकाई, है; पर यह पहली इकाई की स्टाइल गाइड से शुरू होता है, दूसरी के स्थिरांकों में आगे बढ़ता है, पाँचवीं के अनुबंधों में, जो उसके बाद से हर फ़ंक्शन के साथ रहते हैं, और चौथी और छठी के निश्चरों में आकार लेता है। इससे यह निकलता है कि इन दोनों की उपलब्धि किसी एक इकाई के नाम नहीं की जा सकती, और इन्हें पूरे पाठ्यक्रम में विकसित करना उचित है।

विषय-वस्तु

पाठ्यक्रम दस इकाइयों में संगठित है: यह परिचय, विषय-वस्तु की आठ इकाइयाँ और एक समापन। विषय-वस्तु की हर इकाई एक परिचय पाठ से खुलती है, जो उसके पाठों, उसके द्वारा ज्ञात मानी गई बातों और उसके द्वारा हल की जाने वाली समस्या को प्रस्तुत करता है, और प्रवेश मूल्यांकन से शुरू होता है; और एक सारांश पाठ से बंद होती है, जो इकाई की अवधारणाओं की शृंखला का पुनर्निर्माण करता है, जो किसी भी भाषा में लागू होता है उसे C++ में उसके रूप से अलग करता है, इकाई के अपरिभाषित व्यवहार को एकत्र करता है, समापन मूल्यांकन में प्रवेश मूल्यांकन के कौशलों को दोहराता है, और पाठों के प्रश्नों से अधिक कठिन चुनौतियाँ प्रस्तुत करता है।

इकाई 0. पाठ्यक्रम का परिचय

इसमें यही पाठ है, जो प्रयोजन, भाषा का चुनाव, समग्र उद्देश्य, विषय-वस्तु, अध्ययन-भार और पाठ्यक्रम की रूपरेखा तय करता है।

इकाई 1. पहले कदम

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

1. C++ में पहले कदम: परिचय।
2. समस्या से एल्गोरिदम तक: इनपुट और आउटपुट का विनिर्देश, क्रमांकित चरण, हाथ से ट्रेस, अनुक्रम, निर्णय और पुनरावृत्ति।
3. प्रोग्राम, कंपाइलर और C++: प्रीप्रोसेसिंग, कंपाइलेशन और लिंकिंग; कंपाइल्ड और इंटरप्रेटेड भाषाओं की तुलना; भाषा के मानक।
4. Windows, macOS और Linux पर परिवेश स्थापित करना: तीनों पूरी मार्गदर्शिकाएँ, कंपाइलर, Visual Studio Code और उसका C++ एक्सटेंशन, जाँच और आम समस्याएँ।
5. कंपाइल करना, चलाना और कॉन्फ़िगर करना: पाठ्यक्रम के विकल्प, त्रुटियाँ और चेतावनियाँ, डिटेक्टर, संपादक का बिल्ड टास्क और कंसोल की एन्कोडिंग।
6. प्रोग्राम की बनावट: इन्क्लूड, main, स्टेटमेंट, ब्लॉक, टिप्पणियाँ और पाठ्यक्रम की स्टाइल गाइड।
7. इनपुट, आउटपुट और त्रुटियाँ: std::cin, std::println और फ़ॉर्मैट विनिर्देश, अपेक्षा से भिन्न इनपुट और त्रुटियों का वर्गीकरण।
8. C++ में पहले कदम: सारांश और चुनौतियाँ।

इकाई 2. डेटा और प्रकार

इसका उद्देश्य यह सिखाना है कि हर डेटा मेमोरी में एक प्रकार के साथ रहता है, जो तय करता है कि वह कौन-से मान ले सकता है, कितनी जगह घेरता है और कौन-सी संक्रियाएँ स्वीकार करता है, और यह कि प्रोग्राम की संख्या गणित की संख्या नहीं, बल्कि सीमाओं वाला एक निरूपण है।

1. डेटा और प्रकार: परिचय।
2. चर और मेमोरी: घोषणा और ब्रेस इनिशियलाइज़ेशन, असाइनमेंट, अवस्था का ट्रेस, नाम और अन-इनिशियलाइज़्ड चर।
3. पूर्णांक और उनका निरूपण: आधार 2 और 16, हर प्रकार के मानों की परास, दो का पूरक, और चिह्नित तथा अचिह्नित ओवरफ़्लो।
4. फ़्लोटिंग-पॉइंट संख्याएँ: $0.1$ सटीक क्यों नहीं है, संचित पूर्णांकन, सहनसीमा के साथ तुलना, अनंत और अ-संख्या (NaN)।
5. वर्ण, बूलियन, रूपांतरण और स्थिरांक: किसी वर्ण का कोड, अंतर्निहित और स्पष्ट रूपांतरण, सूचना खोने वाले रूपांतरणों की अस्वीकृति, const, constexpr और auto।
6. डेटा और प्रकार: सारांश और चुनौतियाँ।

इकाई 3. व्यंजक और संक्रियक

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

1. व्यंजक और संक्रियक: परिचय।
2. अंकगणितीय संक्रियाएँ: ऋणात्मक संख्याओं के साथ भागफल और शेषफल, व्यंजक वृक्ष, प्राथमिकता, साहचर्यता और परिणाम का प्रकार।
3. संबंध और तर्क: संयुक्त शर्तें, डी मॉर्गन के नियमों से उनका निषेध, शॉर्ट-सर्किट गणना और 1 < x < 5 वाली त्रुटि।
4. असाइनमेंट, साइड इफ़ेक्ट और अपरिभाषित व्यवहार: किसी व्यंजक का मान और प्रभाव, इंक्रीमेंट, गणना का क्रम, और जिसे मानक परिभाषित नहीं करता उसकी सूची।
5. बिट और गणितीय लाइब्रेरी: बिटवार संक्रियक, शिफ़्ट, मास्क, <cmath> और <numbers> के स्थिरांक।
6. व्यंजक और संक्रियक: सारांश और चुनौतियाँ।

इकाई 4. नियंत्रण प्रवाह

इसका उद्देश्य निर्णयों और लूपों से निष्पादन के क्रम को नियंत्रित करना और उनकी शुद्धता पर विचार करना सिखाना है: कि हर स्थिति सँभाली जाए, कि हर लूप वही करे जो उसे करना चाहिए, और कि वह समाप्त हो। यह उसे साकार करती है जिसकी घोषणा पाठ्यक्रम के पहले पाठ ने की थी: निर्णय और पुनरावृत्ति, अब लिखे हुए और सत्यापित।

1. नियंत्रण प्रवाह: परिचय।
2. निर्णय: शृंखलित और नेस्टेड if और else, परस्पर अपवर्जी और सर्वसमावेशी स्थितियाँ, enum class के साथ switch और उसके जाल।
3. लूप: while, do और for, किसी लूप का ट्रेस, उसके रूपों के बीच रूपांतरण और नेस्टेड लूप।
4. सही लूप की रचना: काउंटर, संचायक, अधिकतम और सेंटिनल के पैटर्न, निश्चर, समाप्ति और डिबगर से पहला परिचय।
5. संख्यात्मक एल्गोरिदम: अभाज्यता परीक्षण, यूक्लिड का एल्गोरिदम, आधार परिवर्तन, हॉर्नर नियम और द्विभाजन विधि, हर एक अपने औचित्य के साथ।
6. नियंत्रण प्रवाह: सारांश और चुनौतियाँ।

इकाई 5. फ़ंक्शन

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

1. फ़ंक्शन: परिचय।
2. फ़ंक्शन: घोषणा, परिभाषा और कॉल, कॉल स्टैक, पूर्व-शर्त और पश्च-शर्त, और वह फ़ंक्शन जो कोई मान नहीं लौटाता।
3. पैरामीटर और स्कोप: मान द्वारा, रेफ़रेंस द्वारा और कॉन्स्ट रेफ़रेंस द्वारा पास करना, संरचित बाइंडिंग से अनेक परिणाम, चरों का स्कोप और जीवनकाल।
4. फ़ंक्शनों से डिज़ाइन: क्रमिक परिशोधन, बॉडी से पहले इंटरफ़ेस, “एक फ़ंक्शन, एक काम” का नियम और ओवरलोडिंग।
5. पुनरावर्तन: आधार स्थिति और पुनरावर्ती स्थिति, आगमन से शुद्धता और समाप्ति, स्टैक और पुनरावर्तन की लागत।
6. फ़ंक्शन: सारांश और चुनौतियाँ।

इकाई 6. संयुक्त डेटा

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

1. संयुक्त डेटा: परिचय।
2. ऐरे: std::array, इंडेक्स से और रेंज-आधारित for से ट्रैवर्सल, सीमाओं के भीतर इंडेक्स, और तुलना के लिए C ऐरे।
3. वेक्टर: std::vector, अज्ञात लंबाई की शृंखला को पढ़ना, संचय, फ़िल्टर और रूपांतरण, आकार और क्षमता।
4. एल्गोरिदम की लागत: प्रभावी संक्रियाओं की गिनती, वृद्धि की कोटियाँ और समय का मापन।
5. खोजना और क्रमबद्ध करना: रैखिक खोज और द्विआधारी खोज, अपने निश्चरों के साथ सिलेक्शन सॉर्ट और इंसर्शन सॉर्ट, और लाइब्रेरी के एल्गोरिदम।
6. तालिकाएँ: द्वि-आयामी तालिकाएँ, पंक्तियों और स्तंभों के अनुसार उनका ट्रैवर्सल, परिवर्त, गुणनफल, और फ़्लैट वेक्टर में तालिका।
7. रिकॉर्ड: struct, डेज़िग्नेटेड इनिशियलाइज़र, पैरामीटर के रूप में रिकॉर्ड, और किसी फ़ील्ड के अनुसार क्रमबद्ध करना।
8. संयुक्त डेटा: सारांश और चुनौतियाँ।

इकाई 7. टेक्स्ट और फ़ाइलें

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

1. टेक्स्ट और फ़ाइलें: परिचय।
2. स्ट्रिंग: std::string और उसकी संक्रियाएँ, npos, std::string_view व्यू, और तुलना के लिए C स्ट्रिंग।
3. टेक्स्ट ASCII नहीं है: UTF-8 एन्कोडिंग, बाइट और वर्ण, और वे संक्रियाएँ जो टेक्स्ट को तोड़ देती हैं।
4. इनपुट को सही ढंग से पढ़ना: std::getline, स्ट्रीम की अवस्था, अमान्य डेटा के बाद पुनर्प्राप्ति, और std::from_chars से सत्यापन।
5. टेक्स्ट फ़ाइलें: खोलना, पंक्ति-दर-पंक्ति पढ़ना, लिखना, जोड़ना, और अल्पविराम से अलग किए गए मानों वाली फ़ाइल को संसाधित करना।
6. टेक्स्ट और फ़ाइलें: सारांश और चुनौतियाँ।

इकाई 8. बड़े प्रोग्राम

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

1. बड़े प्रोग्राम: परिचय।
2. कई फ़ाइलें और अपनी लाइब्रेरी: हेडर और कार्यान्वयन, इन्क्लूड गार्ड, एक परिभाषा नियम और पृथक कंपाइलेशन।
3. प्रोग्रामों का परीक्षण: विनिर्देश से निकाले गए परीक्षण मामले, स्वचालित परीक्षण, assert और static_assert।
4. प्रोग्रामों की डिबगिंग: Visual Studio Code का डिबगर, ब्रेकपॉइंट, कॉल स्टैक और किसी त्रुटि का स्थान खोजने की एक व्यवस्थित रणनीति।
5. बड़े प्रोग्राम: सारांश और चुनौतियाँ।

इकाई 9. पाठ्यक्रम का समापन

इसमें C++ में प्रोग्रामिंग I: अंतिम समीक्षा पाठ है, जो सात समग्र उद्देश्यों को याद दिलाता है, एक चित्र में दिखाता है कि हर उद्देश्य पर किन इकाइयों और पाठों में काम होता है, समापन मूल्यांकनों के पहले प्रयास को उद्देश्य के अनुसार एकत्र करता है और बताता है कि अध्ययन आगे कहाँ जाता है।

अध्ययन-भार और क्रेडिट

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

परिणाम

पाठ्यक्रम के पाठों में कुल मिलाकर $105$ हल किए गए प्रश्न, $105$ अभ्यास प्रश्न और $52$ चुनौतियाँ हैं, साथ ही सोलह इकाई-मूल्यांकन और सत्तर छोटे अभ्यास जिन्हें साइट तुरंत जाँचती है। प्रति इकाई अनुमानित अध्ययन-भार, घंटे तक पूर्णांकित, नीचे दिया गया है:

• इकाई 0, पाठ्यक्रम का परिचय: $1$ घंटा।
• इकाई 1, पहले कदम: $28$ घंटे।
• इकाई 2, डेटा और प्रकार: $22$ घंटे।
• इकाई 3, व्यंजक और संक्रियक: $22$ घंटे।
• इकाई 4, नियंत्रण प्रवाह: $22$ घंटे।
• इकाई 5, फ़ंक्शन: $22$ घंटे।
• इकाई 6, संयुक्त डेटा: $30$ घंटे।
• इकाई 7, टेक्स्ट और फ़ाइलें: $21$ घंटे।
• इकाई 8, बड़े प्रोग्राम: $20$ घंटे।
• इकाई 9, पाठ्यक्रम का समापन: $1$ घंटे से कम।

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

फिर भी, यह संख्या नाममात्र की है: यही पाठ्यक्रम के क्रेडिट तय करती है, और यह स्थिर गति से पढ़ने और हर चुनौती के लिए पौन घंटे को मानकर चलती है। जब तक इसे वास्तविक विद्यार्थियों के साथ मापा न जाए, इसके साथ एक यथार्थवादी परास देना उचित है। यदि पढ़ना मानी गई गति के आधे से चले, जैसा तब होता है जब हर उदाहरण हाथ से लिखा जाता है, कंपाइल किया जाता है और यह देखने के लिए बदला जाता है कि क्या बदलता है, और हर चुनौती पैंतालीस के बजाय पचहत्तर मिनट माँगे, तो वही विधि लगभग $250$ घंटे देगी। अतः अपेक्षित अध्ययन-भार लगभग $188$ और लगभग $250$ घंटों के बीच रहता है। ऊपरी सिरा एक सतर्क सीमा है, माप नहीं; परास तब सुधारी जाएगी जब यह ज्ञात होगा कि पाठ्यक्रम पढ़ने वाले वास्तव में कितना समय लगाते हैं, और तब तक क्रेडिट नाममात्र की संख्या से गिने जाते हैं।

सुझाई गई गति

गतियों के नाम रखने के लिए यह योजना वही मानदंड अपनाती है जो साइट की अन्य अध्ययन योजनाएँ: पूर्णकालिक अध्ययन $60$ क्रेडिट के एक शैक्षणिक वर्ष का है, लगभग $1650$ घंटे जो लगभग चालीस सप्ताहों में बँटे हैं, अर्थात प्रति सप्ताह लगभग $40$ घंटे, और अंशकालिक अध्ययन इसका आधा है, प्रति सप्ताह लगभग $20$ घंटे। इससे सोलह सप्ताह के एक सत्र की अनुशंसित गति निकलती है, प्रति सप्ताह लगभग $12$ घंटे के अध्ययन के साथ, जो पूर्णकालिक अध्ययन के एक-तिहाई से थोड़ा कम है; यथार्थवादी परास के साथ, प्रति सप्ताह $12$ से $16$ घंटे। यह सत्र गणितीय तर्कशास्त्र I: प्रस्तावात्मक तर्क के साथ साझा किया जा सकता है, जिसकी सत्यता सारणियाँ और उपपत्ति का विचार इस पाठ्यक्रम की शर्तों और निश्चरों में पहचाने जा सकते हैं।

लगभग $20$ घंटे प्रति सप्ताह की गहन गति, अर्थात अंशकालिक अध्ययन, पाठ्यक्रम को नौ या दस सप्ताहों में पूरा कर देती है। लगभग $6$ घंटे प्रति सप्ताह की अधिक ढीली गति इसे दो सत्रों तक ले जाती है, जो लगभग आधे-आधे बँटते हैं: इकाइयाँ 0 से 4, एल्गोरिदम से नियंत्रण प्रवाह तक, लगभग $95$ घंटे लेती हैं, और इकाइयाँ 5 से 9, फ़ंक्शनों से अंतिम परियोजना तक, लगभग $93$। यह बँटवारा स्वाभाविक है: इकाई 4 के अंत तक विद्यार्थी एक ही main में पूरे प्रोग्राम लिखने लगता है, और दूसरा आधा उसे उन्हें व्यवस्थित करना सिखाता है।

क्रेडिट

इस साइट के क्रेडिट उस कुल अध्ययन-भार को मापते हैं जो कोई पाठ्यक्रम उसे पढ़ने वाले से माँगता है (पढ़ना, प्रश्न, चुनौतियाँ और दोहराना), न कि कक्षा के घंटों को। एक क्रेडिट लगभग $27.5$ घंटे के काम के बराबर है, और पूर्णकालिक अध्ययन का एक वर्ष $60$ क्रेडिट के, अर्थात लगभग $1650$ घंटों के बराबर; यह वही मानदंड है जिससे ऊपर वाला अनुभाग अध्ययन की गतियों के नाम रखता है।

फिर भी, अनुमानित $188$ घंटों को $27.5$ से भाग देने पर 6.8 मिलता है, जो पूर्णांकित होकर $7$ होता है। यदि क्रेडिट के लिए $25$ से $30$ घंटे के काम का परास स्वीकार किया जाए, तो पाठ्यक्रम के क्रेडिट की संख्या $C$, 6.3 और 7.5 के बीच सीमित होती है:

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

इनकी उपयोगिता व्यावहारिक है: ये साइट के पाठ्यक्रमों के भार की आपस में तुलना करने में, और यह तय करने में सहायता करते हैं कि उपलब्ध समय से अधिक हुए बिना एक साथ कितने पाठ्यक्रम पढ़ना उचित है। उदाहरण के लिए, सोलह सप्ताह के एक सत्र में अंशकालिक अध्ययन, अर्थात लगभग $320$ घंटे, कुल लगभग $12$ क्रेडिट के पाठ्यक्रमों के लिए पर्याप्त है; उसी सत्र में पूर्णकालिक अध्ययन, लगभग $23$ क्रेडिट के लिए।

ये क्रेडिट अध्ययन की योजना बनाने के लिए साइट का अपना माप हैं: ये किसी आधिकारिक क्रेडिट प्रणाली के अनुरूप नहीं हैं, और न ही किसी संस्था द्वारा शैक्षणिक मान्यता का संकेत देते हैं।

पाठ्यक्रम की रूपरेखा

अध्ययन का स्वरूप

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

एक पाठ की संरचना

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

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

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

वाचक

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

मूल्यांकन

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

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

कृत्रिम बुद्धिमत्ता सहायक

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

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

इस पाठ्यक्रम को कैसे पढ़ें

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

मुख्य नियम एक ही है: हर उदाहरण को लिखना और कंपाइल करना। प्रोग्रामिंग पढ़कर नहीं सीखी जाती, बल्कि लिखकर, कंपाइल करके और यह पढ़कर कि कंपाइलर क्या उत्तर देता है। इसलिए विद्यार्थी Windows, macOS और Linux पर परिवेश स्थापित करना पाठ का अनुसरण करके अपना परिवेश स्थापित करता है, और हर प्रोग्राम को अपने Visual Studio Code में उन विकल्पों के साथ दोहराता है जिन्हें तय करना कंपाइल करना, चलाना और कॉन्फ़िगर करना पाठ सिखाता है; जो ऐसे कंप्यूटर का उपयोग करता है जिस पर वह प्रोग्राम स्थापित नहीं कर सकता, उसके पास अस्थायी रूप से एक ऑनलाइन कंपाइलर है, जिसका वर्णन स्थापना वाला पाठ करता है। उदाहरणों को कॉपी करने के बजाय हाथ से लिखना उचित है, क्योंकि हाथ वह याद रखता है जिसे आँख छोड़ देती है; हर प्रोग्राम का आउटपुट उसे चलाने से पहले अनुमानित करना उचित है, क्योंकि अनुमान और प्राप्त परिणाम के बीच का अंतर ठीक वही है जो अभी सीखना बाकी है; और कंपाइलर की हर चेतावनी को ऐसे प्रश्न की तरह पढ़ना उचित है जो उत्तर का पात्र है, न कि ऐसे शोर की तरह जिसे सह लिया जाए। प्रोग्राम के चल जाने के बाद, उसे जान-बूझकर बदलना भी उचित है (कोई सेमीकोलन मिटाना, कोई प्रकार बदलना, किसी वेक्टर की सीमा से बाहर जाना) और यह पढ़ना कि कंपाइलर या डिटेक्टर क्या कहते हैं, क्योंकि हर जान-बूझकर पैदा की गई त्रुटि ऐसी त्रुटि है जिसे बाद में पहचाना जाएगा।

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

संस्करण नियंत्रण

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