Dead Code Finder: Static Analysis యొక్క కఠినమైన వాస్తవం

నేను ఒక హ్యాకథాన్ కోసం డెడ్ కోడ్‌ను (dead code) కనుగొనడానికి ఒక టూల్‌ను రూపొందించాను. దీని లక్ష్యం చాలా సరళమైనది. ఏదీ పిలవని (call చేయని) కోడ్‌ను కనుగొనడం.

కోడ్‌ను తొలగిస్తే ఏమి విచ్ఛిన్నమవుతుందో తెలుసుకోవడం నా ఉద్దేశ్యం కాదు. ఏదైనా నిర్దిష్ట కోడ్ భాగాన్ని అసలు ఎవరైనా పిలుస్తున్నారా లేదా అని తెలుసుకోవడమే నా లక్ష్యం.

నేను దీనికి Dead Code Finder అని పేరు పెట్టాను. ఇది కాల్స్ (calls) మరియు ఇంపోర్ట్స్ (imports) కోసం ఒక knowledge graph ను ఉపయోగిస్తుంది. ఇది ప్రతి ఫలితాన్ని మూడు వర్గాలుగా విభజిస్తుంది:

• Confident: సున్నా ఇన్‌కమింగ్ ఎడ్జెస్ (zero incoming edges) మరియు ఎంట్రీ పాయింట్ కాదు. • Uncertain: ఇన్హెరిటెన్స్ (inheritance) వంటి సందర్భాలలో static analysis సరిపోదు. • Skipped: డెకరేటర్లు (decorators) లేదా టెస్ట్ ఫ్రేమ్‌వర్క్‌ల వంటి టూల్ పరిష్కరించలేని అంశాలు.

నేను ఒక కఠినమైన నియమాన్ని పాటించాను. కోడ్‌ను తొలగించడం సురక్షితం అని ఎప్పుడూ చెప్పకూడదు. గ్రాఫ్‌లో ఎటువంటి రిఫరెన్స్ దొరకలేదని మాత్రమే రిపోర్ట్ చెబుతుంది.

ఈ ప్రాజెక్ట్ నేను ఊహించిన దానికంటే కష్టంగా ఉంది. ప్లాట్‌ఫామ్‌తో నేను రెండు ప్రధాన సమస్యలను ఎదుర్కొన్నాను:

  1. Missing Tools: కాన్ఫిగ్‌రేషన్‌లో ఉన్నప్పటికీ, రన్‌టైమ్ సమయంలో గ్రాఫ్ టూల్స్ అందుబాటులో లేవు.
  2. Unreliable Injection: ఏజెంట్ కోసం పూర్తి లాజిక్‌ను అందించడంలో సిస్టమ్ కొన్నిసార్లు విఫలమైంది.

నేను దీనిని ఒక fallback mode నిర్మించడం ద్వారా పరిష్కరించాను. గ్రాఫ్ టూల్స్ లేనట్లయితే, టూల్ రిపోజిటరీలోని అసలు ఫైళ్లను చదువుతుంది. రిఫరెన్స్‌లను కనుగొనడానికి ఇది ఫైల్ సెర్చ్‌లను ఉపయోగిస్తుంది. ఒకవేళ ఇది ఈ పద్ధతిని ఉపయోగిస్తే, ఫలితాలను inferred అని గుర్తిస్తుంది.

నేను కొన్ని నిర్దిష్ట సందర్భాలలో లాజిక్ లోపాలను కూడా సరిదిద్దాల్సి వచ్చింది:

  • Dunder methods: __init__ వంటి మెథడ్స్ తరచుగా సున్నా ఇన్‌కమింగ్ ఎడ్జెస్‌ను చూపుతాయి, ఎందుకంటే గ్రాఫ్ కాల్‌ను మెథడ్‌కు బదులుగా క్లాస్‌కు లింక్ చేస్తుంది. నేను ఎన్‌క్లోజింగ్ క్లాస్‌ను (enclosing class) తనిఖీ చేయడం ద్వారా దీనిని సరిదిద్దాను.
  • Decorators: డిక్షనరీలో స్ట్రింగ్ లుకప్‌ల ద్వారా పిలవబడే ఫంక్షన్లు static graph కు డెడ్ కోడ్‌లా కనిపిస్తాయి. నేను వీటిని Skipped బకెట్‌లోకి మార్చాను.
  • Tests: టెస్ట్ ఫ్రేమ్‌వర్క్‌లు reflection ద్వారా మెథడ్స్‌ను కనుగొంటాయి. ఇవి కూడా Skipped బకెట్‌లోకి వెళ్తాయి.

ఫలితాలు నమ్మదగినవిగా ఉన్నాయి. నా fallback mode డెడ్ కోడ్‌ను సరిగ్గా గుర్తించింది మరియు నిజమైన గ్రాఫ్ డేటాతో సరిపోలింది. ఇది ఇన్హెరిటెన్స్ వంటి అనిశ్చిత సందర్భాలను కూడా సరిగ్గా లేబుల్ చేసింది.

నేర్చుకున్న పాఠాలు:

  • వాటిపై ఆధారపడే లాజిక్‌ను వ్రాయడానికి ముందు అందుబాటులో ఉన్న టూల్స్‌ను ధృవీకరించుకోండి.
  • "నాకు తెలియదు" అని చెప్పే రిపోర్ట్, నమ్మకంగా తప్పు చెప్పే రిపోర్ట్ కంటే మెరుగైనది.
  • అనిశ్చితిని (uncertainty) లేబుల్ చేయడం వల్ల మీ ఖచ్చితమైన (confident) ఫలితాలపై చర్య తీసుకోవడం విలువైనదిగా మారుతుంది.

Source: https://dev.to/hereforlolz/dead-code-finder-gitlab-orbit-based-static-analysis-that-turned-out-to-be-harder-than-expected-4jgk

Optional learning community: https://t.me/GyaanSetuAi