കമ്പ്യൂട്ടർ എഞ്ചിനീയറിംഗിലെ ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് ആൻഡ് വെരിഫിക്കേഷൻ ഡിസിപ്ലിനിലേക്കുള്ള ആമുഖം

നേട്ടങ്ങൾ:

• സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റ് ലൈഫ് സൈക്കിളിൽ AI യഥാർത്ഥ വേഗത നൽകുന്നത് എവിടെയാണെന്നും തീരുമാനവും ഉത്തരവാദിത്തവും എഞ്ചിനീയർക്ക് എവിടെയാണെന്നും വേർതിരിച്ചറിയാനുള്ള കഴിവ്
• കംപൈലേഷൻ, ടെസ്റ്റിംഗ്, റിവ്യൂ എന്നിവയിലൂടെ നിർമ്മിച്ച എല്ലാ കോഡും ഡിസൈനും പരിശോധിക്കുന്ന മൂന്ന്-ലേയേർഡ് എഞ്ചിനീയറിംഗ് അച്ചടക്കം പ്രയോഗിക്കാനുള്ള കഴിവ്.
• രഹസ്യാത്മക സോഴ്‌സ് കോഡ്, ക്രെഡൻഷ്യലുകൾ, ഉപഭോക്തൃ ഡാറ്റ എന്നിവ പങ്കിടാതെ തന്നെ AI പ്രയോജനപ്പെടുത്തുന്നതിന് സന്ദർഭം മായ്‌ക്കുന്ന ശീലം നേടുക.

നിങ്ങൾ ഒരു കമ്പ്യൂട്ടർ എഞ്ചിനീയർ ദിനത്തിൽ നോക്കുമ്പോൾ, മിക്ക ടീമുകളിലും ചിത്രം സമാനമാണ്: ഒരു ബിസിനസ്സ് അഭ്യർത്ഥന മനസ്സിലാക്കൽ, ഡിസൈൻ, കോഡ് എഴുതൽ, മറ്റൊരാളുടെ കോഡ് വായിക്കൽ, ഡീബഗ്ഗിംഗ് (ഒരു പ്രോഗ്രാം തെറ്റായി പ്രവർത്തിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് കണ്ടെത്തി അത് പരിഹരിക്കുന്ന പ്രക്രിയ), ടെസ്റ്റുകൾ എഴുതുക, ഡോക്യുമെൻ്റേഷൻ തയ്യാറാക്കുക, കോഡ് അവലോകനം ചെയ്യുക, മീറ്റിംഗുകളിൽ പങ്കെടുക്കുക. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, യഥാർത്ഥ "എഞ്ചിനീയറിംഗ് വിധിന്യായ"ത്തിനായി നീക്കിവച്ചിരിക്കുന്ന സമയം, അതായത്, ഒരു പരിഹാരം ശരിയാണോ, സുരക്ഷിതമാണോ, സുസ്ഥിരമാണോ എന്നത് ആവർത്തിച്ചുള്ള ജോലിയിൽ തകർന്നിരിക്കുന്നു. ഇവിടെയാണ് ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് (ചുരുക്കത്തിൽ AI; ഒരു വലിയ ഭാഷാ മാതൃകയിൽ ടെക്സ്റ്റിലും കോഡിലും പ്രവർത്തിക്കുന്ന സോഫ്റ്റ്‌വെയർ) പ്രവർത്തിക്കുന്നത്. AI നിങ്ങൾക്കായി തീരുമാനം എടുക്കുന്നില്ല; ഇത് തീരുമാനത്തിന് നിങ്ങളെ തയ്യാറാക്കുന്നു, ഒരു കോഡ് അസ്ഥികൂടം നിർമ്മിക്കുന്നു, ബഗ് കുറയ്ക്കുന്നു, കൂടാതെ ഒരു ഡ്രാഫ്റ്റ് നിങ്ങളുടെ മുന്നിൽ വയ്ക്കുന്നു. ഈ മൊഡ്യൂളിലുടനീളം ഞങ്ങൾ AI-യെ ഒരു "ഓട്ടോമാറ്റിക് പ്രോഗ്രാമർ" ആയിട്ടല്ല, മറിച്ച് ഓരോ തവണയും ഔട്ട്‌പുട്ട് കംപൈൽ ചെയ്യുകയും പരീക്ഷിക്കുകയും അവലോകനം ചെയ്യുകയും ചെയ്യുന്ന ഒരു അച്ചടക്കമുള്ള ജോഡി പ്രോഗ്രാമിംഗ് പങ്കാളിയായാണ് സ്ഥാപിക്കുക.

