𝗗𝗶𝘀𝗽𝗼𝘀𝗮𝗯𝗹𝗲 𝗖𝗼𝗱𝗲 𝗜𝘀 𝗔 𝗟𝗶𝗲
AI யுகத்தில் குறியீட்டின் (code) ஆயுட்காலம் முடிந்துவிட்டது என்று மக்கள் கூறுகிறார்கள். AI 10 மடங்கு வேகத்தில் குறியீட்டை மீண்டும் எழுதும் என்று அவர்கள் உரிமை கொண்டாடுகிறார்கள். பிறகு எப்போது வேண்டுமானாலும் அதை மீண்டும் உருவாக்கிவிடலாம் என்றால், ஏன் நீண்ட காலம் நிலைத்திருக்கும் குறியீட்டை எழுத வேண்டும் என்று அவர்கள் கேட்கிறார்கள்.
இந்த எண்ணம் ஒரு மாயை. மென்பொருளைப் பராமரிக்காதவர்களிடமிருந்தே பெரும்பாலும் இது வருகிறது.
இந்த வாதம் கேட்பதற்கு நன்றாகத் தோன்றலாம். உங்களுக்கு ஒரு குழப்பமான codebase கிடைக்கிறது. அதைத் தூக்கி எறிந்துவிட்டு, AI-யிடம் சுத்தமான ஒன்றை உருவாக்குமாறு கேட்கிறீர்கள். இது முன்னேற்றம் போலத் தோன்றலாம். ஆனால் உண்மையில், இது ஒரு பொறியியல் தோல்வி (engineering failure).
ஒரு நிலைநிறுத்தப்பட்ட codebase பற்றி மக்கள் மறந்திருப்பது இதுதான்: அது வெறும் தர்க்கம் (logic) மட்டுமல்ல. நீங்கள் சரிசெய்த ஒவ்வொரு பிழையின் (error) பதிவும் அதில் உள்ளது.
வரிசை 412-இல் உள்ள அந்த விசித்திரமான 'if' கூற்று (statement) ஒரு காரணத்திற்காகவே அங்கு உள்ளது. ஒரு நேர மண்டல மாற்றத்தின் போது (time zone change), ஒரு கட்டண வழங்குநரிடமிருந்து (payment provider) வரும் ஒரு குறிப்பிட்ட பிழையை அது கையாள்கிறது. அந்தத் தர்க்கம் எந்த ஒரு டிக்கெட்டிலும் (ticket) இல்லை. அது குறியீட்டிலேயே வாழ்ந்து கொண்டிருக்கிறது.
ஒவ்வொரு முறை குறியீட்டை மீண்டும் எழுதும்போதும் (rewrite), ஒருவித நினைவாற்றல் இழப்பு ஏற்படுகிறது. மறைமுகமான அறிவு (implicit knowledge) மற்றும் விளிம்புநிலைச் சூழல்களைக் கையாளும் முறையை (edge-case handling) நீங்கள் இழக்கிறீர்கள். AI வேகமாக குறியீட்டை எழுத முடியும், ஆனால் உங்கள் குழுவின் கடந்த கால முடிவுகளை அதனால் மீண்டும் உருவாக்க முடியாது. ஒரு சிஸ்டம் தோல்விக்குப் பிறகு, உங்கள் retry logic-க்காக நீங்கள் செலவிட்ட மாத கால உழைப்பை அதனால் மீண்டும் கொண்டு வர முடியாது.
உற்பத்தியின் வேகம் என்பது புரிந்துகொள்ளும் வேகம் அல்ல. சில நிமிடங்களில் ஆயிரம் வரிகள் கொண்ட குறியீட்டை நீங்கள் உருவாக்க முடியும். ஆனால் ஆயிரம் வரிகள் கொண்ட குறியீட்டைப் படிக்க இன்னும் பல மணிநேரம் ஆகும். AI இந்த விகிதத்தை மாற்றாது.
தட்டச்சு செய்வது (Typing) ஒருபோதும் கடினமான பகுதி அல்ல. என்ன தட்டச்சு செய்ய வேண்டும் என்பதைக் கண்டறிவதே கடினமான பகுதி.
குறியீட்டை ஒருமுறை பயன்படுத்தும் பொருளாக (disposable) கருதுவது என்பது, உங்கள் பயனர்களையும் உங்கள் சேவையின் தொடர்ச்சியையும் (uptime) ஒருமுறை பயன்படுத்தும் பொருளாகவே பார்ப்பது என்று அர்த்தம். ஒவ்வொரு முறை குறியீட்டை மீண்டும் எழுதும்போதும் ஒரு ஆபத்து கால அவகாசம் (risk window) உருவாகிறது. ஒவ்வொரு ஆபத்து காலமும் பின்னடைவுகளுக்கு (regressions) வழிவகுக்கிறது. ஒவ்வொரு பின்னடைவும் உங்களை நம்பியிருக்கும் ஒரு பயனரை பாதிக்கிறது.
நீங்கள் ஒரு வார இறுதித் திட்டத்தை (weekend project) உருவாக்குகிறீர்கள் என்றால், உங்களுக்குத் தோன்றும்போது அதை மீண்டும் எழுதிக் கொள்ளலாம். யாருக்கும் கவலையில்லை.
ஆனால் மக்கள் நம்பியிருக்கும் ஒரு தயாரிப்பை நீங்கள் நிர்வகித்தால், இந்த ஆடம்பரத்தை நீங்கள் செய்ய முடியாது. ஒரு விடுமுறை நாளில் அதிகாலை 2 மணிக்கு எதையாவது உடைத்துவிட உங்களுக்கு அனுமதி இல்லை.
Rewrites தொழில்நுட்பக் கடனை (tech debt) சரிசெய்யாது. அவை அதைத் தேடிக் கண்டுபிடிப்பதற்கான காலக் கடிகாரத்தை மட்டுமே ரீசெட் செய்கின்றன.
இந்த வாதம் திட்டங்களைத் தொடங்குபவர்களுக்கும், ஆனால் அவற்றை ஒருபோதும் பராமரிக்காதவர்களுக்கும் மட்டுமே பயன்படும். AI எல்லாவற்றையும் மாற்றக்கூடியதாக ஆக்கிவிடும் என்ற கருத்தை விற்பனை செய்பவர்களுக்கும் இது பயன்படும். ஆனால், ஒரு rewrite தோல்வியடையும் போது அழைப்பு (page) வரும் பொறியாளருக்கோ அல்லது பயனருக்கோ இது உதவாது.
பராமரிப்பு என்பது மென்பொருளின் யதார்த்தம். ஒரு சேவையைத் தொடர்ந்து இயங்க வைக்க வேண்டிய அவசியம் உங்களுக்கு இல்லை என்றால் மட்டுமே Disposable code என்ற தத்துவம் வேலை செய்யும்.
சிறந்த மற்றும் அதிக காலம் நிலைத்திருக்கும் குறியீட்டை எழுத AI-யைப் பயன்படுத்துங்கள். எல்லாவற்றையும் ஆரம்பத்திலிருந்து மீண்டும் உருவாக்குவதற்கான சாக்காக அதைத் தேடாதீர்கள்.
நிலைத்தன்மைதான் சுறுசுறுப்பை (agility) நீடித்திருக்கச் செய்கிறது.
உங்கள் அமைப்பில் உள்ள மிகப்பழமையான குறியீடு எது? அதை நீங்கள் நீக்கினால் எதை இழப்பீர்கள்?
ஆதாரம்: https://dev.to/adioof/disposable-code-is-a-psyop-by-people-who-dont-maintain-anything-33kg
விருப்பத்தேர்வு கற்றல் சமூகம்: https://t.me/GyaanSetuAi