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