சக்கரத்தை மீண்டும் கண்டுபிடிப்பது ஏன் பயனுள்ளதாக இருக்கும்?

மற்ற நாள் நான் ஒரு மூத்த பதவிக்கு விண்ணப்பித்த JavaScript டெவலப்பரை நேர்காணல் செய்தேன். நேர்காணலில் இருந்த ஒரு சக ஊழியர், HTTP கோரிக்கையை உருவாக்கும் ஒரு செயல்பாட்டை எழுதுமாறு வேட்பாளரிடம் கேட்டார், அது தோல்வியுற்றால், பல முறை மீண்டும் முயற்சிக்கவும்.

அவர் நேரடியாக பலகையில் குறியீட்டை எழுதினார், எனவே தோராயமாக ஏதாவது வரைந்தால் போதும். விஷயம் என்ன என்பதை அவர் நன்றாகப் புரிந்து கொண்டதாக அவர் வெறுமனே காட்டியிருந்தால், நாங்கள் மிகவும் திருப்தி அடைந்திருப்போம். ஆனால், துரதிர்ஷ்டவசமாக, அவரால் வெற்றிகரமான தீர்வைக் கண்டுபிடிக்க முடியவில்லை. பிறகு, நாங்கள் அதை உற்சாகப்படுத்தினோம், பணியை கொஞ்சம் எளிதாக்க முடிவு செய்தோம், மேலும் அழைப்புகளைக் கொண்ட ஒரு செயல்பாட்டை வாக்குறுதிகளின் அடிப்படையில் கட்டமைக்கப்பட்ட செயல்பாடாக மாற்றும்படி அவரிடம் கேட்டோம்.

ஆனால் ஐயோ. ஆம், அவர் இதற்கு முன்பு அத்தகைய குறியீட்டை எதிர்கொண்டார் என்பது தெளிவாகத் தெரிந்தது. அங்கு எல்லாம் எப்படி வேலை செய்கிறது என்பதை அவர் பொதுவாக அறிந்திருந்தார். நமக்குத் தேவையானது கருத்தின் புரிதலை நிரூபிக்கும் ஒரு தீர்வின் ஓவியம் மட்டுமே. இருப்பினும், வேட்பாளர் பலகையில் எழுதிய குறியீடு முற்றிலும் முட்டாள்தனமானது. ஜாவாஸ்கிரிப்ட்டில் என்ன வாக்குறுதிகள் உள்ளன என்பதைப் பற்றி அவருக்கு மிகவும் தெளிவற்ற யோசனை இருந்தது மற்றும் அவை ஏன் தேவை என்பதை உண்மையில் விளக்க முடியவில்லை. ஒரு இளையவருக்கு இது மன்னிக்கத்தக்கதாக இருந்திருக்கும், ஆனால் அவர் இனி ஒரு மூத்த பதவிக்கு பொருந்தவில்லை. இந்த டெவெலப்பரால் சிக்கலான வாக்குறுதிகளின் சங்கிலியில் உள்ள பிழைகளை எவ்வாறு சரிசெய்வது மற்றும் அவர் சரியாக என்ன செய்தார் என்பதை மற்றவர்களுக்கு விளக்குவது எப்படி?

டெவலப்பர்கள் ஆயத்த குறியீட்டை சுயமாகவே கருதுகின்றனர்

வளர்ச்சி செயல்பாட்டின் போது, ​​நாங்கள் தொடர்ந்து மீண்டும் உருவாக்கக்கூடிய பொருட்களை சந்திக்கிறோம். ஒவ்வொரு முறையும் அவற்றை மீண்டும் எழுத வேண்டியதில்லை என்பதற்காக, குறியீடு துண்டுகளை மாற்றுகிறோம். அதன்படி, முக்கிய பகுதிகளின் மீது எங்கள் கவனத்தை செலுத்துவதன் மூலம், நாங்கள் வேலை செய்யும் முடிக்கப்பட்ட குறியீட்டை சுயமாகத் தெளிவாகப் பார்க்கிறோம் - எல்லாம் சரியாக வேலை செய்யும் என்று நாங்கள் கருதுகிறோம்.

பொதுவாக இது வேலை செய்கிறது, ஆனால் விஷயங்கள் தந்திரமானதாக இருக்கும்போது, ​​​​இயக்கவியலைப் புரிந்துகொள்வது பலனளிக்கும்.

