एक बड़े और जटिल सॉफ्टवेयर उत्पाद को वर्षों तक कैसे बनाए रखा जा सकता है?


156

मैं कई सालों से एक सॉफ्टवेयर डेवलपर के रूप में काम कर रहा हूं। यह मेरा अनुभव रहा है कि परियोजनाएं अधिक जटिल और अचूक होती हैं क्योंकि अधिक डेवलपर्स उत्पाद के विकास में शामिल होते हैं।

ऐसा लगता है कि विकास के एक निश्चित चरण में सॉफ़्टवेयर में "हैकर" और "हैकर" प्राप्त करने की प्रवृत्ति होती है, खासकर जब टीम के सदस्यों में से कोई भी कंपनी में वास्तुकला के काम को परिभाषित नहीं करता है।

मुझे यह निराशा होती है कि एक डेवलपर जिसे कुछ बदलना है, उसे वास्तुकला की बड़ी तस्वीर प्राप्त करने में मुश्किल समय होता है। इसलिए, समस्याओं को ठीक करने या मूल वास्तुकला के खिलाफ काम करने वाले तरीके में बदलाव करने की प्रवृत्ति है। परिणाम कोड है जो अधिक से अधिक जटिल हो जाता है और यहां तक ​​कि समझने में कठिन होता है।

क्या स्रोत कोड को वास्तव में वर्षों तक बनाए रखने के बारे में कोई उपयोगी सलाह है?


9
अत्यधिक अनुशंसा वाली पुस्तकें: स्टीव मैककोनेल द्वारा 'सॉफ्टवेयर प्रोजेक्ट सर्वाइवल गाइड', स्टीव मैककोनेल द्वारा 'रैपिड डेवलपमेंट', मार्टिन फाउलर द्वारा 'रिफैक्टिंग'
इमरान उमर बुकश

15
... और अंकल बॉब द्वारा 'क्लीन कोड';) (रॉबर्ट सी। मार्टिन)
गंडालफ

34
क्या यह बहुत सवाल नहीं है, जिसने कई दशकों तक विश्वविद्यालयों में भारी पढ़ने और पूरे पाठ्यक्रम के लायक बनाया है?
detly

17
@ एरिक यिन - मैं टिप्पणियों पर असहमत हूं। मेरे लिए वे एक कोड गंध हैं और लंबे समय तक परियोजनाओं में अच्छे से अधिक नुकसान करते हैं क्योंकि वे अनिवार्य रूप से तारीख को प्राप्त करते हैं और भ्रामक हो जाते हैं।
JohnFx

8
@ एरिक यिन: स्व-दस्तावेजीकरण कोड के लिए प्रयास करते हैं। केवल इरादे की टिप्पणियों का उपयोग करें जहां वे समझ बढ़ाते हैं।
मिच गेहूं

जवाबों:


138

कोड रोट से बचने का एकमात्र वास्तविक समाधान अच्छी तरह से कोड करना है!

अच्छी तरह से कोड कैसे करें यह एक और सवाल है। यहां तक ​​कि अगर आप एक उत्कृष्ट प्रोग्रामर हैं, तो यह काफी कठिन है। एक विषम टीम में, यह अभी भी बहुत कठिन हो जाता है। आउटसोर्स (उप) परियोजनाओं में ... बस प्रार्थना करें।

सामान्य अच्छी प्रथाओं में मदद मिल सकती है:

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

8
ये महान बिंदु हैं। मुझे यह स्वीकार करना चाहिए कि मैं "इसे सरल बनाए रखता हूं" के साथ संघर्ष करता हूं। यह अलग-अलग संदर्भों में अलग-अलग लोगों के लिए अलग-अलग चीजों का मतलब लगता है, जो "सरल" बल्कि जटिल बनाता है (लेकिन फिर मेरे पास चीजों को जटिल करने की एक प्राकृतिक प्रवृत्ति है)।
क्रामि

3
मैं आपकी बातों से पूरी तरह सहमत हूं, खासकर "केआईएस"। लेकिन मुझे एक प्रवृत्ति दिखाई देती है कि अधिक से अधिक (युवा?) डेवलपर्स यहां तक ​​कि सबसे सरल संदर्भों का वर्णन करने के लिए जटिल संरचनाओं का उपयोग करते हैं।
१०:१२


8
उम्म, और "8. इसे सरल रखें"।
दाऊद इब्न करीम

