AI સાથે કોડિંગ અને પેર પ્રોગ્રામિંગ

નફો:

• સ્પષ્ટ ઇનપુટ-આઉટપુટ અને અવરોધ વ્યાખ્યાઓ સાથે AI માં કાર્યો, વર્ગો અને મોડ્યુલો લખવાની ક્ષમતા
• એક જોડી પ્રોગ્રામિંગ પાર્ટનર તરીકે AI નો ઉપયોગ કરવાની ક્ષમતા અને નાના, ચકાસી શકાય તેવા ભાગોમાં, પગલું દ્વારા પ્રગતિ
• AI દ્વારા જનરેટ કરાયેલ કોડને કમ્પાઇલ કરીને અને તેને નાના ઉદાહરણો સાથે ચલાવીને લોજિક અને એજ કેસની ભૂલોને પકડવાની ક્ષમતા

પેર પ્રોગ્રામિંગ એ છે જ્યારે બે વિકાસકર્તાઓ એક જ સમસ્યા પર કામ કરે છે, જેમાં એક લેખન અને બીજામાં સુધારો થાય છે. AI સાથે કોડિંગ એ આ જ સંબંધનું ડિજિટલ સંસ્કરણ છે: તમે દિશા, અવરોધો અને સ્વીકૃતિ માપદંડ સેટ કરો છો; AI ઝડપી ડ્રાફ્ટ બનાવે છે; તમે દરેક પગલાને કમ્પાઇલ કરીને અને તેનું પરીક્ષણ કરીને ચકાસો છો. અહીં સૌથી મોટી છટકું એઆઈને કહેવાનું છે કે "મને આ એપ્લિકેશન શરૂઆતથી અંત સુધી લખો" અને 200-લાઈન બ્લોકને આંધળાપણે સ્વીકારો. સારી જોડી પ્રોગ્રામિંગ નાના પગલાઓમાં આગળ વધે છે: દરેક પગલું સમજી શકાય તેવું, પરીક્ષણ કરી શકાય તેવું અને ઉલટાવી શકાય તેવું હોવું જોઈએ.

આ એકમમાં તમે સ્પષ્ટ ઇનપુટ-આઉટપુટ કોન્ટ્રાક્ટ સાથે ફંક્શન્સ, ક્લાસ અને મોડ્યુલોને કેવી રીતે પ્રિન્ટ કરવા તે શીખી શકશો; પગલું દ્વારા AI ને કેવી રીતે માર્ગદર્શન આપવું; અને અમે જોઈશું કે તે નાના ઉદાહરણો સાથે બનાવેલ કોડને ચલાવીને તર્ક અને એજ કેસની ભૂલોને કેવી રીતે પકડવી. ધ્યેય ગતિ નથી, પરંતુ ચકાસાયેલ ઝડપ છે.

વિભાવનાઓ: ઇનપુટ-આઉટપુટ કોન્ટ્રાક્ટ: ફંક્શન શું ઇનપુટ લે છે અને તે કયા આઉટપુટ અને ભૂલ વર્તનનું વચન આપે છે તેની સ્પષ્ટ વ્યાખ્યા. એજ કેસ: ઇનપુટ જે સામાન્ય નથી પરંતુ વાસ્તવમાં આવી શકે છે (ખાલી, શૂન્ય, નકારાત્મક, ખૂબ મોટી, શૂન્ય). વૃદ્ધિશીલ વિકાસ: નાના, કાર્યકારી ટુકડાઓ સાથે આગળ વધવું અને દરેક પગલાને માન્ય કરવું.

નેટ કોન્ટ્રાક્ટ સાથે પ્રિન્ટીંગ કોડ

ગુણવત્તા કોડનો આધાર કામ શરૂ કરતા પહેલા "તમે શું ઇચ્છો છો" તે બરાબર વ્યાખ્યાયિત કરવાનો છે. AI માં ફંક્શન લખતી વખતે, તેને પાંચ વસ્તુઓ આપો: ભાષા અને સંસ્કરણ, ઇનપુટ પ્રકારો અને અર્થો, આઉટપુટ, ભૂલની સ્થિતિ અને અવરોધો (પ્રદર્શન, બાહ્ય પુસ્તકાલય પ્રતિબંધ, શૈલી). આ AI ને અનુમાન લગાવતા અટકાવે છે.