ഈ ആദ്യ യൂണിറ്റിൽ, ഞങ്ങൾ മൂന്ന് കാര്യങ്ങൾ വ്യക്തമാക്കുന്നു: സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റ് ലൈഫ് സൈക്കിളിൻ്റെ ഏത് ഘട്ടങ്ങളിലാണ് (ഒരു സോഫ്റ്റ്‌വെയർ ആശയത്തിൽ നിന്ന് ഉൽപ്പാദനത്തിലേക്ക് കടന്നുപോകുന്ന ഘട്ടങ്ങൾ: വിശകലനം, ഡിസൈൻ, കോഡിംഗ്, ടെസ്റ്റിംഗ്, വിന്യാസം, പരിപാലനം) AI യഥാർത്ഥ മൂല്യം ചേർക്കുന്നു; ഏതൊക്കെ തീരുമാനങ്ങൾ എഞ്ചിനീയറുടെ പക്കൽ കർശനമായി തുടരണം; ഇത് ചെയ്യുമ്പോൾ നിങ്ങൾ പാലിക്കേണ്ട സ്ഥിരീകരണവും രഹസ്യസ്വഭാവമുള്ള അച്ചടക്കവും എന്താണ്. ഈ മേൽക്കൂര ശരിയായി ഇൻസ്റ്റാൾ ചെയ്തില്ലെങ്കിൽ, തുടർന്നുള്ള യൂണിറ്റുകളിലെ സാങ്കേതിക വിദ്യകൾ അപകടകരമാകും; കാരണം സോഫ്‌റ്റ്‌വെയറിലെ ഒരു പിശക് ഒരേ സമയം ദശലക്ഷക്കണക്കിന് ഉപയോക്താക്കളിലേക്ക് എത്തുകയും അത് ഒരു സുരക്ഷാ തകരാറായി മാറുകയും ചെയ്യും.

ആശയങ്ങൾ: ഹാലൂസിനേഷൻ: യഥാർത്ഥത്തിൽ നിലവിലില്ലാത്ത ഒരു രീതി, ലൈബ്രറി, API അല്ലെങ്കിൽ പെരുമാറ്റം എന്നിവയെക്കുറിച്ചുള്ള AI-യുടെ ബോധ്യപ്പെടുത്തുന്ന കൃത്രിമത്വം. സന്ദർഭം: നിങ്ങൾ AI-ക്ക് നൽകുന്ന ഇൻപുട്ട് (കോഡ്, പിശക് സന്ദേശം, ആവശ്യകത, നിയന്ത്രണങ്ങൾ). സ്ഥിരീകരണം: സ്വതന്ത്രമായ രീതിയിൽ ഔട്ട്പുട്ട് പരിശോധിക്കുന്നു (സമാഹാരം, പരിശോധന, ഡോക്യുമെൻ്റേഷൻ). ഈ മൂന്ന് ആശയങ്ങളും മൊഡ്യൂളിൻ്റെ നട്ടെല്ലാണ്.

ഏതൊക്കെ ബിസിനസ്സുകളിൽ AI ആക്‌സിലറേറ്റർ ആണ്, ഏത് ബിസിനസ്സുകളിൽ ഇത് അപകടകരമാണ്?

സോഫ്‌റ്റ്‌വെയർ ജോലികൾ ഫലങ്ങളുടെ അടിസ്ഥാനത്തിൽ ദ്വിമുഖ സ്പെക്‌ട്രത്തിൽ വീഴുന്നു. ഒരറ്റത്ത് റിവേഴ്‌സിബിൾ, റിസ്‌ക് കുറഞ്ഞ തയ്യാറെടുപ്പ് ജോലികൾ; മറുവശത്ത്, പ്രൊഡക്ഷൻ പരിതസ്ഥിതിയിൽ പ്രവേശിക്കാൻ ബുദ്ധിമുട്ടുള്ള മടക്കി നൽകാവുന്ന ടാസ്ക്കുകൾ ഉണ്ട്, അത് ഡാറ്റ നഷ്‌ടത്തിനും സുരക്ഷാ തകരാറുകൾക്കും തടസ്സങ്ങൾക്കും കാരണമായേക്കാം. ഈ സ്പെക്ട്രത്തിൽ നിങ്ങൾ എവിടെ നിൽക്കുന്നു എന്നതിനെ ആശ്രയിച്ച് AI യുടെ മൂല്യം വ്യത്യാസപ്പെടുന്നു.

ബിസിനസ് തരം

AI സംഭാവന

എഞ്ചിനീയറുടെ പങ്ക്

കോഡ് അസ്ഥികൂടം / ബോയിലർപ്ലേറ്റ്

