முக்கியமான எடுத்துக்காட்டுகள்
1. வாசிக்க எளிதான மற்றும் பராமரிக்க எளிதான குறியீட்டை எழுதுங்கள்
குறியீட்டு தரத்தின் ஒரே செல்லுபடியாகும் அளவீடு: WTFs/நிமிடம்
வாசிப்பு முக்கியம். சுத்தமான குறியீடு மற்ற டெவலப்பர்களால் எளிதாகப் புரிந்துகொள்ளப்பட வேண்டும். இது எளிமையான, அழகான மற்றும் குழப்பமில்லாததாக இருக்க வேண்டும். விரிவான கருத்துக்களைப் பயன்படுத்தாமல், அதன் நோக்கத்தை தெளிவாக வெளிப்படுத்தும் குறியீட்டை எழுத முயற்சிக்கவும். பொருத்தமான மாறிலிகள் மற்றும் செயல்பாட்டு பெயர்களைப் பயன்படுத்தவும், செயல்பாடுகளை சிறிய மற்றும் கவனமாகக் கையாளவும், குறியீட்டை தரவியல் அடிப்படையில் ஒழுங்குபடுத்தவும்.
பராமரிப்பு வளர்ச்சியை சாத்தியமாக்குகிறது. மாற்றுவதில் கடினமான குறியீடு ஒரு பொறுப்பு ஆகிறது. உங்கள் குறியீட்டை மாறுபட்ட தேவைகளுக்கு ஏற்ப மாறுபடக்கூடிய மற்றும் மாடுலர் ஆக வடிவமைக்கவும். DRY (உங்களை மீண்டும் மீண்டும் செய்ய வேண்டாம்) மற்றும் SOLID போன்ற கொள்கைகளைப் பின்பற்றவும், loosely coupled, highly cohesive அமைப்புகளை உருவாக்கவும். செயல்பாட்டை மாற்றாமல் குறியீட்டு அமைப்பை மேம்படுத்துவதற்காக மீண்டும் வடிவமைக்கவும்.
சுத்தமான குறியீடு பயன் தருகிறது. சுத்தமான குறியீடு எழுதுவதற்கு அதிக முன்னணி முயற்சி தேவை, ஆனால் இது நீண்ட காலத்தில் முக்கியமான நேரம் மற்றும் தலைவலி சேமிக்கிறது. சுத்தமான குறியீடு பிழைகளை கண்டறிய, விரிவாக்க, மற்றும் பராமரிக்க எளிதாக உள்ளது. இது டெவலப்பர்களுக்கு மேலும் திறமையாக வேலை செய்ய உதவுகிறது மற்றும் மாற்றங்களின் போது பிழைகளை அறிமுகப்படுத்தும் ஆபத்தை குறைக்கிறது. சுத்தமான குறியீட்டை உங்கள் வளர்ச்சி நடைமுறையின் முக்கிய பகுதியாகக் கொள்ளுங்கள்.
2. பொருத்தமான பெயர் வழிமுறைகளை பின்பற்றுங்கள்
ஒரு மாறிலியின், செயல்பாட்டின், அல்லது வகுப்பின் பெயர், அனைத்து முக்கிய கேள்விகளுக்கும் பதிலளிக்க வேண்டும். இது ஏன் உள்ளது, என்ன செய்கிறது, மற்றும் எப்படி பயன்படுத்தப்படுகிறது என்பதைச் சொல்ல வேண்டும்.
நோக்கத்தை வெளிப்படுத்தும் பெயர்களைப் பயன்படுத்தவும். மாறிலிகள், செயல்பாடுகள், மற்றும் வகுப்புகளின் நோக்கம் மற்றும் நடத்தை தெளிவாகக் கூறும் பெயர்களைத் தேர்ந்தெடுக்கவும். ஒரே எழுத்து பெயர்கள் அல்லது குறியாக்கங்களைத் தவிர்க்கவும். எளிதாகக் கூறக்கூடிய, தேட எளிதான பெயர்களைப் பயன்படுத்தவும். எடுத்துக்காட்டாக:
- மோசம்: d (நாட்களில் கழிக்கப்பட்ட நேரம்)
- நல்லது: elapsedTimeInDays
ஒற்றுமை மற்றும் துல்லியமாக இருங்கள். உங்கள் குறியீட்டில் ஒற்றுமையான பெயர் வழிமுறைகளைப் பயன்படுத்தவும். குழப்பத்தைத் தவிர்க்க துல்லியமாக இருங்கள் - எடுத்துக்காட்டாக, getActiveAccounts() மற்றும் getActiveAccountInfo() போன்ற பொருத்தமான வேறுபாடுகளைப் பயன்படுத்தவும். மதிப்பில்லாத சிக்கல்களைச் சேர்க்கும் குறியீடுகள் அல்லது முன்னுரிமைகளைத் தவிர்க்கவும். வகுப்பு பெயர்கள் பெயர்களாக இருக்க வேண்டும், செயல்பாட்டு பெயர்கள் வினாக்களாக இருக்க வேண்டும்.
பெயர் நீளம் பரப்புக்கு ஏற்ப இருக்க வேண்டும். பெரிய பரப்புகளுக்கான மாறிலிகள் மற்றும் செயல்பாடுகளுக்கு நீளமான, விளக்கமான பெயர்களைப் பயன்படுத்தவும். சிறிய, உள்ளூர் பரப்புகளுக்கு குறுகிய பெயர்கள் ஏற்றதாக இருக்கின்றன. ஒரு பெயரின் நீளம் அதன் பயன்பாட்டு பரப்புக்கு ஏற்ப இருக்க வேண்டும். பெயர் பயன்படுத்தப்படும் சூழ்நிலைக்கு உள்ளே வாசிப்பு மற்றும் புரிதலுக்காக மேம்படுத்தவும்.
3. செயல்பாடுகளை சிறிய மற்றும் கவனமாகக் கையாளுங்கள்
செயல்பாடுகள் ஒரு விஷயத்தைச் செய்ய வேண்டும். அவை அதை நன்கு செய்ய வேண்டும். அவை அதை மட்டும் செய்ய வேண்டும்.
சிறியது அழகானது. செயல்பாடுகள் சிறியதாக இருக்க வேண்டும் - பொதுவாக 5-10 வரிகள் நீளமாக. அவை ஒரு திரையில் பொருந்த வேண்டும் மற்றும் உடனே புரிந்துகொள்ளப்பட வேண்டும். நீண்ட, சிக்கலான செயல்பாடுகளை எழுதுவதற்குப் பதிலாக, நன்கு பெயரிடப்பட்ட உதவியாளர் செயல்பாடுகளில் குறியீட்டை எடுக்கவும். சிறிய செயல்பாடுகள் புரிந்துகொள்ள, சோதிக்க, மற்றும் பராமரிக்க எளிதாக உள்ளன.
ஒரு விஷயத்தை நன்கு செய்யுங்கள். ஒவ்வொரு செயல்பாட்டுக்கும் ஒரு தனி, தெளிவான நோக்கம் இருக்க வேண்டும். ஒரு செயல்பாடு பல விஷயங்களைச் செய்கிறதெனில், அவற்றை தனித்தனியாக செயல்பாடுகளில் எடுக்கவும். ஒரு செயல்பாடு அதிகமாக செய்கிறதற்கான சின்னங்கள்:
- பல நிலைகளில் அப்ஸ்ட்ராக்ஷன்
- பல பிரிவுகள் அல்லது குறியீட்டு தொகுதிகள்
- பல்வேறு அளவுருக்கள்
ஒரு அப்ஸ்ட்ராக்ஷன் நிலையை பராமரிக்கவும். ஒரு செயல்பாட்டின் உள்ளே உள்ள உரைகள் அனைத்தும் ஒரே அப்ஸ்ட்ராக்ஷன் நிலை அளவிலேயே இருக்க வேண்டும். உயர் நிலை தரவுகளை கீழ் நிலை விவரங்களுடன் கலக்காதீர்கள். கீழ் நிலை செயல்பாடுகளை தனித்தனியாக எடுக்கவும். இது செயல்பாடுகளை கவனமாகவும், கருத்தியல் ரீதியாக எளிதாகவும் வைத்திருக்குவதால் வாசிப்பை மேம்படுத்துகிறது.
4. சரியான வடிவமைப்பு மற்றும் ஒழுங்குபடுத்தல் நடைமுறைகளைப் பின்பற்றுங்கள்
குறியீட்டு வடிவமைப்பு தொடர்பானது, மற்றும் தொடர்பு தொழில்முறை டெவலப்பரின் முதன்மை வேலை.
ஒற்றுமையான வடிவமைப்பு முக்கியம். உங்கள் குறியீட்டில் ஒற்றுமையான இடைவெளி, வரி உடைப்பு, மற்றும் இடைவெளிகளைப் பயன்படுத்தவும். இது வாசிப்பை மேம்படுத்துகிறது மற்றும் அறிவாற்றலைக் குறைக்கிறது. உங்கள் குழுவுடன் வடிவமைப்பு தரநிலைகளைப் பற்றி ஒப்புக்கொண்டு, அவற்றைப் பின்பற்றுவதற்கான தானியங்கி கருவிகளைப் பயன்படுத்தவும். முக்கிய வடிவமைப்பு வழிகாட்டுதல்கள்:
- சரியான இடைவெளி
- ஒற்றுமையான வளைவுகள்
- தரவியல் வரி உடைப்புகள்
- பொருத்தமான இடைவெளி
குறியீட்டை தரவியல் அடிப்படையில் ஒழுங்குபடுத்தவும். தொடர்புடைய குறியீட்டை ஒன்றாகக் குழுவாகக் கையாளவும் மற்றும் தொடர்பில்லாத குறியீட்டைப் பிரிக்கவும். தரவியல் பிரிவுகளுக்கு இடையே "பராகிராப்" இடைவெளிகளை உருவாக்க வெள்ளை வரிகளைப் பயன்படுத்தவும். தொடர்புடைய செயல்பாடுகளை அருகில் வைக்கவும். ஒரு தனி கருத்து அல்லது கூறு மீது கவனம் செலுத்தி கோப்புகளை வைத்திருக்கவும். தேவையான போது பெரிய கோப்புகளை சிறிய, கவனமாகக் கையாளுங்கள்.
தரநிலைகளைப் பின்பற்றவும். உங்கள் மொழி மற்றும் சமூகத்திற்கான தரநிலைகளைப் பின்பற்றவும். இது உங்கள் குறியீட்டை மற்ற டெவலப்பர்களுக்கு மேலும் பரிச்சயமாகவும், அணுகலுக்கேற்பவும் ஆக்குகிறது. எடுத்துக்காட்டாக, ஜாவாவில்:
- வகுப்பு பெயர்கள் PascalCase ஐப் பயன்படுத்துகின்றன
- செயல்பாட்டு பெயர்கள் camelCase ஐப் பயன்படுத்துகின்றன
- நிலையானவை ALL_CAPS ஐப் பயன்படுத்துகின்றன
5. சார்புகளை நிர்வகிக்கவும் மற்றும் நகல்களைத் தவிர்க்கவும்
நகல்தான் மென்பொருளில் அனைத்து தீமைகளின் மூலமாக இருக்கலாம்.
நகல்களை நீக்கவும். நகலான குறியீடு ஒரு அப்ஸ்ட்ராக்ஷனுக்கான தவறான வாய்ப்பு ஆகிறது. நீங்கள் நகல்களைப் பார்க்கும் போது, பொதுவான குறியீட்டை மீண்டும் பயன்படுத்தக்கூடிய செயல்பாடு அல்லது வகுப்பில் எடுக்கவும். இது தரவியல் அடிப்படையில் மையமாக்குவதன் மூலம் பராமரிப்பை மேம்படுத்துகிறது மற்றும் மாறுபட்ட மாற்றங்களின் ஆபத்தை குறைக்கிறது. கவனிக்க வேண்டிய நகலின் வகைகள்:
- ஒரே மாதிரியான குறியீட்டு தொகுதிகள்
- சிறிய மாறுபாடுகளுடன் ஒத்த ஆல்காரிதங்கள்
- மீண்டும் மீண்டும் switch/case அல்லது if/else சங்கிலிகள்
சார்புகளை கவனமாக நிர்வகிக்கவும். மாட்யூல்களுக்கிடையேயான சார்புகளை குறைக்கவும். குறியீட்டை மேலும் மாடுலர் மற்றும் சோதிக்கக்கூடியதாக மாற்றுவதற்காக சார்பு ஊட்டம் மற்றும் கட்டுப்பாட்டின் மாறுபாட்டைப் பயன்படுத்தவும். சார்பு மாறுபாட்டின் கொள்கையைப் பின்பற்றவும் - அப்ஸ்ட்ராக்ஷன்களில் சார்ந்திருங்கள், குறிப்புகளில் அல்ல. இது உங்கள் குறியீட்டை மேலும் மாறுபடக்கூடியதாகவும், மாற்றுவதற்கு எளிதாகவும் ஆக்குகிறது.
குறைந்த அறிவு கொள்கையைப் பயன்படுத்தவும். ஒரு மாட்யூல், அது கையாளும் பொருட்களின் உள்ளடக்கங்களைப் பற்றி அறியக்கூடாது. இது மாட்யூல்களுக்கிடையேயான சார்புகளை குறைக்கிறது. எடுத்துக்காட்டாக, டெமெட்டர் சட்டத்தைப் பயன்படுத்தவும் - ஒரு செயல்பாடு மட்டும் அழைக்க வேண்டும்:
- அதன் சொந்த பொருள்
- அளவுருக்களாகக் கொடுக்கப்பட்ட பொருட்கள்
- அது உருவாக்கும் பொருட்கள்
- அதன் நேரடி கூறு பொருட்கள்
6. பிழைகளை அழகாக கையாளுங்கள்
பிழை கையாளுதல் முக்கியம், ஆனால் இது தரவுகளை மறைக்குமானால், அது தவறு.
பிழை குறியீடுகளைப் பயன்படுத்தாமல் தவிர்க்கவும். பிழைகள் சுத்தமானவை மற்றும் உங்கள் குறியீட்டின் முக்கிய தரவுகளை குழப்புவதில்லை. இது பிழை கையாளுதலை மகிழ்ச்சியான பாதையிலிருந்து பிரிக்க அனுமதிக்கிறது. பிழைகளைப் பயன்படுத்தும் போது:
- தகவலளிக்கும் பிழை செய்திகளை உருவாக்கவும்
- பிழைகளுடன் தொடர்பு வழங்கவும்
- அழைப்பாளர்களின் தேவைகளை அடிப்படையாகக் கொண்டு பிழை வகுப்புகளை வரையறுக்கவும்
null ஐ திருப்பாதீர்கள். null ஐ திருப்புவது null pointer பிழைகளை உருவாக்குகிறது மற்றும் null சரிபார்ப்புகளால் குறியீட்டை குழப்புகிறது. அதற்குப் பதிலாக:
- பட்டியலுக்கு null ஐப் பதிலாக காலியான தொகுப்புகளைத் திருப்பவும்
- Null Object மாதிரியைப் பயன்படுத்தவும்
- ஜாவாவில் Optional அல்லது செயல்பாட்டு மொழிகளில் Maybe ஐப் பயன்படுத்தவும்
try-catch-finally உருப்படிகளை முதலில் எழுதுங்கள். பிழைகளை உருவாக்கக்கூடிய குறியீட்டை எழுதும்போது try-catch-finally உடன் தொடங்குங்கள். இது அழைப்பாளர் குறியீட்டிற்கான வரம்பு மற்றும் எதிர்பார்ப்புகளை வரையறுக்க உதவுகிறது. இது வளங்களை சரியாக நிர்வகிக்கவும், விடுவிக்கவும் உறுதி செய்கிறது, பிழை நிலைகளிலும்.
7. முழுமையான யூனிட் சோதனைகளை எழுதுங்கள்
சோதனை குறியீடு உற்பத்தி குறியீட்டுக்கேற்ப முக்கியம்.
TDD இன் மூன்று சட்டங்களைப் பின்பற்றுங்கள். சோதனை-வழிநடத்தும் மேம்பாடு (TDD) குறியீட்டு தரம் மற்றும் வடிவமைப்பை மேம்படுத்துகிறது:
- எந்த உற்பத்தி குறியீட்டை எழுதுவதற்கு முன் ஒரு தோல்வியடைந்த சோதனையை எழுதுங்கள்
- தோல்வியை நிரூபிக்க சோதனையின் அளவுக்கு மட்டும் எழுதுங்கள்
- சோதனையை கடந்து செல்ல தேவையான உற்பத்தி குறியீட்டை மட்டும் எழுதுங்கள்
சோதனைகளை சுத்தமாகவும் பராமரிக்கவும். உற்பத்தி குறியீட்டுக்கான தரக் கொள்கைகளை உங்கள் சோதனைகளுக்கும் பயன்படுத்தவும். சோதனை குறியீட்டை அடிக்கடி மீண்டும் வடிவமைத்து மேம்படுத்தவும். நன்கு அமைக்கப்பட்ட சோதனைகள் ஆவணமாகவும், உற்பத்தி குறியீட்டின் பயனற்ற மீண்டும் வடிவமைப்புக்கு உதவுகின்றன.
விரிவான சோதனை உள்ளடக்கத்திற்கான இலக்கு. எல்லா முனைகளையும், எல்லை நிலைகளையும், பிழை நிலைகளையும் உள்ளடக்கிய சோதனைகளை எழுதுங்கள் - மகிழ்ச்சியான பாதையை மட்டும் அல்ல. சோதனை உள்ளடக்கத்தில் இடைவெளிகளை அடையாளம் காண சோதனை உள்ளடக்க கருவிகளைப் பயன்படுத்தவும். 100% உள்ளடக்கம் பிழையில்லா குறியீட்டை உறுதி செய்யாது, ஆனால் மீண்டும் வடிவமைப்பில் மற்றும் மாற்றங்களில் நம்பிக்கையை வழங்குகிறது.
8. குறியீட்டை தொடர்ந்து மீண்டும் வடிவமைக்கவும்
நீங்கள் கண்டது போலவே முகாமை சுத்தமாக விட்டு விடுங்கள்.
வாய்ப்பு கிடைத்தால் மீண்டும் வடிவமைக்கவும். நீங்கள் ஒரு குறியீட்டின் மீது வேலை செய்யும் போது குறியீட்டு அமைப்பை மேம்படுத்துங்கள். Boy Scout விதியைப் பின்பற்றுங்கள்: நீங்கள் கண்டதை விட குறியீட்டை மேம்படுத்துங்கள். சிறிய, படிப்படியாக மேம்பாடுகள் காலத்திற்குப் பிறகு சேர்க்கின்றன மற்றும் குறியீட்டு சிதைவுகளைத் தடுக்கும். பொதுவான மீண்டும் வடிவமைப்பு தொழில்நுட்பங்களில் உள்ளன:
- செயல்பாடுகள் அல்லது வகுப்புகளை எடுக்குதல்
- தெளிவுக்காக மறுபெயரிடுதல்
- சிக்கலான நிலைகளை எளிதாக்குதல்
- நகல்களை நீக்குதல்
சோதனைகளுடன் பாதுகாப்பாக மீண்டும் வடிவமைக்கவும். மீண்டும் வடிவமைப்புக்கு முன் எப்போதும் ஒரு உறுதியான சோதனை தொகுப்பை வைத்திருக்கவும். சிறிய, படிப்படியாக மாற்றங்களைச் செய்யவும் மற்றும் அடிக்கடி சோதனைகளை இயக்கவும். இது உங்கள் மாற்றங்கள் ஏற்கனவே உள்ள செயல்பாட்டை உடைக்கவில்லை என்பதில் நம்பிக்கையை வழங்குகிறது. பிழைகளை அறிமுகப்படுத்தும் ஆபத்தை குறைக்க தானியங்கி மீண்டும் வடிவமைப்பு கருவிகளைப் பயன்படுத்தவும்.
மீண்டும் வடிவமைப்பை மதிப்பீடு செய்வதுடன் மதிப்பை வழங்கவும். தொடர்ந்த மீண்டும் வடிவமைப்பு முக்கியம், ஆனால் இது முன்னேற்றத்தை முடக்கக் கூடாது. முழுமையாகவும் அல்லாமல் "சரியாக போதுமானது" என்பதற்கான இலக்கை நோக்குங்கள். குறியீட்டின் மிகுந்த சிக்கலான அல்லது அடிக்கடி மாறுபடும் பகுதிகளில் மீண்டும் வடிவமைப்பை மையமாக்கவும். தொடர்ந்த குறியீட்டு மேம்பாட்டுக்கு ஆதரவு உறுதி செய்ய பங்குதாரர்களுக்கு மீண்டும் வடிவமைப்பின் மதிப்பை தொடர்பு கொள்ளுங்கள்.
9. பொருள் சார்ந்த மற்றும் செயல்பாட்டு நிரலாக்கக் கொள்கைகளைப் பயன்படுத்துங்கள்
பொருட்கள் தங்கள் தரவுகளை அப்ஸ்ட்ராக்ஷன்களின் பின்னால் மறைக்கின்றன மற்றும் அந்த தரவின் மீது செயல்படும் செயல்பாடுகளை வெளிப்படுத்துகின்றன. தரவுத்தொகுப்புகள் தங்கள் தரவுகளை வெளிப்படுத்துகின்றன மற்றும் பொருத்தமான செயல்பாடுகள் இல்லை.
பொருள் சார்ந்த கொள்கைகளை புத்திசாலித்தனமாகப் பயன்படுத்தவும். மாறுபட்ட, மாடுலர் வடிவமைப்புகளை உருவாக்க எண்கோள்படுத்தல், மரபு, மற்றும் பல்வகைமையைப் போன்ற கொள்கைகளைப் பயன்படுத்தவும். SOLID கொள்கைகளைப் பின்பற்றவும்:
- தனி பொறுப்புக் கொள்கை
- திறந்த-மூடிய கொள்கை
- லிஸ்கோவ் மாற்று கொள்கை
- இடைமுகப் பிரிப்பு கொள்கை
- சார்பு மாறுபாட்டுக் கொள்கை
செயல்பாட்டு நிரலாக்கக் கருத்துக்களைப் பயன்படுத்தவும். பொருள் சார்ந்த மொழிகளில் கூட, செயல்பாட்டு நிரலாக்க நுட்பங்கள் சுத்தமான குறியீட்டை உருவாக்கலாம்:
- புற விளைவுகள் இல்லாத தூய செயல்பாடுகள்
- மாற்றமில்லாத தரவுகள்
- உயர்-ஆர்டர் செயல்பாடுகள்
- செயல்பாட்டு சேர்க்கை
சிக்கலுக்கு உரிய அணுகுமுறையைத் தேர்ந்தெடுக்கவும். பொருள் சார்ந்த மற்றும் செயல்பாட்டு முறைமைகள் ஒவ்வொன்றும் பலவகைமைகள் மற்றும் பலவீனங்களை கொண்டுள்ளன. நீங்கள் நடத்தை கொண்ட சிக்கலான துறைகளை மாதிரியாக்க வேண்டும் என்றால் பொருள் சார்ந்த வடிவமைப்பைப் பயன்படுத்தவும். தரவுப் மாற்றம் மற்றும் செயலாக்க குழாய்களுக்கான செயல்பாட்டு அணுகுமுறைகளைப் பயன்படுத்தவும். பல நவீன மொழிகள் ஒரு கலவையான அணுகுமுறையை ஆதரிக்கின்றன, இது உங்கள் அமைப்பின் ஒவ்வொரு பகுதிக்கும் சிறந்த கருவியைப் பயன்படுத்த அனுமதிக்கிறது.
10. ஒருங்கிணைப்பை கவனமாகக் கருத்தில் கொள்ளுங்கள்
ஒருங்கிணைப்பு ஒரு பிரிவாக்க உத்தியாகும். இது எப்போது செய்யப்படுகிறதோ அதிலிருந்து செய்யப்படுகிறதைக் கையாள உதவுகிறது.
ஒருங்கிணைப்பின் சவால்களைப் புரிந்துகொள்ளுங்கள். ஒருங்கிண
கடைசியாக புதுப்பிக்கப்பட்டது:
FAQ
What's "Clean Code: A Handbook of Agile Software Craftsmanship" about?
- Focus on Clean Code: "Clean Code" by Robert C. Martin emphasizes writing code that is easy to read, understand, and maintain.
- Professionalism in Coding: It argues that clean code is a hallmark of professionalism in software development.
- Practical Advice: The book provides guidelines, examples, and case studies to help developers write clean and efficient code.
Why should I read "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Improve Coding Skills: It teaches how to write code that is clean, efficient, and maintainable.
- Learn from Experts: Part of the Robert C. Martin series, known for its technical and pragmatic approach.
- Long-term Benefits: Writing clean code reduces maintenance costs and makes you a more valuable developer.
What are the key takeaways of "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Code Readability: Emphasizes that code should be easy to read and understand.
- Single Responsibility Principle: Advocates for each class or function to have one reason to change.
- Continuous Improvement: Encourages developers to continuously improve their code, following the Boy Scout Rule.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" define clean code?
- Elegance and Efficiency: Clean code is described as elegant and efficient, with minimal dependencies.
- Readable and Maintainable: It should read like well-written prose, making the designer's intent clear.
- Focused and Single-minded: Each function, class, and module should have a single, clear purpose.
What is the Single Responsibility Principle in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- One Reason to Change: A class or module should have one, and only one, reason to change.
- Improves Cohesion: Ensures that classes are cohesive, with closely related methods and variables.
- Facilitates Maintenance: Makes the code easier to maintain and extend, reducing the impact of changes.
What is the "Boy Scout Rule" mentioned in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Continuous Improvement: Suggests leaving the codebase cleaner than you found it.
- Small, Incremental Changes: Encourages making small improvements, like renaming variables or breaking up functions.
- Professional Responsibility: Presented as a professional responsibility to ensure maintainability.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" approach Test-Driven Development (TDD)?
- Fundamental Discipline: TDD is crucial for writing clean, reliable code.
- Three Laws of TDD: Write a failing test first, write code to pass the test, then refactor.
- Benefits: Helps catch bugs early and improves code design.
What are "code smells" according to "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Definition: Indicators of potential problems that hinder readability or maintainability.
- Examples: Long methods, large classes, and duplicated code.
- Addressing Smells: Provides heuristics and refactoring techniques to improve code quality.
How does "Clean Code: A Handbook of Agile Software Craftsmanship" suggest handling exceptions?
- Prefer Exceptions: Use exceptions instead of error codes for better context and management.
- Provide Context: Include meaningful messages and context when throwing exceptions.
- Avoid Checked Exceptions: Suggests using unchecked exceptions for cleaner code.
What role do unit tests play in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Ensure Code Quality: Unit tests ensure code works as intended and remains maintainable.
- Test-Driven Development: Advocates writing tests before production code.
- Clean and Readable Tests: Tests should be as clean and readable as production code.
What is the role of refactoring in "Clean Code: A Handbook of Agile Software Craftsmanship"?
- Continuous Improvement: Refactoring improves code structure and readability without changing functionality.
- Techniques: Provides techniques like Extract Method and Rename Variable to enhance code quality.
- Fearless Refactoring: With comprehensive tests, developers can refactor confidently.
What are the best quotes from "Clean Code: A Handbook of Agile Software Craftsmanship" and what do they mean?
- "Clean code does one thing well." Emphasizes focus and clarity in code.
- "Leave the campground cleaner than you found it." Encourages continuous improvement of the codebase.
- "You know you are working on clean code when each routine you read turns out to be pretty much what you expected." Highlights the importance of readability and predictability.
விமர்சனங்கள்
கிளீன் கோட் என்பது வாசகர்களால் வாசிக்க எளிதான, பராமரிக்க எளிதான குறியீடு எழுதுவதற்கான அதன் கொள்கைகளுக்காக பெரும்பாலும் நேர்மறை விமர்சனங்களைப் பெறுகிறது. பெயர்கள், செயல்பாடுகள் மற்றும் சோதனை ஆகியவற்றில் நடைமுறை ஆலோசனைகளை வாசகர்கள் பாராட்டுகிறார்கள். புத்தகத்தின் ஜாவா மையம் மற்றும் சில கடுமையான வழிகாட்டுதல்கள் பொதுவான விமர்சனங்கள் ஆகும். பலர் இதனை வளர்ச்சியாளர்களுக்கான அடிப்படையான வாசிப்பு எனக் கருதுகிறார்கள், ஆனால் சிலர் அனுபவமிக்க நிரலாளர்களுக்குப் பெரிதும் பயனுள்ளதாகக் காணவில்லை. வழக்கு ஆய்வுகள் மற்றும் மறுசீரமைப்பு எடுத்துக்காட்டுகள் சிலரால் பாராட்டப்படுகின்றன, ஆனால் மற்றவர்கள் இதனை அதிகமாகச் செய்ததாக விமர்சிக்கிறார்கள். மொத்தத்தில், விமர்சகர்கள் இந்த புத்தகம் குறியீட்டு தரத்திற்கான மதிப்புமிக்க உள்ளடக்கங்களை வழங்குகிறது என ஒத்துக்கொள்கிறார்கள், அனைத்து ஆலோசனைகளும் பொதுவாகப் பயன்படுத்தக்கூடியவை அல்ல என்றாலும்.
Similar Books
