BIG का जवाब कब देना है?


278

बिग रिवरिट्स के बारे में सवाल पढ़ें और मुझे एक सवाल याद आया कि मैं खुद जवाब चाहता हूं।

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

अब मैंने लंबे समय से ऊपरी प्रबंधन को इस भयावह आवेदन के कुल पुनर्लेखन का प्रस्ताव देने पर विचार किया था। मैं धीरे-धीरे व्यक्तिगत समय पर प्रयास कर रहा हूं, लेकिन मुझे वास्तव में लगता है कि ऐसा करने के लिए यह कुछ समर्पित संसाधनों के हकदार हैं। बड़े पुनर्लेखन पर लेख पढ़ने के बाद मैं दूसरे विचार रख रहा हूं। और यह अच्छा नहीं है जब मैं अपने वरिष्ठों को अपने पुनर्लेखन का समर्थन करना चाहता हूं। (मैं एक काफी छोटी कंपनी में काम करता हूं इसलिए प्रस्ताव को मंजूरी मिलने की संभावना है)

टीएल; डीआर एक बड़ा उत्तर फिर से लिखना है और आप इसका समर्थन करने के लिए किन तर्कों का उपयोग कर सकते हैं?


1
इसके अलावा, संबंधित: programmers.stackexchange.com/questions/20246/…
IAbstract

6
यह पुराना है, लेकिन यह एक क्लासिक है - जोएल की "थिंग्स यू नॉट डू नेवर डू, पार्ट आई" joelonsoftware.com/articles/fog000000006969.html
मेव

यह एक बड़ा सवाल है। बहुत प्रासंगिक है, यह स्थिति सॉफ्टवेयर इंजीनियरिंग में अक्सर होती है।
ब्रैड थॉमस

जवाबों:


325

क्षमा करें, यह लंबा होने जा रहा है, लेकिन यह व्यक्तिगत अनुभव पर आधारित है, क्योंकि कई पुन: लिखने वाली परियोजनाओं पर आर्किटेक्ट और डेवलपर दोनों हैं।

निम्नलिखित स्थितियों से आपको किसी प्रकार के पुनर्लेखन पर विचार करना चाहिए। मैं यह तय करने के बारे में बात करूंगा कि किसके बाद क्या करना है

  • डेवलपर रैंप-अप समय बहुत अधिक है। यदि किसी नए डेवलपर को रैंप करने के लिए नीचे (अनुभव के स्तर) से अधिक समय लगता है, तो सिस्टम को फिर से डिज़ाइन करने की आवश्यकता है। रैंप-अप समय से, मेरा मतलब है कि नए डेवलपर के पहले समय की राशि उनके पहले कमिट (एक छोटी सी सुविधा पर) करने के लिए तैयार है
    • कॉलेज के बाहर ताजा - 1.5 महीने
    • अभी भी हरा है, लेकिन 1 महीने से पहले अन्य परियोजनाओं पर काम किया है
    • मध्य स्तर - 2 सप्ताह
    • अनुभवी - 1 सप्ताह
    • वरिष्ठ स्तर - 1 दिन
  • मौजूदा आर्किटेक्चर की जटिलता के कारण तैनाती को स्वचालित नहीं किया जा सकता है
  • मौजूदा कोड की जटिलता के कारण साधारण बग फिक्स में भी बहुत समय लगता है
  • नई विशेषताओं में बहुत लंबा समय लगता है, और कोडबेस की अन्योन्याश्रयता के कारण लागत बहुत अधिक होती है (नई सुविधाओं को अलग नहीं किया जा सकता है, और इसलिए मौजूदा सुविधाओं को प्रभावित करता है)
  • मौजूदा कोडबेस की अन्योन्याश्रयता के कारण औपचारिक परीक्षण चक्र बहुत लंबा होता है।
  • बहुत अधिक उपयोग मामलों को बहुत कम स्क्रीन पर निष्पादित किया जाता है। यह उपयोगकर्ताओं और डेवलपर्स के लिए प्रशिक्षण मुद्दों का कारण बनता है।
  • मौजूदा व्यवस्था में जो तकनीक है, वह इसकी मांग करती है
    • प्रौद्योगिकी में अनुभव के साथ गुणवत्ता डेवलपर्स को खोजने के लिए बहुत कठिन हैं
    • इसे हटा दिया गया है (इसे नए प्लेटफार्मों / सुविधाओं का समर्थन करने के लिए उन्नत नहीं किया जा सकता है)
    • बस एक और अधिक उच्च स्तरीय उच्च स्तरीय तकनीक उपलब्ध है
    • पुरानी तकनीक के बुनियादी ढांचे को बनाए रखने की लागत बहुत अधिक है

ये बातें काफी हद तक स्पष्ट हैं। जब एक पूर्ण पुनर्लेखन बनाम एक वृद्धिशील पुनर्निर्माण पर निर्णय लेना अधिक व्यक्तिपरक है, और इसलिए अधिक राजनीतिक रूप से चार्ज किया जाता है। मैं विश्वास के साथ कह सकता हूं कि स्पष्ट रूप से कहा गया है कि यह कभी भी अच्छा विचार नहीं है कि गलत है।

यदि किसी सिस्टम को इंक्रीमेंटल रिडिजाइन किया जा सकता है, और आपके पास इस तरह के काम के लिए प्रोजेक्ट स्पॉन्सरशिप का पूरा सपोर्ट है, तो आपको यह करना चाहिए। यहाँ समस्या है, यद्यपि। कई प्रणालियों में वृद्धि को फिर से डिज़ाइन नहीं किया जा सकता है। यहाँ कुछ कारणों का मैंने सामना किया है जो इसे रोकते हैं (तकनीकी और राजनीतिक दोनों)।

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

ध्यान रखें कि वृद्धिशील रूप से पुनर्वितरण की कुल लागत हमेशा एक पूर्ण पुनर्लेखन करने की तुलना में अधिक होती है, लेकिन संगठन का प्रभाव आमतौर पर छोटा होता है। मेरी राय में, यदि आप एक पुनर्लेखन को सही ठहरा सकते हैं, और आपके पास सुपरस्टार डेवलपर्स हैं, तो इसे करें।

इसे केवल तभी करें जब आप निश्चित हो सकते हैं कि पूरा होने के माध्यम से इसे देखने की राजनीतिक इच्छाशक्ति है। इसका मतलब है कि कार्यकारी और अंतिम उपयोगकर्ता दोनों ही खरीद-इन करते हैं। इसके बिना, आप असफल होंगे। मैं मान रहा हूं कि यही वजह है कि जोएल कहते हैं कि यह एक बुरा विचार है। कार्यकारी और अंत उपयोगकर्ता खरीदने में कई आर्किटेक्ट के लिए दो सिर वाला गेंडा जैसा दिखता है। आपको इसे आक्रामक रूप से बेचना होगा, और इसके पूर्ण होने तक लगातार जारी रखने के लिए अभियान चलाना होगा। यह मुश्किल है, और आप अपनी प्रतिष्ठा को किसी ऐसी चीज पर अटकाने की बात कर रहे हैं जिसे कुछ लोग सफल नहीं देखना चाहेंगे।

सफलता के लिए कुछ रणनीतियाँ:

  • यदि आप, हालांकि, मौजूदा कोड को बदलने की कोशिश नहीं करते हैं। खरोंच से सिस्टम को डिज़ाइन करें। अन्यथा आप अपना समय बर्बाद कर रहे हैं। मैंने "रूपांतरण" परियोजना के बारे में कभी नहीं देखा या सुना है जो बुरी तरह से समाप्त नहीं हुई।
  • एक समय में नई प्रणाली एक टीम में उपयोगकर्ताओं को माइग्रेट करें। उन टीमों को पहचानें जिनके पास मौजूदा प्रणाली के साथ MOST दर्द है, और पहले उन्हें माइग्रेट करें। उन्हें मुंह से वचन देकर खुशखबरी फैलाने दें। इस तरह आपका नया सिस्टम भीतर से बिक जाएगा।
  • अपनी ज़रूरत के अनुसार अपना ढांचा डिज़ाइन करें। कुछ I-6-महीने-निर्माण-इस ढांचे के साथ शुरू न करें, जिसने कभी वास्तविक कोड नहीं देखा है।
  • जितना संभव हो अपनी तकनीक को छोटा रखें। ओवर-डिजाइन मत करो। आप आवश्यकतानुसार तकनीकों को जोड़ सकते हैं, लेकिन उन्हें बाहर निकालना मुश्किल है। इसके अतिरिक्त, आपके पास जितनी अधिक परतें हैं, उतना ही यह काम करने के लिए डेवलपर्स के लिए है। गेट-गो से मुश्किल मत करो।
  • उपयोगकर्ताओं को सीधे डिज़ाइन प्रक्रिया में शामिल करें, लेकिन उन्हें यह निर्धारित करने की अनुमति न दें कि यह कैसे करना है। उन्हें यह दिखा कर उनका विश्वास अर्जित करें कि यदि आप अच्छे डिजाइन सिद्धांतों का पालन करते हैं तो आप उन्हें वह दे सकते हैं जो वे बेहतर चाहते हैं।

25
मुझे लगता है कि जोएल का कहना है कि पुनर्लेखन करने से आप पुराने कोड में जमा ज्ञान को खो देते हैं।
क्वांट_देव

