जब हर कोई मास्टर पर काम कर रहा हो, तो मैं दर्द को कैसे कम कर सकता हूं?


123

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

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

सबसे कुशल Git उपयोगकर्ता के रूप में (पढ़ें: मैंने इसे पहले इस्तेमाल किया है, हालांकि सुपर-कॉम्प्लेक्स के लिए कुछ भी नहीं), मैं नीति सेट करने वाला व्यक्ति हूं, उपकरण सिखा रहा हूं, और गंदगी को साफ कर रहा हूं। जब तक हम शाखाओं पर विकास करने के लिए स्विच नहीं कर सकते, तब तक हम एक साझा, सक्रिय मास्टर कम त्रुटि-प्रवण बनाने के लिए उपकरणों का उपयोग कैसे कर सकते हैं?

टीम विंडोज पर Tortoise Git का उपयोग कर रही है। हम कछुआ Git का उपयोग कर रहे हैं क्योंकि हमने पहले कछुआ SVN का उपयोग किया था। ( मैं व्यक्तिगत रूप से कुछ ऑपरेशनों के लिए Cygwin के तहत कमांड लाइन का उपयोग करता हूं , लेकिन टीम ने स्पष्ट कर दिया है कि उन्हें GUI की आवश्यकता है और हम इस एक के साथ जा रहे हैं।) उत्तर इस उपकरण के साथ काम करना चाहिए, प्रतिस्थापन का प्रस्ताव नहीं करना चाहिए।

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

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

सर्वर बिटबकेट (जीथबब नहीं) है। मेरे पास हमारी रिपॉजिटरी पर पूरा प्रशासनिक नियंत्रण है, लेकिन सर्वर पर कोई भी अधिक आम तौर पर नहीं है। इनमें से कोई भी परिवर्तनशील नहीं है।

स्रोत फ़ाइलें XML हैं। ग्राफिक्स फाइलें भी हैं, जिन्हें हर कोई जानता है कि आप विलय नहीं कर सकते हैं, लेकिन हमारे पास लगभग कभी भी टक्कर नहीं होती है। मर्ज टकराव XML फ़ाइलों से आते हैं, ग्राफिक्स से नहीं।

जब तक हम समीक्षित, परीक्षण-मान्य पुल अनुरोधों के साथ सुविधा शाखाओं का उपयोग करने के लिए आगे बढ़ सकते हैं, तब तक मैं मास्टर को साझा करने के लिए Git के हमारे उपयोग में क्या परिवर्तन कर सकता हूं?


52
कछुए का उपयोग न करें, गिट एक्सटेंशन का उपयोग करें। कछुआ यह छिपाने की कोशिश करता है कि गिट एसवीएन नहीं है और अधिकांश गिट महानता को नष्ट कर देता है। मैं SVN-> Git ट्रांज़िशन से दो बार गुज़रा, और Git एक्सटेंशन लोगों को गिट तरीके से सोचने के लिए एक महान उपकरण था।
विल्बर्ट

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

10
मुझे पता है कि आपने अन्य ऐप्स की सिफारिश नहीं करने के लिए कहा था, लेकिन @Wilbert के पास यह अधिकार है। TortoiseGit चीजों को छिपाने की कोशिश करता है, जो वास्तव में उन्हें मेरे अनुभव में अधिक दर्दनाक बनाता है। यदि कोई UI वांछित है, तो मैंने सबसे आसान संक्रमण पाया है (पढ़ें: मैं टूलिंग और देवऑप्स पर गैर-पारंपरिक सॉफ्टवेयर टीमों को प्रशिक्षित करता हूं) एटलसियन के सोर्सट्री (उचित प्रशिक्षण के साथ, निश्चित रूप से) के माध्यम से किया गया है। मैंने गिट के मॉडल को समझने में उनकी मदद करने के लिए GitFlow का भी उपयोग किया है (हालांकि, यह सभी टीमों के लिए उपयुक्त नहीं है)।
जसकाव

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

14
@DanK, मुझे भी लगता है कि op ने समस्या की जड़ को गलत बताया। यदि आपके पास मास्टर पर क्लोबबेरिंग परिवर्तन हैं और आप किसी शाखा में जाते हैं, तो आपके पास ब्रांच पर परिवर्तन करने वाले लोग होंगे। यदि आप अलग-अलग शाखाओं में जाते हैं, तो आपके पास ऐसे लोग होंगे जिनकी अपनी शाखाओं में विलय की समस्या है (या जो अंत में महीनों तक विलय के बिना अपनी शाखा में विकसित होते हैं)।
user3067860