ആവർത്തന ഘടനയുടെ ദ്രുത തലമുറ

ലോജിക്കും എഡ്ജ് സ്റ്റാറ്റസ് നിയന്ത്രണവും

ഡീബഗ്ഗിംഗ്

അനുമാനവും സാധ്യമായ കാരണങ്ങളുടെ പട്ടികയും

പുനരുൽപാദനവും മൂലകാരണവും സ്ഥിരീകരണം

എഴുത്ത് പരീക്ഷകൾ

ടെസ്റ്റ് ഡ്രാഫ്റ്റും രംഗം സൃഷ്ടിക്കലും

അർത്ഥവത്തായ ഉറപ്പും സ്കോപ്പ് പരിശോധനയും

റീഫാക്റ്ററിംഗ്

പുനർനിർമ്മാണ നിർദ്ദേശം

പരിശോധനയിലൂടെ പെരുമാറ്റം നിലനിർത്തുക

ഡോക്യുമെൻ്റേഷൻ

ആദ്യത്തെ ഡ്രാഫ്റ്റും ഘടനയും

കോഡിനെതിരെ ശരിയാണോയെന്ന് പരിശോധിക്കുക

വാസ്തുവിദ്യ/സുരക്ഷാ തീരുമാനം

ഓപ്ഷനുകളുടെയും ഗുണദോഷങ്ങളുടെയും പട്ടിക

അന്തിമ തീരുമാനവും ഉത്തരവാദിത്തവും

നിയമം ലളിതമാണ്: ഒരു AI ഔട്ട്‌പുട്ടിൻ്റെ അപകടസാധ്യത, ആ ഔട്ട്‌പുട്ട് ഒരു പിശക് വരുത്തിയാൽ അത് വരുത്തുന്ന നാശത്തിന് തുല്യമാണ്. ഒരു വേരിയബിൾ പേര് തെറ്റായി നിർദ്ദേശിക്കുന്നത് നിരുപദ്രവകരമാണ്; തെറ്റായ ആധികാരികത (ഉപയോക്താവ് യഥാർത്ഥത്തിൽ അവർ ആരാണെന്ന് പരിശോധിക്കുന്നത്) മുഴുവൻ സിസ്റ്റത്തെയും ദുർബലമാക്കുന്നു. അതിനാൽ ഔട്ട്പുട്ട് ഉപയോഗിക്കുന്നതിന് മുമ്പ് ആദ്യം ചോദിക്കേണ്ട ചോദ്യം ഇതാണ്: "ഇത് തെറ്റാണെങ്കിൽ എന്ത് സംഭവിക്കും, ആരാണ് ഇത് ശ്രദ്ധിക്കുന്നത്, എപ്പോൾ?"

മുന്നറിയിപ്പ്: AI ഒഴുക്കുള്ളതും ആത്മവിശ്വാസമുള്ളതുമായ കോഡ് നിർമ്മിക്കുന്നു. ഒഴുക്ക് കൃത്യതയ്ക്ക് യാതൊരു ഉറപ്പുമില്ല. യഥാർത്ഥത്തിൽ നിലവിലില്ലാത്ത ഒരു ഫംഗ്‌ഷൻ നാമമോ തെറ്റായ പാരാമീറ്റർ ക്രമമോ സുരക്ഷിതമല്ലാത്ത പാറ്റേണോ പോലും ഒരു ഭാഷാ മോഡലിന് വിശ്വസനീയമായി നിർമ്മിക്കാൻ കഴിയും. സോഫ്റ്റ്വെയറിൽ, ഇത് കടലാസിൽ അവശേഷിക്കുന്നില്ല; ഇത് കംപൈൽ ചെയ്യുന്നു, പ്രവർത്തിപ്പിക്കുന്നു, ഉൽപ്പാദനത്തിൽ പൊട്ടിത്തെറിക്കുന്നു.

എഞ്ചിനീയർക്ക് വിടേണ്ട തീരുമാനങ്ങൾ

ചില തീരുമാനങ്ങൾ ഒരിക്കലും പൂർണ്ണമായും യാന്ത്രികമാകരുത്; സാങ്കേതികവും നിയമപരവും ധാർമ്മികവുമായ അപകടസാധ്യതകൾ വഹിക്കുന്നു:

• ഉൽപ്പാദനത്തിനുള്ള അംഗീകാരം: ഉൽപ്പാദനത്തിലേക്ക് ഒരു കോഡിൻ്റെ പ്രകാശനവും ഇതിൻ്റെ ഉത്തരവാദിത്തവും.
• സുരക്ഷയും ആർക്കിടെക്ചറും: ആധികാരികത, അംഗീകാരം, എൻക്രിപ്ഷൻ, ഡാറ്റ മോഡൽ എന്നിവ പോലുള്ള ചെലവേറിയ തീരുമാനങ്ങൾ.
• ലൈസൻസും പകർപ്പവകാശവും: വാണിജ്യ ഉൽപ്പന്നത്തിൽ നിർമ്മിച്ച കോഡിൻ്റെ ഉപയോഗക്ഷമതയും ലൈസൻസ് പാലിക്കലും.
• രഹസ്യാത്മക ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നു: ഉപഭോക്തൃ ഡാറ്റ, സോഴ്സ് കോഡ് രഹസ്യങ്ങൾ, ഐഡൻ്റിറ്റി വിവരങ്ങൾ എന്നിവയുമായുള്ള ഇടപാടുകൾ.

മുന്നറിയിപ്പ്: "ഈ കോഡ് സുരക്ഷിതമാണ്, ഉൽപ്പാദനത്തിന് തയ്യാറാണ്" എന്ന് AI പറഞ്ഞാലും, സുരക്ഷാ പരിശോധനയും കോഡ് അവലോകനവും യഥാർത്ഥ ലോഡിന് കീഴിലുള്ള മൂല്യനിർണ്ണയവും കൂടാതെ ഇത് സ്വീകരിക്കുന്നത് അസ്വീകാര്യമാണ്. സുരക്ഷാ-നിർണ്ണായക പ്രവർത്തനങ്ങളിൽ, AI ഔട്ട്പുട്ട് ഒരിക്കലും ഒരു യോഗ്യതയുള്ള എഞ്ചിനീയറുടെ അംഗീകാരത്തിന് പകരമാവില്ല; ഒരു തീരുമാനത്തിലേക്ക് നയിക്കുന്ന ഏതൊരു ഔട്ട്‌പുട്ടും നടപ്പിലാക്കുന്നതിന് മുമ്പ് അംഗീകൃത എഞ്ചിനീയർ സ്വതന്ത്രമായി പരിശോധിച്ചുറപ്പിക്കുകയും അംഗീകരിക്കുകയും വേണം.

സ്ഥിരീകരണ അച്ചടക്കം: ത്രീ-ലെയർ നിയന്ത്രണം

ഒരു മുതിർന്ന നിരൂപകനെപ്പോലെ AI ഔട്ട്‌പുട്ട് അന്ധമായി ഉപയോഗിക്കുന്നതിന് മൂന്ന് ലെയറുകൾ നിയന്ത്രണം പ്രയോഗിക്കുക. മൊഡ്യൂളിലുടനീളം ഞങ്ങൾ ആവർത്തിക്കുന്ന അടിസ്ഥാന റിഫ്ലെക്സാണിത്.

1. കംപൈലേഷനും സ്റ്റാറ്റിക് ചെക്കിംഗും: കോഡ് യഥാർത്ഥത്തിൽ കംപൈൽ/റൺ ചെയ്യുന്നുണ്ടോ? തരം പിശകുകൾ, ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ, നിലവിലില്ലാത്ത API-കൾ എന്നിവയുണ്ടോ? സ്റ്റാറ്റിക് അനാലിസിസ് ടൂൾ (കോഡ് പ്രവർത്തിപ്പിക്കാതെ പരിശോധിക്കുന്ന ഉപകരണം) എന്താണ് പറയുന്നത്?
2. ഇൻഡിപെൻഡൻ്റ് റീപ്രൊഡക്ഷൻ (ടെസ്റ്റിംഗ്): ചെറിയ, അറിയപ്പെടുന്ന ഇൻപുട്ടുകൾ ഉപയോഗിച്ച് കോഡ് പ്രവർത്തിപ്പിക്കുക, നിങ്ങൾക്ക് പ്രതീക്ഷിക്കുന്ന ഔട്ട്പുട്ട് ലഭിക്കുമോ എന്ന് നോക്കുക. എഡ്ജ് കേസുകൾ പരീക്ഷിച്ചുനോക്കൂ (ശൂന്യം, പൂജ്യം, നെഗറ്റീവ്, വലുത്).
3. ഉറവിട പരിശോധന: AI ഉപയോഗിക്കുന്ന എല്ലാ API, ലൈബ്രറി പതിപ്പ്, ഭാഷാ സവിശേഷതകൾ എന്നിവ ഔദ്യോഗിക ഡോക്യുമെൻ്റേഷനിൽ നിന്ന് പരിശോധിച്ചുറപ്പിച്ചിരിക്കണം.