14
@quant_dev आंशिक रूप से हाँ, लेकिन जब आप कभी-कभी फिर से लिखते हैं तो आपको पता चलता है कि पुरानी प्रणाली में कई बग पुराने तरीके से काम करने के कारण थे, न कि सख्ती से तर्क से संबंधित कि आदर्श प्रणाली को कैसे काम करना चाहिए।
तजार्ट

13
जोएल का कहना है कि यह विफल हो जाएगा, क्योंकि पुनर्लेखन के दौरान, आप अपने एप्लिकेशन में कोई नई कार्यक्षमता नहीं जोड़ रहे हैं। पुनर्लेखन का एकमात्र उद्देश्य तकनीकी ऋण के कुछ या सभी को समाप्त करना है। दी, यह कोई छोटी बात नहीं है, लेकिन यह जोखिम भरा है अगर आपके प्रतियोगी अपने सॉफ़्टवेयर में नई सुविधाओं और कार्यक्षमता को जोड़ रहे हैं, जबकि आप केवल तकनीकी ऋण से छुटकारा पा रहे हैं।
रॉबर्ट हार्वे

25
मैंने एक कोडबेस के साथ काम किया है जो इन सभी मानदंडों को फिट करता है + और फिर भी एक बिग रिवाइराइट अभी भी विफल रहा है और कुछ मायनों में हमें आधा-कार्यान्वित "नया सौदा" कोड देकर चीजों को बदतर बना दिया है जो कि पुराने अराजकता से बहुत अलग था, लेकिन नहीं बहुत अधिक प्रबंधनीय। IMO, केवल अगर यह रिफलेक्टर करने के लिए पूरी तरह से असंभव हो जाता है, तो क्या आपको सुविधाओं को जोड़ने और उन बगों को ठीक करने से सभी ध्यान हटा देना चाहिए जो आज ग्राहकों को खर्च कर रहे हैं। जब तक आप वास्तव में अविवेकी कोड के बारे में बात कर रहे हैं, एक टीम जो मॉड्यूलर बिट्स को आसानी से पुन: उपयोग के लिए बाहर नहीं निकाल सकती है क्योंकि आप जाते हैं, वैसे भी बड़े आरडब्ल्यू के लिए अच्छी तरह से फिर से आर्किटेक्ट नहीं कर सकते हैं।
एरिक रेपेने

11
यह एक उपयोगी उत्तर है, लेकिन मधुमक्खी के शानदार से बहुत दूर है, क्योंकि यह कुछ चीजों पर गलत प्रभाव डालता है। उदाहरण के लिए, "ध्यान रखें कि वृद्धिशील रूप से रीडेसिग करने की कुल लागत हमेशा एक पूर्ण पुनर्लेखन करने की तुलना में अधिक होती है" - उस वाक्य में "हमेशा" शब्द गलत है, क्योंकि "वेतन वृद्धि को फिर से करना" आपको कम से कम कुछ हिस्सों का पुन: उपयोग करने का अवसर देता है। मौजूदा डिज़ाइन के, जबकि "पूर्ण पुनर्लेखन" आपको प्रदान नहीं करता है। मुझे पता है कि निश्चित रूप से, क्योंकि मैं वास्तव में उस स्थिति में था, जहां हमने आंशिक रूप से पूर्ण रूप से आंशिक रूप से एक> 100K एलओसी आवेदन को फिर से लिखा था।
डॉक्टर ब्राउन

109

मैंने दो बड़े पुनर्लेखन में भाग लिया है। पहले एक छोटा प्रोजेक्ट था। दूसरा सॉफ्टवेयर कंपनी का मुख्य उत्पाद था।

कई नुकसान हैं:

  • पुनर्लेखन हमेशा अपेक्षा से अधिक समय लेता है।
  • ग्राहक के लिए पुनर्लेखन का कोई सीधा प्रभाव / लाभ नहीं है।
  • पुनर्लेखन के लिए समर्पित क्षमता का उपयोग ग्राहक को समर्थन देने के लिए नहीं किया जाता है।
  • जब तक आपके पास 100% दस्तावेज़ीकरण न हो, आप एक फिर से लिखना के साथ कार्यक्षमता खो देंगे।

असली जवाब शायद ही कभी दिया हो। आप कुछ भी खोए बिना और बहुत अधिक जोखिम के बिना कोड के अधिकांश को रिफ्लेक्टर कर सकते हैं।

यदि इसका उत्तर दिया जा सकता है तो:

  • आप दूसरी भाषा या प्लेटफ़ॉर्म पर जा रहे हैं।
  • आप ढांचे / बाहरी घटकों को स्विच कर रहे हैं।
  • मौजूदा कोडबेस अब रखरखाव योग्य नहीं है।

लेकिन मैं दृढ़ता से रिफ्लेक्टिंग का उपयोग करते हुए धीमे दृष्टिकोण की सलाह देता हूं। यह कम जोखिम भरा है और आप अपने ग्राहकों को खुश रखते हैं।


11
प्रतिक्षेपक दृष्टिकोण के लिए +1। मौजूदा सिस्टम को फिर से लिखने और बनाए रखने के लिए बहुत समय या मैनहॉर्स नहीं है।
रयान हेस

यह वर्तमान में एक डेमो ऐप के लिए उपयोग किया जाता है (हाल ही में किसी भी ग्राहक ने इसे नहीं खरीदा है और मुझे लगा कि अब इसे फिर से बनाने का सबसे अच्छा समय है)।
जोन सेप

4
@ जॉन: एक कार्यकारी के रूप में, मेरे पास एक आवेदन पर एक पुनर्लेखन को फिर से लिखने के लिए बहुत कठिन समय होगा, जिसे मेरी बिक्री टीम को अभी तक ग्राहक नहीं मिला है। सभी ईमानदारी में, मैं इसे एक निश्चित समय देना चाहूंगा, और फिर तय करूंगा कि क्या करना है। अगर दिलचस्पी नहीं है, तो मैं पूरी बात को रद्दी कर दूंगा और कुछ और करूंगा।
NotMe

4
मैंने हाल ही में जावा में एक विजुअल बेसिक एप्लिकेशन को फिर से लिखा है। इसने इसे विंडोज (कोई जावा जीयूआई) के तहत एक सेवा के रूप में चलाने की अनुमति दी - ग्राहक को लाभ।

4
"पुनर्लेखनों का ग्राहक के लिए कोई प्रत्यक्ष प्रभाव / लाभ नहीं है" - यह अक्सर एक मिथक है, जैसा कि नए ढांचे प्रदान करते हैं "बहुत उत्पादकता उत्पादकता में" बनाया गया है जो या तो असंभव है या लागू करने के लिए बहुत महंगा है। एक उदाहरण, एक vb6 ऐप को एक .net ऐप में अपग्रेड करने से उपयोगकर्ता बड़ी फ़ाइलों (64 बिट आर्किटेक्चर के कारण) को खोलने की अनुमति देता है, जिसका अर्थ है कि अंतिम उपयोगकर्ताओं को कृत्रिम रूप से अपने काम को तोड़ने की ज़रूरत नहीं है।
स्टीफन

72

यह फिर से लिखने का समय है:

आवेदन को फिर से लिखने की लागत + फिर से लिखे गए आवेदन को बनाए रखने की लागत समय के साथ मौजूदा प्रणाली को बनाए रखने की लागत से कम है।

कुछ कारक जो वर्तमान को और अधिक महंगे बनाए रखते हैं:

  • भाषा इतनी पुरानी है कि आपको ऐसे लोगों को भुगतान करना होगा जो इसे (COBOL) में प्रोग्राम करने के लिए बहुत पैसा जानते हैं।
  • (अनुभव से, दुर्भाग्य से) सिस्टम एक हार्डवेयर आर्किटेक्चर पर है जो इतना पुराना है कि उन्हें मशीन को जोड़ने के लिए Ebay और COLLECT भागों को परिमार्जन करना होगा क्योंकि यह अभी चल नहीं रहा है। इसे "हार्डवेयर लाइफ सपोर्ट" कहा जाता है और यह महंगा है क्योंकि जैसे-जैसे हिस्से अधिक दुर्लभ होते जाते हैं, वे (हो सकता है) कीमत में बढ़ जाते हैं या वे (बिल्कुल) अंततः बाहर निकल जाएंगे।
  • यह इतना जटिल हो गया है कि //Here be dragons.टिप्पणी आपके कोड पर है।
  • आप कोई अन्य परियोजना नहीं लिख सकते हैं और कंपनी में नए मूल्य जोड़ सकते हैं क्योंकि आप हमेशा इस बदसूरत जानवर को पैच कर रहे हैं।

ठीक यही बात मुझे फिर से लिखने के लिए प्रेरित करती है जिसमें मैंने भाग लिया था। कोड था तो नाजुक, और नई सुविधाओं को जोड़ने की लागत तो , अधिक है कि नहीं पुनर्लेखन नहीं रह गया है एक विकल्प था।
फ्रैंक शीयर

16
मैं यहाँ बिंदु # 2 के बारे में बात कर रहा हूँ।
पॉल नाथन

4
@ पाओल: मैंने भी तब किया जब एक ग्राहक ने मुझे बताया कि, तब मुझे पता चला कि वे गंभीर थे ... और यह कि मैं फिर से लिखने के लिए आवश्यकताओं को इकट्ठा कर रहा हूं। क्या रोमांचक दिन था।
रयान हेस

3
समस्या यह है कि आप लागतों को कैसे मापते हैं।