जवाबों:


11

अब तक SourceTree अवधारणाओं को सीखने के लिए सबसे अच्छा IDE था, क्योंकि यह सभी प्रासंगिक संवादों और प्रत्येक चरण पर आपके द्वारा दिखाए गए विकल्पों को दिखाता है, डिफ़ॉल्ट विकल्प आमतौर पर ठीक होते हैं, रिबास के साथ गड़बड़ न करें, आदि। बस सामान्य प्रवाह का पालन करें:

  • मास्टर से खींचो, बस सुनिश्चित करें कि आप अद्यतित हैं
  • अपनी फ़ाइलों को संशोधित करें
  • अपने परिवर्तन करें (यह केवल स्थानीय रूप से है)
  • मास्टर से फिर से खींचो (इससे संघर्ष दिखाई देगा)
  • सभी फाइलों को तब तक संपादित करें जब तक कि टकराव हल न हो जाए, मतलब फाइल उस प्रॉपर स्थिति में है जिसे आप (कोई <<<<< HEAD और >>>> कच्ची फाइल में मास्टर संदेश) करना चाहते हैं
  • मर्ज परिवर्तन करें
  • धक्का दें

यदि हर कोई इस नुस्खा का पालन करता है, तो उन्हें ठीक होना चाहिए।

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

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

सिस्टम को सीखना कठिन है, खासकर यदि आप Svn के साथ बड़े हुए हैं, धैर्य रखें और उन्हें इसे ठीक से सीखने के लिए समय दें, नए उपयोगकर्ताओं के साथ आप कभी-कभी कुछ गड़बड़ करने वाले दिन की सफाई कर सकते हैं, जो सामान्य है। ;)


9
नाइटपिक: सोर्सट्री एक इंटीग्रेटेड डेवलपमेंट एनवायरनमेंट नहीं है ...
मैथ्यू

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

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

100

याद रखने के लिए तीन मुख्य बातें हैं जब आप उसी शाखा से किसी और के रूप में काम कर रहे हैं:

  • कभी भी उपयोग न करें --forceजब तक आप वास्तव में नहीं जानते कि आप क्या कर रहे हैं।
  • या तो आपके commitया stashहर काम से पहले प्रगति pull
  • यह आम तौर पर आसान हो जाता है यदि आप pullसही से पहले एक push

इसके अलावा, मैं इंगित करूंगा कि वितरित संस्करण नियंत्रण से यह कोई फर्क नहीं पड़ता कि आपका "आधिकारिक" रेपो शाखाओं का उपयोग करता है या नहीं। इसका कोई असर नहीं पड़ता कि व्यक्तिगत उपयोगकर्ता अपने स्थानीय भंडार में क्या करते हैं। मैं स्थानीय शाखाओं को पाने के लिए git का उपयोग करता था जब मेरी कंपनी पूरी तरह से अलग केंद्रीय VCS का उपयोग करती थी। यदि वे अपनी विशेषताओं के लिए स्थानीय शाखाएँ बनाते हैं और अपने स्थानीय में विलय की गलतियाँ करते हैं master, तो रिफ्लैग या किसी अन्य जादू में जाए बिना इसे ठीक करना बहुत आसान है ।


51
हमेशा pullसे पहले pushमहान सलाह है, लेकिन मैं एक कदम आगे जाऊंगा और सुझाव दूंगा कि आप विचार करें कि क्या आप कर सकते pull --rebaseहैं।
अनएक्समाइंडर

20
@anaximander, मैं आपको सलाह दूंगा कि या तो हर कोई --rebase या कोई भी उपयोग करता है ...
keuleJ

12
@ टेम्परालवुल्फ़ यही है कि उन्होंने मुझे केक के बारे में भी बताया ...
ब्लैक वीजेबल सेबल

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

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

68

क्या हर किसी के लिए एक दिन सीख लेना संभव है?

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

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

मैं खिड़कियों का उपयोग नहीं करता हूं, लेकिन अगर कछुआ मूल रूप से उनसे छिप रहा है और दिखावा कर रहा है कि यह SVN है तो शायद कछुआ गलत उपकरण है।


