स्रोत नियंत्रण में परिवर्तन करने के लिए कितनी बार? [बन्द है]


204

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

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

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


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

अस्पष्टता से बचने के लिए, अगर कुछ विशेष स्थितियों में आपको कमिटेड कोड को कमिट करने और पुश करने की आवश्यकता होती है, तो आप वापस आने के बाद और उस ब्रांच को फिर से जारी रखना चाहते हैं, जब आप उस चीज को समाप्त कर लेते हैं जिसे आपको पिछली अधूरी कमिट में संशोधन करना होता है और फिर उसे पुश करना होता है। यह पूरी तरह से आपके ऊपर है कि आप अपने वर्किंग ट्री को कैसे साफ रखें और रेट्रोस्पेक्ट्स के लिए उपयोगी है, लेकिन विश्वास करें कि जब यह बहुत ही छिपे हुए या सूक्ष्म कीड़े या खराब फंक्शंस को खोजने और निपटने के लिए आता है, तो यह एक बहुत बड़ी मदद है यदि आपके पास क्लीन और प्रोफेशनल वर्किंग ट्री है git डिबग टूल का उपयोग करना चाहते हैं जैसे - git blame या git bisect
Eric

जवाबों:


196

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

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


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

57
यदि आप वितरित संस्करण नियंत्रण प्रणाली का उपयोग करते हैं तो इस तरह के दृष्टिकोण के साथ निर्माण को तोड़ने की संभावना नहीं बढ़ती है।
स्किपहोप्पी

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

26
और अगर आप 2 सप्ताह का काम कर रहे हैं, तो आप एक विशाल कमिटमेंट के माध्यम से खुदाई नहीं करना चाहते हैं कि यह देखने के लिए कि किस कोड ने बिल्ड को तोड़ दिया है। बार-बार आने से आप समस्याओं को बहुत छोटे कोडबेस में अलग कर सकते हैं क्योंकि आप जानते हैं कि केवल थोड़ा सा कोड बदल गया है।
स्टीवन स्‍पॉट

1
@ मायकेजे यह सब इस बात पर निर्भर करता है कि आप स्रोत नियंत्रण का उपयोग कैसे कर रहे हैं। इसके अलावा, यदि आप Git जैसी किसी चीज का उपयोग कर रहे हैं, और अपनी शाखा में काम कर रहे हैं, तो आप अन्य टीम के सदस्यों या यहां तक ​​कि CI / CD पाइपलाइन के लिए बिल्ड को प्रभावित नहीं करेंगे।
क्रिस पिसेट्समैन

82

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

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


1
मुझे आपका बयान पसंद है। यदि आप बार-बार दस बार करते हैं, तो कोई समस्या नहीं होगी (लेकिन यदि आप उस समय का 1/10 भाग करते हैं तो संभावना होगी)।
कैमिलो मार्टिन


24

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


20

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


12

मैं हर उस कार्य को करता हूं जो मैं एक कार्य के साथ करता हूं। जो आमतौर पर 30 मिनट से 1 घंटे तक का होता है।


12

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


7
और अगर इसकी कम है, तो आप शायद सही टिप्पणी नहीं कर रहे हैं।
जद इसाकेस

11

मैं ओपन-सोर्स मंत्र (पैराफ्रास्ड) का पालन करता हूं - जल्दी कमिट करें, अक्सर।

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

यह प्रतिबद्ध-अक्सर रणनीति निरंतर एकीकरण वातावरण में विशेष रूप से उपयोगी है क्योंकि यह अन्य विकास प्रयासों के खिलाफ एकीकरण परीक्षण की अनुमति देता है, समस्याओं का शीघ्र पता लगाता है।


10

ऐसा कोड न करें जो वास्तव में काम न करे। बैकअप समाधान के रूप में अपने रिपॉजिटरी का उपयोग न करें।

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


25
या एक शाखा बनाएँ। यही वे वहां के लिए हैं।
ब्रायन कार्लटन

2
संस्करण नियंत्रण डेटा को खो जाने, या बैकअप होने से रोकने के लिए है। लेकिन यह भी एक रीसायकल बिन होने का इरादा नहीं है। केवल कोड जो संकलित किया जाना चाहिए, लेकिन यह आवश्यक नहीं है कि एक प्रतिबद्ध बनाने के लिए सुविधा पूरी हो।
jmort253

8

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

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

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


7

मुझे नहीं लगता कि आपको कितनी बार चिंता करनी चाहिए। यहां महत्वपूर्ण बात यह है कि क्या, कब और क्यों। यह कहते हुए कि आपको हर 3 घंटे या हर 24 घंटे पर वास्तव में कोई मतलब नहीं है। जब आपके पास कुछ करने के लिए प्रतिबद्ध है, तो न करें यदि आप नहीं करते हैं।

यहाँ संस्करण नियंत्रण के लिए मेरी अनुशंसित सर्वोत्तम प्रथाओं में से एक उद्धरण है :

