कभी-कभी कोड दोहराव "दंड" का परिणाम होता है: दो चीजें समान दिखती हैं, लेकिन ऐसा नहीं है।
यह संभव है कि अति-अमूर्तता आपके सिस्टम की वास्तविक प्रतिरूपकता को तोड़ सकती है। प्रतिरूपकता के शासन के तहत, आपको यह तय करना होगा "परिवर्तन की संभावना क्या है?" और "क्या स्थिर है?"। जो कुछ भी स्थिर है वह इंटरफ़ेस में डाला जाता है, जबकि जो कुछ भी अस्थिर होता है वह मॉड्यूल के कार्यान्वयन में संलग्न हो जाता है। फिर, जब चीजें बदल जाती हैं, तो आपको जो परिवर्तन करने की आवश्यकता होती है, उस मॉड्यूल को अलग कर दिया जाता है।
जब आपको लगा कि स्थिर था, तो रिफैक्टरिंग आवश्यक है (जैसे यह एपीआई कॉल हमेशा दो तर्क लेगा) को बदलने की आवश्यकता है।
इसलिए, इन दो डुप्लिकेट कोड के टुकड़े के लिए, मैं पूछूंगा: क्या एक के लिए आवश्यक बदलाव का मतलब है कि दूसरे को भी बदलना होगा?
आप इस सवाल का जवाब कैसे दे सकते हैं कि एक अच्छा अमूर्त क्या हो सकता है।
डिजाइन पैटर्न भी उपयोगी उपकरण हैं। शायद आपका डुप्लिकेट कोड किसी न किसी रूप में एक ट्रावेलर कर रहा है, और इटरेटर पैटर्न को लागू किया जाना चाहिए।
यदि आपके डुप्लिकेट किए गए कोड में कई रिटर्न मान हैं (और यही कारण है कि आप एक सरल निकालने की विधि नहीं कर सकते हैं), तो शायद आपको एक वर्ग बनाना चाहिए जो वापस लौटाए गए मान रखता है। वर्ग प्रत्येक बिंदु के लिए एक सार पद्धति कह सकता है जो दो कोड के टुकड़ों के बीच भिन्न होता है। आप तब कक्षा के दो ठोस कार्यान्वयन करेंगे: प्रत्येक टुकड़े के लिए एक। [यह C ++ में टेम्प्लेट की अवधारणा के साथ भ्रमित नहीं होने के लिए प्रभावी रूप से टेम्पलेट विधि डिजाइन पैटर्न है। वैकल्पिक रूप से, आप जो देख रहे हैं, वह रणनीति पैटर्न के साथ बेहतर हल हो सकता है।]
इसके बारे में सोचने का एक और प्राकृतिक और उपयोगी तरीका उच्च-क्रम के कार्यों के साथ है। उदाहरण के लिए, लैम्बदास बनाना या अमूर्त को पास करने के लिए कोड के लिए अनाम आंतरिक वर्गों का उपयोग करना। आम तौर पर, आप दोहराव को हटा सकते हैं, लेकिन जब तक कि उनके बीच वास्तव में कोई संबंध न हो [अगर एक बदल जाता है, तो दूसरे को अवश्य ही] तब आपको मदद नहीं करते हुए, मॉड्यूलरिटी को नुकसान पहुँचा सकता है।