7
# 6 एक +10 के योग्य है।
जिम जी।

55

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

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

एक अच्छा साइड इफेक्ट के रूप में, यूनिट परीक्षण भी आपके बग की गिनती को कम करने की उम्मीद करेंगे।


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

40

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

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

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


बहुत अच्छी बात है, आप बैल की आंख मारा! कहने के लिए दु: खी है, लेकिन वास्तव में यहाँ क्या हो रहा है। और बिना टेक लीड के चीजों को बदलना नामुमकिन
सा लगता है

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

1
@ मर्फ़ आपको रखरखाव के चरण के दौरान सभी-जानने वाली टीम का नेतृत्व क्यों नहीं करना चाहिए? मैंने कभी भी हर बॉस से अपेक्षा की थी कि टीम लीड से कुछ भी कम नहीं है, और जब मैं टीम लीड था तो मुझे खुद से कम की उम्मीद नहीं थी।
maple_shaft

1
@maple_shaft क्योंकि a) मुझे नहीं लगता कि उस एक प्रोजेक्ट के लिए समर्पित एक टीम लीड है और यह पहली आवश्यकता से कम या ज्यादा है और बी) मुझे लगता है कि आपको डिज़ाइन और इम्प्लांटेशन (यह सब) को समझने की आवश्यकता है और वह है कठिन। एक तरफ हम सभी का तर्क है कि हमें अपनी परियोजनाओं पर सभी जानकारियों का एक भी फ़ॉन्ट नहीं होना चाहिए और फिर भी यहां हम कह रहे हैं कि हमें एक होना चाहिए? यह जोड़ नहीं है?
मर्फ़

2
@maple_shaft शायद मुझे एक गंभीर पुराने प्रोग्रामर होने के नाते (-: लेकिन इसमें एक समस्या है कि यह अक्सर "स्टाइल" को लागू करता है जिसे मौजूदा कोडबेस में गहराई से पालन करने की आवश्यकता होती है - और यह कोडर और लीड दोनों के लिए विदेशी हो सकता है (बहुत सारे के लिए) वास्तविक दुनिया के कारणों से)
मर्फ़

18

कई चीजें हैं जो हम कर सकते हैं:

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

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

एक ऐसे वातावरण का विकास करें जहाँ वास्तु निर्णय आसानी से संप्रेषित होते हैं। लोगों को डिजाइन और वास्तुकला के बारे में बात करने के लिए प्रोत्साहित करें - न केवल वर्तमान परियोजना के संदर्भ में, बल्कि सामान्य रूप से भी।

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

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

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


1
+1, विशेष रूप से "एक टीम बनाने के लिए जो एक साथ अच्छी तरह से काम कर सकती है और वास्तव में एक काम करने वाले उत्पाद को शिप कर सकती है।"
डेवोरडे

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

1
@ कैस्पर: बिल्कुल। आप व्यक्त करते हैं कि मैंने जो कुछ किया था उससे बेहतर मेरे मन में था।
क्रामि

18

जिस तरह से मैं इस मुद्दे के बारे में जा रहा हूं वह इसे जड़ से खत्म करना है:

मेरी व्याख्या Microsoft / .NET से शर्तों का उपयोग करेगी , लेकिन किसी भी प्लेटफ़ॉर्म / टूलबॉक्स पर लागू होगी:

  1. नामकरण, कोडिंग, चेकइन, बग फ्लो, प्रक्रिया प्रवाह के लिए मानकों का उपयोग करें - मूल रूप से कुछ भी।
  2. मानकों का पालन नहीं करने वाले टीम के सदस्यों को अलविदा कहने से डरो मत। कुछ डेवलपर्स केवल मानकों के एक निर्धारित सेट के भीतर काम नहीं कर सकते हैं और कोड-बेस को साफ रखने के लिए युद्ध के मैदान पर 5 वें स्तंभ दुश्मन बन जाएंगे
  3. लंबे समय तक परीक्षण करने के लिए कम कुशल टीम के सदस्यों को आवंटित करने से डरो मत।
  4. सड़ने वाले कोड में जांच से बचने के लिए अपने शस्त्रागार में प्रत्येक उपकरण का उपयोग करें: इसमें समर्पित उपकरण, साथ ही पूर्व-लिखित इकाई परीक्षण शामिल हैं जो बिल्ड फ़ाइलों, प्रोजेक्ट फ़ाइलों, निर्देशिका संरचना, आदि का परीक्षण करते हैं।
  5. लगभग 5-8 सदस्यों की एक टीम में, आपका सबसे अच्छा लड़का लगभग लगातार काम कर रहा है - उस गंदगी को साफ करना जो दूसरे को पीछे छोड़ते हैं। यहां तक ​​कि अगर आप क्षेत्र में सबसे अच्छा विशेषज्ञ पाते हैं, तो भी आपके पास एक गड़बड़ होगी - यह अपरिहार्य है, लेकिन इसे निरंतर रिफैक्टिंग द्वारा विवश किया जा सकता है।
  6. इकाई परीक्षण लिखें और उन्हें बनाए रखें - परियोजना को साफ रखने के लिए इकाई परीक्षणों पर निर्भर न रहें, वे नहीं करते हैं।
  7. सब कुछ पर चर्चा करें। टीम में चीजों पर चर्चा करने के लिए घंटे खर्च करने से डरो मत। यह जानकारी का प्रसार करेगा और खराब कोड के मूल कारणों में से एक को हटा देगा: प्रौद्योगिकियों, लक्ष्यों, मानकों आदि पर भ्रम।
  8. Be बहुत कोड लिखने सलाहकार के साथ सावधान: अपने कोड, लगभग परिभाषा से, वास्तविक shitty सामान हो जाएगा।
  9. चेकइन से पहले प्रक्रिया कदम के रूप में अधिमानतः करें। रोलबैक कमिट करने से न डरें।
  10. रिलीज से पहले अंतिम चरण में कभी भी खुले / करीबी सिद्धांत का उपयोग न करें : यह केवल सड़ने वाले कोड को गंध की ओर ले जाता है।
  11. जब भी किसी समस्या का सामना किया जाता है, तो समाधान को लागू करने से पहले उसे पूरी तरह से समझने के लिए समय निकालें - अधिकांश कोड सड़ांध समस्याओं के समाधान को पूरी तरह से समझ में नहीं आने से आती है।
  12. सही तकनीकों का उपयोग करें। ये अक्सर सेट में आते हैं और नए सिरे से होते हैं: यह एक फ्रेमवर्क के बीटा संस्करण पर निर्भर करने के लिए बेहतर है जिसे आप भविष्य में समर्थन से सुनिश्चित कर रहे हैं, बेहद स्थिर, लेकिन अप्रचलित फ्रेमवर्क पर निर्भर रहने के लिए, जो असमर्थित हैं।
  13. श्रेष्ठ लोगों को काम पर रखें।
  14. बाकी लेट - आप एक कॉफी शॉप नहीं चला रहे हैं।
  15. यदि प्रबंधन सबसे अच्छा आर्किटेक्ट नहीं है और वे निर्णय लेने की प्रक्रिया में हस्तक्षेप करते हैं - तो दूसरी नौकरी ढूंढें।

1
अब, 'खाली समय' में C # री-राइट पर काम करने के दौरान 100 फॉर्म और कक्षाओं के साथ एक बुरे सपने वाले 12 साल पुराने VB6 ऐप को बनाए रखने और बढ़ाने के लिए आप क्या करेंगे?
jfrankcarr

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

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

1
"# 10 से असहमत - यदि कोड गुणवत्ता के साथ मदद करता है अगर सही ढंग से किया जाता है" यह मेरे काम के अनुभव में बिल्कुल गलत है: कोड लॉक दूर नहीं किया जा सकता है, जिसका अर्थ है कि यह अपनी वर्तमान स्थिति में खुला रहेगा। इस अवस्था को किसी चरण में काम करने के लिए सत्यापित किया जा सकता है, लेकिन बाद के चरण में यह सत्यापन एक गलत सकारात्मक है: अंतिम प्रणाली परीक्षण से पहले चरण तक सभी कोड को फिर से तैयार करने के लिए खुला छोड़ दिया जाना चाहिए।
कास्पर