സ്ഥിരീകരണ പ്രോംപ്റ്റ് (ഔട്ട്‌പുട്ട് പരിശോധിക്കുന്നത് എളുപ്പമാക്കുന്നു): "നിങ്ങളുടെ കോഡിൽ നിങ്ങൾ ഉപയോഗിക്കുന്ന എല്ലാ ബാഹ്യ ലൈബ്രറികളും രീതികളും ഭാഷാ സവിശേഷതകളും ലിസ്റ്റുചെയ്യുക. ഓരോന്നിനും, ഏത് പതിപ്പിലാണ് ഇത് ലഭ്യമാണെന്ന് സൂചിപ്പിക്കുകയും 'ഡോക്യുമെൻ്റേഷനിൽ നിന്ന് പരിശോധിച്ചുറപ്പിച്ചിരിക്കണം' എന്ന് ലേബൽ ചെയ്യുകയും ചെയ്യുക. നിങ്ങൾക്ക് ഉറപ്പില്ലാത്ത ഏതെങ്കിലും API-കൾ ഉണ്ടാക്കരുത്; നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ, പ്രത്യേകം വിലാസം പട്ടികപ്പെടുത്തുകയും 'ഉറപ്പില്ലാത്തവ' എന്ന് എഴുതുകയും ചെയ്യുക."

നിങ്ങളുടെ സ്വന്തം കോഡ് പ്രോംപ്റ്റിനെ വിമർശിക്കുക: "നിങ്ങളെ നിയമിച്ച ഒരു മുതിർന്ന എഞ്ചിനീയറെപ്പോലെ നിങ്ങൾ ഇപ്പോൾ എഴുതിയ കോഡ് വിമർശനാത്മകമായി നോക്കുക. ഈ മൂന്ന് തലക്കെട്ടുകൾക്ക് കീഴിൽ മൂർത്തമായ ഇനങ്ങൾ നൽകുക: (1) ലോജിക്/എഡ്ജ് കേസ് പിശകുകൾ, (2) സുരക്ഷാ അപകടങ്ങൾ, (3) പ്രകടനക്ഷമത അല്ലെങ്കിൽ വായനാ പ്രശ്നങ്ങൾ. ഓരോ ഇനത്തിനും, 'എന്തുകൊണ്ടാണ് പ്രശ്നം' എന്ന് എഴുതുക, 'എനിക്ക് ഒരു പ്രശ്‌നവുമില്ല' എന്ന് എഴുതുക; അത് അലങ്കരിക്കാൻ ശ്രമിക്കുക."

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായത്:"എനിക്ക് ഒരു ഉപയോക്തൃ പ്രാമാണീകരണ ഫംഗ്‌ഷൻ എഴുതുക."(ഫലം: ഏത് ഭാഷ, ഏത് റൂൾ, ഏത് പിശക് സ്വഭാവം, ജനറിക് കോഡ്, പലപ്പോഴും സുരക്ഷിതമല്ല അല്ലെങ്കിൽ സന്ദർഭത്തിന് പുറത്താണ്.)STRONG:"പൈത്തൺ 3.11-ന് ഒരു ഇമെയിൽ മൂല്യനിർണ്ണയ ഫംഗ്‌ഷൻ എഴുതുക. ഇൻപുട്ട്: സ്ട്രിംഗ്. ഔട്ട്‌പുട്ട്: സാധുതയുള്ളതാണെങ്കിൽ, തെറ്റ്, അല്ലാത്തപക്ഷം, അടിസ്ഥാന നിയമങ്ങൾ ആവശ്യമില്ല. ഫംഗ്‌ഷൻ അനുബന്ധ ബ്ലോക്കിന് താഴെയുള്ള ഒരു 5-സാമ്പിൾ ടെസ്റ്റ് മതിയാകും: '@' ഇല്ല, ഇരട്ട '@', സ്‌പെയ്‌സുകൾ മാത്രം.

വ്യത്യാസം സന്ദർഭത്തിലാണ്. ശക്തമായ പ്രോംപ്റ്റ്; ഭാഷ, പതിപ്പ്, ഇൻപുട്ട്-ഔട്ട്പുട്ട് കരാർ, നിയന്ത്രണങ്ങൾ, പരീക്ഷണ പ്രതീക്ഷ എന്നിവ ഇതിൽ ഉൾപ്പെടുന്നു. ഈ ഒറ്റ അച്ചടക്കം ഹാലുസിനേഷനുകളുടെയും സുരക്ഷിതമല്ലാത്ത കോഡിൻ്റെയും അപകടസാധ്യതയെ വളരെയധികം കുറയ്ക്കുന്നു.

മിനി കേസുകൾ

