AI सह कोडिंग आणि पेअर प्रोग्रामिंग

नफा:

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

पेअर प्रोग्रॅमिंग म्हणजे जेव्हा दोन विकसक एकाच समस्येवर काम करतात, एक लेखन आणि दुसरा सुधारित करते. AI सह कोडिंग ही याच संबंधाची डिजिटल आवृत्ती आहे: तुम्ही दिशा, मर्यादा आणि स्वीकृती निकष सेट करता; एआय द्रुत मसुदा तयार करते; आपण प्रत्येक चरण संकलित करून आणि चाचणी करून सत्यापित करता. येथे सर्वात मोठा सापळा म्हणजे AI ला सांगणे "मला हा अनुप्रयोग सुरुवातीपासून शेवटपर्यंत लिहा" आणि 200-लाइन ब्लॉक आंधळेपणाने स्वीकारा. चांगली जोडी प्रोग्रामिंग लहान चरणांमध्ये पुढे जाते: प्रत्येक चरण समजण्यायोग्य, चाचणी करण्यायोग्य आणि उलट करता येण्यासारखे असावे.

या युनिटमध्ये तुम्ही स्पष्ट इनपुट-आउटपुट कॉन्ट्रॅक्टसह फंक्शन्स, क्लासेस आणि मॉड्यूल्स कसे मुद्रित करायचे ते शिकाल; एआय स्टेप बाय स्टेप कसे मार्गदर्शन करावे; आणि लहान उदाहरणांसह तयार केलेला कोड चालवून लॉजिक आणि एज केस एरर कसे पकडायचे ते आपण पाहू. ध्येय गती नाही, परंतु सत्यापित गती आहे.

संकल्पना: इनपुट-आउटपुट करार: फंक्शन कोणते इनपुट घेते आणि ते कोणत्या आउटपुट आणि त्रुटी वर्तनाचे वचन देते याची स्पष्ट व्याख्या. एज केस: इनपुट जे सामान्य नाही परंतु प्रत्यक्षात येऊ शकते (रिक्त, शून्य, ऋण, खूप मोठे, शून्य). वाढीव विकास: लहान, कार्यरत तुकड्यांसह पुढे जाणे आणि प्रत्येक चरण प्रमाणित करणे.

नेट कॉन्ट्रॅक्टसह प्रिंटिंग कोड

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

1. करार लिहा. इनपुट, आउटपुट, त्रुटी, मर्यादा.
2. एक लहान युनिट विचारा. एकाच जबाबदारीसह कार्य; हे फार मोठे मॉड्यूल नाही.
3. चाचणी ब्लॉकची विनंती करा. कोडच्या पुढे काही नमुना धावा/चाचण्या जोडा.
4. संकलित करा आणि चालवा. एज केसेससह वापरून पहा, डोळ्याद्वारे आउटपुट सत्यापित करा.
5. पुढील चरणावर जा. एकदा तुकड्याची पुष्टी झाल्यानंतर, त्यावर तयार करा.

कॉन्ट्रॅक्टेड फंक्शन प्रॉम्प्ट: "TypeScript 5 साठी एक फंक्शन लिहा. उद्देश: शॉपिंग कार्टमधील आयटमच्या एकूण रकमेची गणना करा. इनपुट: { किंमत: संख्या, प्रमाण: संख्या [] ॲरे. आउटपुट: संख्या (एकूण). नियम: जर प्रमाण किंवा किंमत ऋण असेल तर थ्रो एरर; एएमपी 2 मधील एरर 2 एररसाठी 0 परत करा. बाह्य लायब्ररी वापरू नका फंक्शनच्या खाली 5 चाचणी प्रकरणे जोडा (सामान्य, रिक्त, नकारात्मक प्रमाण, दशांश किंमत, एकल आयटम).

एक जोडी म्हणून AI चे मार्गदर्शन

जोडी प्रोग्रामिंगमध्ये चांगली प्रगती ही एका मोठ्या विनंतीऐवजी संवाद आहे. प्रथम, कंकालची विनंती करा आणि ते चालवा; नंतर धार स्थिती जोडा; नंतर दोष निराकरण करा. हा दृष्टिकोन कोड समजण्याजोगा ठेवतो आणि प्रत्येक टप्प्यावर तुम्हाला नियंत्रणात ठेवतो.

