అత్యుత్తమ కోడ్ లైన్ అంటే మీరు అసలు రాయని లైన్. వేరొకరి ఉత్సాహాన్ని (enthusiasm) కొన్ని సంవత్సరాల పాటు నిర్వహించాల్సి వచ్చినప్పుడు, ఈ ఆలోచన సోమరితనానికి ఒక సాకులా అనిపించవచ్చు. సాఫ్ట్వేర్ రాయడం అనేది నిర్మాణం (construction) లాగా అనిపించినప్పటికీ, అది తోటపని (gardening) లాగా పనిచేస్తుంది. వదిలేస్తే, తోట మీకు కావాలన్నా కాకపోయినా పెరుగుతుంది. కోడ్ కూడా అలాగే చేస్తుంది. ఎప్పుడు ఆపాలి అని తెలుసుకోవడమే అసలైన నైపుణ్యం.
మీ కోడ్ ఒక బాధ్యత (Liability)
మీరు కమిట్ చేసే ప్రతి లైన్ కొన్ని నిరంతర బాధ్యతలను సృష్టిస్తుంది. అర్థరాత్రి ఏదైనా ఇన్సిడెంట్ (incident) వచ్చినప్పుడు మీరు దానిని మళ్ళీ చదువుతారు. స్ట్రింగ్ హ్యాండ్లింగ్ను మార్చేలా మీ ఫ్రేమ్వర్క్ ఒక మైనర్ వెర్షన్ అప్డేట్ ఇచ్చినప్పుడు మీరు దానిని టెస్ట్ చేస్తారు. ప్రొడక్షన్ నుండి వచ్చే లాగ్స్ అర్థం కానప్పుడు మీరు దానిని డీబగ్ చేస్తారు. గత వారం చేరిన మీ సహోద్యోగికి లేదా పన్నెండు నెలల తర్వాత ఆ సందర్భం (context) మర్చిపోయిన మీకు మీరు దానిని వివరించాల్సి ఉంటుంది.
ఇది అస్పష్టత (obscurity) కోసం చేసే వాదన కాదు. ఇది జ్యామితి (geometry). బగ్స్ దాక్కోవడానికి స్థలం కావాలి. మీ కోడ్ పరిధి (surface area) ఎంత తక్కువగా ఉంటే, వైఫల్యాలు (failure) అంత తక్కువ చోట్ల దాక్కుంటాయి. ఎనభై లైన్ల ఫంక్షన్ మరియు ఆరు నెస్టెడ్ కండిషన్స్ ఉండటం వల్ల అది చదవడానికి కష్టంగా ఉండటమే కాదు; అది మీకు ఆశ్చర్యకరమైన సమస్యలను ఇచ్చే అవకాశం గణాంకపరంగా (statistically) ఎక్కువగా ఉంటుంది. సంయమనం (Restraint) అంటే ప్రయత్నం లేకపోవడం కాదు. రాయని కోడ్లో లోపాలు (defects) సున్నా అని గుర్తించడమే అది.
తెలివితేటలు ఒక పన్నులా మారినప్పుడు
కొన్ని బిజినెస్ రూల్స్తో ఆర్డర్ టోటల్ను లెక్కించే పనిని తీసుకోండి: డిస్కౌంట్ అప్లై చేయడం, టాక్సబుల్ ఐటమ్స్ను తనిఖీ చేయడం, తొలగించిన వాటిని వదిలేయడం. ఒక డెవలపర్ ఒకే ఎక్స్ప్రెషన్ను రాస్తాడు. అది ఒక కాంప్లెక్స్ ఫిల్టర్ చైన్ ద్వారా లిస్ట్ను స్ట్రీమ్ చేస్తుంది, ఒక హెల్పర్ లైబ్రరీని పిలుస్తుంది, కర్రీడ్ రిడ్యూసర్తో ఫలితాన్ని ఫోల్డ్ చేస్తుంది మరియు మొత్తాన్ని తిరిగి ఇస్తుంది. ఇది కాంపాక్ట్గా ఉంటుంది. విద్యాపరమైన కోణంలో ఇది ఎలిగెంట్గా కూడా ఉండవచ్చు. కానీ దానిని చదవాలంటే, మీరు హెల్పర్ లైబ్రరీ యొక్క ఇంప్లిసిట్ కాస్టింగ్, స్ట్రీమ్లోని ఆపరేషన్ల క్రమం మరియు బిజినెస్ లాజిక్ అన్నింటినీ ఒకే సమయంలో అర్థం చేసుకోవాలి. మీరు మధ్యలో బ్రేక్పాయింట్ (breakpoint) పెట్టలేరు. చైన్ను విరగ్గొట్టకుండా మీరు లాగ్ స్టేట్మెంట్ను జోడించలేరు. ఆ కోడ్ పేజీలో తక్కువగా కనిపిస్తుంది కానీ మెదడుపై భారం ఎక్కువగా పెంచుతుంది.
మరొక డెవలపర్ ఒక సాధారణ లూప్ను రాస్తుంది. ఆమె ఒక రన్నింగ్ టోటల్ను డిక్లేర్ చేస్తుంది, ఐటమ్స్ ద్వారా ఇటరేట్ చేస్తుంది మరియు టాక్స్ వర్తిస్తుందో లేదో నిర్ణయించడానికి ఒక సాధారణ if స్టేట్మెంట్ను ఉపయోగిస్తుంది. ఈ బ్లాక్ నిలువుగా పెద్దదిగా ఉన్నప్పటికీ, దాని ఉద్దేశ్యం (intent) స్పష్టంగా ఉంటుంది. ఐదు అబ్స్ట్రాక్షన్స్ (abstractions) మెదడులో ఉంచుకోకుండానే మీరు దానిని పై నుండి కింద వరకు చదవగలరు. మీరు డీబగ్గర్లో దానిని స్టెప్ బై స్టెప్ చూడగలరు. మొత్తం ఎక్స్ప్రెషన్ను రీఫ్యాక్టర్ చేయకుండానే మీరు నాలుగవ లైన్లో లాగింగ్ను జోడించగలరు.
తెలివైన కోడ్ (Clever code) పుల్ రిక్వెస్ట్లో (pull request) పది నిమిషాల పాటు స్మార్ట్గా కనిపిస్తుంది. సింపుల్ కోడ్ బోరింగ్గా కనిపిస్తుంది, కానీ తెల్లవారుజామున రెండు గంటల సమయంలో సమస్యలను పరిష్కరించేటప్పుడు (troubleshooting) మీకు కావాల్సింది కూడా అదే బోరింగ్ కోడ్. మీ లక్ష్యం స్పష్టత (clarity), తెలివితేటల ప్రదర్శన కాదు.
సిస్టమ్స్కు నిర్మాణం కావాలి, హీరోలు కాదు
ఈ సూత్రం ఆర్కిటెక్చర్కు కూడా వర్తిస్తుంది. ఒక తెలివైన సిస్టమ్ హ్యాండ్రైటెన్ కన్సెన్సస్ లాజిక్, ప్రత్యేకమైన ఆర్కెస్ట్రేషన్ స్క్రిప్ట్లు మరియు కేవలం ఒక ఇంజనీర్కు మాత్రమే తెలిసిన డాక్యుమెంట్ చేయని క్యాషింగ్ షార్ట్కట్లపై ఆధారపడవచ్చు. ఆ సిస్టమ్ తనంతట తానుగా నడవదు; దానిని పట్టుకుని ఉంచే వ్యక్తి యొక్క నిరంతర ప్రతిభపై నడుస్తుంది. ఆ వ్యక్తి సెలవు తీసుకున్నా లేదా కొత్త ఉద్యోగంలో చేరినా, సిస్టమ్ అస్థిరంగా మారుతుంది.
బాగా డిజైన్ చేయబడిన సిస్టమ్స్ దానికి బదులుగా నిర్మాణం మరియు పరిమితులపై (constraints) ఆధారపడతాయి. అవి తప్పుడు డేటాను తిరస్కరించే డేటాబేస్ స్కీమాలు, సరిహద్దులను నిర్వచించే API కాంట్రాక్టులు, డిప్లాయ్మెంట్కు ముందే కేటగిరీ ఎర్రర్లను పట్టుకునే టైప్ సిస్టమ్స్ మరియు ఉద్దేశించిన మార్గాన్ని స్పష్టంగా చూపే మాడ్యూల్ సెపరేషన్లను ఉపయోగిస్తాయి. అవి స్థిరంగా ఉండటానికి హీరోల అవసరం లేదు. అవి అలసిపోయిన మనుషుల (tired humans) తో కూడా పనిచేసేలా రూపొందించబడ్డాయి, ఎందుకంటే ప్రొడక్షన్లో సాఫ్ట్వేర్ను నడిపేది కూడా అలాంటి మనుషులే.
AI విస్తరణ సమస్య (The AI Amplification Problem)
ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ కోడింగ్ అసిస్టెంట్లు ఈ పాఠాన్ని మరింత అత్యవసరంగా మార్చాయి. ఈ టూల్స్ టెక్స్ట్ను వేగంగా ఉత్పత్తి చేస్తాయి. మీరు ఒక సాధారణ సమస్యను ఇస్తే, అవి తరచుగా మీ దగ్గర ఇప్పటికే ఉన్న యుటిలిటీలను ఇంపోర్ట్ చేస్తూ, మీ డొమైన్లో లేని ఎడ్జ్ కేస్లను (edge cases) హ్యాండిల్ చేస్తూ, మీరు రెండు సంవత్సరాల క్రితమే వదిలేసిన ఫ్రేమ్వర్క్ వెర్షన్ యొక్క ఇడియమ్స్ను (idioms) ఉపయోగిస్తూ ఒక పెద్ద, సంక్లిష్టమైన పరిష్కారాన్ని ఇస్తాయి. AI తక్షణ పనిని మాత్రమే చూస్తుంది. మీరు మొత్తం సిస్టమ్ను చూడాలి.
దీర్ఘకాలిక వ్యయాన్ని పరిగణనలోకి తీసుకోకుండా ప్రతి సూచనను అంగీకరిస్తే, కోడ్ జనరేషన్ వల్ల కోడ్ అనవసరంగా పెరిగిపోతుంది. మీ రిపోజిటరీ కంపైల్ అయ్యే, టెస్ట్లను పాస్ అయ్యే, చూడటానికి బాగుండే కోడ్తో నిండిపోతుంది, కానీ దానిని ఎవరూ నిజంగా అర్థం చేసుకోలేరు. ప్రమాదం అనేది స్పష్టంగా కనిపించే సింటాక్స్ ఎర్రర్లో లేదు. అవి రివ్యూలో దొరికిపోతాయి. ప్రమాదం ఏమిటంటే కోడ్బేస్ క్రమంగా మందపాటిగా మారడం, అక్కడ ప్రతి ఫైల్ విడిగా చూస్తే సరిగ్గా ఉన్నట్లు అనిపిస్తుంది కానీ మొత్తం కలిపి చూస్తే ఏ ఒక్క మనిషి మెదడుకు కూడా అర్థం కాదు. ఇంజనీరింగ్ వేగం ఇలాగే చనిపోతుంది. ఒక పెద్ద ప్రమాదంతో కాదు, ఎవరికీ అర్థం కాని వాటిని తాకడానికి భయపడి, ఎవరూ తొలగించడానికి ఇష్టపడని అంశాల నిశ్శబ్దంగా పేరుకుపోవడంతో.
తొలగించడం అనేది ఒక డిజైన్ నైపుణ్యం
గొప్ప ఇంజనీర్లు అందరికంటే వేగంగా టైప్ చేయడం ద్వారా తమను తాము నిరూపించుకోరు. వారు సరళతను ఎంచుకోవడం ద్వారా మరియు పేరుకుపోవడం కంటే తొలగించడాన్ని ఎంచుకోవడం ద్వారా విజయం సాధిస్తారు. కోడ్ను తొలగించాలంటే దానిని అర్థం చేసుకోవాలి. మీరు డేటా ఫ్లోను ట్రాస్ చేయాలి, ఆ ఫీచర్ను ఎక్కడా వాడటం లేదని నిర్ధారించుకోవాలి మరియు వ్యాపార అవసరాలకు అది ఇక అవసరం లేదని సరిచూసుకోవాలి. కోడ్ను జోడించడం కంటే తొలగించడం కష్టం, ఎందుకంటే దానికి ఖచ్చితత్వం అవసరం.
టీమ్లు తరచుగా షీప్ చేసిన ఫీచర్లను మరియు భారీ పుల్ రిక్వెస్ట్లను పంపే వారిని వేడుకగా కొనియాడుతుంటాయి. కానీ నాలుగు వేల లైన్ల డెడ్ లాజిక్ను తొలగించి, సిస్టమ్ను వేగంగా మరియు సులభంగా అర్థమయ్యేలా చేసే ఇంజనీర్ను కొనియాడే టీమ్లు చాలా తక్కువ. అయితే, ఆ నెగటివ్ లైన్ కౌంట్ సంస్థ యొక్క భవిష్యత్తుకు గొప్ప సేవగా మారుతుంది.
ఖరీదైన భాగం
ఇప్పుడు కోడ్ చౌకగా దొరుకుతుంది. ఎవరైనా సెకన్లలో పేజీల కొద్దీ కోడ్ను జనరేట్ చేయవచ్చు. ఖరీదైన వనరు ఏమిటంటే స్పష్టత. ఒక సిస్టమ్ను అర్థమయ్యేలా ఉంచడానికి సమయం, విచక్షణ మరియు నిగ్రహం అవసరం. నిజమైన ఇంజనీరింగ్ అనేది డ్రాఫ్టింగ్ లో కాదు, ఎడిటింగ్లో జరుగుతుంది.
తక్కువ రాయండి. ఎక్కువ తొలగించండి. సరళంగా డిజైన్ చేయండి.