आप किसी प्रोग्राम को इन-डेवलपमेंट से रिलीज़ करने के लिए कैसे परिवर्तित करते हैं?


67

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

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

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

बेहतर / पाठ्यपुस्तक के तरीके हैं, मुझे यकीन है। लेकिन मुझे एक वास्तविक कार्य वातावरण में काम करना होगा जहां सब कुछ पाठ्यपुस्तक नहीं है।

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

संपादित करें

मैं कुछ बातें स्पष्ट करना चाहता हूं।

  • मैं इसे ठीक से करने से पहले 100% हूं और बाद में नहीं, कोड साफ और पठनीय है। लेकिन मुझे भी काम करना होगा और कोड की सुंदरता के बारे में सब साफ और चमकदार नहीं हो सकता। मुझे एक समझौता खोजना होगा।

  • अक्सर एक नई सुविधा वास्तव में सिर्फ एक चीज होती है जिसे हम आज़माना चाहते हैं और देखते हैं कि क्या यह इस तरह से कुछ को लागू करने के लिए समझ में आता है। (मोबाइल ऐप में जासूसी, वास्तविक डिवाइस पर वास्तविक रूप से देखने और महसूस करने के लिए) इसलिए यह कुछ छोटा है जो (imho) पहले "चलो देखते हैं" पुनरावृत्ति में बहुत अधिक काम का औचित्य नहीं रखता है। हालांकि कभी-कभी यह सवाल उठता है कि मैं इस Tech.debt का भुगतान कैसे करूं? यही सवाल है।

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


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

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

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

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

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

जवाबों:


98

इसलिए मैं उस समय सुपर क्लीन कोड लिखने में ज्यादा समय बर्बाद नहीं करता क्योंकि मुझे कभी नहीं पता कि कुछ समय तक रहता है।

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

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

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

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

मैं परीक्षण के बीच में हूं और बग फिक्स एक फिर से लिखना होगा

... जो मैंने ऊपर लिखा है, उसके लिए वास्तविक प्रमाण है: जब आप अपने कोड को डीबग करना शुरू करते हैं, तो तुरंत "गंदा" हो जाता है और आपको धीमा कर देगा।

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

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


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

44
@ निक्कीडी: यह टाइमफ्रेम ब्लोट नहीं करता है। समय सीमा पहले ही फूला हुआ था; जब आप सॉफ्टवेयर लिखते हैं और आपने जिस तकनीकी ऋण के लिए बजट नहीं दिया था, उस ब्लोट के लिए आपने अभी-अभी खाता नहीं बनाया है।
एरिक लिपर्ट

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

10
@NikkyD: नहीं, मैं आपके कोड को इसी तरह लिखने का सुझाव देता हूं कि कैसे एक बिलियर्ड विशेषज्ञ अपनी गेंदों को खेलता है: प्रत्येक शॉट बाहरी व्यक्ति के लिए सरल दिखता है, क्योंकि शॉट के बाद गेंदें एक नए "सरल शॉट" के लिए स्थिति में रुक जाती हैं। और बिलियर्ड या कोडिंग में, अभ्यास के कुछ साल लगते हैं ;-)
डॉक्टर ब्राउन

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

22

आपके पास दो अलग-अलग समस्याएं हैं, दोनों एक ही लक्षण (मैला कोड) के साथ:

समस्या # 1: अपर्याप्त आवश्यकताओं पर नियंत्रण का मतलब यह नहीं है कि आपके हितधारक आपकी आवश्यकताओं को अक्सर बदलते हैं, मेरा मतलब है कि आप बगफिक्स / टेस्ट चक्र के दौरान आवश्यकताओं को बदलने की अनुमति दे रहे हैं। यहां तक ​​कि चुस्त तरीके भी उस का समर्थन नहीं करते हैं; आप निर्माण करते हैं, आप परीक्षण करते हैं, आप वितरित करते हैं, आप नई आवश्यकताओं को इंजेक्ट करते हैं।

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

इसके अलावा, कृपया समझें कि आप एक डेवलपर के रूप में सबसे कठिन स्थिति में काम कर रहे हैं: इन-हाउस डेवलपर के जीवन पर जोएल स्पोल्स्की को पढ़ें । इसलिए, यदि आपको अपनी पवित्रता को बरकरार रखना है तो आपको अतिरिक्त सतर्क रहने की जरूरत है।


21

यह एक आम समस्या है - खासकर जब क्राफ्टिंग अनिवार्य रूप से एक सॉफ्टवेयर परीक्षण गुब्बारा है जैसा कि यह था।

