మరొక రోజు నేను సీనియర్ స్థానానికి దరఖాస్తు చేస్తున్న జావాస్క్రిప్ట్ డెవలపర్‌ని ఇంటర్వ్యూ చేసాను. ఇంటర్వ్యూకి హాజరైన ఒక సహోద్యోగి, అభ్యర్థిని HTTP అభ్యర్థన చేయడానికి మరియు విఫలమైతే, అనేకసార్లు మళ్లీ ప్రయత్నించే ఫంక్షన్‌ను వ్రాయమని అభ్యర్థించారు.
అతను కోడ్‌ను నేరుగా బోర్డుపై వ్రాసాడు, కాబట్టి సుమారుగా ఏదైనా గీయడానికి సరిపోతుంది. విషయమేమిటో అతనికి బాగా అర్థమయ్యేలా చూపించి ఉంటే, మేము చాలా సంతృప్తి చెందాము. కానీ, దురదృష్టవశాత్తు, అతను విజయవంతమైన పరిష్కారాన్ని కనుగొనలేకపోయాడు. అప్పుడు మేము, ఉత్సాహంతో, పనిని కొంచెం సులభతరం చేయాలని నిర్ణయించుకున్నాము మరియు కాల్‌బ్యాక్‌లతో కూడిన ఫంక్షన్‌ను వాగ్దానాలపై నిర్మించిన ఫంక్షన్‌గా మార్చమని అడిగాము.
కానీ అయ్యో. అవును, అతను ఇంతకు ముందు అలాంటి కోడ్‌ను ఎదుర్కొన్నాడని స్పష్టమైంది. అక్కడ ప్రతిదీ ఎలా పనిచేస్తుందో అతనికి సాధారణ పరంగా తెలుసు. మనకు కావలసిందల్లా భావన యొక్క అవగాహనను ప్రదర్శించే పరిష్కారం యొక్క స్కెచ్. అయితే, అభ్యర్థి బోర్డుపై రాసిన కోడ్ పూర్తిగా అర్ధంలేనిది. జావాస్క్రిప్ట్‌లో వాగ్దానాలు ఏమిటో అతనికి చాలా అస్పష్టమైన ఆలోచన ఉంది మరియు అవి ఎందుకు అవసరమో నిజంగా వివరించలేకపోయాడు. ఒక జూనియర్ కోసం ఇది క్షమించదగినది, కానీ అతను ఇకపై సీనియర్ స్థానానికి సరిపోడు. ఈ డెవలపర్ వాగ్దానాల సంక్లిష్ట గొలుసులో బగ్‌లను ఎలా పరిష్కరించగలడు మరియు అతను సరిగ్గా ఏమి చేసాడో ఇతరులకు ఎలా వివరించగలడు?
డెవలపర్‌లు రెడీమేడ్ కోడ్ స్వీయ-స్పష్టంగా భావిస్తారు
అభివృద్ధి ప్రక్రియలో, మేము నిరంతరం పునరుత్పాదక పదార్థాలను ఎదుర్కొంటాము. మేము కోడ్ శకలాలను బదిలీ చేస్తాము, తద్వారా మేము వాటిని ప్రతిసారీ తిరిగి వ్రాయవలసిన అవసరం లేదు. తదనుగుణంగా, కీలకమైన భాగాలపై మా దృష్టిని కేంద్రీకరించడం ద్వారా, మేము పనిచేసిన పూర్తి కోడ్‌ను స్వీయ-స్పష్టంగా చూస్తాము - ప్రతిదీ సరిగ్గా పని చేస్తుందని మేము ఊహిస్తాము.
మరియు సాధారణంగా ఇది పని చేస్తుంది, కానీ విషయాలు గమ్మత్తైనప్పుడు, మెకానిక్‌లను అర్థం చేసుకోవడం వల్ల ఫలితం ఉంటుంది.
అందువల్ల, సీనియర్ డెవలపర్ స్థానం కోసం మా అభ్యర్థి వాగ్దాన వస్తువులు స్వీయ-స్పష్టంగా ఉన్నట్లు భావించారు. వేరొకరి కోడ్‌లో ఎక్కడైనా సంభవించినప్పుడు వాటిని ఎలా ఎదుర్కోవాలో అతనికి బహుశా ఆలోచన ఉండవచ్చు, కానీ అతను సాధారణ సూత్రాన్ని అర్థం చేసుకోలేదు మరియు ఇంటర్వ్యూలో దానిని పునరావృతం చేయలేడు. బహుశా అతను ఆ భాగాన్ని హృదయపూర్వకంగా జ్ఞాపకం చేసుకున్నాడు - ఇది అంత కష్టం కాదు:
return new Promise((resolve, reject) => {
functionWithCallback((err, result) => {
return err ? reject(err) : resolve(result);
});
});నేను కూడా చేసాను - మరియు మనమందరం ఏదో ఒక సమయంలో దీన్ని చేసాము. వారు కేవలం ఒక కోడ్ భాగాన్ని గుర్తుపెట్టుకున్నారు, తద్వారా వారు దానిని తమ పనిలో ఉపయోగించుకోవచ్చు, అయితే అక్కడ ప్రతిదీ ఎలా పని చేస్తుందో సాధారణ ఆలోచన మాత్రమే ఉంటుంది. డెవలపర్ నిజంగా భావనను అర్థం చేసుకుంటే, అతను ఏదైనా గుర్తుంచుకోవాల్సిన అవసరం లేదు - అతను దీన్ని ఎలా చేయాలో తెలుసు మరియు కోడ్‌లో అవసరమైన ప్రతిదాన్ని సులభంగా పునరుత్పత్తి చేస్తాడు.
మూలాలకు తిరిగి వెళ్ళు
2012లో, ఫ్రంట్-ఎండ్ ఫ్రేమ్‌వర్క్‌ల ఆధిపత్యం ఇంకా స్థాపించబడనప్పుడు, j క్వెరీ ప్రపంచాన్ని పరిపాలించింది మరియు నేను పుస్తకాన్ని చదివాను , j క్వెరీ సృష్టికర్త జాన్ రెసిగ్ రచించారు.
ఈ పుస్తకం పాఠకులకు మొదటి నుండి వారి స్వంత j క్వెరీని ఎలా సృష్టించాలో నేర్పుతుంది మరియు లైబ్రరీ యొక్క సృష్టికి దారితీసిన ఆలోచనా ప్రక్రియపై ఒక ప్రత్యేకమైన అంతర్దృష్టిని అందిస్తుంది. ఇటీవలి సంవత్సరాలలో, j క్వెరీ దాని పూర్వ ప్రజాదరణను కోల్పోయింది, కానీ నేను ఇప్పటికీ పుస్తకాన్ని బాగా సిఫార్సు చేస్తున్నాను. ఇవన్నీ నేనే ఆలోచించి ఉండగలనన్న పట్టుదల ఆమెలో నాకు బాగా కలచివేసింది. రచయిత వివరించిన దశలు చాలా తార్కికంగా అనిపించాయి, చాలా స్పష్టంగా అనిపించింది, నేను ఇప్పుడే j క్వెరీని సులభంగా సృష్టించగలనని నేను తీవ్రంగా ఆలోచించడం ప్రారంభించాను.
వాస్తవానికి, వాస్తవానికి నేను అలాంటిదేమీ చేయలేను - ఇది భరించలేని కష్టం అని నేను నిర్ణయించుకున్నాను. నా స్వంత పరిష్కారాలు పని చేయడానికి చాలా సరళంగా మరియు అమాయకంగా కనిపిస్తాయి మరియు నేను వదులుకుంటాను. నేను j క్వెరీని స్వీయ-స్పష్టమైన విషయాలుగా వర్గీకరిస్తాను, సరైన ఆపరేషన్‌లో మీరు గుడ్డిగా నమ్మాలి. తదనంతరం, నేను ఈ లైబ్రరీ యొక్క మెకానిక్‌లను పరిశోధించడానికి సమయాన్ని వృథా చేయను, కానీ దానిని ఒక రకమైన బ్లాక్ బాక్స్‌గా ఉపయోగిస్తాను.
కానీ ఈ పుస్తకం చదవడం నన్ను వేరే వ్యక్తిని చేసింది. నేను సోర్స్ కోడ్‌ను చదవడం ప్రారంభించాను మరియు అనేక పరిష్కారాల అమలు నిజానికి చాలా పారదర్శకంగా, స్పష్టంగా ఉందని కనుగొన్నాను. లేదు, వాస్తవానికి, ఇలాంటి వాటి గురించి మీ స్వంతంగా ఆలోచించడం వేరే కథ. కానీ ఇది ఇతరుల కోడ్‌ను అధ్యయనం చేయడం మరియు ఇప్పటికే ఉన్న పరిష్కారాలను పునరుత్పత్తి చేయడం ద్వారా మన స్వంతదానితో ముందుకు రావడంలో మాకు సహాయపడుతుంది.
మీరు పొందే ప్రేరణ మరియు మీరు గమనించడం ప్రారంభించిన నమూనాలు మిమ్మల్ని డెవలపర్‌గా మారుస్తాయి. మీరు నిరంతరం ఉపయోగించే మరియు మీరు మాయా కళాఖండంగా భావించే అలవాటు ఉన్న అద్భుతమైన లైబ్రరీ మ్యాజిక్‌పై అస్సలు పని చేయదని మీరు కనుగొంటారు, కానీ సమస్యను సరళంగా మరియు వనరులతో పరిష్కరిస్తుంది.
కొన్నిసార్లు మీరు కోడ్‌ను దశలవారీగా విశ్లేషించాల్సి ఉంటుంది, కానీ ఈ విధంగా, చిన్న, స్థిరమైన దశల్లో కదులుతూ, మీరు పరిష్కారానికి రచయిత యొక్క మార్గాన్ని పునరావృతం చేయవచ్చు. ఇది కోడింగ్ ప్రక్రియలో లోతుగా డైవ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది మరియు మీ స్వంత పరిష్కారాలతో ముందుకు రావడంలో మీకు మరింత విశ్వాసాన్ని ఇస్తుంది.
నేను మొదట వాగ్దానాలతో పనిచేయడం ప్రారంభించినప్పుడు, అది నాకు స్వచ్ఛమైన మాయాజాలంగా అనిపించింది. అవి అదే కాల్‌బ్యాక్‌లపై ఆధారపడి ఉన్నాయని నేను కనుగొన్నాను మరియు నా ప్రోగ్రామింగ్ ప్రపంచం తలకిందులైంది. కాబట్టి కాల్‌బ్యాక్‌ల నుండి మనలను రక్షించడం యొక్క నమూనా, దాని ఉద్దేశ్యం, కాల్‌బ్యాక్‌లను ఉపయోగించి అమలు చేయబడుతుందా?!
ఈ విషయాన్ని విభిన్న కళ్లతో చూడడానికి మరియు ఇది నా ముందు ఉన్న కోడ్ యొక్క కొంత భాగం కాదని గ్రహించడంలో నాకు సహాయపడింది, ఇది నా జీవితంలో నేను ఎప్పటికీ అర్థం చేసుకోలేని నిషేధిత సంక్లిష్టత. ఇవి సరైన ఉత్సుకత మరియు లోతైన ఇమ్మర్షన్‌తో సమస్యలు లేకుండా అర్థం చేసుకోగల నమూనాలు. ఈ విధంగా వ్యక్తులు కోడ్ చేయడం మరియు డెవలపర్‌లుగా ఎదగడం నేర్చుకుంటారు.
ఈ చక్రాన్ని తిరిగి ఆవిష్కరించండి
కాబట్టి ముందుకు సాగండి మరియు చక్రాలను తిరిగి ఆవిష్కరించండి: మీ స్వంత డేటా బైండింగ్ కోడ్‌ను వ్రాయండి, స్వదేశీ వాగ్దానాన్ని సృష్టించండి లేదా మీ స్వంత రాష్ట్ర నిర్వహణ పరిష్కారాన్ని కూడా చేయండి.
వీటన్నింటిని ఎవరూ ఉపయోగించరు - కానీ ఇప్పుడు దీన్ని ఎలా చేయాలో మీకు తెలుసు. మరియు మీ స్వంత ప్రాజెక్ట్‌లలో అటువంటి అభివృద్ధిని ఉపయోగించుకునే అవకాశం మీకు ఉంటే, అది సాధారణంగా గొప్పది. మీరు వాటిని అభివృద్ధి చేయగలరు మరియు ఇంకేదైనా నేర్చుకోగలరు.
ఇక్కడ పాయింట్ మీ కోడ్‌ను ఉత్పత్తికి పంపడం కాదు, కొత్తది నేర్చుకోవడం. ఇప్పటికే ఉన్న పరిష్కారం యొక్క మీ స్వంత అమలును వ్రాయడం అనేది ఉత్తమ ప్రోగ్రామర్‌ల నుండి నేర్చుకోవడానికి మరియు తద్వారా మీ నైపుణ్యాలను మెరుగుపర్చడానికి ఒక గొప్ప మార్గం.
మూలం: www.habr.com