37
"यदि कछुआ मूल रूप से उनसे छिप रहा है और यह दिखावा कर रहा है कि यह SVN है तो शायद कछुआ गलत उपकरण है।" इस। मुझे पता है कि ओपी ने कहा था कि वह टूल को रिप्लेस नहीं करेगा, लेकिन अगर यह अस्पष्ट है कि कैसे किसी भी तरह से काम करता है तो यह आपके डेवलपर्स की व्यक्तिगत वृद्धि और आपकी परिचालन दक्षता के लिए एक बाधा है। यदि वे इसे नहीं समझते हैं तो आपकी टीम आपके VCS का दुरुपयोग करती रहेगी।
2rs2ts 16

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

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

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

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

26

कभी-कभी, आप जो कर रहे हैं उसे बदलना होगा।

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

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

यदि आप ब्रांचिंग का उपयोग नहीं कर सकते हैं , तो आप एक merge-and-pushस्क्रिप्ट लिखने पर विचार कर सकते हैं जो कुछ दर्द बिंदुओं को दूर कर सकती है। शायद यह जांच करेगा कि उपयोगकर्ता मास्टर पर पीछे नहीं है, एक भ्रूण और पुल करें, और फिर मर्ज करने का प्रयास करें ( संभवतः के साथ--no-commit --no-ff ), और इसी तरह।


3
हम आपके द्वारा बताए गए सभी कारणों (लेकिन सबसे विशेष रूप से नियंत्रित पीआरएस और जनादेश से पहले शाखा पर होने वाले संघर्षों को हल करने की क्षमता के लिए) शाखा में जाने के लिए जा रहे हैं। क्या आप मर्ज-एंड-पुश स्क्रिप्ट पर हमला करने के बारे में अधिक कह सकते हैं?
मोनिका सेलियो

6
मैं इस सलाह से असहमत हूं। लंबे समय तक चलने वाली सुविधा शाखाएं मास्टर से काम करने की तुलना में बहुत अधिक विनाशकारी हो सकती हैं (जो कि अगर आपके पास एक अच्छा वर्कफ़्लो नहीं है तो क्या होने वाला है)। इस विषय पर मार्टिन फाउलर का एक शानदार लेख है । दिन के अंत में, OPs टीम में वर्कफ़्लो कोऑपरेशन इश्यू होता है न कि एक Git इश्यू .. मैं तर्क दूंगा कि ज्यादा ब्रांच्स बस इस प्रॉब्लम को कंपाउंड करेंगी।
15

6
लंबे समय से चल रही सुविधा शाखाएं वह नहीं हैं जो मैं वकालत कर रहा था (न ही उल्लेखित)। मैं मानता हूं कि वे "नियमित" विकास के लिए बुरे हैं, और यहां कोई बेहतर नहीं होगा। मर्जिंग से पहले समीक्षा / परीक्षण किए जा सकने वाले परिवर्तनों के छोटे सेटों के साथ नियमित, "रैवियोली" शाखाएं बहुत उपयोगी हैं, और यहां केवल इसलिए कम उपयोगी नहीं होगा क्योंकि यह उत्तर में उल्लिखित सभी कारणों के लिए एक दस्तावेज रेपो है।
16:17 पर दान 1701

3
निश्चित रूप से, मैं समझता हूं कि आप क्या कह रहे हैं और मैं सिद्धांत रूप में असहमत नहीं हूं, लेकिन वर्तमान में यहां वर्णित सहयोग के मुद्दों के साथ, यहां तक ​​कि सबसे अच्छे इरादों के साथ, मुझे लगता है कि ओपी टीम की शाखाएं अनजाने में लंबे समय तक चलने वाली शाखाओं में बदल जाएंगी । दिन के अंत में, मेनलाइन बनाम फीचर शाखा पर काम करना यहां की मूल समस्या नहीं है। समस्या वितरित वीसीएस के इन्स / आउट की समझ और डेवलपर्स के बीच सहयोग / सामंजस्य की कमी का एक सामान्य अभाव है। फ़ीचर ब्रांचिंग अपने आप ठीक नहीं होगा लेकिन IMO इसे बढ़ा देता है।
DanK

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

12

जोर दें कि आप विलय को फिर से कर सकते हैं

यह आपके लिए स्पष्ट हो सकता है लेकिन पूर्व एसवीएन उपयोगकर्ताओं को पता नहीं हो सकता है कि वे कई बार मर्ज को हल करने का प्रयास कर सकते हैं। इससे आपके प्राप्त झंडे की संख्या में कटौती हो सकती है।

