एआई के साथ कोडिंग और पेयर प्रोग्रामिंग

लाभ:

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

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

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

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

नेट अनुबंध के साथ मुद्रण कोड

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

1. अनुबंध लिखें. इनपुट, आउटपुट, त्रुटि, बाधा।
2. एक छोटी इकाई के लिए पूछें. एक ही जिम्मेदारी वाला कार्य; यह कोई बहुत बड़ा मॉड्यूल नहीं है.
3. एक परीक्षण ब्लॉक का अनुरोध करें. कोड के आगे कुछ नमूना रन/परीक्षण जोड़ें।
4. संकलित करें और चलाएँ. इसे एज केस के साथ आज़माएं, आंखों से आउटपुट सत्यापित करें।
5. अगले चरण पर जाएं। एक बार एक टुकड़े की पुष्टि हो जाने पर, उस पर निर्माण करें।

अनुबंधित फ़ंक्शन प्रॉम्प्ट: "टाइपस्क्रिप्ट 5 के लिए एक फ़ंक्शन लिखें। उद्देश्य: शॉपिंग कार्ट में वस्तुओं की कुल मात्रा की गणना करें। इनपुट: {मूल्य: संख्या, मात्रा: संख्या }[] सरणी। आउटपुट: संख्या (कुल)। नियम: यदि मात्रा या कीमत नकारात्मक है तो त्रुटि फेंकें; खाली सरणी के लिए 0 लौटाएं; दशमलव त्रुटि के लिए 2 दशमलव स्थानों पर गोल करें। बाहरी लाइब्रेरी का उपयोग न करें। फ़ंक्शन के नीचे 5 परीक्षण मामले जोड़ें (सामान्य, खाली, नकारात्मक मात्रा, दशमलव मूल्य, एकल आइटम)।"

एक जोड़ी के रूप में एआई का मार्गदर्शन करना

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

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

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

युक्ति: एआई-जनरेटेड कोड को समझे बिना स्वीकार न करें। "मुझे यह समझाओ, तुमने क्या धारणाएँ बनाईं?" प्रश्न छिपी हुई त्रुटियों को प्रकट करता है और आपको उस कोड का बचाव करने की अनुमति देता है, क्योंकि कोड आपकी जिम्मेदारी है। जिस कोड को आप नहीं समझते उसे उत्पादन में डालना किसी अनुबंध पर हस्ताक्षर किए बिना उसे भेजने जैसा है।

कमजोर संकेत/मजबूत संकेत

कमजोर: "एक सॉर्टिंग फ़ंक्शन लिखें।" (परिणाम: कौन सी भाषा, क्या सॉर्ट किया जा रहा है, क्या यह स्थिर है, प्रदर्शन बाधा क्या है, कोड जो अस्पष्ट है और शायद आवश्यकता को पूरा नहीं करता है।) मजबूत: "जावा 17 के लिए, एक ऐसी विधि लिखें जो List<कर्मचारी> ऑब्जेक्ट को पहले विभाग (वर्णमाला) द्वारा, फिर वेतन (अवरोही) द्वारा सॉर्ट करती है। मूल सूची को प्रतिस्थापित न करें, नई सूची लौटाएं। शून्य विभाग को अंत में आने दें। टिप्पणी पंक्ति में विधि की जटिलता स्पष्ट करें। 4 नमूनों के साथ एक मुख्य परीक्षण ब्लॉक जोड़ें।"

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

किनारे के मामलों और छोटे नमूनों के साथ सत्यापन

जो कोड सुखद परिदृश्य में काम करता है वह सही कोड नहीं है। उत्पादित प्रत्येक कार्य को सचेत रूप से बाध्य करें:

एज केस प्रकार

नमूना इनपुट

अपेक्षित व्यवहार

रिक्त इनपुट

खाली सरणी/स्ट्रिंग

कोई त्रुटि नहीं, तार्किक खाली परिणाम

शून्य/नकारात्मक

0, -1

परिभाषित और सही व्यवहार

महान मूल्य

लाखों रिकॉर्ड

अतिप्रवाह/प्रदर्शन नियंत्रण

शून्य/अपरिभाषित

जगह की कमी

नियंत्रित त्रुटि या डिफ़ॉल्ट

डुप्लिकेट/असामान्य

दोहराव, उलटा क्रम

सही परिणाम

मिनी मामले

केस 1 - साइलेंट राउंडिंग त्रुटि। एआई एक फ़ंक्शन लिखता है जो दशमलव (फ्लोट) प्रकार के साथ धन एकत्र करता है; 0.1 + 0.2 0.30000000000004 देता है। त्रुटि तब हल हो जाती है जब इंजीनियर "2 अंकों को पूर्णांकित करें और पूरे पैनी का उपयोग करें" नियम जोड़ता है। 3-पंक्ति वाला नियम मासिक समाधान में हजारों पैसे के अंतर को रोकता है।

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

केस 3 - चरण दर चरण कमाई। एक डेवलपर एक बार में 150-लाइन आयात मॉड्यूल प्रिंट करता है; जब उसे कोई गलती मिलती है, तो वह यह नहीं जान पाता कि यह कहां से आई है। दूसरा डेवलपर उसी काम को 5 छोटे चरणों में विभाजित करता है, प्रत्येक चरण का 2 मिनट में परीक्षण करता है और तीसरे चरण में त्रुटि तुरंत पकड़ लेता है।

सामान्य गलतियाँ

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

संक्षेप में

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

आवेदन कार्य

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

चेकलिस्ट

• [ ] मैंने एक अनुबंध लिखा है जिसमें इनपुट, आउटपुट, त्रुटियां और बाधाएं शामिल हैं।
• [ ] मैंने एक बड़े ब्लॉक के बजाय छोटे चरणों में कोड तैयार किया।
• [ ] मैंने कोड के आगे एक परीक्षण/नमूना रन ब्लॉक जोड़ा।
• [ ] मैंने जानबूझकर कम से कम 5 एज मामलों का परीक्षण किया है।
• [ ] मैंने एआई को कोड समझाया और उसकी धारणाओं की समीक्षा की।
• [ ] मैंने पाई गई त्रुटि को ठीक किया और पुन: परीक्षण करके सुधार की पुष्टि की।