3
@ कैस्पर: IMHO, खुले / बंद सिद्धांत को "आप स्रोत को बदल नहीं सकते" के रूप में नहीं समझा जाना चाहिए, बल्कि "कोड को डिज़ाइन करें जैसे कि यह जमे हुए हो जाएगा"। यह सुनिश्चित करें कि कोड को बिना परिवर्तन के पुन: व्यवस्थित करने के लिए यह संभव है कि कोड को विस्तारित किया जाए। परिणाम औसत कोड की तुलना में अनजाने में अधिक शिथिल युग्मित और अत्यधिक सामंजस्यपूर्ण है। तीसरे पक्ष द्वारा उपयोग के लिए एक पुस्तकालय विकसित करते समय यह सिद्धांत भी महत्वपूर्ण है, क्योंकि वे केवल अपने कोड को अंदर नहीं जा सकते हैं और संशोधित नहीं कर सकते हैं, इसलिए आपको इसे ठीक से एक्स्टेंसिबल करने की आवश्यकता है।
केविन कैथार्ट

12

यूनिट टेस्ट लिखते समय, रिफैक्टरिंग द्वारा क्लीन रॉटेड कोड। जब भी आप जो भी कोड छूते हैं, उस पर (इस) डिज़ाइन ऋण का भुगतान करें:

  • एक नई सुविधा विकसित करें
  • एक समस्या ठीक करें

अपने परीक्षण-प्रथम विकास चक्र को बहुत तेज़ी से गति दें:

  • कोड मॉड्यूल को स्क्रिप्टिंग भाषा में बदलने के लिए रीफैक्टरिंग
  • तेज, क्लाउड-आधारित परीक्षण मशीनों का उपयोग करें

निम्न युग्मन का उपयोग करने के लिए रिफ्लेक्टर कोड (अत्यधिक आंतरिक रूप से चिपकने वाली इकाइयों का):

  • सरल, (अधिक) कार्य (दिनचर्या)
  • मॉड्यूल
  • ऑब्जेक्ट (और कक्षाएं या प्रोटोटाइप)
  • शुद्ध कार्य (दुष्प्रभावों के बिना)
  • विरासत पर, प्रतिनिधिमंडल का जिक्र
  • परतें (एपीआई के साथ)
  • छोटे, एक-उद्देश्य कार्यक्रमों के संग्रह जो एक साथ काम कर सकते हैं

जैविक विकास अच्छा है; बड़ा अप-फ्रंट डिजाइन खराब है।

एक नेता है जो मौजूदा डिजाइन के बारे में जानकार है। यदि नहीं, तो परियोजना के कोड को तब तक पढ़ें जब तक आप जानकार न हों।

किताबों को फिर से पढ़ना।


1
+1 अच्छा पहला जवाब, खुद को हमसे मिलाने का सही तरीका!
यानिस

11

सरल उत्तर: आप नहीं कर सकते

इसलिए आपको छोटे और सरल सॉफ्टवेयर लिखने का लक्ष्य रखना चाहिए । यह आसान नहीं है।

यह केवल तभी संभव है जब आप इसे सरल और संक्षिप्त तरीके से परिभाषित करने के लिए अपनी प्रतीत होने वाली जटिल समस्या के बारे में लंबे समय तक सोचते हैं।

समस्याओं का समाधान जो वास्तव में बड़ा और जटिल है, अक्सर छोटे और सरल मॉड्यूल के निर्माण से हल किया जा सकता है।

दूसरे शब्दों में, जैसा कि अन्य ने बताया, सरलता और ढीली युग्मन प्रमुख तत्व हैं।

यदि यह संभव या संभव नहीं है, तो आप शायद अनुसंधान कर रहे हैं (जटिल समस्याओं के बिना कोई सरल समाधान, या बिना किसी ज्ञात समाधान के)। अनुसंधान को बनाए रखने योग्य उत्पादों का सीधे उत्पादन करने की अपेक्षा न करें, यह वह नहीं है जिसके लिए अनुसंधान है।


9

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

सभी में हम कोड बेस को बनाए रखने का एक उचित काम किया है। हमने जो मुख्य काम किए हैं, वे निम्न हैं:

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

2) एक साफ-सुथरा विकास का माहौल रखें - अब उपयोग किए जाने वाले कोड को हटाने के बारे में सतर्क रहें, और परियोजना निर्देशिका में बैकअप प्रतियां / काम करने वाली प्रतियां / प्रयोगात्मक कोड मौजूद न रखें।

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


8