एसवीएन में जब आप काम कर रहे होते हैं trunkतो आपके आस-पास बैठे हुए बिना परिवर्तन के बदलाव होते हैं। तो आप एक करेंगे svn update। किस बिंदु पर आपके परिवर्तन अन्य लोगों के साथ हमेशा के लिए बदल जाएंगे। इसे (afaik) पूर्ववत करने का कोई तरीका नहीं था, इसलिए आपके पास मैन्युअल रूप से सब कुछ जांचने के अलावा कोई विकल्प नहीं था और उम्मीद थी कि रेपो एक अच्छी स्थिति में था। जब वास्तव में आप मर्ज को फिर से शुरू करने में अधिक सहज होंगे।

लोगों की मानसिकता वैसी ही होगी जब हम गम में चले गए। बहुत सी अनजाने त्रुटियों के लिए अग्रणी।

सौभाग्य से गिट के साथ एक रास्ता है, विशेष रूप से क्योंकि आप स्थानीय कमिट कर सकते हैं। (मैं बाद में वर्णन करता हूं कि यह कैसे कमांडलाइन में व्यक्त किया गया है)

हालांकि यह कैसे किया जाता है, टूलिंग के आधार पर अलग-अलग होगा। मुझे लगता है कि कई GUI में एक बटन के रूप में एक पुल को फिर से दिखाना कुछ नहीं है लेकिन संभव है। मुझे पसंद है कि आप साइबरविन का उपयोग करें। मेरे सहकर्मी सोर्सेट्री का उपयोग करते हैं। चूंकि आप BitBucket का उपयोग करते हैं, इसलिए इसका उपयोग करने के लिए समझ में आएगा कि आपके GUI के रूप में यह उसी कंपनी द्वारा प्रबंधित किया गया है: Atlassian। मुझे संदेह है कि कुछ तंग एकीकरण है।

खींचने के संबंध में