वाढीव प्रगती प्रॉम्प्ट: "आम्ही एक वाचक लिहू जो CSV फाईल वाचतो आणि ओळींना ऑब्जेक्टमध्ये रूपांतरित करतो. चला प्रत्येक चरणाची पुष्टी न करता, मी स्टेप बाय स्टेप वर जाऊ या. पायरी 1: फक्त सांगाडा लिहा जो फाईलला ओळींमध्ये विभाजित करेल आणि हेडर लाइन विभक्त करेल. तरीही हात जोडू नका किंवा शॉर्ट कन्व्हर्स टाइप करू नका.

कोड प्रॉम्प्ट समजावून सांगा आणि त्याचे समर्थन करा: "तुम्ही नुकतेच लिहिलेले कार्य समजावून सांगा, ओळीनुसार नाही तर निर्णयानुसार निर्णय घ्या: तुम्ही कोणता डिझाइन निर्णय घेतला आणि का, तुम्ही कोणती एज केस हाताळली आणि कशी, तुम्ही कोणती प्रकरणे जाणूनबुजून वगळली? कोडमधील 3 गृहितकांची यादी करा जी मी चुकवू नये."

टीप: AI-व्युत्पन्न केलेला कोड समजून घेतल्याशिवाय स्वीकारू नका. "हे मला समजावून सांगा, तुम्ही कोणते गृहितक केले?" प्रश्न दोन्ही लपविलेल्या त्रुटी प्रकट करतो आणि तुम्हाला त्या कोडचे रक्षण करण्यास अनुमती देतो, कारण कोड तुमची जबाबदारी राहते. तुम्हाला न समजलेला कोड उत्पादनामध्ये टाकणे म्हणजे करारावर स्वाक्षरी न करता पाठवण्यासारखे आहे.

कमकुवत प्रॉम्प्ट / मजबूत प्रॉम्प्ट

WEAK:"सॉर्टिंग फंक्शन लिहा."(परिणाम: कोणती भाषा, काय क्रमवारी लावली जात आहे, ती स्थिर आहे, कार्यक्षमतेची मर्यादा काय आहे, कोड जो अस्पष्ट आहे आणि कदाचित आवश्यकतेनुसार नाही.)STRONG:"Java 17 साठी, एक पद्धत लिहा जी यादी<employee> ऑब्जेक्टची विभागानुसार प्रथम क्रमवारी लावते (अक्षरानुसार NPLACE), नंतर REDOC नुसार मूळ). सूची, नल डिपार्टमेंटला शेवटच्या टप्प्यात येऊ द्या.

शक्तिशाली प्रॉम्प्ट; क्रमवारी निकष (दोन-स्तर), साइड इफेक्ट नियम (मूळ बदलणे), शून्य वर्तन आणि चाचणी अपेक्षा समाविष्ट करते. या तपशीलांशिवाय, AI एक प्रशंसनीय परंतु चुकीचे उपाय तयार करते; उदाहरणार्थ ते मूळ सूची दूषित करू शकते आणि यामुळे इतरत्र एक मूक त्रुटी निर्माण होईल.

एज केसेस आणि लहान नमुने सह प्रमाणीकरण

आनंदी परिस्थितीत कार्य करणारा कोड योग्य कोड नाही. तयार केलेल्या प्रत्येक फंक्शनला जाणीवपूर्वक सक्ती करा:

एज केस प्रकार

नमुना इनपुट

अपेक्षित वर्तन

रिक्त इनपुट

रिक्त ॲरे/स्ट्रिंग

त्रुटी नाही, तार्किक रिक्त परिणाम

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

0, -1

परिभाषित आणि योग्य वर्तन

महान मूल्य

लाखो रेकॉर्ड

ओव्हरफ्लो/कार्यप्रदर्शन नियंत्रण

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

गहाळ जागा

नियंत्रित त्रुटी किंवा डीफॉल्ट

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

पुनरावृत्ती, उलट क्रम

योग्य परिणाम

मिनी केसेस