2
मुझे यह प्रतिक्रिया, मजेदार और सच्ची पसंद है। मैं "कम" से पहले "मात्रात्मक" जोड़ना चाहूंगा। इसलिए कई बार, यह दावा करना आसान है, लेकिन समय बर्बाद करने में सक्षम होना महत्वपूर्ण है।
केविन ह्सू

17

यदि आपको परियोजना की वास्तुकला में मूलभूत परिवर्तन की आवश्यकता है, तो संभवतः नए सिरे से शुरू करने का समय है।

उस के साथ भी, संभावित रूप से कोड के बड़े स्वैथ होंगे जो अभी भी आपकी नई परियोजना में फिर से उपयोग करने के लायक हैं।

हालांकि निष्पक्ष चेतावनी चेतावनी। एक वर्तमान परियोजना के अपने व्यावसायिक नियमों का परीक्षण किया गया होगा और वास्तविक उपयोग के अनगिनत आदमी घंटों के साथ इसे परिष्कृत किया जाएगा, ऐसा कुछ जो खरोंच से शुरू हुई परियोजना का सच नहीं होगा।

मुझे संदेह है कि एक समय सीमा या आंत की भावना इस तरह के कठोर उपाय का एक उपयुक्त उपाय है। इस कार्रवाई में भाग लेने के लिए आपके पास स्पष्ट , रक्षात्मक और अच्छी तरह से समझे जाने वाले कारण होने चाहिए।


3
आपको बहुत सावधानी बरतने की आवश्यकता है 'कोड के बड़े स्वप्नों को फिर से असाइन करें', इससे अप्रयुक्त विरासत कोड और खराब कोड संरचना हो सकती है। मेरी राय में रिफैक्टरिंग एक बेहतर उपाय है।
13

1
माना। उस कथन के भाग को आपके 'नए' प्रोजेक्ट में 'रिफ्लेक्टर' के रूप में समझा जाना चाहिए। यही है, अगर आप वास्तव में पहले से ही उस कठोर पथ पर प्रतिबद्ध हैं। जैसा कि दूसरों ने उल्लेख किया है, यह एक चरम दुर्लभता है जिसे लगभग कभी नहीं किया जाना चाहिए।
डैन मैकग्राथ

1
+1। इसके अलावा, फिर से लिखने में समय लगेगा, जिसके दौरान रखरखाव करना होगा, लेकिन समान बदलाव दोनों आधारभूत आधारों पर किए जाने की आवश्यकता होगी।
लैरी कोलेमन

12

हालाँकि मैं क्रामि के जवाब और जोएल की राय से सहमत हूँ, लेकिन कई बार ऐसा भी होता है जब कोई पुनर्लेखन करना उचित होता है। लंबे समय तक रहने वाले अनुप्रयोगों में (मैं 10-20 साल या उससे अधिक की तरह बात कर रहा हूं), रखरखाव समय के साथ अधिक से अधिक महंगा हो जाता है। यह कोड अधिक से अधिक स्पेगेटी-ईश बनने के कारण है क्योंकि मूल वास्तुकला त्वरित रखरखाव पैच के लिए बलिदान किया जाता है। इसके अलावा, पुरानी तकनीकों के लिए डेवलपर्स अधिक दुर्लभ और अधिक महंगे हो जाते हैं। अंत में, हार्डवेयर की उम्र शुरू हो जाती है और पुराने एप्लिकेशन को शीर्ष पर चलाने के लिए नए हार्डवेयर, ऑपरेटिंग सिस्टम, फ्रेमवर्क इत्यादि को खोजना कठिन हो जाता है। इसके अलावा, व्यवसाय विकसित होते हैं, और सबसे अधिक संभावना है कि एक पुरानी प्रणाली संगठन की व्यावसायिक आवश्यकताओं के साथ-साथ एक ब्रांड नई प्रणाली को पूरा नहीं कर सकती है।

तो आप सभी चल रहे रखरखाव की लागत, साथ ही व्यापार से एक नई प्रणाली के संभावित लाभों को तौलना चाहते हैं, खरोंच से चीज को फिर से लिखने की लागत के खिलाफ। एक पुनर्लेखन की लागत के बारे में अपने अनुमानों में बहुत निराशावादी बनें । यह लगभग हमेशा अधिक लागत लेता है और जितना आपको लगता है उससे अधिक समय लगेगा।


Hofstadter के कानून का उल्लेख करने के लिए +1 ।
बालनॉर्न

11

रुकें! जवाब देना लगभग कभी जवाब नहीं है। अधिक बार नहीं, रिफैक्टिंग एक बेहतर शर्त है।


बेशक, ऐसे समय होते हैं जब एक पुनर्लेखन उचित होता है:

  • आप एक नए प्लेटफ़ॉर्म पर जा रहे हैं, जहाँ माइग्रेशन टूल मौजूद नहीं हैं (या सस्ते में पर्याप्त रूप से नहीं लिखा जा सकता है)।
  • फिर से लिखा जाने वाला आवेदन तुच्छ है।
  • मूल एप्लिकेशन के लिए स्रोत कोड खो गया है, और पुनर्प्राप्ति पुनर्लेखन की तुलना में अधिक महंगा है।
  • मौजूदा एप्लिकेशन द्वारा लागू किए गए व्यावसायिक नियमों का अधिकांश हिस्सा अब लागू नहीं होता है।
  • मौजूदा कोड के कुछ सक्रिय उपयोगकर्ता हैं।
  • आपके पास फिर से लिखने के लिए संसाधन (समय, प्रतिभा और उपकरण) हैं।
  • कानूनी या व्यावहारिक कारणों से मौजूदा एप्लिकेशन को उत्पादन वातावरण में नहीं चलाया जा सकता है।

यह समझने के लिए कि मैं पुनर्लेखन पर विचार करने की सलाह क्यों देता हूं, विचार करें कि पुनर्लेखन में क्या शामिल है। तुम्हे अवश्य करना चाहिए:

  1. मौजूदा एप्लिकेशन क्या करता है, इसकी बारीकियों को समझें। यह आमतौर पर तुच्छ नहीं है जब आप सभी सूक्ष्म व्यापार नियमों को ध्यान में रखते हैं जो इसे एन्कैप्सुलेट करते हैं, पर्यावरण (मानव और तकनीकी दोनों) जिसमें यह संचालित होता है और वर्तमान समाधान के फायदे और नुकसान। अधिक बार नहीं, एकमात्र स्थान जो यह जानकारी मौजूद है (यदि कहीं भी) मौजूदा एप्लिकेशन के स्रोत कोड में है। यह दुर्भाग्यपूर्ण है कि पुनर्लेखन करने का एक मुख्य कारण यह है कि मौजूदा कोड को समझना और बनाए रखना मुश्किल है।

  2. परीक्षण और विश्वसनीय एक नए अनुप्रयोग में इस कार्यक्षमता (या इसका एक अद्यतन संस्करण) को पुन: उत्पन्न करें। मौजूदा कोड डेवलपर्स द्वारा नहीं समझा जा सकता है, लेकिन आमतौर पर इसके उपयोगकर्ताओं द्वारा अच्छी तरह से समझा जाता है। यह उनकी वर्तमान व्यावसायिक आवश्यकताओं को पूरा नहीं कर सकता है, लेकिन वे कम से कम आपको बता सकते हैं कि विभिन्न परिस्थितियों में आवेदन क्या करता है।

रिफैक्टरिंग के बड़े लाभ हैं:

  • आप एक समय में एक छोटा सा सामान ले सकते हैं।
  • मौजूदा, काम कर रहे आवेदन के संदर्भ में किसी भी परिवर्तन का परीक्षण किया जा सकता है।
  • मौजूदा कोड के काम करने के तरीके के बारे में परिकल्पना का परीक्षण छोटे परिवर्तन करके और क्या होता है, देखकर किया जा सकता है।
  • परिवर्तन अक्सर एक ही बार में सभी चरणों में उपयोगकर्ताओं को वितरित किए जा सकते हैं।
  • रिफैक्टरिंग के शुरुआती चरणों से सीखना रिफैक्टरिंग के बाद के चरणों को सूचित कर सकता है।
  • यदि आप प्रक्रिया के माध्यम से भाग को छोड़ देते हैं, तब भी एक क्लीनर कोड आधार के रूप में लाभ होगा (जैसा कि एक पुनर्लेखन के विपरीत जो उपयोगकर्ता या डेवलपर्स को कोई लाभ प्रदान करने के लिए पूरा किया जाना चाहिए)।

याद रखें, यह भी, कि यदि आप एक पुनर्लेखन करते हैं, तो आपको नए कोड बेस में बहुत सारे नए बग और मेस की गारंटी दी जाएगी।


2
क्या आप यह बताकर इस उत्तर पर विस्तार कर सकते हैं कि पुनर्लेखन की तुलना में अधिक बार रिफैक्टिंग करना बेहतर क्यों नहीं है? और फिर से लिखना उत्तर कब होगा ?
गैबलिन

इस तथ्य को देखते हुए कि एक पुनर्लेखन सबसे अधिक बार एक अलग पोशाक में सिर्फ एक ही गड़बड़ है, आप सही हैं। यदि आप उस एकल समस्या को समाप्त कर सकते हैं, तो आप गलत हैं। जब सही लोग ऐसा करते हैं तो कोई निरपेक्षता नहीं होती है।
19G पर JensG

10