मुझे लगता है कि आप सही हैं कि विलय pullलोगों को गड़बड़ कर रहा है। A pullवास्तव git fetchमें सर्वर से होने वाले परिवर्तनों को प्राप्त करता है, उसके बाद git merge origin/<branchname>* जो आपके स्थानीय शाखा में दूरस्थ परिवर्तनों को मर्ज करता है। ( https://git-scm.com/docs/git-pull )

अपशॉट सभी मानक मर्ज कमांड्स पुल के साथ काम करते हैं। यदि उस मर्ज का विरोध होता है तो आप गर्भपात करा सकते हैं git merge --abort। जो आपको अपने मर्ज से पहले वापस ले जाना चाहिए। तो आप git pullया तो के साथ फिर से कोशिश कर सकते हैं git merge origin/<branchname>

यदि आप किसी तरह से सीख सकते हैं कि अपने सह-कार्यकर्ता की GUI उपकरण का उपयोग करके उपरोक्त कैसे करें तो मुझे लगता है कि आपकी अधिकांश समस्याओं का समाधान हो जाएगा। क्षमा करें, मैं अधिक विशिष्ट नहीं हो सकता।

* मैं समझता हूं कि उत्पत्ति हमेशा यहां नहीं होती है।

git reflogसमस्याओं के निदान के लिए उपयोग करें

मुझे, आप की तरह, ज्यादातर GUI साधनों के दुरुपयोग से उत्पन्न समस्याओं का निदान करना है। मुझे लगता है कि git reflogकभी-कभी सहायक हो सकता है क्योंकि यह भंडार पर कार्रवाई का एक सुसंगत निशान है। हालांकि कई बार पढ़ना मुश्किल होता है।

एक विकल्प

जब से आपकी स्थिति अस्थायी है , तब तक आप एसवीएन में वापस जा सकते हैं जब तक कि आपके पास रोल आउट करने की प्रक्रिया नहीं है। मुझे ऐसा करने में संकोच होगा क्योंकि कई जगह यह कहा जाता है कि 'हमने एक बार कोशिश की थी, लेकिन यह काम नहीं किया ...' और कभी भी इसे वापस लेने का प्रयास नहीं किया।

कुछ अन्य सामान्य संक्रमणकालीन समस्याएं

  • लोग अक्सर अपने रेपो को हटा देते हैं और पुनः प्राप्त कर लेते हैं, क्योंकि उनका रेपो एक असामान्य स्थिति में था। आमतौर पर यह स्थानीय और दूरस्थ अंतर का ट्रैक खोने के कारण होता था। GUI टूल और CLI दोनों ही इसको अच्छे से दिखाने में विफल होते हैं। सीएलआई में मुझे git log --decorateमतभेदों का अवलोकन करने का सबसे आसान तरीका लगता है। लेकिन अगर चीजें मास्टर (उदाहरण के लिए) पर बहुत अधिक बालों वाली मिलती हैं तो आप कर सकते हैंgit reset --hard origin/master

2
अपने अंतिम बिंदु पर: एक वास्तविक त्वरित, संरचनात्मक अवलोकन के लिए, मुझे git log --oneline --decorate --graphआदर्श लगता है । इतना तो, कि मैंने उस सटीक संयोजन के लिए एक शेल उर्फ ​​को परिभाषित किया है।
सेमीस्टर

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

8

एक संभव तंत्र, जिसे बहुत सारे ओपन सोर्स टीमों ने अपनाया है, वह है कि फोर्किंग मॉडल का उपयोग करना है - https://www.atlassian.com/git/tutorials/comparing-workflows (स्पष्ट रूप से याद रखने के लिए सुनिश्चित करें जब फोर्किंग वर्कफ़्लो की चर्चा करें) ) का है

इसमें प्रत्येक डेवलपर या उप-टीम के पास रिपॉजिटरी का अपना कांटा होता है, जिसे वे BitBucket से चेक आउट करते हैं, इसके लिए एक तंत्र प्रदान करते हैं , डिफ़ॉल्ट रिमोट के अलावा "अपस्ट्रीम" मूल की स्थापना करते हैं - उन्हें "भ्रूण अपस्ट्रीम" को याद रखना होगा। नियमित आधार पर "और" रिमोट / अपस्ट्रीम / मास्टर को मर्ज करें।

यह संभवतः आपके निर्माण तंत्र की समस्याओं को हल करेगा क्योंकि निर्माण उपकरण संभवतः एक अलग परियोजना पर मास्टर को इंगित किया जाएगा, अर्थात कांटा।

तब आप ज्यादातर लोगों को सीधे मास्टर प्रोजेक्ट में धकेलने की क्षमता से निकाल सकते हैं और समीक्षा और अनुमोदन भूमिकाओं वाले लोगों की एक छोटी टीम बना सकते हैं। Https://www.atlassian.com/git/tutorials/making-a-pull-request देखें

- जगह सुनिश्चित करना है कि किसी भी वांछनीय चेकों धक्का से पहले किया जाता है बस के बारे में हुक पर Git पुस्तक खंड में है पर पढ़ने के लिए https://git-scm.com/book/gr/v2/Customizing-Git-Git-Hooks - आप यह सुनिश्चित करने के लिए प्रस्तावित प्रतिबद्ध पर कुछ परीक्षण चलाने जैसे काम करने के लिए पूर्व-प्रतिबद्ध और पूर्व-पुश हुक का उपयोग कर सकते हैं, यह सुनिश्चित करने के लिए कि काम वैध है, आदि - क्लाइंट साइड हुक के साथ एकमात्र समस्या यह है कि डेवलपर्स उन्हें अक्षम कर सकते हैं या सक्षम करने में विफल हो सकते हैं। उन्हें।

TortoiseGit में अपस्ट्रीम भ्रूण / मर्ज और हुक दोनों उपलब्ध हैं।


एक बुरा विचार नहीं, वास्तव में। यह भी लगता है कि इस टीम को एक मर्ज मास्टर से लाभ होगा जब तक कि वे अधिक आरामदायक न हों। +1
ग्रेग बर्गार्ड्ट

2
BitBucket में एक फोर्क सिंकिंग फीचर है जो संभव होने पर अपने आप फॉर्क्स फॉर्क्स को फास्ट करता है। यह आज कांटा करने के लिए बहुत सुविधाजनक है और अगले सप्ताह मूल से ऊपर की ओर कभी भी चिंता किए बिना खींचें।
piedar

3

यह प्रतिवाद करने वाला है, लेकिन मेरी बात सुनो:

उन्हें उत्साह के साथ प्रयोग शुरू करने के लिए प्रोत्साहित करें

गिट के बारे में दिलचस्प चीजों में से एक यह है कि किसी भी स्थानीय ऑपरेशन को पूरी तरह से सुरक्षित बनाना आश्चर्यजनक रूप से आसान है। जब मैंने पहली बार git का उपयोग करना शुरू किया, तो मैंने जो कुछ भी पाया, उसमें से एक को मैं पूरी तरह से पूरी निर्देशिका के रूप में तैयार कर रहा था, जब मैंने किसी चीज़ को खराब कर दिया था। मुझे बाद में पता चला कि यह एक बहुत बड़ा कीचड़ है और यह लगभग कभी भी आपके काम की सुरक्षा के लिए आवश्यक नहीं है, लेकिन इसमें बहुत सुरक्षित और बहुत सरल होने का गुण है , भले ही आपको पता नहीं हो कि आप क्या कर रहे हैं और कैसे कर रहे हैं आप जिस कमांड को आज़माना चाहते हैं, वह चालू हो जाएगा। जब आप ऐसा कर रहे होते हैं तो केवल आपको ही बचना होता है push। यदि आप कुछ भी धक्का नहीं देते हैं, तो यह 100% सुरक्षित तरीका है जो आप चाहते हैं।

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

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

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

उन्हें ins और git के बहिष्कार सीखने से हतोत्साहित करना बंद करें

मैंने कुछ भी नहीं धकेलने का उल्लेख किया, जो वास्तव में उन चीजों में से एक के खिलाफ जाता है जो आप उन्हें सिखा रहे हैं: हमेशा "कमिट एंड पुश"। मेरा मानना ​​है कि आपको उन्हें ऐसा करने के लिए कहना बंद कर देना चाहिए और उनसे कहना चाहिए कि वे इसके विपरीत करना शुरू कर दें। Git में मूल रूप से 5 "स्थान" हैं जहाँ आपके परिवर्तन हो सकते हैं:

  • डिस्क पर, uncommitted
  • मंचन किया लेकिन प्रतिबद्ध नहीं
  • एक स्थानीय प्रतिबद्ध में
  • एक स्थानीय झड़प में
  • दूरस्थ रिपॉजिटरी (केवल कमिट और टैग कभी-कभी अलग-अलग रिपॉजिटरी के बीच धकेल दिए जाते हैं और खींचे जाते हैं)

उन्हें एक ही चरण में सब कुछ खींचने और धक्का देने के लिए प्रोत्साहित करने के बजाय, इन 5 अलग-अलग स्थानों का लाभ उठाने के लिए प्रोत्साहित करें। उन्हें प्रोत्साहित करें:

  • इससे पहले कि वे कुछ भी करें, बदलाव लाएं।
  • एक बनाओ निर्णय कैसे प्राप्त किए गए परिवर्तनों को संभाल। विकल्प हैं:

    • उनके स्थानीय परिवर्तन करें, फिर भ्रूण परिवर्तन के शीर्ष पर उन्हें वापस कर दें।
    • उनके स्थानीय परिवर्तन करें और फिर प्राप्त परिवर्तनों के साथ एक मर्ज करें।
    • उनके परिवर्तनों को मर्ज करें, मर्ज करें और फिर किसी भी टकराव को सुलझाएं और हल करें।

      वहाँ अन्य सामान है, लेकिन मैं इसे यहाँ नहीं मिलेगा। ध्यान दें कि एक पुल का शाब्दिक अर्थ सिर्फ एक भ्रूण और एक मर्ज है। यह उनके जैसा नहीं है; यह वह है। (पासिंग में --rebaseबदलाव लाने के लिए पुल + मर्ज से लाने के लिए + रिबेज।)

  • उनके परिवर्तनों को चरणबद्ध करें और फिर उनकी समीक्षा करें।
  • उनके मंचन में बदलाव करें और फिर समीक्षा करें।
  • अलग से धक्का।

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

एक बार जब उन्हें यह समझने की आदत हो जाती है कि उनके परिवर्तन कहाँ हैं, तो वे यह तय करना शुरू कर सकते हैं कि कब कदमों को छोड़ें और कुछ ऑपरेशनों को मिलाएं (जब खींचना है क्योंकि आप पहले से ही जानते हैं कि आप लाना चाहते हैं + मर्ज करना चाहते हैं या उस कमेंट और पुश विकल्प पर क्लिक करना चाहते हैं) ।

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

ऐसा करने से वास्तव में स्वाभाविक रूप से अगली रणनीति बन जाएगी:

उन्हें स्थानीय शाखाओं का उपयोग करने के लिए प्रोत्साहित करें

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

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

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

सारांश

संक्षेप में, git SVN नहीं है और इसे इस तरह नहीं माना जा सकता है। आपको:

  • सुरक्षित प्रयोग को प्रोत्साहित करके डर को खत्म करें।
  • उन्हें यह समझने में मदद करें कि git अलग कैसे है ताकि वे देख सकें कि उनके सामान्य वर्कफ़्लो को कैसे बदलता है।
  • उन्हें अपनी समस्याओं को अधिक आसानी से हल करने में मदद करने के लिए उपलब्ध सुविधाओं को समझने में मदद करें।

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

विशिष्ट लक्षण

तत्काल शब्द में, निम्नलिखित विचार मदद कर सकते हैं।

rebase

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

merge.ff=only

यह एक व्यक्तिगत स्वाद की बात होने जा रही है, लेकिन मैं आपको कम से कम अस्थायी रूप से इसकी सिफारिश करने जा रहा हूं क्योंकि आपने पहले ही उल्लेख किया है कि आपको संघर्ष से निपटने में परेशानी है। मैं यह निर्धारित merge.ffकरनेonly की अनुशंसा करता हूं :

git config --global merge.ff only

"एफएफ" का अर्थ है "तेजी से आगे बढ़ना।" एक तेज़ फ़ॉरवर्ड मर्ज तब होता है जब git को अलग-अलग कमिट से परिवर्तनों को संयोजित करने की आवश्यकता नहीं होती है। यह बस ग्राफ में एक सीधी रेखा के साथ शाखा के पॉइंटर को एक नई प्रतिबद्ध तक ले जाता है।

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

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


2

मैं ठीक उसी SVN के माध्यम से चला गया -> मेरी कंपनी में अनुभव और मेरे अनुभव से, एकमात्र उपाय समय है। लोगों को साधनों की आदत डालें, उन्हें गलतियाँ करने दें, उन्हें दिखाएं कि उन्हें कैसे ठीक किया जाए। आपका वेग थोड़ी देर के लिए भुगतना होगा, और लोग काम खो देंगे, और हर कोई थोड़ा तनावग्रस्त हो जाएगा, लेकिन यह आपके VCS के रूप में मौलिक रूप से कुछ बदलने की प्रकृति है।

उस ने कहा, मैं हर किसी से सहमत हूं जो इस बात से सहमत है कि कछुआ एक बाधा के बजाय एक बाधा है, इसलिए संक्रमण काल ​​में जल्दी। TortoiseGit है ... सबसे अच्छा समय पर एक महान जीयूआई नहीं है, और यह देखकर कि वास्तव में कैसे सादगी के नाम पर काम करता है, यह आपके सहकर्मियों को दो-चरण की प्रतिबद्धताओं जैसे मुख्य गिट अवधारणाओं की समझ हासिल करने से रोक रहा है।

हमने देवों को एक सप्ताह के लिए कमांड-लाइन (गिट बश या पॉश-गिट ) का उपयोग करने के लिए मजबूर करने का निर्णय लिया , और यह समझने के लिए अद्भुत काम किया कि वास्तव में गिट कैसे संचालित होता है और यह एसवीएन से कैसे भिन्न होता है। यह कठोर लग सकता है, लेकिन मेरा सुझाव है कि आप इसे सरलता से आज़माएं क्योंकि यह गिट मॉडल की समझ पैदा करता है - और एक बार जब वे नीचे आ जाते हैं, तो आपके सहकर्मी जो भी पसंद करते हैं, उन पर GUI facades का उपयोग करना शुरू कर सकते हैं।

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


1

ठीक है, हाल ही में मैंने निम्नलिखित वर्कफ़्लो को कभी भी नहीं अपनाया *

1) हर कोई अपनी शाखा का उपयोग करता है, जो मास्टर शाखा से एक कॉपी है।