1. કરાર લખો. ઇનપુટ, આઉટપુટ, ભૂલ, અવરોધ.
2. નાના એકમ માટે પૂછો. એક જ જવાબદારી સાથેનું કાર્ય; તે એક વિશાળ મોડ્યુલ નથી.
3. ટેસ્ટ બ્લોકની વિનંતી કરો. કોડની બાજુમાં થોડા નમૂના રન/પરીક્ષણો ઉમેરો.
4. કમ્પાઇલ કરો અને ચલાવો. ધાર કેસો સાથે તેનો પ્રયાસ કરો, આંખ દ્વારા આઉટપુટ ચકાસો.
5. આગલા પગલા પર જાઓ. એકવાર એક ભાગની પુષ્ટિ થઈ જાય, તેના પર બિલ્ડ કરો.

કોન્ટ્રાક્ટેડ ફંક્શન પ્રોમ્પ્ટ: "TypeScript 5 માટે ફંક્શન લખો. હેતુ: શોપિંગ કાર્ટમાં આઇટમ્સની કુલ રકમની ગણતરી કરો. ઇનપુટ: { કિંમત: સંખ્યા, જથ્થો: સંખ્યા [] એરે. આઉટપુટ: સંખ્યા (કુલ). નિયમો: જો જથ્થો અથવા કિંમત નકારાત્મક હોય તો થ્રો એરર; ખાલી જગ્યાઓ માટે 0 ની રકમ પરત કરો; ખાલી જગ્યાઓ માટે 0 ની સંખ્યા. બાહ્ય લાઇબ્રેરીનો ઉપયોગ કરશો નહીં ફંક્શનની નીચે 5 ટેસ્ટ કેસ (સામાન્ય, ખાલી, નકારાત્મક જથ્થો, દશાંશ કિંમત, સિંગલ આઇટમ).

એક જોડી તરીકે AI ને માર્ગદર્શન આપવું

જોડી પ્રોગ્રામિંગમાં સારી પ્રગતિ એ એક મોટી વિનંતીને બદલે સંવાદ છે. પ્રથમ, હાડપિંજરને વિનંતી કરો અને તેને ચલાવો; પછી ધારની સ્થિતિ ઉમેરો; પછી બગ ફિક્સ કરો. આ અભિગમ કોડને સમજી શકાય તેવું રાખે છે અને દરેક પગલા પર તમને નિયંત્રણમાં રાખે છે.

ઇન્ક્રીમેન્ટલ પ્રોગ્રેસ પ્રોમ્પ્ટ: "અમે એક રીડર લખીશું જે CSV ફાઇલ વાંચે છે અને લાઇનોને ઑબ્જેક્ટમાં રૂપાંતરિત કરે છે. ચાલો દરેક પગલાની પુષ્ટિ કર્યા વિના આગળના પગલા પર આગળ વધીએ, ચાલો STEP BY STEP પર જઈએ. પગલું 1: ફક્ત હાડપિંજર લખો જે ફાઇલને લીટીઓમાં વિભાજિત કરે છે અને હેડર લાઇનને અલગ કરે છે. તે હજી પણ ટૂંકા રૂપાંતરણને ઉમેરશો નહીં અથવા ટેરર ​​લખો નહીં."

કોડ પ્રોમ્પ્ટને સમજાવો અને તેને વાજબી ઠેરવો: "તમે જે ફંક્શન લખ્યું છે તે સમજાવો, લીટી દ્વારા નહીં, પરંતુ નિર્ણય દ્વારા નિર્ણય: તમે કયો ડિઝાઇન નિર્ણય લીધો અને શા માટે, તમે કયા ધારના કેસને હેન્ડલ કર્યા અને કેવી રીતે, તમે ઇરાદાપૂર્વક કયા કેસોને બાકાત રાખ્યા? કોડમાં 3 ધારણાઓની સૂચિ બનાવો કે જે મારે ચૂકી ન જવું જોઈએ."

ટીપ: AI-જનરેટેડ કોડને સમજ્યા વિના તેને સ્વીકારશો નહીં. "મને આ સમજાવો, તમે કઈ ધારણાઓ કરી?" પ્રશ્ન બંને છુપી ભૂલો દર્શાવે છે અને તમને તે કોડનો બચાવ કરવાની મંજૂરી આપે છે, કારણ કે કોડ તમારી જવાબદારી રહે છે. ઉત્પાદનમાં તમે સમજી શકતા નથી તે કોડ મૂકવો એ કરાર પર હસ્તાક્ષર કર્યા વિના મોકલવા જેવું છે.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