यह ग्राफिक मदद कर सकता है, यह कोड आधार गुणवत्ता और अनुप्रयोग के व्यावसायिक मूल्य का एक कार्य है:

यहां छवि विवरण दर्ज करें

यह चार्ट एक गाइड बनने का दिखावा करता है, जब लीगेसी सॉफ्टवेयर की री-इंजीनियरिंग उचित होती है और जब यह नहीं होता है। उदाहरण के लिए, यदि सॉफ़्टवेयर का उच्च व्यावसायिक मूल्य है और कोड की गुणवत्ता खराब है, तो एक पुन: इंजीनियरिंग उचित है।


4
आप कम व्यावसायिक मूल्य वाली परियोजना को फिर से लिखने में निवेश क्यों करेंगे? बस इसे स्क्रैप करें!
जोर्जेन फॉग

यही कारण है कि यह प्रतिमा "प्रतिस्थापित या ..." है। आप उस चीज़ से प्रतिस्थापित कर सकते हैं जिसका मूल्य है। या उस चीज में बनाओ, जिसका मूल्य है। लेकिन आपके पास एक बिंदु है। मैं इसे "स्क्रैप इट" विकल्प जोड़ने के लिए संपादित करूँगा।
ट्यूलेंस कोर्डोवा

8

मुझे लगता है कि मैं अपने करियर में एकमात्र ऐसी स्थिति में हूँ जहाँ बड़े पुनर्लेखन का जवाब है:

कंपनी विलय, सिस्टम कार्यक्षमता में भारी ओवरलैप। कई, कई प्रणालियों को विलय और सेवानिवृत्त कर दिया गया है, और अन्य अभी भी प्रक्रिया में हैं।

मुझे दूसरी कंपनी से एक सिस्टम विरासत में मिला है जो अभी भी चालू है। इसका एक विशाल कोड आधार है, जो कई विभागों का समर्थन हमारे स्वयं के समान है, लेकिन पूरी तरह से अलग डिजाइन और रूपरेखा के साथ। इसका उपयोग करने के लिए केवल एक व्यवसाय क्षेत्र बचा है, जो पर्याप्त पैसा बनाता है जो इस चीज़ को एक ज़ोंबी अवस्था में जीवित रखता है। सभी पुरानी विशेषज्ञता चली गई है, कोई दस्तावेज नहीं है। समर्थन का बोझ अधिक है, हर हफ्ते विफलताओं के साथ। इसे हमारी कंपनियों के सिस्टम में विलय नहीं किया गया है, क्योंकि हमारी कंपनी ने व्यवसाय के इस विशेष क्षेत्र का कभी समर्थन नहीं किया है, इसलिए हमारे पास कार्यक्षमता या विशेषज्ञता नहीं है।

ऐसा लग रहा है कि यह एक ऐसा मामला है जहां पुनर्लेखन की आवश्यकता है। ऐसा लगता है कि मुझे इस बीहोम का पता लगाने जा रहा है, इस व्यवसाय के लिए समर्पित कार्यक्षमता के बिट्स को बाहर निकालना, और उन टुकड़ों को फिर से लिखना जो हमारे मौजूदा सिस्टम में जोड़े जाने की आवश्यकता है। एक बार ऐसा करने के बाद, हमारे मौजूदा सिस्टम इस नए क्षेत्र का समर्थन कर सकते हैं, और इस जानवर को इसके दुख से बाहर रखा जा सकता है। अन्यथा मैं अपनी पवित्रता खोता जा रहा हूं।


लगता है कि आपके नियोक्ता को ग्राहकों से बात करने और स्थिति की व्याख्या करने की आवश्यकता है ताकि यह पता लगाया जा सके कि उनकी मदद करने का सबसे अच्छा तरीका क्या हो सकता है, भले ही इसका मतलब है कि उन्हें शुरू में अधिक भुगतान करना होगा, क्योंकि वे लंबे समय में बचत करेंगे।

7

मैंने एक छोटी सी सॉफ्टवेयर कंपनी के लिए काम किया जिसमें कुछ DOS एप्लिकेशन थे जिन्हें Y2K को संभालने के लिए अपग्रेड किया गया था, जिन्हें विंडोज 16-बिट ऐप के रूप में फिर से लिखा गया था और एक अतिरिक्त 'छोटे' फीचर के साथ 32 बिट ऐप के रूप में पूरी तरह से फिर से लिखा गया था (अंततः केवल इसका उपयोग किया गया था) एक ग्राहक) जिसने पूरे ढांचे को प्रभावित किया।

16 बिट कोड को 32 में स्थानांतरित करना एक व्यक्ति द्वारा एक महीने में किया जा सकता था, लेकिन NOOOOOOOOO, हमें Soooooooooo को बेहतर बनाने के लिए इसे फिर से लिखना पड़ा। इस बात को अन्य उद्योगों के लिए अनुकूलित किया जा सकता है, इससे पहले कि वे शुरू हो जाएं, उनके पास पूर्ण चश्मा और पेसो-कोड होगा। चश्मा बनाया गया था, लेकिन असली कोड लिखने में इतना समय नहीं लगा। यह देर से जारी किया गया था, 16 बिट 'शुरू' से अधिक बग्स के साथ (यह v.3.0 पर था और अंत में उस बिंदु पर जहां हमने लगभग एक सप्ताह बिना किसी नए बग की रिपोर्टिंग के इसे बनाया)।

आपको लगता है कि 3-4 बार एक ही आवेदन को फिर से लिखना कुछ सुधार लाएगा, लेकिन मुझे नहीं लगता कि एक जीयूआई फ्रंट-एंड को इतना उचित ठहराया जा सकता है।

तकनीकी सहायता के प्रमुख के रूप में यह मेरा पहला आईटी काम था। मुझे इस बारे में एक किताब लिखनी चाहिए कि वितरण के लिए सॉफ्टवेयर का विकास कैसे नहीं किया जाए। जाहिर तौर पर हमने कई गलतियां कीं, लेकिन इस तथ्य को कि हम आवेदनों को फिर से लिखना जारी रखते हुए अक्षमता को कम कर रहे हैं।


5

मेरे पास केस के समान ही था केवल कोड भी स्ट्रट्स का उपयोग नहीं कर रहा था। इसके बजाए मैंने उन क्षेत्रों को लक्षित किया जो विशेष रूप से भद्दे थे और बहुत सारी समस्याएं पैदा कर रहे थे। यह लक्षित दृष्टिकोण हमें वृद्धिशील रूप से बेहतर मिला।

2 साल की अवधि में हमने एन्हांसमेंट कार्य के साथ-साथ बिट्स और टुकड़ों को फिर से बनाने पर काम किया। हमने हमेशा एक प्रोजेक्ट प्लान में एक 'हार्डनिंग' कार्य किया। उन विशिष्ट क्षेत्रों पर ध्यान केंद्रित करने से जो अच्छी तरह से काम नहीं करते थे हमें हिरन के लिए सबसे धमाकेदार मिला। जो सामान काम करता था, उसे हमने अकेला छोड़ दिया। यह भी महत्वपूर्ण है कि यह काम सामान्य विकास के दौरान किया गया था और जारी किया गया था। एक बड़े पुनर्लेखन के साथ समस्या यह है कि आप एक वर्ष या उससे अधिक के लिए बंद हो जाते हैं और तब तक जब तक आप वापस आते हैं तब तक हर चीज वैसे भी बदल जाती है और कुछ बुरा कीड़े खत्म हो गए और आपने अपना आरओआई खो दिया।

हमने पूरी बात फिर कभी नहीं लिखी। हमने हालांकि नए काम के लिए उस मंच का उपयोग करना बंद कर दिया था, और एक बड़े नए प्रोजेक्ट के लिए एक नया ताज़ा मंच पेश किया। यह मंजूर हो गया और हमने उचित समय में एक बेहतरीन उत्पाद दिया।


5

इसलिए यहाँ मैं अपने डेस्क पर बैठा हूँ, मैंने एक बड़ी aspx फ़ाइल, इसके पीछे डेटाबेस की पूर्ण गड़बड़ के लिए कोड को फिर से लिखना शुरू कर दिया, और MSSQL के लिए MS Access इंटरफ़ेस को बदल दिया।

यह एस्प कार्यक्रम जैसी चीजों से अटे पड़े हैं

  • include(close.aspx) जिसके अंदर कोड की एक पंक्ति है जो अंतिम खुले डेटाबेस कनेक्शन को बंद करती है।
  • लिगेसी कोड बस बेतरतीब ढंग से टिप्पणी की
  • सुरक्षा के लिए कोई विचार नहीं
  • स्पेगेटी कोड, इसकी हजारों लाइनें। सभी एक फाइल में।
  • उनके नाम के पीछे कोई स्पष्ट अर्थ के साथ कार्य और चर

अगर हमें कभी थोड़ा बदलाव करने की जरूरत है, तो यह दुःस्वप्न मोड पर कल-टो के पांच एक साथ खेल खेलने जैसा है।

मुझे कार्यक्षमता को दोहराने और उत्पाद बनाने के लिए काम पर रखा गया था जो उद्योग में दूसरों के लिए अनुकूलन योग्य और बिक्री योग्य हो सकता है। समस्या यह है कि पिछले 10 वर्षों में हर एक व्यवसाय की जरूरत को पूरा करने के लिए लिखा गया है (ठीक है, मैं उनके बारे में पाँच या छह सिग्मा कहूँगा)।