आइए मास्टर शाखा "मास्टर", और मेरी अपनी शाखा "my_master" का नाम दें।

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

मेरी शाखा पर Currenly, बस कोडिंग समाप्त हो गई

git add . && git commit -m "Message" && git push

मास्टर शाखा पर वापस जाएं

git checkout master

खींचो अगर यह अप टू डेट नहीं है

git pull

मेरी अपनी शाखा में वापस जाओ

git checkout my_master

मेरी अपनी शाखा के लिए नवीनतम मास्टर मर्ज करें

git merge master

संघर्ष और विलय को ठीक करें

सब कुछ फिर से टेस्ट करें

जब सब कुछ मेरी अपनी शाखा में विलय और तय हो जाए, तो इसे धक्का दें

git push

मास्टर शाखा पर वापस जाएं

git checkout master

मेरी शाखा के साथ विलय

git merge my_master

संघर्षों का होना असंभव है क्योंकि वे पिछले विलय के साथ आपकी अपनी शाखा में हल हो गए हैं

पुश मास्टर

git push

यदि हर कोई इसका अनुसरण करता है, तो मास्टर शाखा साफ होगी।


0

इसलिए हमारे पास एक टीम है जिसने टीएफएस से गिट में स्विच किया और सोच के पुराने तरीकों को बनाए रखा। ऑपरेशन के सामान्य नियम कमोबेश एक जैसे हैं।