चूंकि आपने परियोजना प्रबंधन के साथ प्रश्न को टैग किया है, इसलिए मैंने कुछ गैर-कोड बिंदुओं को जोड़ने की कोशिश की है :)

  • टर्नओवर की योजना - मान लें कि जब तक यह अपने रखरखाव चरण को पूरा नहीं करता है, तब तक पूरी विकास टीम गायब हो जाएगी - कोई भी डेवलपर अपने नमक को हमेशा के लिए अपने सिस्टम को बनाए रखना चाहता है। समय रहते ही हैंडओवर सामग्री तैयार करना शुरू कर दें।

  • संगति / एकरूपता पर पर्याप्त बल नहीं दिया जा सकता है। यह 'अकेले जाओ' की संस्कृति को हतोत्साहित करेगा और नए डेवलपर्स को पूछने के लिए प्रोत्साहित करेगा, अगर वे संदेह में हैं।

  • इसे मुख्यधारा में रखें - उपयोग की जाने वाली प्रौद्योगिकियां, डिज़ाइन पैटर्न और मानक - क्योंकि टीम के लिए एक नया डेवलपर (किसी भी स्तर पर) जल्दी से उठने और चलने की अधिक संभावना होगी।

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

  • नियमों को स्पष्ट रूप से रखें - न केवल आपकी वर्तमान विकास टीम के लिए, बल्कि भविष्य के रखरखाव डेवलपर्स के बारे में सोचें। यदि इसका अर्थ है कि प्रत्येक पृष्ठ पर प्रासंगिक डिज़ाइन और कोडिंग मानक प्रलेखन के लिए हाइपरलिंक डालना, तो ऐसा ही हो।

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


7

अत्यधिक अभेद्य कोड की एक संपत्ति फ़ंक्शन शुद्धता है

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

यह संपत्ति युग्मन / सामंजस्य गुणों की तुलना में गवाह करना आसान है। आपको इसे प्राप्त करने के लिए अपने रास्ते से बाहर जाने की ज़रूरत नहीं है, और मैं व्यक्तिगत रूप से इसे अधिक मूल्यवान मानता हूं।

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

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

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


2
आप जो वर्णन करते हैं उसका एक और नाम निर्धारक होने की संपत्ति है
jinglesthula

6

अन्य उत्तरों के अलावा, मैं परतों की सिफारिश करूंगा। बहुत सारे नहीं बल्कि विभिन्न प्रकार के कोड को अलग करने के लिए पर्याप्त है।

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

एक और तरीका यह है कि सभी को कॉम्पर्ट और द डेली डब्ल्यूटीएफ पढ़ने को मिले ताकि वे खराब डिजाइन और खराब प्रोग्रामिंग के परिणामों को सीख सकें और वे डेली डब्ल्यूटीएफ पर पोस्ट किए गए अपने स्वयं के कोड को देखकर डर जाएंगे ।


6

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

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

दस्तावेज़ीकरण नहीं टिप्पणियाँ, कोड ज्यादातर स्व दस्तावेजीकरण होना चाहिए, लेकिन डिज़ाइन दस्तावेज़, श्रेणी पदानुक्रम और निर्भरता, वास्तु प्रतिमान, आदि कुछ भी जो कोड आधार को समझने के लिए एक नया, या यहां तक ​​कि मौजूदा, प्रोग्रामर की मदद करता है। इसके अलावा, उन विषम छद्म पुस्तकालयों का दस्तावेजीकरण करना जो अंततः पॉप-अप करते हैं, जैसे "इस कार्यक्षमता के लिए इस वर्ग को एक तत्व में जोड़ें" मदद कर सकता है, क्योंकि यह लोगों को पुन: लेखन कार्यक्षमता से भी रोकता है।

हालाँकि, यदि आपके पास एक गंभीर समय सीमा है, तो भी मुझे लगता है कि एक और अच्छी बात यह है:

हैक और त्वरित सुधार से बचें । जब तक क्विक फिक्स वास्तविक फिक्स नहीं होता है, तब तक अंतर्निहित समस्या का पता लगाना हमेशा बेहतर होता है, और फिर उसे ठीक करें। जब तक आप सचमुच "अगले 2 मिनट में यह काम कर रहे हैं, या आप निकाल रहे हैं" परिदृश्य, जब तक कि अब ठीक करना एक बेहतर विचार है, क्योंकि आप बाद में कोड को ठीक करने नहीं जा रहे हैं, आप बस जा रहे हैं आपके पास अगले कार्य पर जाएं।

और मेरा व्यक्तिगत पसंदीदा टिप एक उद्धरण से अधिक है, हालांकि मुझे स्रोत याद नहीं है:

"ऐसा कोड मानें कि आपके बाद आने वाला व्यक्ति एक समलैंगिक मनोरोगी है जो जानता है कि आप कहां रहते हैं"