यदि हम उत्पाद बेचना नहीं चाहते थे, तो उन्हें शायद फिर से लिखने की ज़रूरत नहीं होगी क्योंकि यह सबसे अधिक वही है जो वे चाहते हैं - शायद सुरुचिपूर्ण ढंग से नहीं, लेकिन अच्छा कोड बनाने पर पैसा खर्च करना समझदारी नहीं थी 'वहीं काम करें।'


4

जोएल स्पोल्स्की का इस पर एक उत्कृष्ट लेख है: थिंग्स यू शुड नेवर डू, पार्ट आई

आप जो शीर्षक बता सकते हैं, उसकी तरह एक तरफा (वह इस बारे में बात करता है कि आपको कोड क्यों नहीं फेंकना चाहिए) IMO, इसके लिए बहुत सच्चाई है, मैंने हाल ही में एक्सेल की 25 वीं वर्षगांठ पर एक चैनल 9 वीडियो देखा, जहां कुछ देवों ने कहा, कैसे आज भी अगर आपने स्रोत पर गौर किया है तो आप संशोधन की जाँच करेंगे और उस कोड का उपयोग करते हुए अंत में वापस जाएंगे जो 20 साल पहले लिखा गया था।

आप 100% निश्चित नहीं हो सकते हैं (जब नेटस्केप गलती भी करता है (जोल्स आर्टिकल से)), मुझे ऐसा लगा जैसे जोएल का लेख भगवान ने भेजा है, क्योंकि मैं निराशावादी हो सकता हूं और प्यार दूर कोड सोच को फेंक सकता हूं, मैं हमेशा इसे एक बेहतर लिख सकता हूं समय, लेकिन मैंने महसूस किया है कि अब केवल यह बहुत खर्च होता है

एक ठोस जवाब देने के लिए, मैं सिर्फ इतना कहूंगा कि आपको लागत मूल्य बनाम गहन विश्लेषण करने की आवश्यकता है।

मेरी असली दुनिया: एक सिल्वरलाइट ऐप Im विकासशील v0.6 अब तक async कॉल की गड़बड़ी है जो कोड को इतना जटिल बना देता है। जब से मैंने इस हफ्ते रिएक्टिव एक्सटेंशन्स की खोज की है, मैं वास्तव में अधिकांश कोड को फिर से लिखना चाहता हूं, लेकिन अब मैं अपने ग्राहक को क्या बताऊं? कार्यक्रम पूरी तरह से ठीक काम करता है (कुछ मेमोरी लीक थो के साथ) लेकिन वे परवाह नहीं करते हैं? मैं संभवतः उन्हें यह नहीं बता सकता कि ओह इम को 2-3 और सप्ताह लग रहे हैं क्योंकि मैं फिर से कुछ करना चाहता हूं। फिर भी, मैं शाखा में जा रहा हूं और अपने खाली समय में इसके साथ फिर से लिखना / खेलना चाहता हूं ।

बस मेरे 2 सेंट ठीक है !?


आपका पहला क्रियान्वयन अक्सर उप-विषयी होता है क्योंकि ऐसी चीज़ें होती हैं जिन्हें आप डिज़ाइन करते समय अभी तक नहीं जानते हैं। यह आमतौर पर शुरू करने के बजाय आकार में पुन: प्रयोज्य होगा, जैसा कि आपने सबसे अधिक संभावना है कि कुछ सही किया है । यदि नहीं, तो यह एक सबूत है, और उन्हें अक्सर त्यागने की आवश्यकता होती है।

ब्रांचिंग के लिए +1। बहुत सारे लोग कहते हैं "फिर से लिखना मत" क्योंकि ऐसा लगता है जैसे आप पुराने कोड को फेंक रहे हैं - लेकिन आप नहीं हैं। आपके पास समानांतर कोडबेस हो सकते हैं।
लंचमीट 317

निष्पक्ष होने के लिए, यदि आप एक व्यक्ति हैं जो सलाह के लिए जोएल स्पोल्स्की से पूछते हैं, तो आपको पूर्ण पुन: लिखना नहीं करना चाहिए :-) और अन्यथा, आपको केवल एक फिर से लिखना चाहिए यदि आप सभी हितधारकों को समझा सकते हैं कि जोएल के तर्क क्यों नहीं गिनाते हैं आपके विशिष्ट मामले में।
gnasher729

3

मौजूदा समाधान कोई पैमाना नहीं है।

मैं तुम्हें, एमएस एक्सेस देख रहा हूं।


मुझे यकीन नहीं है कि आप सही देख रहे हैं। जेट रेड का मतलब कभी एएफ़एके नहीं था।
जेन्सजी

यह पूछे गए प्रश्न का उत्तर कैसे देता है?
gnat

3

जोएल के अनुसार, बड़े पुनर्लेखन एक सबसे खराब रणनीतिक गलती है जिसे एक कंपनी कर सकती है:

थिंग्स यू सेड नेवर डू, पार्ट आई

... यह याद रखना महत्वपूर्ण है कि जब आप खरोंच से शुरू करते हैं तो यह मानने का कोई कारण नहीं है कि आप पहली बार किए गए काम से बेहतर काम करने जा रहे हैं। सबसे पहले, आपके पास संभवतः समान प्रोग्रामिंग टीम नहीं है जो संस्करण एक पर काम करती है, इसलिए आपके पास वास्तव में "अधिक अनुभव" नहीं है। आप बस ज्यादातर पुरानी गलतियों को फिर से बनाने जा रहे हैं, और कुछ नई समस्याओं को पेश करते हैं जो मूल संस्करण में नहीं थे।

बड़े पैमाने पर फेंकने के लिए पुराने मंत्र का निर्माण खतरनाक है जब बड़े पैमाने पर वाणिज्यिक अनुप्रयोगों के लिए आवेदन किया जाता है। यदि आप प्रायोगिक रूप से कोड लिख रहे हैं, तो आप पिछले सप्ताह लिखे गए फ़ंक्शन को रिप करना चाहते हैं जब आप एक बेहतर एल्गोरिदम के बारे में सोचते हैं। कोई बात नहीं। आप इसे उपयोग में आसान बनाने के लिए एक कक्षा को रिफलेक्टर करना चाहते हैं। वह भी ठीक है। लेकिन पूरे कार्यक्रम को फेंकना एक खतरनाक मूर्खता है, और अगर नेटस्केप वास्तव में सॉफ्टवेयर उद्योग के अनुभव के साथ कुछ वयस्क पर्यवेक्षण था, तो शायद उन्होंने खुद को पैर में इतनी बुरी तरह से गोली नहीं मारी होगी।


5
हाँ। मैं उस के लिए कुछ counterarguments के लिए देख रहा था। इसे कभी-कभी करना पड़ता है।
जोन सेप

3
जोएल के लेख के संदर्भ के बिना हर पुनर्लेखन तर्क पूर्ण नहीं है। मैं जो कहता हूं, वह यह है कि लेख में कुछ अच्छे बिंदु हैं, लेकिन अपने आप के लिए विचार करना चाहिए। शायद आप कह रहे होंगे कि आप लेख से सहमत क्यों हैं। मैं जोएल के साथ व्यक्तिगत रूप से सहमत नहीं हूं - सिर्फ इसलिए कि कभी-कभी खुद को खोदने से बेहतर है कि आप खुद को बोर होने के बजाय गड्ढे में समाप्त करें। किसी भी मामले में, एक पुनर्लेखन, मुझे लगता है, पुन: मूल्यांकन के लिए उन अव्यक्त व्यावसायिक प्रक्रियाओं को सतह पर लाएगा।
अहमद

जोल्स लेख अच्छा है क्योंकि यह ध्यान से बताता है कि बुरी चीजें कैसे जा सकती हैं।

6
जोएल नेटस्केप नेविगेटर ब्राउज़र का एक उदाहरण का उपयोग करता है। यह एक उपभोक्ता उत्पाद है जो बड़े बजट के साथ प्रतिस्पर्धा के खिलाफ काम करने वाले बड़े पैमाने पर विकास वक्र के बीच में था। यह नेटस्केप के लिए एक रणनीतिक गलती थी। दूसरी ओर, आंतरिक कस्टम "एंटरप्राइज़" सॉफ़्टवेयर प्रोजेक्ट अलग-अलग हैं। आप बाजार हिस्सेदारी के लिए जल्दी नहीं कर रहे हैं। प्रतिस्पर्धी उत्पाद पर आपके सभी उपयोगकर्ताओं के जाने का कोई खतरा नहीं है। यह एक व्यापार निर्णय के लिए नीचे आता है: क्या लंबे समय में खुद के लिए फिर से लिखना भुगतान की लागत और / या यह व्यवसाय के लक्ष्यों को प्राप्त करने का सबसे अच्छा तरीका है?
स्कॉट व्हिटलॉक 20

मुझे लगा कि जोएल ने प्रमुख अवधारणा को मारा है, "आप कभी नहीं जानते कि कौन से निर्णय का दस्तावेजीकरण नहीं किया गया है कि आपको कठिन तरीका सीखना होगा"
MathAttack

2

कभी नहीं, हमेशा रिफ्लेक्टर - सच्चाई यह है कि अगर कोड आपके द्वारा लिखा गया था - तो आप कोई भी बेहतर नहीं कर पाएंगे।