எனவே, மூத்த டெவலப்பர் பதவிக்கான எங்கள் வேட்பாளர் வாக்குறுதி பொருட்களை சுயமாக வெளிப்படுத்துவதாகக் கருதினார். வேறொருவரின் குறியீட்டில் எங்காவது நிகழும்போது அவற்றை எவ்வாறு கையாள்வது என்பது பற்றி அவருக்கு ஒரு யோசனை இருக்கலாம், ஆனால் அவர் பொதுவான கொள்கையைப் புரிந்து கொள்ளவில்லை மற்றும் நேர்காணலின் போது அதை மீண்டும் செய்ய முடியவில்லை. ஒருவேளை அவர் அந்த பகுதியை இதயத்தால் நினைவில் வைத்திருந்தார் - இது அவ்வளவு கடினம் அல்ல:

return new Promise((resolve, reject) => {
  functionWithCallback((err, result) => {
   return err ? reject(err) : resolve(result);
  });
});

நானும் அதைச் செய்தேன் - நாம் அனைவரும் அதை ஒரு கட்டத்தில் செய்திருக்கலாம். அவர்கள் ஒரு குறியீட்டை மனப்பாடம் செய்தார்கள், பின்னர் அவர்கள் அதை தங்கள் வேலையில் பயன்படுத்த முடியும், அதே நேரத்தில் எல்லாம் எப்படி வேலை செய்கிறது என்பது பற்றிய பொதுவான யோசனை மட்டுமே இருந்தது. ஆனால் டெவலப்பர் இந்த கருத்தை உண்மையிலேயே புரிந்து கொண்டால், அவர் எதையும் நினைவில் வைத்திருக்க வேண்டியதில்லை - அதை எப்படி செய்வது என்று அவருக்குத் தெரியும், மேலும் அவருக்கு தேவையான அனைத்தையும் குறியீட்டில் எளிதாக இனப்பெருக்கம் செய்வார்.

வேர்களுக்குத் திரும்பு

2012 ஆம் ஆண்டில், முன்-இறுதி கட்டமைப்பின் ஆதிக்கம் இன்னும் நிறுவப்படாதபோது, ​​jQuery உலகை ஆண்டது, நான் புத்தகத்தைப் படித்தேன் ஜாவாஸ்கிரிப்ட் நிஞ்ஜாவின் ரகசியங்கள், jQuery உருவாக்கிய ஜான் ரெசிக் எழுதியது.

புத்தகம் வாசகருக்கு புதிதாக jQuery ஐ எவ்வாறு உருவாக்குவது என்பதைக் கற்பிக்கிறது மற்றும் நூலகத்தின் உருவாக்கத்திற்கு வழிவகுத்த சிந்தனை செயல்முறையைப் பற்றிய தனித்துவமான பார்வையை வழங்குகிறது. சமீபத்திய ஆண்டுகளில், jQuery அதன் முந்தைய பிரபலத்தை இழந்துவிட்டது, ஆனால் நான் இன்னும் புத்தகத்தை மிகவும் பரிந்துரைக்கிறேன். அவளைப் பற்றி என்னை மிகவும் கவர்ந்தது, இதையெல்லாம் நானே நினைத்திருக்க முடியும் என்ற விடாப்பிடியான உணர்வு. ஆசிரியர் விவரித்த படிகள் மிகவும் தர்க்கரீதியாகத் தோன்றின, மிகவும் தெளிவாகத் தோன்றின, நான் அதில் இறங்கினால் jQuery ஐ எளிதாக உருவாக்க முடியும் என்று நான் தீவிரமாக சிந்திக்க ஆரம்பித்தேன்.

நிச்சயமாக, உண்மையில் என்னால் இதுபோன்ற எதையும் செய்ய முடியாது - இது தாங்க முடியாத கடினம் என்று நான் முடிவு செய்திருப்பேன். எனது சொந்த தீர்வுகள் மிகவும் எளிமையானவை மற்றும் வேலை செய்ய அப்பாவியாகத் தோன்றும், நான் விட்டுவிடுவேன். நான் jQuery ஐ சுய-தெளிவான விஷயங்கள் என்று வகைப்படுத்துவேன், சரியான செயல்பாட்டில் நீங்கள் கண்மூடித்தனமாக நம்ப வேண்டும். அதன்பிறகு, இந்த நூலகத்தின் இயக்கவியலை ஆராய்வதில் நான் நேரத்தை வீணடிக்க மாட்டேன், ஆனால் அதை ஒரு வகையான கருப்புப் பெட்டியாகப் பயன்படுத்துவேன்.

ஆனால் இந்தப் புத்தகத்தைப் படித்தது என்னை வேறு மாதிரி ஆக்கியது. நான் மூலக் குறியீட்டைப் படிக்க ஆரம்பித்தேன் மற்றும் பல தீர்வுகளை செயல்படுத்துவது உண்மையில் மிகவும் வெளிப்படையானது, வெளிப்படையானது என்று கண்டுபிடித்தேன். இல்லை, நிச்சயமாக, இதுபோன்ற ஒன்றை நீங்களே நினைப்பது வேறு கதை. ஆனால் இது மற்றவர்களின் குறியீட்டைப் படிப்பதும், ஏற்கனவே உள்ள தீர்வுகளை மீண்டும் உருவாக்குவதும் நமக்குச் சொந்தமான ஒன்றைக் கொண்டு வர உதவுகிறது.