കേസ് 1 - കൃത്രിമ രീതി. തീയതി ലൈബ്രറിയിൽ date.addBusinessDays(5) എന്നൊരു രീതി ഉണ്ടെന്ന് AI-യിൽ നിന്ന് ഒരു ഡെവലപ്പർ കേൾക്കുന്നു, അത് ആത്മവിശ്വാസത്തോടെ വിശദീകരിക്കുന്നു. ഡോക്യുമെൻ്റേഷൻ നോക്കുമ്പോൾ, അത്തരമൊരു രീതി ഇല്ലെന്ന് അദ്ദേഹം കാണുന്നു, ശരിയായ മാർഗം ഒരു മാനുവൽ ലൂപ്പാണ്. 10 മിനിറ്റ് പരിശോധനയിലൂടെ ഉൽപ്പാദനത്തിലേക്ക് പോകുന്നതിന് മുമ്പ് ഹാലുസിനേഷൻ ക്യാപ്‌ചർ ചെയ്യപ്പെടും.

കേസ് 2 - എഡ്ജ് സ്റ്റേറ്റ് നഷ്ടം. AI ഒരു "ശരാശരി കണക്കുകൂട്ടുക" ഫംഗ്‌ഷൻ നിർമ്മിക്കുന്നു; 1,000 വരി ഡാറ്റ ഉപയോഗിച്ച് പരീക്ഷിക്കുമ്പോൾ ഇത് പ്രവർത്തിക്കുന്നു. എന്നിരുന്നാലും, ലിസ്റ്റ് ശൂന്യമാകുമ്പോൾ, അത് പൂജ്യം പിശക് കൊണ്ട് വിഭജനം നൽകുന്നു. എഞ്ചിനീയർ ശൂന്യമായ ഇൻപുട്ട് ടെസ്റ്റ് ചേർത്തതിനാൽ, അത് തത്സമയമാകുന്നതിന് മുമ്പ് അദ്ദേഹം പിശക് കാണുകയും പരിഹരിക്കുകയും ചെയ്യുന്നു. സിംഗിൾ എഡ്ജ് കണ്ടീഷൻ ടെസ്റ്റ് പുലർച്ചെ 3 മണിക്ക് പ്രൊഡക്ഷൻ അലാറം തടയുന്നു.

കേസ് 3 - സ്വകാര്യതാ അപകടസാധ്യത. ഒരു യഥാർത്ഥ ഡാറ്റാബേസ് കണക്ഷൻ സ്ട്രിംഗും API കീയും ഉള്ള ഒരു ഫയൽ ഒരു പബ്ലിക് ടൂളിലേക്ക് ഒട്ടിക്കാൻ ഒരു വിദഗ്ദ്ധൻ ഒരുങ്ങുകയാണ്. സ്ഥാപനത്തിൻ്റെ നയം ഓർക്കുന്നു; ഇത് രഹസ്യങ്ങളെ <REDACTED> ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു, കോഡ് ഒരു പ്രതിനിധി ഉദാഹരണമായി കുറയ്ക്കുകയും അത് ആവശ്യപ്പെടുകയും ചെയ്യുന്നു. അങ്ങനെ, 5 മിനിറ്റിനുള്ളിൽ അയാൾക്ക് സഹായം ലഭിക്കുന്നു, പക്ഷേ അവൻ്റെ ഐഡൻ്റിറ്റി വിവരങ്ങൾ പുറത്തുവരുന്നില്ല.

രഹസ്യ കോഡും ഐഡൻ്റിറ്റി വിവരങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള തത്വം

സോഫ്റ്റ്വെയറിൻ്റെ ഏറ്റവും സെൻസിറ്റീവ് ഭാഗം; സോഴ്‌സ് കോഡ് രഹസ്യങ്ങൾ, ഐഡൻ്റിറ്റി വിവരങ്ങൾ (API കീ, പാസ്‌വേഡ്, ടോക്കൺ), ഉപഭോക്തൃ/വ്യക്തിഗത ഡാറ്റ. അടിസ്ഥാന തത്വം: പങ്കിടുന്നതിന് മുമ്പ് വൃത്തിയാക്കുക, സാധ്യമെങ്കിൽ ഒരു പ്രതിനിധി ഉദാഹരണം ഉപയോഗിച്ച് പ്രശ്നത്തിൻ്റെ സാരാംശം മാത്രം ചോദിക്കുക.

