version control - स्रोत नियंत्रण में परिवर्तन कितनी बार प्रतिबद्ध करते हैं?




version-control (18)

मुझे स्रोत नियंत्रण में कितनी बार परिवर्तन करना चाहिए? हर छोटी सुविधा के बाद, या केवल बड़ी सुविधाओं के लिए?

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

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


अंगूठे का नियम, जिसका मैं उपयोग करता हूं, चेक-इन है जब फाइलों के समूह को चेक-इन किया जा सकता है, एक चेक-इन टिप्पणी द्वारा कवर किया जा सकता है।

आम तौर पर यह सुनिश्चित करने के लिए होता है कि चेक-इन परमाणु हैं और टिप्पणियां अन्य डेवलपर्स द्वारा आसानी से पच सकती हैं।

यह विशेष रूप से सच है जब आपके परिवर्तन कॉन्फ़िगरेशन फ़ाइल को प्रभावित करते हैं (जैसे एक वसंत संदर्भ फ़ाइल या स्ट्रैट कॉन्फ़िगरेशन फ़ाइल) जिसमें अनुप्रयोग विस्तृत दायरा है। यदि आप चेक इन करने से पहले कई 'समूह' परिवर्तन करते हैं, तो उनके प्रभाव कॉन्फ़िगरेशन फ़ाइल में ओवरलैप होते हैं, जिससे 2 समूह एक-दूसरे के साथ विलय हो जाते हैं।


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


आपको एक तरफ सुरक्षा और पुनर्प्राप्ति के बीच समझौता को संतुलित करना होगा और दूसरी परियोजना के लिए परिवर्तन प्रबंधन में आसानी होगी।

मैंने उपयोग की जाने वाली सबसे अच्छी योजना के उस प्रश्न के दो जवाब हैं।

हमने 2 पूरी तरह से अलग भंडारों का उपयोग किया: एक परियोजना व्यापक भंडार था और दूसरा हमारा व्यक्तिगत भंडार था (हम उस समय आरसीएस का उपयोग कर रहे थे)।

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

एक बार हमारे पास कोड का एक हिस्सा था जो संकलित करेगा, ठीक से परीक्षण किया गया था और सामान्य उपयोग के लिए तैयार होने के रूप में स्वीकार किया गया था, इसे प्रोजेक्ट रिपोजिटरी में चेक किया गया था।

दुर्भाग्यवश यह प्रणाली व्यावहारिक होने के लिए विभिन्न वीसीएस प्रौद्योगिकियों के उपयोग पर निर्भर थी। मुझे उसी प्रकार के वीसीएस (उदाहरण के लिए दो उपवर्तन भंडार) का उपयोग करते समय एक ही परिणाम प्राप्त करने की कोई संतोषजनक विधि नहीं मिली है।

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


कम से कम दिन में एक बार।


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

Commits की आवृत्ति पर, मैं इस तरह से सोचता हूं, अगर मेरी हार्ड डिस्क दुर्घटनाग्रस्त हो गई और मैंने कुछ नहीं किया - तो मेरे लिए यह कुछ मात्रा 2 घंटे का काम है।

बेशक, मैं कुछ ऐसा नहीं करता जो संकलित नहीं करता है।


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

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


जब भी मैं एक कार्य के साथ किया जाता हूं मैं हर बार प्रतिबद्ध करता हूं। आमतौर पर इसमें 30 मिनट से 1 घंटा लगते हैं।


जब भी मैं कोड का एक "पूर्ण विचार" पूरा करता हूं जो संकलित करता है और चलता है मैं चेक-इन करता हूं। यह आमतौर पर 15-60 मिनट के बीच कहीं भी समाप्त होता है। कभी-कभी यह लंबा हो सकता है, लेकिन मैं हमेशा जांचने की कोशिश करता हूं कि मेरे पास बहुत से कोड परिवर्तन हैं जो विफलता के मामले में मैं फिर से लिखना नहीं चाहता हूं। मैं आमतौर पर यह सुनिश्चित करता हूं कि मेरा कोड संकलित हो और मैं घर जाने से पहले कार्य दिवस के अंत में चेक-इन करता हूं।

मैं "बहुत अधिक" काम / चेक-इन बनाने के बारे में चिंता नहीं करता। यह वास्तव में बेकार होता है जब आपको कुछ लिखना होता है, और यह अच्छा है कि मामले में छोटे वेतन वृद्धि में रोलबैक करने में सक्षम होना अच्छा लगे।


जैसा कि अन्य ने कहा है, एक तार्किक खंड को करने का प्रयास करें जो "पूर्ण" पर्याप्त है कि यह अन्य देवताओं के रास्ते में नहीं मिलता है (उदाहरण के लिए, यह स्वचालित परीक्षण बनाता है और पास करता है)।

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

मैं यह नहीं कह रहा हूं कि यह पालन करने के लिए एक अच्छा पैटर्न है; मैं केवल यह इंगित कर रहा हूं कि "किया गया" आपकी टीम / कंपनी की नीतियों पर निर्भर करता है।



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


मैं अभी भी वाक्यांश 'अक्सर प्रतिबद्ध, जल्दी प्रतिबद्ध' वाक्यांश में विश्वास करता हूं। मैं Mercurial जैसे विकेन्द्रीकृत वीसीएस पसंद करते हैं और कई चीजों को करने में कोई समस्या नहीं है और इसे बाद में अपस्ट्रीम दबाएं।

यह वास्तव में एक आम सवाल है, लेकिन वास्तविक सवाल यह है: क्या आप अधूरा कोड कर सकते हैं?


मैं कई प्रतिक्रियाओं से सहमत हूं: कोड में जांच न करें जो संकलित नहीं होगा; यदि आपकी चिंता में कोड या उसके परिवर्तनों का "बैकअप" हो रहा है तो व्यक्तिगत शाखा या भंडार का उपयोग करें; तार्किक इकाइयां पूर्ण होने पर जांचें।

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

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


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

यहां एक संबंधित ब्लॉग पोस्ट है: कोडिंग डरावनी: प्रारंभ में चेक करें, अक्सर चेक इन करें


मैं व्यक्तिगत रूप से कोड के प्रत्येक तार्किक समूह को पूरा / स्थिर / संकलित करता हूं और उस दिन किए बिना किए गए दिन को छोड़ने की कोशिश नहीं करता हूं।


मैं हर 30-60 मिनट में परिवर्तन करना पसंद करता हूं, जब तक कि यह साफ-सुथरा हो और यूनिट परीक्षणों में कोई प्रतिक्रिया न हो।


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


यदि आपकी संस्करण नियंत्रण टिप्पणी एक या दो वाक्यों से अधिक है, तो संभवतः आप अक्सर पर्याप्त नहीं कर रहे हैं।





version-control