AIతో కోడింగ్ మరియు పెయిర్ ప్రోగ్రామింగ్

లాభాలు:

• స్పష్టమైన ఇన్‌పుట్-అవుట్‌పుట్ మరియు నిర్బంధ నిర్వచనాలతో AIకి విధులు, తరగతులు మరియు మాడ్యూల్‌లను వ్రాయగల సామర్థ్యం
• AIని జత ప్రోగ్రామింగ్ భాగస్వామిగా ఉపయోగించగల సామర్థ్యం మరియు చిన్న, ధృవీకరించదగిన భాగాలలో దశలవారీగా పురోగతి
• AI ద్వారా రూపొందించబడిన కోడ్‌ను కంపైల్ చేయడం ద్వారా మరియు చిన్న ఉదాహరణలతో దాన్ని అమలు చేయడం ద్వారా లాజిక్ మరియు ఎడ్జ్ కేస్ ఎర్రర్‌లను క్యాచ్ చేయగల సామర్థ్యం

పెయిర్ ప్రోగ్రామింగ్ అంటే ఇద్దరు డెవలపర్‌లు ఒకే సమస్యపై పని చేయడం, ఒకరు రాయడం మరియు మరొకరు రివైజ్ చేయడం. AIతో కోడింగ్ అనేది ఈ సంబంధం యొక్క డిజిటల్ వెర్షన్: మీరు దిశ, పరిమితులు మరియు అంగీకార ప్రమాణాలను సెట్ చేస్తారు; AI త్వరిత డ్రాఫ్ట్‌ను ఉత్పత్తి చేస్తుంది; మీరు కంపైల్ చేయడం మరియు పరీక్షించడం ద్వారా ప్రతి దశను ధృవీకరించండి. AIకి “ప్రారంభం నుండి ముగింపు వరకు ఈ అప్లికేషన్‌ను వ్రాయండి” అని చెప్పడం మరియు 200-లైన్ బ్లాక్‌ను గుడ్డిగా అంగీకరించడం ఇక్కడ అతిపెద్ద ఉచ్చు. మంచి పెయిర్ ప్రోగ్రామింగ్ చిన్న దశల్లో కొనసాగుతుంది: ప్రతి దశ అర్థమయ్యేలా, పరీక్షించదగినదిగా మరియు తిరగబడేలా ఉండాలి.

ఈ యూనిట్‌లో మీరు స్పష్టమైన ఇన్‌పుట్-అవుట్‌పుట్ ఒప్పందంతో విధులు, తరగతులు మరియు మాడ్యూళ్లను ఎలా ముద్రించాలో నేర్చుకుంటారు; AI దశలవారీగా ఎలా మార్గనిర్దేశం చేయాలి; మరియు చిన్న ఉదాహరణలతో ఉత్పత్తి చేసే కోడ్‌ని అమలు చేయడం ద్వారా లాజిక్ మరియు ఎడ్జ్ కేస్ ఎర్రర్‌లను ఎలా క్యాచ్ చేయాలో చూద్దాం. లక్ష్యం వేగం కాదు, ధృవీకరించబడిన వేగం.

కాన్సెప్ట్‌లు: ఇన్‌పుట్-అవుట్‌పుట్ ఒప్పందం: ఒక ఫంక్షన్ ఏ ఇన్‌పుట్ తీసుకుంటుందో మరియు అది వాగ్దానం చేసే అవుట్‌పుట్ మరియు ఎర్రర్ ప్రవర్తనకు స్పష్టమైన నిర్వచనం. ఎడ్జ్ కేస్: ఇన్‌పుట్ సాధారణం కాదు కానీ వాస్తవానికి సంభవించవచ్చు (ఖాళీ, సున్నా, ప్రతికూలం, చాలా పెద్దది, శూన్యం). పెరుగుతున్న అభివృద్ధి: చిన్న, పని ముక్కలతో కొనసాగడం మరియు ప్రతి దశను ధృవీకరించడం.

నికర ఒప్పందంతో ప్రింటింగ్ కోడ్

పనిని ప్రారంభించడానికి ముందు "మీకు ఏమి కావాలో" సరిగ్గా నిర్వచించడం నాణ్యత కోడ్ యొక్క ఆధారం. AIకి ఫంక్షన్‌ను వ్రాసేటప్పుడు, దానికి ఐదు అంశాలను ఇవ్వండి: భాష మరియు వెర్షన్, ఇన్‌పుట్ రకాలు మరియు అర్థాలు, అవుట్‌పుట్, ఎర్రర్ పరిస్థితులు మరియు పరిమితులు (పనితీరు, బాహ్య లైబ్రరీ నిషేధం, శైలి). ఇది AI ఊహించకుండా నిరోధిస్తుంది.