जब तक आप प्रौद्योगिकी को बदलना नहीं चाहते, कोड में किसी भी संरचना का अभाव है (मैंने इसे बहुत समय पहले कुछ PHP वेबसाइट में देखा था, लेखक सिर्फ शामिल / वर्ग / फ़ंक्शन के बजाय कॉपी / पेस्ट किए गए स्पैगेटी को कॉपी करता है) या आपने किसी अन्य व्यक्ति से कुछ लिया है बहुत बुरी तरह से लिखा गया है।

हर चीज को ब्लैकबॉक्स के रूप में डिजाइन किया जाना चाहिए। मॉड्यूलर, सिंपल एपीआई, जो अंदर है ... वह कम महत्वपूर्ण है :) यदि आपके पास स्पेगेटी है तो आप शायद इसे ब्लैकबॉक्स के अंदर बंद कर सकते हैं, इसलिए यह अच्छे कोड को दूषित नहीं करेगा।


बहुत बढ़िया, स्लावेक! extremeprogramming.org/rules/refactor.html
लुकास एडर

+1, मुझे आपकी राय पसंद है, क्या आप एपीआई के नए सेट पर फिर से लिखने के बारे में अपने विचार जानना चाहेंगे? (नीचे मेरा उत्तर देखें)
गिदोन १४'११ को

हां, ये अच्छे अंक हैं। Microsoft ने winXP कोड को फिर से लिखा और वे पहले विस्टा रिटेल संस्करण में फ़ाइल डिलीट / कॉपी राइट भी नहीं प्राप्त कर सके। जब वे अपने कोड बेस को प्रगति कर रहे थे, तब हम लगातार बेहतर गुणवत्ता प्राप्त कर रहे थे (W3.11 => W95 => W98 => ME => XP), विस्टा जिसमें उन्होंने कई मुख्य भागों को फिर से लिखा था एक आपदा थी। नए एपीआई के लिए ... मैं वर्तमान कोड को अलग कर सकता हूं जितना कि मैं बरकरार रख सकता हूं, और उच्च स्तर पर नए एपीआई का उपयोग कर सकता हूं। उदाहरण के लिए। आपके मुख्य वर्ग वैसे ही बने रहते हैं, जैसे नए एपीआई का उपयोग करके एकीकरण किया जाता है। जब तक सब कुछ इतना गड़बड़ नहीं होता कि
0.17

1
"... सच्चाई यह है कि यदि कोड आपके द्वारा लिखा गया था - तो आप कोई बेहतर नहीं कर पाएंगे।" यदि मेरे पास पर्याप्त प्रतिनिधि हैं तो इस पोस्ट को डाउन-वोट करेंगे। यह सबसे खराब, अवास्तविक है और इसका मतलब है कि किसी भी तरह से लोग उस बिंदु पर प्रगति नहीं कर सकते हैं जिस कोड को वे लिखते हैं वह उस कोड में सुधार है जो उन्होंने अतीत में लिखा था।
J --Mᴇᴇ 12

1
@ J @M and: सहमत - यदि आपने कुछ भी नहीं सीखा है और पहली बार इसे लागू करते समय कोई अनुभव प्राप्त नहीं किया है और / या यदि आप अब एक बेहतर काम नहीं कर सकते हैं, तो आपके पास अधिक ज्ञान / अनुभव / दृष्टि है; तो आप आलू हैं और प्रोग्रामर नहीं हैं।
ब्रेंडन

2

मुझे लगता है कि मुख्य कारण जो पुनर्लेखन को सही ठहराता है, वह प्लेटफ़ॉर्म परिवर्तनों के लिए है। उदाहरण के लिए, यदि आपके पास एक विंडोज़ डेस्कटॉप जीयूआई एप्लिकेशन है और कंपनी के मालिक यह तय करते हैं कि वे अगले संस्करण को वेब आधारित एप्लिकेशन बनाना चाहते हैं। हालांकि हमेशा नहीं, मेरे अनुभव में अधिकांश समय इसके लिए फिर से लिखना होगा, जब तक कि मूल डेवलपर्स ने बहुत मॉड्यूलर और पुन: प्रयोज्य कोड (शायद ही कभी) लिखा हो।


2

"अगर मैं XI के लिए यहाँ से शुरू नहीं होता तो" के बारे में क्लासिक मजाक है।

मैंने एक बार एक नौकरी ली, जहां नियोक्ता की मुख्य प्रेरणा एक व्यावसायिक-महत्वपूर्ण ऐप के लंबे समय से पुनर्लेखन को लॉन्च करने के लिए प्रतिभा लाने के लिए थी। जो प्रश्न मैं पूछने में असफल रहा, वह यह था कि आप इस स्थिति में पहले स्थान पर क्यों थे? यह एक लाल झंडा होना चाहिए था, चाहे इसका कारण यह हो

  • जानवर को बनाए रखने और बढ़ाने के लिए कार्यक्षमता जोड़ने के लिए बहुत अधिक दबाव,

  • विभाग में बहुत कम क्षमता,

  • वृद्धिशील कार्य के लिए ग्राहकों या प्रबंधन से बहुत कम खरीद,

या जो भी हो, और जब तक समस्या असहनीय स्तर तक नहीं पहुंच जाती, तब तक यह दूर हो जाता है।

तो मैं जोएल के साथ सहमत होने जा रहा हूं कि एक बड़े पैमाने पर फिर से लिखना शायद एक बहुत बुरा विचार है - जब तक कि आपके पास इस बात के पुख्ता सबूत न हों कि एक प्रमुख पुनर्लेखन को जरूरी समझने के पीछे के सभी अंतर्निहित कारणों से निपटा गया है , तो आप सभी संभावना में हैं नियत समय में समस्या को दोहराने जा रहा है।


2

यह उत्तर है जब फिर से लिखना संगठन को एक रणनीति बनाने की अनुमति देता है जो एक प्रतिस्पर्धात्मक बढ़त को बढ़ाता है या इसे अपने ग्राहकों को बेहतर तरीके से सेवा करने की अनुमति देता है जो वर्तमान वास्तुकला को समायोजित नहीं कर सकता है।

इसके बजाय, प्रबंधन की चिंताओं को कम करने के लिए अक्सर पुनर्लेखन होता है:

  • सब कुछ .NET में होना चाहिए,
  • हमारे डेवलपर्स का कहना है कि हमारा कोड बेकार है,
  • हम तकनीकी रूप से पिछड़ रहे हैं,
  • हम अपने सिस्टम का समर्थन करने के लिए संसाधनों को खोजने में सक्षम नहीं होंगे या, बहुत बार,
  • दस साल हो गए हैं इसलिए समय आ गया है।

इनमें से अधिकांश चिंताएँ नहीं बढ़ेंगी और यदि वे ऐसा करते हैं तो उन्हें संभाला जा सकता है। हालांकि, पिछले एक सबसे खराब है। यह अनिवार्य रूप से है: हमारे पास कोई कारण नहीं है।

हां, कार की तरह, एक प्रणाली पहनने के लक्षण दिखाना शुरू कर देगी। यह नियमित सर्विसिंग द्वारा कम किया जा सकता है। आप जानते हैं कि थोड़ा निवारक रखरखाव एक लंबा रास्ता तय करने के बारे में वे क्या कहते हैं। एक निवेश के रूप में, रूटीन सर्विसिंग (यानी रिफैक्टरिंग और मानकीकरण) लगभग हमेशा एक पुनर्लेखन की तुलना में कम लागत का होगा।

हालांकि, हमें यह अनुमान लगाना होगा कि एक फिर से लिखना आवश्यक होगा। तारीखें निर्धारित करें और इसके लिए अस्थायी रूप से योजना बनाएं, लेकिन जब तक तारीख अन्य रणनीतिक लक्ष्यों को साकार करने के पक्ष में लगभग देरी हो जाती है, जब तक कि आपके पास एक सम्मोहक कारण नहीं है ...

हाल के वर्षों में हमने बड़े खातों को जीतने का अवसर खो दिया है क्योंकि हम उनकी जरूरतों को समय पर या महंगे फैशन में समायोजित नहीं कर सकते हैं। हमारे सिस्टम को एक एक्स्टेंसिबल आर्किटेक्चर का उपयोग करके फिर से लिखा जाएगा जो कस्टमाइज़ेशन को प्लग करने की अनुमति देता है (और वर्तमान में जैसा कि वर्तमान में है, हार्डकोड नहीं है)। यह विशेष जरूरतों वाले ग्राहकों को समायोजित करने के समय और लागत में नाटकीय रूप से कमी करेगा। हम अधिक खाते जीतेंगे और अपने वर्तमान ग्राहकों की जरूरतों को बेहतर ढंग से पूरा करेंगे।


लगता है कि आप को उस दिशा में सक्षम होना चाहिए। रिफैक्टरिंग करते समय, आपको अपने लचीलेपन को बनाने के लिए ध्यान में रखना होगा ताकि अगली विशेषता लिखने में आसान हो।
इयान

1

वांछित कार्यक्षमता प्रदान करने के लिए पूरी तरह से नई तकनीक पर जाने की आवश्यकता होती है।

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