WEAK:"સૉર્ટિંગ ફંક્શન લખો."(પરિણામ: કઈ ભાષા, શું સૉર્ટ કરવામાં આવી રહ્યું છે, તે સ્થિર છે, કાર્યક્ષમતાની મર્યાદા શું છે, કોડ જે અસ્પષ્ટ છે અને સંભવતઃ જરૂરિયાતને અનુરૂપ નથી.)STRONG:"જાવા 17 માટે, એક પદ્ધતિ લખો કે જે સૂચિ<Employee> ઑબ્જેક્ટને વિભાગ દ્વારા પ્રથમ સૉર્ટ કરે છે (મૂળાક્ષરો મુજબ, NPLACE પછી મૂળાક્ષરો દ્વારા). યાદીમાં, નલ વિભાગને છેલ્લે આવવા દો.

શક્તિશાળી પ્રોમ્પ્ટ; સૉર્ટિંગ માપદંડ (બે-સ્તર), આડ અસર નિયમ (મૂળને બદલવું), શૂન્ય વર્તન અને પરીક્ષણ અપેક્ષાનો સમાવેશ થાય છે. આ વિગતો વિના, AI એક બુદ્ધિગમ્ય પરંતુ ખોટો ઉકેલ ઉત્પન્ન કરે છે; ઉદાહરણ તરીકે તે મૂળ સૂચિને બગડી શકે છે અને આ અન્યત્ર સાયલન્ટ ભૂલ તરફ દોરી જશે.

એજ કેસો અને નાના નમૂનાઓ સાથે માન્યતા

જે કોડ સુખી સ્થિતિમાં કામ કરે છે તે સાચો કોડ નથી. ઉત્પાદિત દરેક કાર્યને સભાનપણે દબાણ કરો:

એજ કેસ પ્રકાર

નમૂના ઇનપુટ

અપેક્ષિત વર્તન

ખાલી ઇનપુટ

ખાલી એરે/સ્ટ્રિંગ

ભૂલ નથી, તાર્કિક ખાલી પરિણામ

શૂન્ય/નકારાત્મક

0, -1

વ્યાખ્યાયિત અને યોગ્ય વર્તન

મહાન મૂલ્ય

લાખો રેકોર્ડ

ઓવરફ્લો/પ્રદર્શન નિયંત્રણ

નલ/અવ્યાખ્યાયિત

જગ્યા ખૂટે છે

નિયંત્રિત ભૂલ અથવા ડિફોલ્ટ

ડુપ્લિકેટ/અસામાન્ય

પુનરાવર્તિત, વિપરીત ક્રમ

સાચું પરિણામ

મીની કેસો

કેસ 1 - સાયલન્ટ રાઉન્ડિંગ ભૂલ. AI એક કાર્ય લખે છે જે દશાંશ (ફ્લોટ) પ્રકારો સાથે નાણાં એકત્રિત કરે છે; 0.1 + 0.2 0.30000000000000004 આપે છે. જ્યારે એન્જિનિયર "2 અંકોમાં રાઉન્ડ કરો અને સંપૂર્ણ પેનિસનો ઉપયોગ કરો" નિયમ ઉમેરે ત્યારે ભૂલ ઉકેલાઈ જાય છે. 3-લાઇનનો નિયમ માસિક સમાધાનમાં હજારો પૈસાના તફાવતને અટકાવે છે.

કેસ 2 - સાઇડ ઇફેક્ટ ટ્રેપ. AI એક પદ્ધતિ લખે છે જે સૂચિને "સૉર્ટ" કરે છે, પરંતુ મૂળ સૂચિને સ્થાને સંશોધિત કરે છે. અનપેક્ષિત વર્તન થાય છે કારણ કે અન્ય મોડ્યુલ સમાન સૂચિનો ઉપયોગ કરે છે. જો "મૂળ બદલો" અવરોધ પ્રોમ્પ્ટમાં હોત, તો ભૂલ ક્યારેય થશે નહીં; કોડ સમીક્ષામાં પકડાય છે અને 2 કલાકના ડિબગીંગને અટકાવે છે.

કેસ 3 - કમાણી સ્ટેપ બાય સ્ટેપ. વિકાસકર્તા એક જ સમયે 150-લાઇન આયાત મોડ્યુલ છાપે છે; જ્યારે તે ભૂલ શોધે છે, ત્યારે તે ક્યાંથી આવી તે શોધી શકતો નથી. અન્ય વિકાસકર્તા સમાન કાર્યને 5 નાના પગલાઓમાં વિભાજિત કરે છે, 2 મિનિટમાં દરેક પગલાનું પરીક્ષણ કરે છે અને 3જા પગલામાં તરત જ ભૂલ પકડે છે.