1. ఒప్పందాన్ని వ్రాయండి. ఇన్‌పుట్, అవుట్‌పుట్, ఎర్రర్, నిర్బంధం.
2. చిన్న యూనిట్ కోసం అడగండి. ఒకే బాధ్యతతో కూడిన ఫంక్షన్; ఇది భారీ మాడ్యూల్ కాదు.
3. టెస్ట్ బ్లాక్‌ని అభ్యర్థించండి. కోడ్ పక్కన కొన్ని నమూనా పరుగులు/పరీక్షలను జోడించండి.
4. కంపైల్ చేసి రన్ చేయండి. అంచు కేసులతో దీన్ని ప్రయత్నించండి, కంటి ద్వారా అవుట్‌పుట్‌ను ధృవీకరించండి.
5. తదుపరి దశకు వెళ్లండి. ఒక భాగాన్ని నిర్ధారించిన తర్వాత, దానిపై నిర్మించండి.

కాంట్రాక్ట్ చేసిన ఫంక్షన్ ప్రాంప్ట్: "టైప్‌స్క్రిప్ట్ 5 కోసం ఒక ఫంక్షన్‌ను వ్రాయండి. ఉద్దేశ్యం: షాపింగ్ కార్ట్‌లోని మొత్తం వస్తువులను లెక్కించండి. ఇన్‌పుట్: {ధర: సంఖ్య, పరిమాణం: సంఖ్య [] శ్రేణి. అవుట్‌పుట్: సంఖ్య (మొత్తం). నియమాలు: పరిమాణం లేదా ధర ప్రతికూలంగా ఉంటే లోపం ఏర్పడుతుంది; డెసిమాల్ ఎరర్‌కి 0ని తిరిగి ఇవ్వండి లైబ్రరీ ఫంక్షన్ క్రింద 5 పరీక్ష కేసులను జోడించండి (సాధారణ, ఖాళీ, ప్రతికూల పరిమాణం, దశాంశ ధర, ఒకే అంశం)."

AIని జతగా మార్గనిర్దేశం చేస్తుంది

పెయిర్ ప్రోగ్రామింగ్‌లో మంచి పురోగతి అనేది ఒక పెద్ద అభ్యర్థన కంటే డైలాగ్. మొదట, అస్థిపంజరాన్ని అభ్యర్థించండి మరియు దానిని అమలు చేయండి; ఆపై అంచు స్థితిని జోడించండి; అప్పుడు ఒక బగ్ పరిష్కరించబడింది. ఈ విధానం కోడ్‌ను అర్థమయ్యేలా ఉంచుతుంది మరియు అడుగడుగునా మిమ్మల్ని నియంత్రణలో ఉంచుతుంది.

పెరుగుతున్న ప్రోగ్రెస్ ప్రాంప్ట్: "మేము CSV ఫైల్‌ని చదివి, పంక్తులను ఆబ్జెక్ట్‌గా మార్చే రీడర్‌ను వ్రాస్తాము. ప్రతి దశను నేను నిర్ధారించకుండానే తదుపరి దశకు వెళ్దాం. దశ 1: ఫైల్‌ను పంక్తులుగా విభజించి, హెడర్ లైన్‌ని వేరు చేసే అస్థిపంజరాన్ని వ్రాయండి. చిన్న టైప్ మార్పిడిని ఇంకా జోడించవద్దు."

కోడ్ ప్రాంప్ట్‌ను వివరించండి మరియు సమర్థించండి: "మీరు ఇప్పుడే వ్రాసిన ఫంక్షన్‌ను లైన్ వారీగా కాకుండా, నిర్ణయం ద్వారా వివరించండి: మీరు ఏ డిజైన్ నిర్ణయం తీసుకున్నారు మరియు ఎందుకు, ఏ అంచు కేసును నిర్వహించారు మరియు ఎలా, మీరు ఉద్దేశపూర్వకంగా మినహాయించారు? నేను మిస్ చేయకూడని 3 అంచనాలను కోడ్‌లో జాబితా చేయండి."

చిట్కా: AI రూపొందించిన కోడ్‌ను అర్థం చేసుకోకుండా అంగీకరించవద్దు. "ఇది నాకు వివరించండి, మీరు ఏ అంచనాలు చేసారు?" ప్రశ్న రెండూ దాచిన లోపాలను వెల్లడిస్తాయి మరియు ఆ కోడ్‌ని రక్షించడానికి మిమ్మల్ని అనుమతిస్తుంది, ఎందుకంటే కోడ్ మీ బాధ్యతగా ఉంటుంది. ఉత్పత్తిలో మీకు అర్థం కాని కోడ్‌ను ఉంచడం అనేది సంతకం చేయకుండానే ఒప్పందాన్ని పంపడం లాంటిది.

బలహీనమైన ప్రాంప్ట్ / బలమైన ప్రాంప్ట్