हां, इसका मतलब है कि हर कोई मास्टर पर काम करता है। यह बुरा नहीं है; और टीएफएस या एसवीएन के लिए इस्तेमाल की जाने वाली टीम को यह सबसे स्वाभाविक लगेगा।

इसे संभव के रूप में दर्द रहित बनाने के लिए सामान्य प्रक्रियाएं:

  1. ऐसा git stash && git pull --rebase && git stash popहर सुबह
  2. जल्दी और अक्सर (तुरंत धक्का देने की ज़रूरत नहीं है; हम कम से कम इस लाभ को जल्दी लेना शुरू कर सकते हैं)
  3. निम्नलिखित लूप को आगे बढ़ाने के लिए:

    git add git commit git pull --rebase fix any merges compile git push loop until you don't get the can't fast forward error message.


यदि आप ऐसा करते हैं, तो आप SVN के साथ बने रह सकते हैं। उसी तरह जैसे आप ऑटोमोबाइल के दिनों में घोड़ा गाड़ी के साथ रह सकते हैं। बेशक, आप अपनी कार को उसी गति से चला सकते हैं जैसे आप घोड़े की गाड़ी से कर सकते हैं। लेकिन, आप इसे हासिल करते हैं, अपने आप को थोपना है, और उन लोगों को बनाना है जो आप पर कार चलाने में सक्षम हैं। अपनी कार चलाना सीखें। अभी।
सेमीस्टर