അജ്ഞാത പ്രോംപ്റ്റ് പാറ്റേൺ: "ഇനിപ്പറയുന്ന ഫംഗ്‌ഷനിൽ ഒരു പിശക് ഉണ്ട്. ഞാൻ യഥാർത്ഥ ബിസിനസ്സ് ലോജിക്കും മറഞ്ഞിരിക്കുന്ന സ്ഥിരാങ്കങ്ങളും പ്രാതിനിധ്യ മൂല്യങ്ങൾ ഉപയോഗിച്ച് മാറ്റി (API കീ, പട്ടിക നാമങ്ങൾ, ഫീൽഡ് നാമങ്ങൾ ജനറിക്). പ്രശ്നം: ഇൻപുട്ട് X-ൽ എനിക്ക് Y പിശക് ലഭിക്കുന്നു. ഈ പ്രതിനിധി കോഡിലെ ലോജിക് പിശക് കണ്ടെത്തി തിരുത്തിയ പതിപ്പ് വിശദീകരിക്കുക. [പ്രതിനിധി കോഡ്]"

നുറുങ്ങ്: സംശയമുണ്ടെങ്കിൽ, ഈ ടെസ്റ്റ് നടത്തുക: "ഞാൻ ഇത് ഒരു ഫോറത്തിൽ പരസ്യമായി എഴുതിയാൽ എൻ്റെ സ്ഥാപനത്തിന് പ്രശ്‌നമുണ്ടാകുമോ?" ഉത്തരം വ്യക്തമല്ലെങ്കിലും ആദ്യം അത് ക്ലിയർ ചെയ്യുക. പിന്നീട് ചോർച്ച പിന്തുടരുന്നതിനേക്കാൾ റീസെറ്റ് ചെയ്യുന്നത് എല്ലായ്പ്പോഴും വിലകുറഞ്ഞതാണ്.

സാധാരണ തെറ്റുകൾ

• കംപൈൽ/ടെസ്റ്റ് ചെയ്യാതെ ഔട്ട്പുട്ട് ഉപയോഗിക്കുന്നു. "AI എഴുതി" എന്നത് ഒരു ന്യായീകരണമല്ല; ഓരോ കോഡും അത് പ്രവർത്തിപ്പിച്ച് പരിശോധിച്ചുറപ്പിക്കുന്നു.
• സന്ദർഭമില്ലാതെ അഭ്യർത്ഥനകൾ നടത്തുന്നു. ഭാഷ, പതിപ്പ്, ഇൻപുട്ട്-ഔട്ട്പുട്ട്, നിയന്ത്രണങ്ങൾ എന്നിവ നൽകിയില്ലെങ്കിൽ, കോഡ് പൊതുവായതും പലപ്പോഴും സുരക്ഷിതവുമല്ല.
• ആലോചിക്കാതെ രഹസ്യ വിവരങ്ങൾ പങ്കുവെക്കുന്നു. API കീ, പാസ്‌വേഡ്, ഉപഭോക്തൃ ഡാറ്റ എന്നിവ മായ്‌ക്കാതെ പുറത്തുവിടാൻ പാടില്ല.
• കൃത്യമായ ഭാഷയെ കൃത്യതയോടെ ആശയക്കുഴപ്പത്തിലാക്കുന്നു. AI കൂടുതൽ ആത്മവിശ്വാസത്തോടെ സംസാരിക്കുന്നു, നിങ്ങൾ കൂടുതൽ ശ്രദ്ധാലുവായിരിക്കണം; ആത്മവിശ്വാസമുള്ള സ്വരം തെളിവല്ല.
• തീരുമാനം AI-യെ ഏൽപ്പിക്കുന്നു. ഉൽപ്പാദനം, സുരക്ഷ, വാസ്തുവിദ്യ എന്നിവയിൽ ഉൾപ്പെടുത്താനുള്ള തീരുമാനം എഞ്ചിനീയറുടെ പക്കലുണ്ട്; AI മെറ്റീരിയലുകൾ മാത്രമാണ് നിർമ്മിക്കുന്നത്.

ചുരുക്കത്തിൽ