நீங்கள் பெறும் உத்வேகம் மற்றும் நீங்கள் கவனிக்கத் தொடங்கும் வடிவங்கள் உங்களை ஒரு டெவலப்பராக மாற்றும். நீங்கள் தொடர்ந்து பயன்படுத்தும் மற்றும் நீங்கள் ஒரு மாயாஜால கலைப்பொருளாக நினைத்துப் பழகிய அந்த அற்புதமான நூலகம் மாயாஜாலத்தில் வேலை செய்யாது, ஆனால் ஒரு சிக்கலை எளிமையாகவும் சமயோசிதமாகவும் தீர்க்கிறது என்பதை நீங்கள் காண்பீர்கள்.

சில நேரங்களில் நீங்கள் குறியீட்டின் மீது துளையிட வேண்டும், அதை படிப்படியாக பகுப்பாய்வு செய்ய வேண்டும், ஆனால் சிறிய, நிலையான படிகளில் நகர்த்துவதன் மூலம், நீங்கள் தீர்வுக்கான ஆசிரியரின் பாதையை மீண்டும் செய்யலாம். இது குறியீட்டு செயல்முறையில் ஆழமாக மூழ்கி, உங்கள் சொந்த தீர்வுகளை கொண்டு வருவதில் அதிக நம்பிக்கையை உங்களுக்கு வழங்கும்.

நான் முதலில் வாக்குறுதிகளுடன் வேலை செய்யத் தொடங்கியபோது, ​​​​அது எனக்கு ஒரு தூய மந்திரமாகத் தோன்றியது. அவர்கள் அதே அழைப்புகளை அடிப்படையாகக் கொண்டவர்கள் என்பதை நான் கண்டுபிடித்தேன், மேலும் எனது நிரலாக்க உலகம் தலைகீழாக மாறியது. கால்பேக்குகளிலிருந்து நம்மைக் காப்பாற்றும் முறை, அழைப்புகளைப் பயன்படுத்தி தானே செயல்படுத்தப்படுகிறது?!

இந்த விஷயத்தை வெவ்வேறு கண்களால் பார்க்கவும், இது எனக்கு முன்னால் உள்ள சுருக்கமான குறியீடு அல்ல என்பதை உணரவும் எனக்கு உதவியது, இது என் வாழ்க்கையில் நான் ஒருபோதும் புரிந்து கொள்ள முடியாத தடைசெய்யும் சிக்கலானது. இவை சரியான ஆர்வத்துடனும் ஆழமான அமிழ்தத்துடனும் பிரச்சனைகள் இல்லாமல் புரிந்து கொள்ளக்கூடிய வடிவங்கள். இப்படித்தான் மக்கள் குறியீட்டைக் கற்றுக்கொண்டு டெவலப்பர்களாக வளர்கிறார்கள்.

இந்த சக்கரத்தை மீண்டும் கண்டுபிடிக்கவும்

எனவே முன்னோக்கிச் சென்று சக்கரங்களை மீண்டும் உருவாக்குங்கள்: உங்கள் சொந்த தரவு பிணைப்புக் குறியீட்டை எழுதுங்கள், உள்நாட்டு வாக்குறுதியை உருவாக்குங்கள் அல்லது உங்கள் சொந்த மாநில நிர்வாக தீர்வை உருவாக்கவும்.
இதையெல்லாம் யாரும் பயன்படுத்த மாட்டார்கள் என்பது முக்கியமல்ல - ஆனால் இப்போது அதை எப்படி செய்வது என்று உங்களுக்குத் தெரியும். உங்கள் சொந்த திட்டங்களில் இதுபோன்ற முன்னேற்றங்களைப் பயன்படுத்த உங்களுக்கு வாய்ப்பு இருந்தால், அது பொதுவாக சிறந்தது. நீங்கள் அவற்றை வளர்த்து வேறு ஏதாவது கற்றுக்கொள்ள முடியும்.

இங்கே புள்ளி உங்கள் குறியீட்டை உற்பத்திக்கு அனுப்புவது அல்ல, ஆனால் புதிதாக ஒன்றைக் கற்றுக்கொள்வது. ஏற்கனவே உள்ள தீர்வை நீங்களே செயல்படுத்துவதை எழுதுவது சிறந்த புரோகிராமர்களிடமிருந்து கற்றுக்கொள்வதற்கும், உங்கள் திறமைகளை மேம்படுத்துவதற்கும் ஒரு சிறந்த வழியாகும்.

ஆதாரம்: www.habr.com