कई दृष्टिकोण हैं जो मदद कर सकते हैं। सबसे पहले TDD दृष्टिकोण कोड आधार को कम करने में मदद कर सकता है जो कि कड़ाई से आवश्यक है। यदि आपके परीक्षण आपके कोड के साथ हाथ में जाते हैं, तो आपको कम से कम कुछ विश्वास हो सकता है कि आपका कोड वैसा ही व्यवहार करे जैसा कि उसे करना चाहिए।

जाते समय रिफ्लेक्टर के लिए समय निकालें। एक बार जब आपके पास एक प्रोटोटाइप होता है और ग्राहक उस पर अपना हाथ पाने के लिए अति-उत्सुक होता है, तो यह कहना मुश्किल है कि आपको क्या (उन्हें) चमकाने के लिए समय चाहिए। मैं एक दैनिक आधार पर जाँच करना पसंद करता हूं, जिसके बाद YMMV में एक रिफ्लेक्टर की जाँच होती है।

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

आउटर से कटिंग प्रोडक्शन कोड एक ड्रैग की तरह लग सकता है लेकिन आपके पर्यावरण पर निर्भर करता है, ऐसे कई टूल्स हैं जो ग्रैड को डॉक्यूडॉक और स्टाइलकॉप के रूप में विकसित कर सकते हैं ।

यह शुरू से ही सही विकास की मानसिकता में आने लायक है। आपको आश्चर्य होगा कि कितने बैक-ऑफ-ए-फाग-पैकेट सिस्टम थे जो कि केवल स्टॉप-गैप समाधान होने वाले थे, आधारशिला अनुप्रयोग बन गए।


आपका मतलब है हर स्टॉप गैप सॉल्यूशन कभी लिखा है, है ना?
रबरडैक

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

11

लगातार

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

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


6
+1 और व्यक्तिगत दृष्टिकोण से, मुझे घर पर व्यक्तिगत परियोजनाओं को हैक करने और अपने दिन के काम में उत्पादन कोड लिखने से गियर बदलना बहुत मुश्किल था। मेरे शौक परियोजनाओं में पेशेवर कोड लिखना तत्काल लाभांश का भुगतान करता था - कोड को पढ़ना आसान था और इसमें बहुत कम कीड़े थे।
रॉबी डी

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

"मैं अपने आप से क्यों इनकार करूंगा और केवल कुछ भविष्य के प्रोग्रामर के लिए बाद में करूंगा?" रहस्योद्घाटन! और अंदाज लगाइये क्या? आप कभी-कभी (और कभी-कभी, अक्सर) भविष्य के प्रोग्रामर होते हैं।
राडारोब

@ रोबीडी, अतिशयोक्ति अवलोकन! एक साक्षात्कार में मालकॉम ग्लैडवेल - वह व्यक्ति जिसने लोकप्रिय जागरूकता (पुस्तक आउटलेयर में ) के लिए "10,000 घंटे का नियम" लाया - ने कहा कि यह "जानबूझकर अभ्यास" होना चाहिए या यह सिर्फ समय बर्बाद कर रहा है। मतलब सुधार पर ध्यान दें, अभ्यास एक कौशल आदि के उस विशिष्ट पहलू को सुधारने के इरादे के साथ निर्दिष्ट करता है
रेडारबोब

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

4

आप इसे "मैं सिर्फ यह देखने के लिए कोशिश कर रहा हूं कि यह कैसे काम करता है" कोड के बीच अंतर करके यह करता है और "यह उत्पाद में स्थित है" कोड। इसे करने के कई तरीके हैं।

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

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

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

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


1

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

इसलिए जवाब है

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

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


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

लघु पुनरावृत्तियों, स्प्रिंट आदि पर फुर्तीला ध्यान केंद्रित करना, प्रोटोटाइप को तेज़ी से बाहर निकालना, आवश्यक रूप से सामने की ओर पर्याप्त डिज़ाइन की उपेक्षा करने पर अधिक दबाव डालता है
ब्रैड थॉमस

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

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

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

0

तुम लिखो:

हर संस्करण एक प्रोटोटाइप के अलावा कुछ भी नहीं है। इसलिए मैं उस समय सुपर क्लीन कोड लिखने में ज्यादा समय बर्बाद नहीं करता क्योंकि मुझे कभी नहीं पता कि कुछ समय तक रहता है। ...

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

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

मुझे लगता है कि आप "क्लीनअप" को बहुत आगे बढ़ा रहे हैं।

अंगूठे का मेरा नियम है:

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

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

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