[...] यदि आप एक ही समय में एक परियोजना में कई बदलाव कर रहे हैं, तो उन्हें तार्किक भागों में विभाजित करें और उन्हें कई सत्रों में करें। इससे व्यक्तिगत परिवर्तनों के इतिहास को ट्रैक करना बहुत आसान हो जाता है, जो बाद में बग को खोजने और ठीक करने का प्रयास करते समय आपको बहुत समय बचाएगा। उदाहरण के लिए, यदि आप A, B और C की सुविधा लागू कर रहे हैं और बग 1, 2 और 3 को ठीक कर रहे हैं, तो इसके परिणामस्वरूप कम से कम छह कमिट, प्रत्येक फीचर के लिए एक और प्रत्येक बग के लिए एक होना चाहिए। यदि आप किसी बड़ी सुविधा पर काम कर रहे हैं या व्यापक रीफैक्टरिंग कर रहे हैं, तो अपने काम को और भी छोटे हिस्सों में विभाजित करने पर विचार करें, और प्रत्येक भाग के पूरा होने के बाद कमिट करें। इसके अलावा, कई तार्किक मॉड्यूल में स्वतंत्र परिवर्तन लागू करते समय, प्रत्येक मॉड्यूल के लिए अलग-अलग परिवर्तन करें, भले ही वे बड़े बदलाव का हिस्सा हों।

आदर्श रूप से, आपको अपनी हार्ड ड्राइव पर बिना किसी बदलाव के अपने कार्यालय को कभी नहीं छोड़ना चाहिए। यदि आप उन परियोजनाओं पर काम कर रहे हैं जहां परिवर्तन अन्य लोगों को प्रभावित करेंगे, तो अपने परिवर्तनों को लागू करने के लिए एक शाखा का उपयोग करने पर विचार करें और जब आप कर रहे हों तो उन्हें ट्रंक में वापस मिला दें। जब पुस्तकालयों या परियोजनाओं में परिवर्तन होता है जो अन्य परियोजनाओं - और इस प्रकार, अन्य लोग - पर निर्भर करते हैं, तो सुनिश्चित करें कि आप कोड बनाने के द्वारा उनके बिल्ड को नहीं तोड़ते हैं जो संकलन नहीं करेंगे। हालाँकि, ऐसा कोड जो संकलन नहीं करता है वह कमिटिंग से बचने का बहाना नहीं है। इसके बजाय शाखाओं का उपयोग करें। [...]


6

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


6

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

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


छोटे बिंदुओं के बारे में अपनी बात पर +1 करने से साथ चलना आसान हो जाता है। सीवीएस कमिट में एक लंबे पैराग्राफ से कुछ भी बुरा नहीं है। यह आपकी आंखों और आपके सिर को नुकसान पहुंचाता है।
jmort253

4

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

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

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


3

जिस क्षण आप इसके बारे में सोचते हैं।

(जब तक आप चेक करते हैं वह सुरक्षित है)


3

आपके स्रोत कोड सिस्टम पर निर्भर करता है और आपके पास और क्या है। यदि आप Git का उपयोग कर रहे हैं, तो जब भी आप एक कदम खत्म करें, तब प्रतिबद्ध रहें मैं एसवीएन का उपयोग करता हूं और जब मैं एक पूरी सुविधा समाप्त करता हूं, तो मैं हर एक से पांच घंटे में यह करना पसंद करता हूं। अगर मैं CVS का उपयोग कर रहा था तो मैं भी ऐसा ही करूंगा।


3

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

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

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


3

मुझे नियमित रूप से जांच करना भी पसंद है। हर बार जब मैंने अपने लक्ष्य की ओर एक कदम पूरा किया है।

यह आमतौर पर हर दो घंटे में होता है

मेरी कठिनाई किसी को बहुत सारे कोड समीक्षा करने के लिए तैयार और सक्षम पा रही है ।

हमारी कंपनी की नीति यह है कि किसी भी चीज़ की जाँच करने से पहले हमें एक कोड समीक्षा की आवश्यकता होती है, जो समझ में आता है, लेकिन विभाग में कोई ऐसा व्यक्ति नहीं है जिसके पास कोड समीक्षा करने के लिए तुरंत समय हो। संभव समाधान:

  1. प्रति चेक में अधिक काम; कम जांच == कम समीक्षा।
  2. कंपनी की चेकइन नीति बदलें। अगर मैंने अभी कुछ रीफैक्टरिंग की है और यूनिट टेस्ट सभी हरे चल रहे हैं, तो शायद मैं नियम को आराम कर सकता हूं?
  3. जब तक कोई समीक्षा कर सकता है और काम जारी रख सकता है, तब तक बदलाव को रोकें। यह समस्याग्रस्त हो सकता है यदि समीक्षक आपको कोड पसंद नहीं करता है और आपको फिर से डिज़ाइन करना होगा। किसी कार्य के विभिन्न चरणों को 'ठंडे बस्ते में डालना' परिवर्तन से गड़बड़ हो सकता है।

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

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

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

2

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


2

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

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

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


तो, यह सिर्फ 2 घंटे का दर्द होगा .. सही है? इतना बुरा क्यों है?
केविन कोनर


2

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


2

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

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

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

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

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

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

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


2

यदि आप उस शाखा पर काम कर रहे हैं जो जारी नहीं की जाएगी, तो एक प्रतिबद्धता हमेशा सुरक्षित होती है।

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

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


2

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

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


1
मेरा मानना ​​है कि अधूरा कोड को तब तक के लिए प्रतिबद्ध किया जा सकता है जब तक कि इसे ठीक से आर्किटेक्चर न किया जाए ताकि इसे बाकी सिस्टम से अलग किया जा सके। उदाहरण के लिए, यदि आप स्टैक ओवरफ्लो में वोटिंग फीचर लागू कर रहे हैं, तो किसी को पता नहीं चलेगा कि यूआई अभी तक नहीं बनाया गया है।
jmort253

2

जब भी आप कुछ कोड को पूरा करते हैं जो काम करता है और अपडेट में मिलने पर किसी और को खराब नहीं करेगा।

और कृपया सुनिश्चित करें कि आप ठीक से टिप्पणी करें।

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