സോഫ്‌റ്റ്‌വെയർ വർക്കിൻ്റെ ആവർത്തിച്ചുള്ളതും സമയമെടുക്കുന്നതുമായ ഭാഗങ്ങളെ AI വേഗത്തിലാക്കുന്നു: അസ്ഥികൂടം കോഡ്, ടെസ്റ്റ് ഡ്രാഫ്റ്റിംഗ്, ബഗ് ചുരുക്കൽ, ഡോക്യുമെൻ്റേഷൻ. എന്നിരുന്നാലും, തീരുമാനവും ഉത്തരവാദിത്തവും എഞ്ചിനീയർക്കാണ്. ഓരോ ഔട്ട്‌പുട്ടും നിയന്ത്രണത്തിൻ്റെ മൂന്ന് പാളികൾ കടന്നുപോകണം (കംപൈൽ/സ്റ്റാറ്റിക്, ടെസ്റ്റിംഗ്, ഉറവിടം). ഈ മൊഡ്യൂളിൻ്റെ ഓരോ യൂണിറ്റിലും ഞങ്ങൾ ആവർത്തിക്കുന്ന രണ്ട് പ്രധാന ശീലങ്ങളാണ് സന്ദർഭം ഉപയോഗിച്ച് പ്രോംപ്റ്റുകൾ എഴുതുന്നതും മറഞ്ഞിരിക്കുന്ന വിവരങ്ങൾ മായ്‌ക്കുന്നതും. നിങ്ങൾ അച്ചടക്കത്തോടെ AI ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾക്ക് വേഗത ലഭിക്കും; നിങ്ങൾ അത് അച്ചടക്കമില്ലാതെ ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾ പിശകുകളും കേടുപാടുകളും ഉൽപാദനത്തിലേക്ക് കൊണ്ടുപോകുന്നു.

ആപ്ലിക്കേഷൻ ടാസ്ക്

നിങ്ങളുടെ സ്വന്തം ജോലിയിൽ നിന്നോ ഒരു സാങ്കൽപ്പിക പ്രോജക്റ്റിൽ നിന്നോ ഒരു ചെറിയ കോഡിംഗ് ടാസ്ക്ക് തിരഞ്ഞെടുക്കുക (ഉദാ. ഒരു മൂല്യനിർണ്ണയ പ്രവർത്തനം). ആദ്യം ഒരു ദുർബലമായ പ്രോംപ്റ്റ് എഴുതി ഔട്ട്പുട്ട് നേടുക. തുടർന്ന് ഈ യൂണിറ്റിൽ നിന്നുള്ള ശക്തമായ പ്രോംപ്റ്റ് പാറ്റേൺ പ്രയോഗിക്കുക: ഭാഷ/പതിപ്പ്, ഇൻപുട്ട്-ഔട്ട്പുട്ട് കരാർ, നിയന്ത്രണങ്ങൾ, ടെസ്റ്റ് പ്രതീക്ഷ എന്നിവ ചേർക്കുക. രണ്ട് പ്രിൻ്റൗട്ടുകളും അടുത്തടുത്ത് വെച്ച് വ്യത്യാസം എഴുതുക. തുടർന്ന് ശക്തമായ ഔട്ട്‌പുട്ട് കംപൈൽ ചെയ്‌ത് കുറഞ്ഞത് മൂന്ന് എഡ്ജ് കെയ്‌സുകളെങ്കിലും (നൾ, സീറോ/നെഗറ്റീവ്, അപ്രതീക്ഷിത ഫോർമാറ്റ്) ഉപയോഗിച്ച് പരീക്ഷിച്ച് ഏത് ടെസ്റ്റിൽ നിങ്ങൾ കണ്ടെത്തുന്നത് ശ്രദ്ധിക്കുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഞാൻ പ്രോംപ്റ്റിൽ ഭാഷ, പതിപ്പ്, ഇൻപുട്ട്-ഔട്ട്പുട്ട് കരാർ എന്നിവ ചേർത്തു.
• [ ] ഞാൻ എഴുതി "ഇത് ഉണ്ടാക്കരുത്, നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ എന്നോട് പറയൂ" കൂടാതെ സ്കോപ്പ് പരിമിതിയും.
• [ ] ഞാൻ കോഡ് സമാഹരിച്ചു/റൺ ചെയ്തു, സ്റ്റാറ്റിക് മുന്നറിയിപ്പുകൾക്കായി പരിശോധിച്ചു.
• [ ] ഞാൻ കുറഞ്ഞത് മൂന്ന് എഡ്ജ് കേസുകളെങ്കിലും പരീക്ഷിച്ചു.
• [ ] ഔദ്യോഗിക ഡോക്യുമെൻ്റേഷനിൽ നിന്ന് ഉപയോഗിച്ച API-കൾ ഞാൻ പരിശോധിച്ചു.
• [ ] ഞാൻ ഏതെങ്കിലും രഹസ്യ കോഡ്/ക്രെഡൻഷ്യലുകൾ മായ്‌ച്ചു അല്ലെങ്കിൽ എൻ്റർപ്രൈസ് ടൂൾ ഉപയോഗിച്ചു.
• [ ] ഉൽപ്പാദനത്തിലും സുരക്ഷയിലും ഏർപ്പെടുത്താനുള്ള തീരുമാനം മനുഷ്യനിൽ തുടരുമെന്ന് ഞാൻ സ്ഥിരീകരിച്ചു.