સામાન્ય ભૂલો

• એક વિનંતીમાં મોટા બ્લોક્સ છાપવા. જોખમી કોડ કે જે સમજવું મુશ્કેલ છે અને ડીબગ થયો છે.
• કોન્ટ્રાક્ટ આપ્યા વગર જ કોડ માંગવો. જો ઇનપુટ-આઉટપુટ-ભૂલ અસ્પષ્ટ છે, તો AI અનુમાન કરશે અને ખોટું હશે.
• માત્ર ખુશ દૃશ્ય પરીક્ષણ. જો ખાલી, શૂન્ય, નકારાત્મક અને મોટા ઇનપુટનો પ્રયાસ કરવામાં આવ્યો નથી, તો ભૂલ ઉત્પાદન પર છોડી દેવામાં આવે છે.
• સમજ્યા વિના સ્વીકારવું. તમે જે કોડ જાહેર કરતા નથી તે દેવું છે જેનો તમે બચાવ કરી શકતા નથી.
• આડઅસરો અને પૈસા/તારીખ જેવા સંવેદનશીલ પ્રકારોને અવગણવા. કાલાતીત ઇતિહાસ સાથે ફ્લોટ મની એ ભૂલનો ઉત્તમ સ્ત્રોત છે.

સારાંશમાં

AI સાથે કોડ લખવું એ શિસ્તબદ્ધ જોડી પ્રોગ્રામિંગ છે: સ્પષ્ટ કરાર, નાના પગલાં, બિલ્ડ અને દરેક પગલા પર પરીક્ષણ. શરૂઆતથી ઇનપુટ-આઉટપુટ-એરર-કંસ્ટ્રેંટ ચોકડી આપવાથી કોડની ગુણવત્તા નક્કી થાય છે. તે જે કોડ બનાવે છે તેને સમજાવવાથી અને કિનારી કેસો સાથે તેને દબાણ કરવાથી સુખી દૃશ્ય હેઠળ છુપાયેલી ભૂલો સપાટી પર આવે છે. ઝડપનો સ્ત્રોત આંધળો સ્વીકાર નથી; ઝડપી ડ્રાફ્ટ વત્તા ઝડપી ચકાસણી છે.

એપ્લિકેશન કાર્ય

એક નાનું પરંતુ વાસ્તવિક કાર્ય પસંદ કરો (દા.ત. ટોટલ ટોટલ, તારીખ તફાવત, ટેક્સ્ટ પાર્સિંગ). કોન્ટ્રાક્ટેડ ફંક્શન પ્રોમ્પ્ટનો ઉપયોગ કરીને પ્રિન્ટ કરો; તેની બાજુમાં ઓછામાં ઓછા 5 પરીક્ષણ દૃશ્યો ઉમેરો. કોડ ચલાવો અને કોષ્ટકનો માર્ગદર્શિકા તરીકે ઉપયોગ કરીને સભાનપણે 5 એજ કેસ અજમાવો. ઓછામાં ઓછા એક કિનારી કેસમાં બગ શોધો (જો નહિં, તો ફંક્શનને દબાણ કરવા માટે એક નવું ઇનપુટ ડિઝાઇન કરો), તેને AI વડે ઠીક કરો અને ફરીથી પરીક્ષણ કરીને ચકાસો કે ફિક્સ કામ કર્યું છે.

ચેકલિસ્ટ

• [ ] મેં એક કરાર લખ્યો છે જેમાં ઇનપુટ, આઉટપુટ, ભૂલો અને અવરોધો શામેલ છે.
• [ ] મેં એક મોટા બ્લોકને બદલે નાના પગલામાં કોડ જનરેટ કર્યો.
• [ ] મેં કોડની બાજુમાં ટેસ્ટ/સેમ્પલ રન બ્લોક ઉમેર્યો છે.
• [ ] મેં સભાનપણે ઓછામાં ઓછા 5 એજ કેસનું પરીક્ષણ કર્યું છે.
• [ ] મેં AI ને કોડ સમજાવ્યો અને તેની ધારણાઓની સમીક્ષા કરી.
• [ ] મેં મળેલી ભૂલ સુધારી અને ફરીથી પરીક્ષણ કરીને સુધારાની પુષ્ટિ કરી.