मैंने हमेशा फ़ंक्शन और क्लास टिप्पणियों को उपयोगी पाया है, भले ही सिंटैक्स हाइलाइटिंग का उपयोग करके फ़ंक्शन और क्लास स्थानों पर कोड सेगमेंट को अलग करने के लिए। मैं बहुत कम ही फ़ंक्शन कोड में टिप्पणी करता हूं, लेकिन मैं हर वर्ग और फ़ंक्शन के लिए एक पंक्ति लिखता हूं, जैसे /** Gets the available times of a clinic practitioner on a specific date. **/या /** Represents a clinic practitioner. **/
निक बेडफोर्ड

5

एक सिद्धांत जिसका उल्लेख नहीं किया गया है, लेकिन यह महत्वपूर्ण है कि मैं खुला / बंद सिद्धांत हूं ।

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

बस मेरे 2 सेंट।


क्या होगा अगर व्यावसायिक आवश्यकताओं को वर्किंग कोड में व्यक्त किया जाए? खराब रूप से फैक्टेड लेकिन तकनीकी रूप से 'वर्किंग' कोड पर एक-न-टच आपको लंबे समय में नुकसान पहुंचा सकता है, खासकर जब आवश्यक परिवर्तन करने का समय आता है।
जिंगलेशूला

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

5
  • स्काउट बनो । हमेशा कोड क्लीनर को छोड़ दिया, जितना आपने पाया।

  • टूटी खिड़कियों को ठीक करें । जब आप संस्करण 3.0 पर होते हैं, तो वे सभी टिप्पणियां "संस्करण 2.0 में बदल जाती हैं"।

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

  • क्या धारणाएं अब सच नहीं हैं जो एक विशेष दिशा में डिजाइन को धक्का देती हैं? हो सकता है कि उस गड़बड़ के पीछे कोई छोटी-मोटी रिफ्लेक्टरिंग छिपी हो।

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

  • एक सप्ताह एक टीम को चेतावनी को हटाने के रूप में बिताएं ताकि वास्तविक समस्याएं दिखाई दें।

  • सभी कोड को कोडिंग मानक पर रिफ़ॉर्मेट करें।

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

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

  • विकी पर डिज़ाइन दस्तावेज़ों को पुनः प्रकाशित करें। यह ज्ञान को संस्थागत बनाने में मदद करता है।

  • रिलीज़ और बिल्ड के लिए चेकलिस्ट जैसी प्रक्रियाएँ लिखें। इससे लोगों को सोचना बंद हो जाता है, इसलिए वे समस्याओं को हल करने पर ध्यान केंद्रित कर सकते हैं। जहाँ भी संभव हो, स्वचालित बनाता है।

  • निरंतर एकीकरण का प्रयास करें । जितनी जल्दी आप एक असफल निर्माण प्राप्त करते हैं, उतनी ही कम समय में परियोजना रेल को बंद कर सकती है।

  • यदि आपकी टीम लीड इन चीजों को नहीं करती है, तो यह कंपनी के लिए बुरा है।

  • यह सुनिश्चित करने की कोशिश करें कि सभी नए कोड को मापा कवरेज के साथ उचित इकाई परीक्षण प्राप्त हों। तो समस्या ज्यादा खराब नहीं हो सकती।

  • यूनिट के कुछ पुराने बिट्स की जांच करने की कोशिश करें जो यूनिट टेस्टेड नहीं हैं। यह परिवर्तन के डर को वापस काटने में मदद करता है।

  • यदि आप अपने एकीकरण और प्रतिगमन परीक्षण को स्वचालित कर सकते हैं। कम से कम एक चेकलिस्ट है। पायलट स्मार्ट होते हैं और उन्हें बहुत भुगतान मिलता है और वे चेकलिस्ट का उपयोग करते हैं। वे भी शायद ही कभी पेंच।


4

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


3

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

इस आशय को सीमित करने का तरीका एक अच्छे डिजाइन के साथ शुरू करना है जो कि विस्तार से निपटने के लिए काफी लचीला है। इस पर कई सुझाव पहले ही पेश किए जा चुके हैं।

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


2

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

एक लंबी चलने वाली परियोजना को बनाए रखना एक व्यक्तिगत डेवलपर के रूप में परियोजना प्रबंधक की अधिक जिम्मेदारी है।

