అనువాదకుని ముందుమాట: ఈ కథనాన్ని చదివిన తర్వాత, మీరు ఆశ్చర్యపోవచ్చు లేదా కోపంగా ఉండవచ్చు. అవును, మేము కూడా ఆశ్చర్యపోయాము: "త్వరగా మరియు తార్కికం లేకుండా చేయండి" అనే స్థితితో టాస్క్‌లను సెట్ చేయడం గురించి, జట్టులోని సోపానక్రమం గురించి రచయిత ఎప్పుడూ వినలేదు. అవును, నిజమే, ఇది కొంచెం వింత వచనం. నిజమే, ప్రోగ్రామర్ సిస్టమ్ ఆర్కిటెక్ట్ పాత్రను పోషించాలని రచయిత సూచిస్తున్నారు - అప్పుడు మీకు ఆర్కిటెక్ట్ ఎందుకు అవసరం? కానీ ఈ అభ్యంతరాలన్నీ మీకు ప్రధాన విషయానికి గుడ్డిగా ఉండకూడదు - అయినప్పటికీ మేము ఈ వచనాన్ని ఎందుకు తీసుకొని అనువదించాము. అతను పాత్రల గురించి మాట్లాడడు. ఈ వచనం వృత్తిపరమైన విధానం మరియు అవగాహన గురించి. నిజం ఏమిటంటే, మీరు మీ చర్యల అర్థం గురించి ఆలోచించకుండా "మీకు చెప్పినట్లు చేసినంత కాలం", మీరు ఎప్పటికీ గొప్ప ప్రోగ్రామర్ కాలేరు.
అనవసరమైన కోడ్‌కు నో చెప్పండి. మీరు చేయాల్సిందల్లా మూడక్షరాలు కలిపి పదం చెప్పడం. దీన్ని కలిసి చేయడానికి ప్రయత్నిద్దాం: "Nooooo!"
అయితే వేచి ఉండండి. ఎందుకు ఇలా చేస్తున్నాం? అన్నింటికంటే, ప్రోగ్రామర్ యొక్క ప్రధాన పని కోడ్ రాయడం. అయితే మీరు అడిగిన ఏదైనా కోడ్ రాయాల్సిన అవసరం ఉందా? లేదు! "కోడ్ ఎప్పుడు వ్రాయకూడదో అర్థం చేసుకోవడం బహుశా ప్రోగ్రామర్‌కు అత్యంత ముఖ్యమైన నైపుణ్యం." .
మేము గుర్తు చేస్తున్నాము: Habr పాఠకులందరికీ - Habr ప్రోమో కోడ్‌ని ఉపయోగించి ఏదైనా Skillbox కోర్సులో నమోదు చేసుకున్నప్పుడు 10 రూబుల్ తగ్గింపు.
Skillbox సిఫార్సు చేస్తోంది: ప్రాక్టికల్ కోర్సు .
ప్రోగ్రామింగ్ అనేది సమస్యను పరిష్కరించే కళ. మరియు మీరు ఈ కళలో మాస్టర్స్.
కొన్నిసార్లు, వీలైనంత త్వరగా పనిని ప్రారంభించే ప్రయత్నంలో, మేము చేతిలో ఉన్న పనిని పూర్తి చేయడం తప్ప మరేమీ గురించి ఆలోచించము. మరియు ఇది మరింత తీవ్రమైన సమస్యలను కలిగిస్తుంది.
ప్రోగ్రామర్లు దేనికి కళ్ళు మూసుకుంటారు?
మీరు వ్రాసే అన్ని కోడ్ ఇతర డెవలపర్‌లకు అర్థమయ్యేలా ఉండాలి మరియు తప్పనిసరిగా పరీక్షించబడాలి మరియు డీబగ్ చేయబడాలి.
కానీ ఒక సమస్య ఉంది: మీరు ఏది వ్రాసినా, అది మీ సాఫ్ట్‌వేర్‌ను క్లిష్టతరం చేస్తుంది మరియు బహుశా భవిష్యత్తులో బగ్‌లను పరిచయం చేస్తుంది.
రిచ్ స్క్రెంట్ ప్రకారం, . అతను వ్రాసేది ఇక్కడ ఉంది:
"కోడ్ చెడ్డది ఎందుకంటే ఇది కుళ్ళిపోతుంది మరియు స్థిరమైన నిర్వహణ అవసరం. కొత్త ఫీచర్‌లను జోడించడం కోసం తరచుగా పాత కోడ్‌ని సవరించాల్సి ఉంటుంది. ఇది ఎంత పెద్దదైతే, లోపం సంభవించే అవకాశం ఎక్కువ మరియు కంపైల్ చేయడానికి ఎక్కువ సమయం పడుతుంది. దీన్ని గుర్తించడానికి మరొక డెవలపర్‌కు ఎక్కువ సమయం పడుతుంది. మరియు రీఫ్యాక్టరింగ్ అవసరమైతే, ఖచ్చితంగా మార్చడానికి విలువైన శకలాలు ఉంటాయి. పెద్ద కోడ్ అంటే తరచుగా తగ్గిన వశ్యత మరియు ప్రాజెక్ట్ యొక్క కార్యాచరణ. సంక్లిష్టమైన కోడ్ కంటే సరళమైన మరియు సొగసైన పరిష్కారం వేగంగా ఉంటుంది.
కోడ్ వ్రాయకూడదని మీకు ఎలా తెలుసు?
సమస్య ఏమిటంటే, ప్రోగ్రామర్లు తమ అప్లికేషన్‌కు అవసరమైన లక్షణాల సంఖ్యను తరచుగా అతిశయోక్తి చేస్తారు. ఫలితంగా, కోడ్‌లోని అనేక విభాగాలు అసంపూర్తిగా ఉంటాయి లేదా ఎవరూ వాటిని ఉపయోగించరు, కానీ అవి అప్లికేషన్‌ను క్లిష్టతరం చేస్తాయి.
మీ ప్రాజెక్ట్‌కి ఏది అవసరమో మరియు ఏది కాదో మీరు స్పష్టంగా అర్థం చేసుకోవాలి.
ఒక ఉదాహరణ కేవలం ఒక పనిని పరిష్కరించే అప్లికేషన్ - ఇమెయిల్ నిర్వహణ. ఈ ప్రయోజనం కోసం, రెండు విధులు ప్రవేశపెట్టబడ్డాయి - లేఖలు పంపడం మరియు స్వీకరించడం. మెయిల్ మేనేజర్ అదే సమయంలో టాస్క్ మేనేజర్‌గా మారాలని మీరు ఆశించకూడదు.
అప్లికేషన్ యొక్క ప్రధాన విధికి సంబంధం లేని లక్షణాలను జోడించడానికి మీరు ప్రతిపాదనలకు "లేదు" అని గట్టిగా చెప్పాలి. అదనపు కోడ్ అవసరం లేదని స్పష్టమయ్యే క్షణం ఇది.
మీ అప్లికేషన్ దృష్టిని ఎప్పటికీ కోల్పోకండి.
ఎల్లప్పుడూ మిమ్మల్ని మీరు ఇలా ప్రశ్నించుకోండి:
— ఇప్పుడు ఏ ఫంక్షన్ అమలు చేయాలి?
— నేను ఏ కోడ్ వ్రాయాలి?
మనసులో వచ్చే ఆలోచనలను ప్రశ్నించండి మరియు బయటి నుండి వచ్చే సూచనలను అంచనా వేయండి. లేకపోతే, అదనపు కోడ్ కేవలం ప్రాజెక్ట్‌ను నాశనం చేస్తుంది.
అనవసరమైన విషయాలను ఎప్పుడు జోడించకూడదో తెలుసుకోవడం మీ కోడ్ బేస్‌ను సంస్థ నియంత్రణలో ఉంచడంలో మీకు సహాయపడుతుంది.
మార్గం ప్రారంభంలో, ప్రోగ్రామర్ రెండు లేదా మూడు సోర్స్ ఫైల్‌లను మాత్రమే కలిగి ఉంటాడు. ఇది సులభం. అప్లికేషన్‌ను కంపైల్ చేయడం మరియు ప్రారంభించడం కోసం కనీసం సమయం అవసరం; ఎక్కడ మరియు దేని కోసం వెతకాలి అనేది ఎల్లప్పుడూ స్పష్టంగా ఉంటుంది.
అప్లికేషన్ విస్తరిస్తున్న కొద్దీ, మరిన్ని కోడ్ ఫైల్స్ కనిపిస్తాయి. వారు కేటలాగ్‌ను పూరిస్తారు, ఒక్కొక్కటి వందల కొద్దీ లైన్‌లతో ఉంటాయి. ఇవన్నీ సరిగ్గా నిర్వహించడానికి, మీరు అదనపు డైరెక్టరీలను సృష్టించాలి. అదే సమయంలో, ఏ విధులు దేనికి కారణమవుతాయో మరియు ఏ చర్యలు వాటికి కారణమవుతాయో గుర్తుంచుకోవడం చాలా కష్టంగా మారుతోంది; దోషాలను పట్టుకోవడానికి కూడా ఎక్కువ సమయం పడుతుంది. ప్రాజెక్ట్ నిర్వహణ కూడా మరింత క్లిష్టంగా మారుతోంది; ఒకటి కాదు, చాలా మంది డెవలపర్‌లు ప్రతిదానిని ట్రాక్ చేయాలి. దీని ప్రకారం, ఖర్చులు, ద్రవ్య మరియు సమయం రెండూ పెరుగుతాయి మరియు అభివృద్ధి ప్రక్రియ మందగిస్తుంది.
ప్రాజెక్ట్ చివరికి భారీగా మారుతుంది మరియు ప్రతి కొత్త ఫీచర్‌ను జోడించడం కోసం మరింత ఎక్కువ శ్రమ పడుతుంది. చాలా చిన్న విషయం కోసం కూడా మీరు చాలా గంటలు గడపవలసి ఉంటుంది. ఇప్పటికే ఉన్న లోపాలను సరిదిద్దడం వలన కొత్తవి కనిపించడానికి దారి తీస్తుంది మరియు అప్లికేషన్ విడుదల గడువులు తప్పిపోతాయి.
ఇప్పుడు ప్రాజెక్టు ప్రాణం కోసం పోరాడాలి. ఎందుకు?
వాస్తవం ఏమిటంటే, మీరు అదనపు కోడ్‌ను ఎప్పుడు జోడించకూడదో మీకు అర్థం కాలేదు మరియు ప్రతి సూచన మరియు ఆలోచనకు “అవును” అని సమాధానం ఇచ్చారు. మీరు అంధులు, కొత్త విషయాలను సృష్టించాలనే కోరిక మిమ్మల్ని ముఖ్యమైన వాస్తవాలను విస్మరించేలా చేసింది.
హర్రర్ సినిమా స్క్రిప్ట్ లాగా ఉంది, సరియైనదా?
మీరు అవుననే చెబుతూ ఉంటే సరిగ్గా ఇదే జరుగుతుంది. కోడ్‌ను ఎప్పుడు జోడించకూడదో అర్థం చేసుకోవడానికి ప్రయత్నించండి. ప్రాజెక్ట్ నుండి అనవసరమైన విషయాలను తీసివేయండి - ఇది మీ జీవితాన్ని చాలా సులభతరం చేస్తుంది మరియు అప్లికేషన్ యొక్క జీవితాన్ని పొడిగిస్తుంది.
"నేను 1000 లైన్ల కోడ్‌లను తొలగించడం నా అత్యంత ఉత్పాదకమైన రోజులలో ఒకటి."
- కెన్ థాంప్సన్.
కోడ్‌ను ఎప్పుడు వ్రాయకూడదో నేర్చుకోవడం కష్టం. కానీ అది అవసరం.
అవును, మీరు ఇప్పుడే డెవలపర్ మార్గాన్ని ప్రారంభించారని మరియు కోడ్ రాయాలనుకుంటున్నారని నాకు తెలుసు. ఇది మంచిది, ఆ మొదటి అభిప్రాయాన్ని కోల్పోకండి, కానీ ఉత్సాహం కారణంగా ముఖ్యమైన కారకాల దృష్టిని కోల్పోకండి. మేము ట్రయల్ మరియు ఎర్రర్ ద్వారా ప్రతిదీ గ్రహించాము. మీరు కూడా తప్పులు చేస్తారు మరియు వాటి నుండి నేర్చుకుంటారు. కానీ మీరు పై నుండి నేర్చుకోగలిగితే, మీ పని మరింత స్పృహలోకి వస్తుంది.
సృష్టిస్తూ ఉండండి, కానీ ఎప్పుడు నో చెప్పాలో తెలుసుకోండి.
Skillbox సిఫార్సు చేస్తోంది:
- ఆన్‌లైన్‌లో దరఖాస్తు చేసుకున్నారు .
- ఆన్‌లైన్ కోర్సు .
- ప్రాక్టికల్ ఒక సంవత్సరం కోర్సు .
మూలం: www.habr.com