Legacy refactor: पहले रैम्बो मोड ऑन करो

IDE से पहले लाल बंदाना

तुम्हें ऐसा legacy मिलता है जो सोवियत ट्रक जितना भरा हुआ है। लालच है सब समझने का, फिर छूने का। गलत चाल। पहले रैम्बो मोड ऑन करो:

• जो पड़ा है, फेंक दो: मरी हुई features, अनपढ़े flags, भूली हुई libs. किसी को काम नहीं? सिर्फ बोझ।
• अजीब helpers हटाओ: एक util जो 2018 में एक मैन्युअल टेस्ट के लिए चला था? बाहर।
• ज़ॉम्बी routes काटो: बिना metric या log वाला endpoint संदिग्ध है। काटो और देखो कौन चिल्लाता है।

बुरा से बुरा, Git से सब वापस मिल जाता है। पुरातत्व बाद में।

पहले purge, बाद में समझ

पेरिमिटर जितना छोटा, दिमाग उतना हल्का। scope घटाते ही दिख जाता है सच में क्या चल रहा है:

1. Calls ट्रेस करो: rg या depcruise तुरंत बताएंगे dependency बची भी है या नहीं। Zero hit? अनइंस्टॉल।
2. Events और jobs देखो: कोई queue जिसे कोई consume नहीं कर रहा या mute cron, ये अलार्म हैं। भूत को कैसे refactor करोगे?
3. Runtime देखो: हटाए गए modules के बिना app चलाओ। असली errors दिखेंगे, कल्पना वाले नहीं।

पुरानी libraries: रखें या फिर से लिखें?

एक ही function के लिए डायनासोर dependency? सिर्फ एक Date format करने के लिए moment.js को 2025 तक घसीटने का कॉन्ट्रैक्ट नहीं था। खुद से पूछो:

• कितनी बार call होती है? तीन जगह? दस लाइन में function लिखो, dependency घटाओ।
• Upgrade का खर्च कितना? अगर lib छह major migrations थोप रही है, शायद replace करना तेज़ है।
• Native विकल्प है? ज़्यादातर हाँ। Standard APIs 80% कवर कर देती हैं, बाकी साफ-सुथरा कोड हो जाता है।

जितना ज्यादा काटोगे, बाकी उतना पठनीय होगा। और अगर सच में कोई जरूरी हिस्सा उड़ा दिया, Git तीस सेकंड में लौटा देगा।

पहले Rambo, फिर architect

ये "धक्का-स्टाइल" हिस्सा आखिरी refactor नहीं है। ये बेस तैयार करना है:

• पेरिमिटर साफ: कम चर्बी, ज़्यादा सार।
• जोखिम कम: कम dependencies, कम bug vectors।
• अगला फेज़ तेज: असली rebuild (tests, design, decoupling) doable बनता है।

तो हाँ, लाल बंदाना बांधो और फटाफट साफ करो। उसके बाद ही ब्लूप्रिंट निकालो, आर्किटेक्चर बनाओ और बड़े लोगों की तरह कोड करो। Git यादें संभालेगा; तुम दिमाग।