लोग हैक का परिचय नहीं देते क्योंकि वे इसे पसंद करते हैं; वे परिस्थितियों से मजबूर हैं।


परिस्थितियों से मजबूर? लोग हैक का परिचय देते हैं क्योंकि (ए) वे बेहतर नहीं जानते हैं => कोचिंग की जरूरत है, (बी) वे बड़ी तस्वीर नहीं देखते हैं => संचार, प्रलेखन और अनुशासन की जरूरत है, (सी) उन्हें लगता है कि वे चालाक हैं => यह सबसे बड़ा है परिस्थितियों से मजबूर (डी) को दूर करने के लिए बाधा => त्वरित दबाव समय के दबाव में ठीक होते हैं, लेकिन किसी को जिम्मेदारी लेनी होगी और बाद में कोड को साफ करना होगा। किसी भी अन्य "परिस्थिति" बस बी एस है । अंगूठे के उस नियम के अपवाद हैं, लेकिन सबसे तथाकथित अपवाद "आलसी" हैं।
JensG

2

मैं सिर्फ एक गैर-तकनीकी मुद्दा और एक (शायद) व्यावहारिक दृष्टिकोण रखना चाहता हूं।

यदि आपका प्रबंधक तकनीकी गुणवत्ता (प्रबंधनीय कोड, सरल वास्तुकला, विश्वसनीय बुनियादी ढांचे, और इसी तरह) के बारे में परवाह नहीं करता है, तो परियोजना में सुधार करना कठिन हो जाता है। इस मामले में कहा जाता है कि प्रबंधक को शिक्षित करना और बनाए रखने और तकनीकी ऋण को संबोधित करने में प्रयासों को "निवेश" करने के लिए राजी करना आवश्यक है ।

यदि आप उन पुस्तकों में पाए गए कोड गुणवत्ता के साथ सपने देखते हैं, तो आपको एक बॉस की भी आवश्यकता है जो इस बारे में चिंतित है।

या यदि आप सिर्फ एक "फ्रेंकस्टीन परियोजना" को वश में करना चाहते हैं, तो ये मेरे सुझाव हैं:

  • व्यवस्थित और सरल करें
  • छोटा कार्य
  • दक्षता पर पठनीयता को प्राथमिकता दें (जब निश्चित रूप से स्वीकार्य हो, और कुछ दक्षता लाभ रखा जाना बहुत दुखी हो)

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

फ़ीचर कार्यान्वयन और बग फिक्स से परे, कोड क्लीन-अप के लिए अपना समय लें।


"... परियोजना मेरे अनुभव में बर्बाद है" - यह जरूरी नहीं है। वैकल्पिक कहा जाता है कि प्रबंधक को शिक्षित करने और "निवेश" प्रयासों को बनाए रखने और तकनीकी-ऋण
gnat

क्षमा करें, मैं खुद को यह लिखने में रोक नहीं पाया कि जैसा कि मेरे पास पहले से ही एक अनुभव था जब प्रबंधक ने तकनीकी-ऋण की मेरी सभी सलाह को अनदेखा कर दिया था। लेकिन मुझे लगता है कि आप सही हैं: उस परियोजना को छोड़ने के लगभग एक साल बाद, प्रबंधक ने उन्हें प्रबंधित करने में असमर्थता के लिए टेक-टीम पर अपने सभी अधिकार खो दिए।
19.

1

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

उन पुस्तकालयों में जो भी प्रोग्रामिंग तकनीकों का उपयोग करें, जो पुस्तकालय के उपयोग को आसान बनाते हैं। ध्यान दें कि किसी भी गैर-ऑब्जेक्ट-ओरिएंटेड भाषा का समर्थन करने वाले फ़ंक्शन पॉइंटर्स वास्तव में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) का समर्थन कर रहे हैं। इसलिए, C में उदाहरण के लिए, आप OOP कर सकते हैं।

आप कई परियोजनाओं के बीच उन छोटे, स्वतंत्र पुस्तकालयों को साझा करने पर भी विचार कर सकते हैं (गिट सबमॉड्यूल आपके दोस्त हैं)।

कहने की जरूरत नहीं है, प्रत्येक छोटे, स्वतंत्र पुस्तकालय को इकाई-परीक्षण किया जाना चाहिए। यदि कोई विशेष पुस्तकालय इकाई-परीक्षण योग्य नहीं है, तो आप कुछ गलत कर रहे हैं।

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


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

0

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

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

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

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

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