केस 1 - सायलेंट राउंडिंग एरर. एआय एक फंक्शन लिहिते जे दशांश (फ्लोट) प्रकारांसह पैसे गोळा करते; 0.1 + 0.2 0.30000000000000004 देते. जेव्हा अभियंता "2 अंकांपर्यंत गोल करा आणि संपूर्ण पेनी वापरा" असा नियम जोडतो तेव्हा त्रुटी दूर होते. 3-ओळींचा नियम मासिक सामंजस्यामध्ये हजारो पेनीस फरक प्रतिबंधित करतो.

केस 2 - साइड इफेक्ट ट्रॅप. AI एक पद्धत लिहिते जी सूची "क्रमवारी" करते, परंतु मूळ सूचीमध्ये बदल करते. अनपेक्षित वर्तन उद्भवते कारण दुसरे मॉड्यूल समान सूची वापरते. "मूळ बदला" प्रतिबंध प्रॉम्प्टमध्ये असल्यास, त्रुटी कधीही उद्भवणार नाही; कोड पुनरावलोकनामध्ये पकडले जाते आणि 2 तासांचे डीबगिंग प्रतिबंधित करते.

प्रकरण 3 - चरण-दर-चरण कमाई. विकसक एकाच वेळी 150-लाइन आयात मॉड्यूल प्रिंट करतो; जेव्हा त्याला चूक आढळते तेव्हा ती कुठून आली हे त्याला सापडत नाही. दुसरा डेव्हलपर समान कामाची 5 लहान पायऱ्यांमध्ये विभागणी करतो, प्रत्येक चरणाची 2 मिनिटांत चाचणी करतो आणि 3ऱ्या चरणात लगेच त्रुटी पकडतो.

सामान्य चुका

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

सारांशात

AI सह कोड लिहिणे हे शिस्तबद्ध पेअर प्रोग्रामिंग आहे: स्पष्ट करार, लहान पायऱ्या, प्रत्येक टप्प्यावर बिल्ड आणि चाचणी. सुरुवातीपासून इनपुट-आउटपुट-एरर-कंस्ट्रेंट चौकडी दिल्याने कोडची गुणवत्ता निश्चित होते. ते तयार करत असलेल्या कोडचे स्पष्टीकरण आणि कडा केसांसह जबरदस्ती केल्याने आनंदी परिस्थितीत लपवलेल्या त्रुटी पृष्ठभागावर आणल्या जातात. गतीचा स्त्रोत आंधळा स्वीकार नाही; जलद मसुदा अधिक जलद पडताळणी आहे.

अर्ज कार्य

एक लहान परंतु वास्तविक कार्य निवडा (उदा. टोटल टोटल, तारखेतील फरक, मजकूर पार्सिंग). कॉन्ट्रॅक्ट फंक्शन प्रॉम्प्ट वापरून प्रिंट करा; त्याच्या पुढे किमान 5 चाचणी परिस्थिती जोडा. कोड चालवा आणि टेबलचा मार्गदर्शक म्हणून वापर करून 5 एज केसेस जाणीवपूर्वक वापरून पहा. कमीत कमी एका एज केसमध्ये बग शोधा (नसल्यास, फंक्शन सक्ती करण्यासाठी नवीन इनपुट डिझाइन करा), AI सह त्याचे निराकरण करा आणि निराकरण कार्य केले की पुन्हा चाचणी करून सत्यापित करा.

चेकलिस्ट

• [ ] मी एक करार लिहिला ज्यामध्ये इनपुट, आउटपुट, त्रुटी आणि मर्यादा समाविष्ट आहेत.
• [ ] मी कोड एका मोठ्या ब्लॉकऐवजी छोट्या चरणांमध्ये व्युत्पन्न केला.
• [ ] मी कोडच्या पुढे एक चाचणी/नमुना रन ब्लॉक जोडला आहे.
• [ ] मी जाणीवपूर्वक किमान 5 एज केसेसची चाचणी केली आहे.
• [] मी AI ला कोड समजावून सांगितला आणि त्याच्या गृहितकांचे पुनरावलोकन केले.
• [ ] मी आढळलेली त्रुटी दुरुस्त केली आणि पुन्हा चाचणी करून निराकरणाची पुष्टी केली.