"वांछित कार्यक्षमता प्रदान करने की आवश्यकता है": ठीक 2000 के आसपास, मैंने C ++ से जावा में एक प्रमुख सर्वर घटक को फिर से शुरू करने, एक वस्तु कैश, और क्लाइंट-नियंत्रित लेनदेन को सक्षम करने के लिए एक परियोजना शुरू की। उस समय, C ++ के लिए कई थ्रेडिंग लाइब्रेरी थीं, जिनका हमें समर्थन करना होगा, और हमारे डेटाबेस कोड के थ्रेड-इनेबल्डिंग को लगभग संपूर्ण पुनर्लेखन की आवश्यकता होगी। ग्राहक के रूप में नियंत्रित लेनदेन के लिए ... पुराने वास्तुकला के साथ नहीं होने वाला।

फिर भी, मुझे यकीन नहीं है कि मैंने पुनर्लेखन किया होगा, सिवाय इसके कि मुझे मौजूदा प्रणाली के व्यवहार का विस्तृत ज्ञान था, और यह अपेक्षाकृत साफ कोड था जिसने अपने 11 वर्षों के जीवन में बहुत अधिक मौसा विकसित नहीं किए थे।


0

उस बिंदु को तय करने के लिए जिस पर आपको शुरू करना चाहिए, आपको काम करने की ज़रूरत है जहाँ आपके वर्तमान प्रोजेक्ट पर जारी रहने का मूल्य शुरू में मूल्य से कम हो जाता है।

यह कारण इतना मुश्किल है कि आप नई परियोजना पर टीम के विकास के वेग का सटीक अनुमान लगाते हैं जब तक कि आप वास्तव में इसे शुरू नहीं करते। कहा कि, यदि, नई परियोजना पर आपके विकास के वेग का एक बहुत रूढ़िवादी अनुमान का उपयोग करते हुए, परियोजना को निवेश पर एक सार्थक रिटर्न देने का अनुमान है, तो आपके पास नए सिरे से शुरू करने के लिए एक व्यावसायिक मामला है।


0

मेरे मीट्रिक के साथ, आपको फिर से लिखने को सही ठहराने के लिए दो शर्तों को पूरा करना होगा:

  1. फिर से लिखने के बाद नई सुविधाओं को लिखने में आसान / तेज / कम छोटी गाड़ी होगी
  2. वर्तमान नई सुविधा को जोड़ने की तुलना में पुनर्लेखन को कम या बराबर समय लगेगा।

फिर भी आप अपने पुनर्लेखन के दायरे को सीमित करना चाहते हैं। एक उदाहरण के लिए, हमारे पास एक कंपनी में कुछ विरासत सॉफ्टवेयर थे जो C ++ में C प्रोग्रामर की मानसिकता के साथ लिखे गए थे जो कि मॉड्यूलरिटी के बारे में नहीं जानते थे। अंतिम परिणाम एक परिमित राज्य मशीन के रूप में स्पेगेटी कोड था जो कई वर्गों और डीएलएल को फैलाता था। हमारे पास एक नई आवश्यकता थी जो कोड में निर्मित मान्यताओं से बहुत अलग थी, और अपने ग्राहकों के लिए कंपनी के पेटेंट मूल्य-जोड़ का हिस्सा बनने जा रही थी।

अन्य विशेषताओं को लागू करने वाले कोड के साथ समय बिताने के बाद, मुझे वास्तव में अच्छा विचार था कि यह पता लगाने में कितना समय लगेगा कि मुझे कौन से स्विच स्टेटमेंट बदलने होंगे, आदि। मेरा प्रस्ताव कोड के अनुभाग को फिर से लिखना था जो था विशाल परिमित राज्य मशीन - यह मुझे मौजूदा कोड को विस्तारित करने की तुलना में कम समय लेना चाहिए। मैं एक डीएलएल में समेकित करने में सक्षम था जो तीन हुआ करता था, और एक बहुत अधिक वस्तु उन्मुख संरचना प्रदान करता है जो महत्वपूर्ण नई कार्यक्षमता को करने के साथ-साथ नई कार्यक्षमता को जोड़ना आसान बनाने के लिए बहुत आसान बना देगा।

पुस्तकालयों का उपयोग करने वाले तीन अन्य अनुप्रयोग थे जिन्हें फिर से लिखने की आवश्यकता थी, इसलिए मैं उन कार्यक्रमों को पूरी तरह से लिखना नहीं चाहता था। दायरा पुस्तकालय तक सीमित था और मौजूदा सॉफ्टवेयर में पुस्तकालय को बांधने के लिए क्या आवश्यक था। मेरे अनुमान दूर नहीं थे, और काम खुद के लिए भुगतान किया। रीडिज़ाइन के कुछ समय बाद, मुझे एक नई सुविधा जोड़ने का काम सौंपा गया। पुराने ढाँचे के साथ मुझे एक हफ्ता क्या हुआ होगा और मुझे एक दिन नया ढाँचा मिला।


0

ओपी परियोजना के दायरे को इंगित नहीं करता है, लेकिन मैंने जो मुख्य सुराग लिया, वह "पुरानी [भाषा / बोली] पुरानी [लिबास] का उपयोग करते हुए लिखा गया था" जो कि मेरे लिए फिर से लिखने के प्राथमिक चालक हैं। वास्तव में, अधिकांश परियोजनाएं जो मैं किसी भी महत्वपूर्ण बाजार दीर्घायु पर रहा हूं, अंततः यह महसूस करता हूं कि संकलकों / दुभाषियों / ऑपरेटिंग-सिस्टम के अपडेट को कोड बेस बनाए रखने में एक महत्वपूर्ण कार्य है।

संक्षेप में, मैं पहले चरण को फिर से लिखने की योजना बनाऊंगा, जिसमें पहले अद्यतन को प्राथमिकता देना होगा। यह हो सकता है कि रास्ते में, आप अन्य अनुकूलन में चुपके कर सकते हैं, लेकिन यह तथ्य कि आप बाद के चरण में कुछ परिवर्तनों को स्थगित करने की योजना बनाते हैं, शेड्यूल पर रहने और "अटक" होने से बचने का एक शानदार तरीका हो सकता है।


0

अच्छी तरह से मैं काल्पनिक परिदृश्यों की कल्पना कर सकता हूं, जहां मैं केवल मौजूदा कोड आधार (काल्पनिक स्थितियों को निकाल सकता हूं, जहां हिरन का गोले में शून्य वजन और मात्रा होती है, जहां कोई भी परवाह नहीं करता है कि क्या हम हफ्तों या उत्पादकता के महीनों में खो देते हैं क्योंकि हम अनदेखी सुविधाओं और बग को जोड़ने के लिए हाथापाई करते हैं। सिस्टम में फिक्स, और जहां सिस्टम एक संगठन द्वारा इतना तुच्छ और नफरत करता है कि मैं नोटपैड ++ और नेटबुक के साथ दस मिनट में पूरी चीज और सेना की जगह ले सकता हूं और सभी की उत्पादकता और नैतिकता को बढ़ा सकता हूं।)

लगभग किसी भी वास्तविक दुनिया के परिदृश्य के लिए हालांकि मैं सिर्फ जगह में रिफैक्टिंग की सिफारिश करूंगा। ^ _ ^। अनिर्दिष्ट कानूनी और व्यावसायिक आवश्यकताओं को पॉप-अप करने के लिए शुरू होता है और अंतिम मिनट हैकिंग बातें एक साथ शुरू होता है जब बहुत से छिपे हुए, अप्रत्याशित लागतों को फिर से लिखना शुरू हो जाता है।

== अधिक अच्छे और सामान के लिए प्लेस में रिफ्लेक्टिंग ==

नियमित पुराने वृद्धिशील दृष्टिकोण के साथ विरासत कोड को फिर से भरना,

  1. यदि आपके पास मौका है कि आप यूएमएल में कनवर्ट करें और दस्तावेज बनाएं कि वहां कितनी बारीक वास्तुकला है।
  2. यदि आप संस्करण नियंत्रण पर हैं, तो कुछ कोड मंथन रिपोर्ट तैयार करने और यह पता लगाने में कि कौन सी फाइलें और फाइल सेक्शन सबसे अधिक बार बदले गए हैं। इन पर ध्यान दें क्योंकि वे संभावित रूप से वे क्षेत्र हैं जिनसे आप पहले निपटना चाहेंगे।
  3. इससे पहले कि आप कोई भी कोड बदलें हमेशा कुछ टेस्ट कवरेज जोड़ने की कोशिश करें (यहां तक ​​कि बदसूरत पूर्ण स्टैक कार्यात्मक परीक्षण करेंगे)। यदि बड़े गन्दे प्रक्रियात्मक कोड अर्क लॉजिक से निपटना है तो आप कुछ उचित नाम पद्धति या फ़ंक्शन में बदलने का इरादा रखते हैं और यदि संभव हो तो कुछ परीक्षण मामलों को जोड़ते हैं जो आपकी नई विधि को सत्यापित करते हैं। जो कुछ भी ईश्वर ने आपको हैक किया है उसे भयानक बना दें और यदि संभव हो तो परिवर्तन को सर्वोपरि करें यदि यह आमतौर पर मार्जिन चौड़ाई या शीर्षक की तरह ट्विक किया जाता है तो यह अगली बार अपडेट करने के लिए थोड़ा और आगे होगा।
  4. एडेप्टर पैटर्न का उपयोग करें और तार्किक रूप से नामित कक्षाओं और विधियों की एक गलीचा के नीचे विरासत कोड के शूरवीरों के बिट्स को छुपाने के लिए काम करें ताकि आपके और अन्य डेवलपर्स के लिए आपके द्वारा प्रदर्शन किए जाने वाले डरावने बिट्स के बारे में चिंता न करें। उन अच्छे छोटे स्वच्छ तरीकों और कक्षाओं के पीछे आपकी पीठ पीछे आपने उस विरासत कोड को छिपाया है - उन अच्छे परिवारों की तरह, जो कि खतरनाक पूर्व ज़ोंबी सदस्यों को खलिहान में रखते हैं ताकि वे दिन-ब-दिन खराब न हों खेत। । । सामान्य रूप से।
  5. जैसा कि आप दूर जा रहे हैं और कोड के वर्गों को साफ करने के लिए अपने परीक्षण कवरेज को बढ़ावा देने के लिए जारी है। अब आप और भी गहरे खोद सकते हैं और जरूरत से ज्यादा आत्मविश्वास के साथ / वांछित होने पर और भी अधिक कोड "फिर से लिखना" कर सकते हैं।
  6. अपने कोडबेस को बेहतर बनाने के लिए दोहराए, या अतिरिक्त रीफैक्टरिंग दृष्टिकोण लागू करें।