బలహీనం:"సార్టింగ్ ఫంక్షన్‌ను వ్రాయండి."(ఫలితం: ఏ భాష, ఏది క్రమబద్ధీకరించబడుతోంది, ఇది స్థిరంగా ఉందా, పనితీరు పరిమితి ఏమిటి, అస్పష్టంగా ఉండే కోడ్ మరియు బహుశా అవసరాలకు సరిపోకపోవచ్చు.)STRONG:"జావా 17 కోసం, జాబితా<ఉద్యోగి> వస్తువును మొదట డిపార్ట్‌మెంట్ వారీగా క్రమబద్ధీకరించే పద్ధతిని వ్రాయండి (అసలు జీతం (అసలైనది) తర్వాత జీతం (అల్ఫాబెటికల్). జాబితా, 4 నమూనాలతో ఒక ప్రధాన పరీక్ష బ్లాక్‌ను జోడించు అని పేర్కొనండి.

శక్తివంతమైన ప్రాంప్ట్; క్రమబద్ధీకరణ ప్రమాణం (రెండు-స్థాయి), సైడ్ ఎఫెక్ట్ నియమం (అసలు స్థానంలో), శూన్య ప్రవర్తన మరియు పరీక్ష అంచనాలను కలిగి ఉంటుంది. ఈ వివరాలు లేకుండా, AI ఆమోదయోగ్యమైన కానీ తప్పు పరిష్కారాన్ని ఉత్పత్తి చేస్తుంది; ఉదాహరణకు ఇది అసలు జాబితాను పాడుచేయవచ్చు మరియు ఇది మరెక్కడా నిశ్శబ్ద లోపానికి దారి తీస్తుంది.

ఎడ్జ్ కేసులు మరియు చిన్న నమూనాలతో ధ్రువీకరణ

సంతోషకరమైన దృష్టాంతంలో పనిచేసే కోడ్ సరైన కోడ్ కాదు. ఉత్పత్తి చేయబడిన ప్రతి విధిని స్పృహతో బలవంతం చేయండి:

ఎడ్జ్ కేస్ రకం

నమూనా ఇన్పుట్

ఊహించిన ప్రవర్తన

ఖాళీ ఇన్‌పుట్

ఖాళీ శ్రేణి/స్ట్రింగ్

లోపం కాదు, తార్కిక ఖాళీ ఫలితం

సున్నా/ప్రతికూల

0, -1

నిర్వచించిన మరియు సరైన ప్రవర్తన

గొప్ప విలువ

లక్షల రికార్డులు

ఓవర్‌ఫ్లో/పనితీరు నియంత్రణ

శూన్యం/నిర్వచించబడలేదు

స్థలం లేదు

నియంత్రిత లోపం లేదా డిఫాల్ట్

నకిలీ/అసాధారణమైనది

పునరావృత, రివర్స్ ఆర్డర్

సరైన ఫలితం

మినీ కేసులు

కేస్ 1 — సైలెంట్ రౌండింగ్ లోపం. AI దశాంశ (ఫ్లోట్) రకాలతో డబ్బును సేకరించే ఒక ఫంక్షన్‌ను వ్రాస్తుంది; 0.1 + 0.2 0.3000000000000004 ఇస్తుంది. ఇంజనీర్ "2 అంకెలకు రౌండ్ చేయండి మరియు మొత్తం పెన్నీలను ఉపయోగించండి" అనే నియమాన్ని జోడించినప్పుడు లోపం పరిష్కరించబడుతుంది. 3-లైన్ నియమం నెలవారీ సయోధ్యలో వేల పెన్నీల వ్యత్యాసాన్ని నిరోధిస్తుంది.

కేస్ 2 - సైడ్ ఎఫెక్ట్ ట్రాప్. AI జాబితాను "క్రమబద్ధీకరించే" పద్ధతిని వ్రాస్తుంది, కానీ అసలు జాబితాను ఆ స్థానంలో మారుస్తుంది. మరొక మాడ్యూల్ అదే జాబితాను ఉపయోగిస్తున్నందున ఊహించని ప్రవర్తన ఏర్పడుతుంది. "ఒరిజినల్‌ని మార్చు" పరిమితి ప్రాంప్ట్‌లో ఉంటే, లోపం ఎప్పటికీ జరగదు; కోడ్ సమీక్షలో చిక్కుకుని 2 గంటల డీబగ్గింగ్‌ను నిరోధిస్తుంది.

కేస్ 3 - ఆదాయాలు దశలవారీగా. డెవలపర్ ఒకేసారి 150-లైన్ దిగుమతి మాడ్యూల్‌ను ప్రింట్ చేస్తాడు; అతను తప్పును కనుగొన్నప్పుడు, అది ఎక్కడ నుండి వచ్చిందో అతను కనుగొనలేడు. మరొక డెవలపర్ అదే పనిని 5 చిన్న దశలుగా విభజించి, ప్రతి దశను 2 నిమిషాల్లో పరీక్షించి, 3వ దశలో వెంటనే లోపాన్ని పట్టుకుంటాడు.