@cmaster: हमारे लिए git का # 1 फायदा सर्वर का नुकसान था जो पूरे स्रोत नियंत्रण इतिहास को नहीं खोता है। (यह हमारे साथ हुआ - हमारे पास बैकअप था लेकिन जब हमने बहाल करने की कोशिश की तो टेप ड्राइव ने टेप खाना शुरू कर दिया।)
जोशुआ

@cmaster: हमने कुछ अन्य उपयोगी git फीचर्स की शुरुआत की है, लेकिन चेंजिंग ब्रांच का उपयोग शायद नहीं किया जाएगा।
जोशुआ

@ सेमीस्टर धीरे-धीरे कार चलाने और घोड़े की सवारी करने के बीच का अंतर यह है कि कार को चलाने से आप इसे तेजी से चलाने के लिए तैयार होते हैं। घोड़े की सवारी नहीं करता है। हर कोई जो एक कार में हॉप करता है, उसे 60 मील प्रति घंटे की गति से जाने के लिए गैस को हिट करने की आवश्यकता होती है।
jpmc26

@ jpmc26 जब मैंने अपना पहला ड्राइविंग सबक लिया, तो मुझे सुनिश्चित करने के लिए 30 किमी / घंटा ड्राइव करने के लिए कहा गया था, और मुझे विश्वास है कि उस पाठ में 50 किमी / घंटा की दूरी भी शामिल थी। यह निश्चित रूप से एक सामान्य घोड़ा गाड़ी की तुलना में अधिक है। और उसी के लिए जाता है git: आप आम तौर पर एक दिन से कांटा और मर्ज करना सीखते हैं। यह उपयोग करने का एक अभिन्न अंग है git। उस से बचें, और आप उसी तरह से उपकरण का दुरुपयोग कर रहे हैं जैसे आप कार का दुरुपयोग कर रहे हैं जब कोई 15 किमी / घंटा से अधिक नहीं जा रहा हो।
10

-3

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

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

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

आप बिना किसी दर्द के इस काम को करने के लिए उदाहरण के लिए सॉर्सेट्री का उपयोग कर सकते हैं।


4
यह "विकास" के साथ "मास्टर" की जगह ले रहा है, लोगों के अतिरिक्त जोखिम के साथ डिफ़ॉल्ट चेकआउट के बाद विकास शाखा में स्विच नहीं करना। मुझे GitLab Flow पसंद है , जो भारी GitFlow और Sparse GitHub Flow के बीच एक खुशहाल माध्यम है।
सेस टिम्मरमैन

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