अमूर्त द्वारा शाखा

  1. आप जिस कोड को हटाना चाहते हैं, उस परेशानी के स्थान को निर्धारित करें (दृढ़ता की परत, पीडीएफ जनरेटर, चालान टैली तंत्र, विजेट जनरेटर, आदि)।
  2. रन (लिखें यदि आवश्यक हो) कोड आधार के खिलाफ कुछ कार्यात्मक परीक्षण मामलों (स्वचालित या मैनुअल लेकिन आप स्वचालित रूप से जानते हैं) सामान्य व्यवहार के साथ-साथ इस कार्यक्षमता को लक्षित करते हैं।
  3. मौजूदा सोर्सबेस से उस घटक से संबंधित तर्क को कुछ उचित इंटरफ़ेस के साथ एक वर्ग में निकालें।
  4. सत्यापित करें कि सभी कोड अब गतिविधि एक्स करने के लिए नए इंटरफ़ेस का उपयोग कर रहे हैं जो पहले पूरे कोड में यादृच्छिक रूप से फैलाया गया था (कोड बेस को ग्रिप करें, नए वर्ग में एक ट्रेस जोड़ें और उन पृष्ठों को सत्यापित करें जो इसे कॉल कर रहे हैं, आदि), और वह आप नियंत्रित कर सकते हैं कि किस कार्यान्वयन का उपयोग किसी एकल फ़ाइल को संशोधित करके किया जाएगा। (ऑब्जेक्ट रजिस्ट्री, फ़ैक्टरी वर्ग, जो भी IActivityXClass = Settings.AcitivtyXImplementer ();)
  5. रेरन फंक्शनल टेस्ट के मामले जो सब कुछ सत्यापित करते हैं, अभी भी अपने नए वर्ग में एक्टिविटी एक्स थ्रिन के साथ काम कर रहे हैं।
  6. नई गतिविधि एक्स रैपर क्लास के आसपास जहां संभव हो, यूनिट टेस्ट लिखें।
  7. विरासत कार्यान्वयन की तुलना में कम पागल स्पेगेटी तर्क के साथ एक नया वर्ग लागू करें जो विरासत वर्ग के समान इंटरफ़ेस का पालन करता है।
  8. सत्यापित करें कि नया वर्ग उस इकाई परीक्षण से गुजरता है जिसे आपने विरासत वर्ग के लिए लिखा था।
  9. पुरानी कक्षा के बजाय नई कक्षा का उपयोग करने के लिए रजिस्ट्री / फ़ैक्ट्रीमेथोड / जो भी हो, को बदलकर अपना कोड अपडेट करें।
  10. सत्यापित करें कि आपके कार्यात्मक परीक्षण अभी भी पास हैं।

ओपन क्लोज्ड सिद्धांत और एक सामान्य व्यापार तर्क / दृढ़ता परत

कुछ हद तक आप अपनी प्रस्तुति, व्यवसाय और दृढ़ता की परत को अलग करने और एक नया ऐप लिखने में सक्षम हो सकते हैं जो विरासत समाधान के साथ पूरी तरह से पीछे की ओर संगत है, या कम से कम अभी भी विरासत समाधान द्वारा इनपुट किए गए डेटा को संभाल सकता है। मैं शायद इस दृष्टिकोण की सिफारिश नहीं करूंगा लेकिन कभी-कभी यह समय / अनुसूची / संसाधनों / आवश्यक नई कार्यक्षमता का एक उचित समझौता है।

  • कम से कम व्यवसाय और दृढ़ता परतों से अलग प्रस्तुति परत।
  • एक नई उई और बेहतर प्रस्तुति परत को लागू करें जो समान सामान्य व्यवसाय और दृढ़ता परत का उपयोग करता है।
  • सत्यापित करें कि नए ui के साथ बनाया गया डेटा पुराने ui को नहीं तोड़ता है। (यदि आप नए टूल के उपयोगकर्ता पुराने टूल के उपयोगकर्ताओं को बाधित करते हैं तो आप गर्म पानी में रहने वाले हैं)। यदि आप पूर्ण पश्चगामी अनुकूलता के लिए प्रयास कर रहे हैं तो आपको उसी दृढ़ता की परतों में सब कुछ सहेजना चाहिए। यदि आप अभी नए टूल में फॉरवर्ड कम्पेटिबिलिटी चाहते हैं तो डेटा को ट्रैक करने के लिए एक नए डेटाबेस और नए टेबल या एक्सटेंशन टेबल का उपयोग करें, जो लीगेसी सिस्टम में नहीं है।
  • नई कार्यक्षमता और दृढ़ता की आवश्यकता के लिए नई तालिकाओं को जोड़ने की आवश्यकता है और विधियाँ मौजूदा विरासत तर्क को नहीं बदलती हैं, या मौजूदा तालिकाओं में कॉलम, बाधाओं को जोड़ते हैं। उदाहरण के लिए, यदि आपको नियोक्ताओं के आपातकालीन संपर्क पर नज़र रखने की आवश्यकता है और कुछ अन्य फ़ील्ड मौजूदा कर्मचारी तालिका को संशोधित नहीं करते हैं (हमें पता नहीं है कि विरासत डेटा उस तालिका के बारे में क्या धारणा बनाती है) एक एक्सटेंशन टेबल कर्मचारी_टेक्स्ट, कर्मचारी_ आईडी, आपातकालीन_कनेक्ट_ड, इत्यादि जोड़ें।
  • नए सिस्टम पर उपयोगकर्ताओं को धीरे-धीरे माइग्रेट करें। यदि संभव हो तो लीगेसी प्रणाली को केवल मोड में पढ़ें, या कुछ उपयोगकर्ताओं को यह कहते हुए चेतावनी दें कि यह अब दिनांक X के बाद उपलब्ध नहीं होगा।
  • नई ui में किसी भी उच्च प्राथमिकता वाली चूक या व्यावसायिक आवश्यकताओं को लागू करना
  • उपयोगकर्ताओं के आधार पर रोल करें।
  • व्यापार तर्क और दृढ़ता परत उपयोगकर्ताओं को अन्य refactoring तरीकों को साफ करने के लिए जारी है।

0

मैं कहूंगा कि रिफ्रैक्टर बनाम रिफ्राइट स्पेस में एक तीसरी श्रेणी है ... और यह आपके भाषा संस्करणों, संकलक और पुस्तकालयों को अपडेट कर रहा है ... कभी-कभी सिर्फ आधुनिक कोडिंग तकनीकों को अपनाने से बहुत लाभ होता है।

उदाहरण के लिए C # को लें, v7 कोड बहुत क्लीनर, सुरक्षित और v2 की तुलना में अधिक संक्षिप्त लिखता है .. एल्विस और नल coalescing ऑपरेटर जैसी चीजें एक टन को बाहर निकालने में मदद करती हैं।

संकलक स्विचन भी पुराने कोड में नए जीवन की सांस ले सकता है। तो हो सकता है कि नए पुस्तकालयों के साथ काम करने और लागू करने के लिए चीजें आसान हों ... नेटवर्किंग कार्यान्वयन कठिनाई के स्पेक्ट्रम का एक बड़ा उदाहरण है।

इसके अलावा- एम्बेडेड लिनक्स सिस्टम ... नए टूल्स को स्थापित करने के बारे में सोचें- svn से स्विच करें। या अपने सिस्टम आदि में Vi जोड़ें।

यह हमेशा एक लेखक के रूप में फिर से लिखना नहीं करता है .. आपकी वास्तुकला में सुधार की आवश्यकता है, लेकिन यह काम करता है ... शायद आपको यह सोचने की ज़रूरत है कि आपका कोड कैसे लिखा गया है आदि।


-2

मुझे नहीं लगता कि मैंने कभी लोगों को एक विरासत ऐप को फिर से लिखते देखा है ।

क्या होता है कि लोग एक अलग वास्तुकला, प्रौद्योगिकियों, आदि के साथ पूरी तरह से नए एप्लिकेशन लिख रहे हैं, जिनमें पिछली पीढ़ी के साथ आम तौर पर कुछ विशेषताएं हैं। और इसे ऐप 2.0 कहा जाता है, लेकिन वास्तव में इसमें मूल के साथ बहुत कम चीजें होती हैं।

लेकिन यह वास्तव में इस अर्थ में मूल का "पुनर्लेखन" नहीं है कि आप फ़ीचर समानता को प्राप्त करने की कोशिश कर रहे हैं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.