प्रोग्रामिंग करते समय पूर्णतावाद अच्छा और बुरा हो सकता है।
यदि प्रश्न अस्पष्ट है तो कृपया टिप्पणी करें।
जवाबों:
KISS और YAGNI , विशेष रूप से YAGNI।
केवल इंजीनियर आपको उन चीजों के लिए एक समाधान बताते हैं जिन्हें आप जानते हैं कि आपको जल्द ही आवश्यकता है। दो साल में जिन चीजों की जरूरत हो सकती है, उसके लिए इंजीनियर न करें, क्योंकि सबसे अधिक संभावना है कि आपको बहुत अलग चीजों की जरूरत होगी और आपको फिर से इंजीनियर बनना होगा।
जिस क्षण आप "इस डिज़ाइन के साथ भविष्य में कुछ बिंदुओं पर हम एक्स, या यहां तक कि वाई" के बारे में बात करना शुरू कर सकते हैं, इसके बजाय "यह डिज़ाइन हमें अगली रिलीज़ में ग्राहक की आवश्यकता जेड करने की अनुमति देता है", यही आपको मिल रहा है वास्तुकला खगोल विज्ञान में।
टिप्पणियों के जवाब में:
YAGNIआज तक कभी नहीं सुना था।
एक पुनरावृत्त दृष्टिकोण का उपयोग करें और यह समस्या ज्यादातर दूर हो जाती है। आपको पहले दिन और उसके बाद लगभग हर दिन कोड चलाना चाहिए। पहले न्यूनतम आवश्यकताओं को पूरा करें और आपके पास जितना समय हो उतना अधिक जोड़ें। कभी भी बड़े बदलाव से न बचें जहां आप अपने कोड को लंबे समय तक नहीं चला सकते।
एक समाधान ओवरकिल होता है जब इसे पूरा करने के लिए लिया गया अतिरिक्त समय संभावित नकारात्मक प्रभाव से अधिक होता है जब आसान समाधान समाप्त होने पर यह स्वाभाविक रूप से उन्नत / संशोधित हो जाता है।
मूल रूप से आप बाद के समय के साथ अब व्यापार कर रहे हैं। यदि आपका खर्च अब अधिक है तो आप बाद में बचा लेंगे, आप इसे गलत कर रहे हैं। यदि आप वास्तव में इंजीनियरिंग से अधिक हैं, तो आप अब समय व्यतीत कर रहे हैं जो इस बात को प्रभावित नहीं करता है कि आप बाद में कितना समय (या इसे और अधिक बनाता है) खर्च करते हैं।
आपको यह अनुभव करने में बेहतर होगा कि आपके पास अधिक अनुभव है। चीजों के बारे में जाने का सबसे अच्छा तरीका (मेरे अनुभव से) वह करना है जो आपको अभी चाहिए, लेकिन इस तरह से जो सबसे आसानी से संवर्धित हो बाद में आवश्यकताओं को इसकी मांग करनी चाहिए। काम करना है कि कैसे मुश्किल बिट है।
मैं बहुत पूर्णतावादी हुआ करता था (फ्रेमवर्क बनाने में समय बिताना, समाधान नहीं)।
लेकिन जिस चीज ने वास्तव में मुझे अपने उत्पादन में तेजी लाने में मदद की, वह थी बीडीडी / टीडीडी सिद्धांतों का पालन करना और बाहर सिद्धांत सहित (जो मुझे गले लगाने के लिए सीखने के लिए विशेष रूप से कठिन पाया गया है)।
यह वास्तव में मुझे सिखाता है कि इसके लिए एक परीक्षण मौजूद होने से पहले कोड की एक भी पंक्ति नहीं लिखनी चाहिए। लेकिन इसके लिए स्वीकृति परीक्षण मौजूद होने से पहले इकाई परीक्षण मौजूद नहीं है। और स्वीकृति परीक्षण वास्तविक उपयोगकर्ता की जरूरतों से आता है।
इसलिए, कोड की सभी लाइनें एक वास्तविक उपयोगकर्ता की आवश्यकता से उत्पन्न होती हैं।
यदि आप सिद्धांत रूप में बाहर से परिचित नहीं हैं, तो यह निर्धारित करता है कि आप निचली परतों के व्यवहार को अनुकरण करने के लिए परीक्षण डबल्स का उपयोग करके अपने आवेदन में सबसे बाहरी परत (यानी लगभग सभी मामलों में GUI) के लिए परीक्षण लिखना शुरू करते हैं। फिर आप परीक्षणों को पारित करने के लिए पर्याप्त लागू करते हैं। शीर्ष परत का यह कार्यान्वयन तब आपके द्वारा अपने एप्लिकेशन की निचली परत को हिट करने तक, आपके द्वारा अगली परत आदि के लिए लिखने के लिए आवश्यक परीक्षणों को निर्धारित करता है।
मुझे लगता है कि मैं इस अनुभव से बेहतर हो गया।
जब मैं (बहुत) युवा था तो मैं हमेशा सबसे सही समाधान के लिए जाता था, कोई समझौता नहीं करता था। अब मैं बजट और समय जैसी चीजों को ध्यान में रखकर बेहतर हूं।
समय सीमा इस रेखा को काफी स्पष्ट करती है।
मेरे मालिक वास्तव में :)
मुझे स्वीकार करना चाहिए कि मैं बेहतर हो रहा हूं, लेकिन मैं अभी भी समझौते के लिए बहुत ज्यादा नहीं हूं। शुक्र है कि मैंने अपने बॉस को मुझ पर लगाम लगाने के लिए;)
मैं overengineering की तुलना में एक और समस्या उठाना चाहता हूँ, क्योंकि overengineering का पता लगाना बहुत आसान है।
मेरी मुख्य समस्या रिफैक्टरिंग के साथ है। समस्या यह है कि ज्यादातर बार, भले ही मैंने कोड को जितना अच्छा हो सके लिखने की कोशिश की, मैं वापस नहीं जानता था, फिर मुझे अब क्या पता है (अधिक कोड, अधिक पैटर्न, नए मुहावरे, नए मुद्दे, नए) समाधान की)। और इसलिए, भले ही यह काम करता है, मैं अब इसे करने के बेहतर तरीके जानता हूं:
हालाँकि, यह काम कर रहा है जैसा कि यह है, और इसलिए इसे फिर से दिखाना एक प्राथमिकता नहीं है, और सच्चाई यह है कि यह मुझे कचोट रहा है; मैं आर्थिक कारणों को समझता हूं, और मैं ग्राहक की उम्मीदों को समझता हूं (वे कोड नहीं देखते हैं और नई सुविधाओं और बग फिक्स को पसंद करते हैं), लेकिन मुझे लगता है कि मेरे पास अभी भी इस पर काम करने का समय था।
अभी के लिए, मैं सिर्फ अपने बॉस के आदेश का पालन करता हूं, लेकिन मुझे यह स्वीकार करना चाहिए कि मैं यह जानकर असहज महसूस कर रहा हूं कि उत्पादन में दिया गया कोड सबसे अच्छा नहीं है जो मैं अब तक ले सकता हूं। पूर्णतावाद, मुझे लगता है।
पेशेवर और व्यक्तिगत रूप से, मैं अपने आप पर लागू करने की कोशिश करता हूं:
जीतने के साथ संतुष्ट रहें।
यदि मेरा कोड समस्या को हल करने के लिए हल करता है और कोई नई समस्या नहीं बनाता है *, तो यह आगे बढ़ने की संभावना है। जब आप बार को सेट करना सीखते हैं तो इसे सेट करने की आवश्यकता होती है, "अच्छा पर्याप्त" बन जाता है, ठीक है, बहुत अच्छा।
पूर्णता प्रकाश की गति की तरह है: आप वहां कभी नहीं पहुंचेंगे, लेकिन जिस ऊर्जा को आप खर्च कर सकते हैं उसकी कोई सीमा नहीं है।
(* - ध्यान दें कि "छोटी गाड़ी" और "बनाए रखने में कठिनाई" दोनों "नई समस्याओं" के शीर्षक के तहत दृढ़ता से आते हैं। इसलिए मैं इसे पूर्ण रूप से कॉल नहीं करता हूं जब तक कि कोड का परीक्षण नहीं किया गया हो, सुपरफ्लूड बिट्स ट्रिम हो गया था, और था टिप्पणियाँ / एपीआई प्रलेखन आज तक लाया।)
अनुभव के साथ मैंने महसूस किया है कि पूर्णतावाद तब तक संभव नहीं है जब तक कि मुझे किसी विशेष संदर्भ (भाषा, रूपरेखा, मंच, मानक) में बेल्ट के तहत कम से कम कुछ साल नहीं मिले हों। एक नौसिखिया के रूप में वहाँ होगा idiosyncrasies के सभी प्रकार है जो आप की (भागने, पूर्वता, सुरक्षित शब्द, वाक्यात्मक चीनी, समय समाप्ति, अतुल्यकालिक कॉल, गैर-दस्तावेजी सुविधाओं और बग), तो मैं बस एक अच्छा समाधान के लिए प्रयास करते हैं, सब जानते नहीं होगा होना जितना संभव हो उतना सीखते हुए। महत्वपूर्ण रूप से, मैं हमेशा परिणाम को रिफैक्ट करने के लिए इसे सरल बनाने की कोशिश करता हूं - मॉड्यूलर वास्तुकला, टिप्पणियां जहां आवश्यक हो, और कोई चालाक चाल नहीं ।
मैं, कई अन्य प्रोग्रामर की तरह, विरासत को बनाए रखने के लिए बहुत सारे कोड हैं। यह सब फिर से करने का प्रलोभन हमेशा रहेगा, लेकिन मैंने अनिवार्य रूप से इसे एक सिद्धांत पर उबाला है:
क्या मैं (या कोई और) फिर से यह पता लगाने जा रहा हूं ?
यह आमतौर पर कुछ अधिक प्रबंधनीय स्पेगेटी-चंक कोड में बहुत सारे स्पेगेटी कोड का ख्याल रखता है। कुछ अंशों को हटा दें, अपने परीक्षणों में फेंक दें, और अब इसे पूर्णता की आवश्यकता नहीं है।