సాధారణ తప్పులు

• ఒక అభ్యర్థనలో పెద్ద బ్లాక్‌లను ముద్రించడం. అర్థం చేసుకోవడం మరియు డీబగ్ చేయడం కష్టంగా ఉండే రిస్కీ కోడ్ పుట్టింది.
• కాంట్రాక్ట్ ఇవ్వకుండా కోడ్ అడుగుతున్నారు. ఇన్‌పుట్-అవుట్‌పుట్-ఎర్రర్ అస్పష్టంగా ఉంటే, AI ఊహించి తప్పు చేస్తుంది.
• సంతోషకరమైన దృశ్యాన్ని పరీక్షిస్తున్నాను. ఖాళీ, శూన్య, ప్రతికూల మరియు పెద్ద ఇన్‌పుట్ ప్రయత్నించకపోతే, లోపం ఉత్పత్తికి వదిలివేయబడుతుంది.
• అవగాహన లేకుండా అంగీకరించడం. మీరు బహిర్గతం చేయని కోడ్ మీరు రక్షించలేని రుణం.
• దుష్ప్రభావాలు మరియు డబ్బు/తేదీ వంటి సున్నితమైన రకాలను విస్మరించడం. టైమ్‌లెస్ హిస్టరీతో ఫ్లోట్ మనీ అనేది ఎర్రర్ యొక్క క్లాసిక్ సోర్స్.

సారాంశంలో

AIతో కోడ్ రాయడం అనేది క్రమశిక్షణతో కూడిన పెయిర్ ప్రోగ్రామింగ్: క్లియర్ కాంట్రాక్ట్, చిన్న దశలు, ప్రతి దశలో బిల్డ్ మరియు టెస్ట్. మొదటి నుండి ఇన్‌పుట్-అవుట్‌పుట్-ఎర్రర్-కంస్ట్రెంట్ క్వార్టెట్ ఇవ్వడం కోడ్ నాణ్యతను నిర్ణయిస్తుంది. ఇది ఉత్పత్తి చేసే కోడ్‌ను వివరించడం మరియు అంచు కేసులతో బలవంతంగా చేయడం వలన సంతోషకరమైన దృష్టాంతంలో దాగి ఉన్న లోపాలను ఉపరితలంపైకి తెస్తుంది. వేగం యొక్క మూలం గుడ్డి అంగీకారం కాదు; త్వరిత డ్రాఫ్ట్ మరియు త్వరిత ధృవీకరణ.

అప్లికేషన్ టాస్క్

చిన్నది కానీ నిజమైన ఫంక్షన్‌ను ఎంచుకోండి (ఉదా. బాస్కెట్ మొత్తం, తేదీ వ్యత్యాసం, వచన అన్వయం). కాంట్రాక్ట్ చేసిన ఫంక్షన్ ప్రాంప్ట్ ఉపయోగించి ప్రింట్ చేయండి; దాని పక్కన కనీసం 5 పరీక్ష దృశ్యాలను జోడించండి. పట్టికను గైడ్‌గా ఉపయోగించి, కోడ్‌ని అమలు చేసి, 5 అంచు కేసులను స్పృహతో ప్రయత్నించండి. కనీసం ఒక ఎడ్జ్ కేస్‌లో బగ్‌ను కనుగొనండి (లేకపోతే, ఫంక్షన్‌ను ఫోర్స్ చేయడానికి కొత్త ఇన్‌పుట్‌ని డిజైన్ చేయండి), AIతో దాన్ని పరిష్కరించండి మరియు ఫిక్స్ పని చేసిందని మళ్లీ పరీక్షించడం ద్వారా ధృవీకరించండి.

చెక్లిస్ట్

• [ ] నేను ఇన్‌పుట్, అవుట్‌పుట్, లోపాలు మరియు పరిమితులను కలిగి ఉన్న ఒప్పందాన్ని వ్రాసాను.
• [ ] నేను ఒక పెద్ద బ్లాక్‌కు బదులుగా చిన్న దశల్లో కోడ్‌ని రూపొందించాను.
• [ ] నేను కోడ్ పక్కన పరీక్ష/నమూనా రన్ బ్లాక్‌ని జోడించాను.
• [ ] నేను స్పృహతో కనీసం 5 అంచు కేసులను పరీక్షించాను.
• [ ] నేను AIకి కోడ్‌ని వివరించాను మరియు దాని అంచనాలను సమీక్షించాను.
• [ ] నేను కనుగొనబడిన లోపాన్ని సరిదిద్దాను మరియు మళ్లీ పరీక్షించడం ద్వారా పరిష్కారాన్ని నిర్ధారించాను.