ทีมงานเอกสารของเราประมาณสิบคนเพิ่งย้ายจาก SVN ไป Git ใน SVN ทุกคนทำงานในระดับปริญญาโท - แบบจำลองที่ฉันเกลียดเสมอ แต่ฉันไม่สามารถทำให้เกิดการเปลี่ยนแปลงนั้นได้ เป็นส่วนหนึ่งของการย้ายไปยัง Git เราได้ตกลงที่จะแก้ไขปัญหาดังกล่าว แต่เรายังไม่สามารถทำได้ (รอการเปลี่ยนแปลงการสร้างที่จะอนุญาตให้สร้างจากสาขาโดยพลการ) ในขณะเดียวกันทุกคนกำลังทำงานกับอาจารย์ ใช่ฉันรู้ว่านี่แย่มากเชื่อฉัน

ตอนนี้เราเห็นอาการสะอึกมากขึ้นกว่าตอนที่เราใช้ SVN ซึ่งบางส่วนเกิดจากแบบจำลองสองขั้นตอนของ Git (ในพื้นที่และระยะไกล) บางครั้งผู้คนยอมรับ แต่ไม่สามารถผลักดันหรือดึงและรับความขัดแย้งกับการเปลี่ยนแปลงในท้องถิ่นที่ค้างอยู่ เมื่อวานมีใครบางคนอุดตันการเปลี่ยนแปลงล่าสุด - อย่างใดอย่างหนึ่ง - ด้วยการผสานผิดไปซึ่งฉันคิดว่าเป็นผสานที่ Git ทำเมื่อคุณดึงและมีการเปลี่ยนแปลงที่โดดเด่น (เขาไม่สามารถบอกฉันได้ว่าสิ่งที่เขาทำและเพราะเขาใช้ GUI ฉันไม่สามารถตรวจสอบประวัติเชลล์ของเขาได้)

ในฐานะผู้ใช้ Git ที่มีความเชี่ยวชาญมากที่สุด (อ่าน: ฉันเคยใช้มาก่อน แต่ไม่ได้มีความซับซ้อนสูง) ฉันเป็นผู้กำหนดนโยบายการสอนเครื่องมือและการทำความสะอาด ฉันสามารถเปลี่ยนแปลงอะไรได้บ้างกับวิธีที่เราใช้เครื่องมือในการสร้างต้นแบบที่ใช้งานร่วมกันและมีข้อผิดพลาดน้อยลงจนกระทั่งเราสามารถเปลี่ยนไปทำการพัฒนาบนสาขาได้

ทีมกำลังใช้ Tortoise Git บน Windows เราเคยใช้ Tortoise Git เพราะเราเคยใช้ Tortoise SVN มาก่อน ( ฉันใช้บรรทัดคำสั่งภายใต้ Cygwin เป็นการส่วนตัวสำหรับการดำเนินการบางอย่าง แต่ทีมได้ระบุไว้อย่างชัดเจนว่าพวกเขาต้องการ GUI และเราจะใช้ GUI นี้) คำตอบควรทำงานกับเครื่องมือนี้ไม่ใช่เสนอการแทนที่

Tortoise Git มี "Commit & Push" พร้อมใช้งานในการดำเนินการครั้งเดียวและฉันได้บอกให้พวกเขาทำเช่นนั้นเสมอ อย่างไรก็ตามมันไม่ได้เป็นแบบปรมาณู - มันสามารถเกิดขึ้นได้ว่าการกระทำ (ซึ่งหลังจากทั้งหมดเป็นแบบท้องถิ่น) ทำงานได้ดี แต่การกดไม่ได้ (พูดเนื่องจากความขัดแย้งหรือปัญหาเครือข่าย) เมื่อสิ่งนั้นเกิดขึ้นพวกเขาจะได้รับข้อผิดพลาดที่ไม่ชัดเจน ฉันได้บอกให้พวกเขาตรวจสอบ BitBucket บันทึกการกระทำถ้าพวกเขามีใด ๆข้อสงสัยเกี่ยวกับเมื่อเร็ว ๆ นี้กระทำและถ้าพวกเขาไม่เห็นมันจะผลักดัน (และเพื่อแก้ไขข้อขัดแย้งหากเป็นปัญหาหรือขอความช่วยเหลือหากพวกเขาไม่รู้ว่าต้องทำอะไร)

ทีมมีนิสัยที่ดีในการ "ดึงเร็วและมักจะ" อย่างไรก็ตามปรากฏว่าการดึงอาจทำให้เกิดความขัดแย้งซึ่งฉันคิดว่าใหม่ หากไม่ใช่เรื่องใหม่บ่อยครั้งยิ่งกว่าใน SVN ฉันได้ยินมาว่าฉันสามารถเปลี่ยนวิธีที่ Git ดึง (rebase แทนการรวม) แต่ฉันไม่มีความเข้าใจที่ดีเกี่ยวกับการแลกเปลี่ยนที่นั่น (หรือวิธีการทำในสภาพแวดล้อมของเรา)

เซิร์ฟเวอร์คือ BitBucket (ไม่ใช่ Github) ฉันมีการควบคุมดูแลเต็มรูปแบบมากกว่าที่เก็บของเรา แต่ไม่มีบนเซิร์ฟเวอร์โดยทั่วไป ไม่มีสิ่งใดที่เปลี่ยนแปลงได้

ไฟล์ต้นฉบับคือ XML นอกจากนี้ยังมีไฟล์กราฟิกที่ทุกคนรู้ว่าคุณไม่สามารถผสานได้ แต่เราก็แทบจะไม่ชนกันเลย ความขัดแย้งในการผสานมาจากไฟล์ XML ไม่ใช่กราฟิก

ฉันสามารถเปลี่ยนแปลงอะไรได้บ้างกับการใช้ Git เพื่อให้การแบ่งปันหลักเป็นไปอย่างราบรื่นมากขึ้นสำหรับทีมจนกว่าเราจะสามารถย้ายไปใช้สาขาคุณลักษณะพร้อมกับคำขอดึงที่ผ่านการตรวจสอบและทดสอบแล้ว

จนถึงตอนนี้ SourceTree เป็น IDE ที่ดีที่สุดในการเรียนรู้แนวคิดเพราะมันแสดงกล่องโต้ตอบและตัวเลือกที่เกี่ยวข้องทั้งหมดที่คุณมีในแต่ละขั้นตอนตัวเลือกเริ่มต้นมักจะใช้ได้ดีไม่ยุ่งกับ rebase เป็นต้นเพียงแค่ทำตามขั้นตอนปกติ:

• ดึงจากต้นแบบเพียงเพื่อให้แน่ใจว่าคุณมีความทันสมัย
• แก้ไขไฟล์ของคุณ
• ยอมรับการเปลี่ยนแปลงของคุณ (เฉพาะที่อยู่ในเครื่อง)
• ดึงอีกครั้งจากต้นแบบ (ซึ่งจะทำให้เกิดความขัดแย้งปรากฏขึ้น)
• แก้ไขไฟล์ทั้งหมดจนกว่าความขัดแย้งจะได้รับการแก้ไขซึ่งหมายความว่าไฟล์อยู่ในสถานะ propper ที่คุณต้องการส่งมอบ (ไม่มี <<<<< HEAD และ >>>> ข้อความหลักในไฟล์ raw)
• ยอมรับการเปลี่ยนแปลงที่ผสาน
• ดัน

หากทุกคนติดตามสูตรนี้พวกเขาควรจะสบายดี

ทุกครั้งที่มีคนทำการเปลี่ยนแปลงที่ใหญ่กว่าหรือส่วนกลางให้แจ้งผู้ใช้คนอื่น ๆ ให้ผูกพันเฉพาะที่และดึงตัวเองออกจากกันดังนั้นพวกเขาจึงไม่ได้รับความขัดแย้งมากเกินไปในภายหลังและคนแรกยังคงอยู่รอบ ๆ เพื่อแก้ไขข้อขัดแย้งร่วมกัน

ลงทุนเวลามากในการทำให้ทุกคนเข้าใจการไหลไม่เช่นนั้นพวกเขาอาจจะได้สักพักแล้วรู้สึกสบายใจกับมันในขณะที่สกรูกิ่งหลักจริง ๆ ตัวอย่างเช่น "ใช้ไฟล์ของฉันแทนรีโมต" เพื่อแก้ไขความขัดแย้ง ออกการเปลี่ยนแปลงทั้งหมดที่ทำโดยคนอื่น

Git เป็นระบบการเรียนรู้ที่ยากโดยเฉพาะอย่างยิ่งถ้าคุณโตขึ้นด้วย Svn จงอดทนและให้เวลาพวกเขาเรียนรู้อย่างเหมาะสมกับผู้ใช้ใหม่บางครั้งคุณสามารถใช้เวลาทั้งวันในการทำความสะอาดระเบียบนั่นเป็นเรื่องปกติ ;)

มีสามสิ่งสำคัญที่ต้องจดจำเมื่อคุณทำงานจากสาขาเดียวกันกับคนอื่น:

• อย่าใช้--forceจนกว่าคุณจะรู้ว่ากำลังทำอะไรอยู่
• อย่างใดอย่างหนึ่งcommitหรือที่ทำงานของคุณในความคืบหน้าทุกครั้งก่อนstashpull
• มันมักจะง่ายขึ้นถ้าคุณขวาก่อนpullpush

นอกเหนือจากนั้นฉันจะชี้ให้เห็นว่าด้วยการควบคุมเวอร์ชันแบบกระจายมันไม่สำคัญว่า repo "อย่างเป็นทางการ" ของคุณจะใช้กิ่งหรือไม่ ที่ไม่มีผลใด ๆ กับสิ่งที่ผู้ใช้แต่ละคนทำใน repos ท้องถิ่นของพวกเขา ฉันเคยใช้ git เพื่อรับสาขาท้องถิ่นเมื่อ บริษัท ของฉันใช้ VCS ส่วนกลางที่แตกต่างอย่างสิ้นเชิง หากพวกเขาสร้างสาขาท้องถิ่นสำหรับฟีเจอร์ของพวกเขาและทำการรวมความผิดพลาดเข้ากับท้องถิ่นของพวกเขาmasterมันง่ายกว่ามากในการแก้ไขโดยไม่ต้องเข้าไปใน reflogหรือเวทมนตร์อื่น ๆ

เป็นไปได้ไหมที่จะใช้เวลาทั้งวันในการเรียนรู้คอมไพล์?

คอมพิวเตอร์ที่ใช้มืออาชีพควรได้รับการคาดหวังว่าจะได้เรียนรู้เครื่องมือใหม่และแม้ว่าจะเป็นไปได้ที่จะทำผิดพลาดมากมายใน VCS ใด ๆ ก็ตามพวกเขาควรใช้เครื่องมือตามที่ออกแบบมาเพื่อใช้งาน

วิธีที่ดีที่สุดในการแนะนำสิ่งนี้คือให้ทุกคนทำงานในสาขาของตัวเองเมื่อพวกเขาทำการเปลี่ยนแปลง (สั้นที่สุดเท่าที่จะทำได้) แล้วทำการรีบูทจากนั้นจึงรวมกลับเข้าที่หลักเมื่อเสร็จแล้ว นี่ไม่ใช่วิธีการทำงานในปัจจุบันที่ไกลเกินไปและแนะนำขั้นตอนการทำงานง่าย ๆ ที่พวกเขาสามารถคุ้นเคยจนกระทั่งพวกเขารู้สึกมั่นใจมากพอที่จะทำงานที่ซับซ้อนมากขึ้น

ฉันไม่ได้ใช้ windows แต่ถ้า Tortoise ซ่อนคอมไพล์จากพวกเขาและแสร้งว่าเป็น SVN บางที Tortoise อาจเป็นเครื่องมือที่ผิด

บางครั้งสิ่งที่คุณทำมีการเปลี่ยนแปลง

ปัญหาที่ใหญ่ที่สุดคือทุกคนทำงานเป็นอาจารย์ นี่ไม่ใช่เรื่องปกติสำหรับการพัฒนารหัสและอาจเป็นรูปแบบที่ไม่ถูกต้องในกรณีของคุณเช่นกัน หากคุณสามารถเปลี่ยนแปลงสิ่งนั้นได้โดยการขอ / กำหนดให้มีการเปลี่ยนแปลงในสาขาแยกกันคุณจะมีรูปร่างที่ดีขึ้นมาก ด้วยสาขาคุณสามารถรับสิ่งต่อไปนี้:

• บังคับใช้ว่าจะไม่มีการผลักดันโดยตรงกับการmasterได้รับอนุญาต
• บังคับใช้ผ่าน Bitbucket ที่ดึงคำขอมีการสร้างและมีอย่างน้อยหนึ่งได้รับการอนุมัติก่อนที่จะมีการควบรวมกิจการ สิ่งนี้ช่วยให้แน่ใจว่ามีคนกำลังดูการเปลี่ยนแปลงและทำให้ตัวเองเจ็บปวดน้อยลงเนื่องจาก UI จะแสดงความขัดแย้งกับรหัสรุ่นระยะไกลไม่ใช่สิ่งที่ผู้ใช้มีบนเดสก์ท็อป สิ่งนี้ป้องกันสถานการณ์จำลองการกระทำสำเร็จ แต่ผลักดันล้มเหลว
• ดำเนินการ "สร้าง" กับ repo ของคุณก่อนที่จะรวม ฉันรู้ว่ามันเป็น repo ของ doc แต่อาจมีการตรวจสอบการสะกดการขูดตามกฎหมายหรือแม้แต่การแปลอัตโนมัติ (ส่งออก STRING_DEF สิ่งไปยังไฟล์ csv) ที่สามารถสร้างได้จากงานสร้างนี้ หรืออาจจะไม่ขึ้นอยู่กับงานของคุณ
• อนุญาตให้ผู้คนทำงานในสิ่งต่าง ๆ หลายอย่างพร้อมกันได้ง่ายขึ้น ใช่สิ่งนี้สามารถทำได้ด้วยการหยุดชะงักเช่นกัน แต่มันก็ค่อนข้างยุ่งเหยิงและมีบางอย่างบอกฉันว่าคุณไม่ได้ใช้สิ่งเหล่านั้น

หากคุณไม่สามารถใช้การแบรนช์ได้คุณอาจลองเขียนmerge-and-pushสคริปต์ที่สามารถลดความเจ็บปวดบางส่วนได้โดยอัตโนมัติ บางทีมันอาจจะตรวจสอบว่าผู้ใช้ไม่ได้อยู่บนต้นแบบทำการดึงและดึงแล้วลองผสาน ( อาจมี--no-commit --no-ff ) และอื่น ๆ

เน้นว่าคุณสามารถทำซ้ำการรวม

อาจชัดเจนสำหรับคุณ แต่ผู้ใช้ SVN คนเดิมอาจไม่ทราบว่าพวกเขาสามารถลองผสานหลาย ๆ ครั้งได้ วิธีนี้อาจช่วยลดจำนวนความช่วยเหลือที่คุณได้รับ

ใน SVN เมื่อออกกำลังกายtrunkคุณจะมีการเปลี่ยนแปลงที่ปราศจากข้อผูกมัด svn updateแล้วคุณต้องการทำ เมื่อถึงจุดนี้การเปลี่ยนแปลงของคุณจะถูกรวมเข้ากับการเปลี่ยนแปลงของคนอื่นตลอดไป ไม่มีวิธีที่จะยกเลิก (afaik) ดังนั้นคุณจึงไม่มีทางเลือก แต่เพียงตรวจสอบทุกอย่างด้วยตนเองและหวังว่า repo จะอยู่ในสถานะที่ดี เมื่อคุณจะรู้สึกสะดวกสบายมากขึ้นเพียงแค่ทำการผสานใหม่

ผู้คนจะมีความคิดเดียวกันแม้เมื่อเราย้ายไปคอมไพล์ นำไปสู่ข้อผิดพลาดโดยไม่ตั้งใจจำนวนมาก

โชคดีที่มีคอมไพล์มีวิธีกลับโดยเฉพาะเพราะคุณสามารถทำคอมมิชชันท้องถิ่น (ฉันอธิบายในภายหลังเกี่ยวกับวิธีการแสดงสิ่งนี้ใน commandline)

แม้ว่าวิธีการทำจะแตกต่างกันไปตามเครื่องมือ ฉันพบว่าการทำซ้ำ pull ไม่ใช่สิ่งที่ปรากฏใน GUIs หลาย ๆ ปุ่มเพียงปุ่มเดียว แต่อาจเป็นไปได้ ฉันชอบคุณใช้ cygwin เพื่อนร่วมงานของฉันใช้ทรีทรี เมื่อคุณใช้ BitBucket มันก็สมเหตุสมผลที่จะใช้มันเป็น GUI ของคุณเนื่องจากมันถูกจัดการโดย บริษัท เดียวกัน: Atlassian ฉันสงสัยว่ามีการรวมที่เข้มงวดมากขึ้น

เกี่ยวกับการดึง

ฉันคิดว่าคุณถูกต้องที่การรวมเข้าด้วยกันpullเป็นสิ่งที่ทำให้ผู้คนสับสน A pullคือการgit fetchดึงการเปลี่ยนแปลงจากเซิร์ฟเวอร์ตามด้วยgit merge origin/<branchname>* ซึ่งผสานการเปลี่ยนแปลงระยะไกลเข้ากับสาขาในพื้นที่ของคุณ ( https://git-scm.com/docs/git-pull )

ผลที่สุดคือคำสั่งผสานแบบมาตรฐานทั้งหมดทำงานด้วยการดึง หากการผสานนั้นมีข้อขัดแย้งคุณสามารถยกเลิกgit merge --abortได้ ซึ่งควรนำคุณกลับไปก่อนที่จะรวม จากนั้นคุณสามารถลองอีกครั้งกับอย่างใดอย่างหนึ่งหรือgit pullgit merge origin/<branchname>

หากคุณสามารถเรียนรู้วิธีการดังกล่าวโดยใช้เครื่องมือ GUI ของเพื่อนร่วมงานที่คุณเลือกฉันคิดว่ามันจะแก้ปัญหาส่วนใหญ่ของคุณได้ ขออภัยฉันไม่สามารถเจาะจงมากขึ้น

* ฉันเข้าใจว่าต้นกำเนิดไม่ใช่กรณีที่นี่เสมอ

ใช้git reflogเพื่อวินิจฉัยปัญหา

ฉันเช่นคุณต้องวินิจฉัยปัญหาที่เกิดขึ้นส่วนใหญ่โดยใช้เครื่องมือ GUI ในทางที่ผิด ฉันพบว่าgit reflogบางครั้งอาจมีประโยชน์เนื่องจากเป็นเส้นทางการดำเนินการที่สอดคล้องกันอย่างเป็นธรรมในที่เก็บ แม้ว่ามันจะยากที่จะอ่านในบางครั้ง

ทางเลือกอื่น

เนื่องจากสถานการณ์ของคุณเป็นแบบชั่วคราวคุณสามารถกลับไปที่ SVN จนกว่าคุณจะมีกระบวนการดำเนินการ ฉันลังเลที่จะทำเช่นนี้เนื่องจากมีหลายที่ที่จะพูดว่า 'เราลองคอมไพล์ครั้งเดียว แต่มันก็ไม่ได้ผล ... ' และไม่เคยหยิบมันขึ้นมาเลย

ปัญหาการเปลี่ยนผ่านอื่น ๆ ที่พบบ่อย

• ผู้คนมักจะลบและกู้คืน repo ของพวกเขาการถูกเชื่อว่า repo ของพวกเขาอยู่ในสถานะที่ใช้ไม่ได้ มักจะเกิดจากการสูญเสียการติดตามความแตกต่างในท้องถิ่นและระยะไกล ทั้งเครื่องมือ GUI และ CLI ไม่สามารถแสดงผลได้ดี ใน CLI ฉันพบgit log --decorateวิธีที่ง่ายที่สุดในการมองเห็นความแตกต่าง แต่ถ้าสิ่งต่าง ๆ ดูมีขนดกเกินไป (เช่น) คุณก็ทำได้git reset --hard origin/master

หนึ่งในกลไกที่เป็นไปได้ที่ทีมโอเพนซอร์ซจำนวนมากได้นำมาใช้คือการใช้โมเดลฟอร์กกิ้ง - https://www.atlassian.com/git/tutorials/comparing-workflows (ให้แน่ใจว่าได้ระบุอย่างชัดเจนเมื่อพูดถึงฟอร์กกิ้งโฟล์ก ) .

ในแต่ละนักพัฒนาหรือทีมย่อยมีที่เก็บแยกต่างหากที่พวกเขาเช็คเอาต์จากBitBucket มีกลไกสำหรับการตั้งค่าต้นกำเนิด "upstream" นอกเหนือจากรีโมตเริ่มต้น - พวกเขาจะต้องจำเอา "ดึงอัพสตรีม " "และ" ผสานรีโมต / อัปสตรีม / มาสเตอร์ "เป็นประจำ

อาจเป็นไปได้ที่จะแก้ไขปัญหากลไกการสร้างของคุณเนื่องจากเครื่องมือสร้างอาจชี้ไปที่ต้นแบบในโครงการอื่นเช่นทางแยก

จากนั้นคุณสามารถลบความสามารถในการผลักดันโดยตรงไปยังโครงการหลักและทำให้คนกลุ่มเล็ก ๆ ที่มีบทบาททบทวนและอนุมัติ ดูhttps://www.atlassian.com/git/tutorials/making-a-pull-request

สถานที่ที่จะอ่านเพื่อให้แน่ใจว่าการตรวจสอบที่น่าพอใจใด ๆ เกิดขึ้นก่อนที่การพุชจะอยู่ในส่วนหนังสือ git บน hooks - https://git-scm.com/book/gr/v2/Customizing-Git-Git-Hooks - คุณสามารถใช้ pre-commit และ pre-push hooks เพื่อทำสิ่งต่าง ๆ เช่นรันการทดสอบบางอย่างกับข้อเสนอที่เสนอเพื่อให้แน่ใจว่างานนั้นถูกต้อง ฯลฯ - ปัญหาเดียวของ hooks ด้านไคลเอ็นต์คือผู้พัฒนาสามารถปิดใช้งานหรือไม่สามารถเปิดใช้งาน พวกเขา

ทั้งการดึงข้อมูล / การผสานและตะขอมีอยู่ใน TortoiseGit

นี่จะฟังดูเป็นเรื่องง่าย แต่ได้ยินฉัน:

กระตุ้นให้พวกเขาเริ่มทดลองใช้คอมไพล์

สิ่งหนึ่งที่น่าสนใจเกี่ยวกับคอมไพล์คือมันง่ายที่จะทำให้การปฏิบัติการในท้องถิ่นปลอดภัยอย่างสมบูรณ์แบบ เมื่อฉันเริ่มใช้ git สิ่งหนึ่งที่ฉันคิดว่าทำคือการซิปไดเร็กตอรี่ทั้งหมดเพื่อสำรองในกรณีที่ฉันทำอะไรบางอย่างผิดพลาด ฉันค้นพบในภายหลังว่านี้เป็น kludge อย่างมากและเกือบจะไม่จริงที่จำเป็นเพื่อปกป้องการทำงานของคุณ แต่มันก็มีคุณธรรมของการเป็นมากปลอดภัยและมากง่ายแม้ว่าคุณไม่ได้รู้ว่าสิ่งที่อยู่ในห่าคุณกำลังทำและวิธีการ คำสั่งที่คุณต้องการลองจะเปิดออก pushสิ่งเดียวที่คุณต้องหลีกเลี่ยงเมื่อคุณทำเช่นนี้คือ หากคุณไม่ได้ทำอะไรเลยนี่เป็นวิธีที่ปลอดภัย 100% ที่จะลองทำทุกสิ่งที่คุณต้องการ

ความกลัวในการลองสิ่งต่าง ๆ เป็นหนึ่งในอุปสรรคที่ใหญ่ที่สุดในการเรียนรู้คอมไพล์ มันจะช่วยให้คุณเพื่อให้การควบคุมมากขึ้นกว่าทุกอย่างที่มันเป็นชนิดของที่น่ากลัว ความจริงก็คือคุณสามารถยึดติดกับการปฏิบัติงานที่ปลอดภัยไม่กี่อย่างสำหรับการใช้ชีวิตประจำวันส่วนใหญ่ของคุณ

ด้วยการให้ความรู้สึกปลอดภัยแก่พวกเขาพวกเขาจะเต็มใจลองคิดวิธีการทำสิ่งต่าง ๆ ด้วยตนเอง และพวกเขาจะได้รับอำนาจมากขึ้นในการค้นหาขั้นตอนการทำงานส่วนบุคคลในเครื่องท้องถิ่นที่เหมาะกับพวกเขา และถ้าทุกคนไม่ได้จะเป็นสิ่งเดียวกันในประเทศที่ดีตราบใดที่พวกเขาเป็นไปตามมาตรฐานกับสิ่งที่พวกเขาผลักดัน หากใช้การบีบอัด repo ทั้งหมดก่อนที่จะทำการผ่าตัดเพื่อให้พวกเขารู้สึกอย่างนั้นมันก็ดี พวกเขาสามารถเลือกวิธีที่ดีกว่าในการทำสิ่งต่าง ๆ เมื่อพวกเขาไปและเมื่อพวกเขาลองสิ่งต่าง ๆ อะไรก็ตามเพื่อให้ตัวคุณเองเริ่มทดลองสิ่งต่าง ๆ และดูว่ามันทำอะไร

นี่ไม่ได้หมายความว่าการฝึกอบรมจะไร้ค่า ในทางตรงกันข้ามการฝึกอบรมสามารถช่วยแนะนำคุณเกี่ยวกับคุณสมบัติและรูปแบบและบรรทัดฐาน แต่มันไม่ได้เป็นการทดแทนการนั่งลงและการทำสิ่งต่าง ๆ ในการทำงานประจำวันของคุณ ทั้ง git และ SVN ไม่ได้เป็นสิ่งที่คุณสามารถไปเรียนแล้วคุณรู้ทุกอย่างเกี่ยวกับ คุณต้องใช้พวกเขาในการแก้ปัญหาของคุณเพื่อทำความคุ้นเคยกับพวกเขาและคุณสมบัติใดที่เหมาะกับปัญหาใด ๆ

หยุดท้อใจพวกเขาจากการเรียนรู้ส่วนลึกและของ git

ฉันพูดถึงว่าไม่ได้ผลักอะไรเลยซึ่งจริงๆแล้วมันขัดแย้งกับหนึ่งในสิ่งที่คุณสอนพวกเขานั่นคือ "Commit & Push" เสมอ ฉันเชื่อว่าคุณควรหยุดบอกให้พวกเขาทำเช่นนี้และบอกให้พวกเขาเริ่มทำตรงกันข้าม Git มี 5 "สถานที่" โดยที่การเปลี่ยนแปลงของคุณสามารถ:

• บนดิสก์ปราศจากข้อผูกมัด
• ฉาก แต่ไม่ได้มุ่งมั่น
• ในการกระทำท้องถิ่น
• ในที่ซ่อนของท้องถิ่น
• ที่เก็บข้อมูลระยะไกล (เฉพาะการส่งมอบและแท็กเท่านั้นที่ถูกผลักและดึงระหว่างที่เก็บที่แตกต่างกัน)

แทนที่จะสนับสนุนให้พวกเขาดึงและผลักดันทุกอย่างในขั้นตอนเดียวกระตุ้นให้พวกเขาใช้ประโยชน์จากสถานที่ทั้ง 5 แห่งนี้ ส่งเสริมให้พวกเขาไปที่:

• เรียกการเปลี่ยนแปลงก่อนที่จะกระทำการใด ๆ

• ทำให้การตัดสินใจวิธีการจัดการกับการเปลี่ยนแปลงที่ลึกซึ้ง ตัวเลือกคือ:

  • คอมมิตการเปลี่ยนแปลงในท้องถิ่นของพวกเขาจากนั้นรีบูตพวกเขาด้านบนของการเปลี่ยนแปลงที่ดึงมา
  • คอมมิชชันการเปลี่ยนแปลงท้องถิ่นของพวกเขาและทำการผสานกับการเปลี่ยนแปลงที่นำมาใช้

  • สะสมการเปลี่ยนแปลงของพวกเขาผสานแล้ว unstash และแก้ไขข้อขัดแย้งใด ๆ

    มีสิ่งอื่นอีก แต่ฉันจะไม่เข้าไปที่นี่ โปรดทราบว่าดึงเป็นตัวอักษรเพียงดึงข้อมูลและการผสาน มันไม่เหมือนพวกเขา มันคือพวกเขา (ผ่าน--rebaseการเปลี่ยนแปลงดึงจากการดึงข้อมูล + ผสานเพื่อดึงข้อมูล + rebase)

• จัดลำดับการเปลี่ยนแปลงและตรวจทาน
• กระทำการเปลี่ยนแปลงตามขั้นตอนและทบทวนการกระทำ
• กดแยกต่างหาก

สิ่งนี้จะกระตุ้นให้พวกเขาตรวจสอบงานของพวกเขาก่อนที่ทุกคนจะสามารถใช้งานได้ซึ่งหมายความว่าพวกเขาจะได้รับข้อผิดพลาดได้เร็วขึ้น พวกเขาจะเห็นความมุ่งมั่นและคิดว่า "รอนั่นไม่ใช่สิ่งที่ฉันต้องการ" และไม่เหมือนใน SVN พวกเขาสามารถย้อนกลับไปลองอีกครั้งก่อนที่พวกเขาจะผลักดัน

เมื่อพวกเขาคุ้นเคยกับแนวคิดของการทำความเข้าใจว่าการเปลี่ยนแปลงอยู่ที่ไหนพวกเขาสามารถเริ่มตัดสินใจได้ว่าจะข้ามขั้นตอนและรวมการดำเนินการบางอย่างเมื่อใดเนื่องจากเมื่อคุณดึงเพราะคุณรู้ว่าคุณต้องการดึงข้อมูล + ผสานหรือเมื่อคลิกตัวเลือก Commit & Push .

นี่คือหนึ่งในผลประโยชน์มหาศาลของ git เหนือ SVN และ git ได้รับการออกแบบโดยคำนึงถึงรูปแบบการใช้งานนี้ ตรงกันข้าม SVN จะถือว่าที่เก็บส่วนกลางดังนั้นจึงไม่แปลกใจหากเครื่องมือสำหรับ git นั้นไม่ได้รับการปรับให้เหมาะสมสำหรับเวิร์กโฟลว์เดียวกัน ใน SVN หากการกระทำของคุณผิดการขอความช่วยเหลือที่แท้จริงเพียงอย่างเดียวของคุณคือการกระทำใหม่เพื่อยกเลิกข้อผิดพลาด

การทำเช่นนี้จริง ๆ แล้วจะนำไปสู่กลยุทธ์ถัดไป:

กระตุ้นให้พวกเขาใช้สาขาท้องถิ่น

กิ่งก้านสาขาในท้องถิ่นช่วยบรรเทาจุดปวดจำนวนมากในการทำงานกับไฟล์ที่ใช้ร่วมกัน ฉันสามารถทำการเปลี่ยนแปลงทั้งหมดที่ฉันต้องการในสาขาของตัวเองและมันจะไม่ส่งผลกระทบต่อทุกคนตั้งแต่ฉันไม่ได้ผลักดันพวกเขา จากนั้นเมื่อถึงเวลาฉันสามารถใช้กลยุทธ์การผสานและการรีบูตเดียวกันทั้งหมดได้ง่ายขึ้นเท่านั้น:

• ฉันสามารถลดสาขาในพื้นที่ของฉันซึ่งทำให้การรวมเข้ากับเรื่องไร้สาระ
• ฉันสามารถใช้การผสานแบบธรรมดา (สร้างการคอมมิตใหม่) ในต้นแบบเพื่อนำการเปลี่ยนแปลงของสาขาท้องถิ่นของฉันไปใช้
• ฉันสามารถสควอชรวมสาขาในพื้นที่ของฉันทั้งหมดเป็นหนึ่งเดียวกับมาสเตอร์ถ้าฉันคิดว่าสาขาของฉันยุ่งเกินกว่าจะกอบกู้

การใช้กิ่งก้านสาขาในท้องถิ่นก็เป็นจุดเริ่มต้นที่ดีในการหากลยุทธ์การแยกสาขาอย่างเป็นระบบ ช่วยให้ผู้ใช้ของคุณเข้าใจความต้องการการแตกแขนงของตัวเองได้ดีขึ้นดังนั้นคุณสามารถเลือกกลยุทธ์ตามความต้องการและระดับความเข้าใจ / ทักษะในปัจจุบันของทีมและไม่เพียงแค่วาง Gitflow เพราะทุกคนเคยได้ยิน

สรุป

กล่าวโดยย่อคือคอมไพล์ไม่ใช่ SVN และไม่สามารถปฏิบัติเช่นนั้นได้ คุณต้อง:

• กำจัดความกลัวด้วยการสนับสนุนการทดลองอย่างปลอดภัย
• ช่วยให้พวกเขาเข้าใจว่าระบบคอมพิวเตอรมีความแตกต่างกันอย่างไรเพื่อให้สามารถเห็นได้ว่าการเปลี่ยนแปลงเวิร์กโฟลว์ปกติของพวกเขานั้นเป็นอย่างไร
• ช่วยให้พวกเขาเข้าใจคุณลักษณะที่มีอยู่เพื่อช่วยแก้ไขปัญหาได้ง่ายขึ้น

ทั้งหมดนี้จะช่วยให้คุณใช้งานการใช้งานคอมไพล์ได้ดีขึ้นเรื่อย ๆจนกว่าจะถึงจุดที่คุณสามารถเริ่มใช้ชุดมาตรฐาน

คุณสมบัติเฉพาะ

ในระยะสั้นแนวคิดต่อไปนี้อาจช่วยได้

rebase

คุณพูดถึงการปฏิเสธและคุณไม่เข้าใจจริงๆในคำถามของคุณ ดังนั้นนี่คือคำแนะนำของฉัน: ลองสิ่งที่ฉันเพิ่งอธิบาย ทำการเปลี่ยนแปลงภายในเครื่องขณะที่บางคนผลักการเปลี่ยนแปลงบางอย่าง กระทำการเปลี่ยนแปลงของคุณในประเทศ บีบอัดไดเร็กทอรีที่เก็บของคุณเป็นแบ็คอัพ เรียกการเปลี่ยนแปลงของบุคคลอื่น ตอนนี้ลองรันคำสั่ง rebase แล้วดูว่าเกิดอะไรขึ้นกับคอมมิทของคุณ! คุณสามารถอ่านโพสต์บล็อกที่ไม่มีที่สิ้นสุดหรือรับการฝึกอบรมเกี่ยวกับ rebase และวิธีการที่คุณควรใช้หรือไม่ควรใช้ ดังนั้นลองมันออกมา

merge.ff=only

อันนี้จะเป็นเรื่องของรสนิยมส่วนตัว แต่ฉันจะแนะนำอย่างน้อยก็ชั่วคราวเนื่องจากคุณพูดถึงคุณแล้วว่ามีปัญหาในการจัดการกับความขัดแย้ง ฉันแนะนำให้ตั้งค่าmerge.ffเป็นonly :

git config --global merge.ff only

"ff" ย่อมาจาก "fast forward" การผสานไปข้างหน้าอย่างรวดเร็วคือเมื่อคอมไพล์ไม่จำเป็นต้องรวมการเปลี่ยนแปลงจากคอมมิทที่ต่างกัน มันเพียงเลื่อนตัวชี้ของสาขาไปยังการกระทำใหม่ตามเส้นตรงในกราฟ

สิ่งนี้ในทางปฏิบัติคือป้องกันไม่ให้คอมไพล์พยายามสร้างคอมมิชชันโดยอัตโนมัติ ดังนั้นถ้าฉันทำอะไรบางอย่างในพื้นที่แล้วดึงการเปลี่ยนแปลงของคนอื่นแทนที่จะพยายามสร้างการรวม (และอาจบังคับให้ผู้ใช้จัดการกับข้อขัดแย้ง) การผสานจะล้มเหลว fetchผลคอมไพล์จะได้ดำเนินการเพียง เมื่อคุณไม่มีข้อผูกพันในท้องถิ่นการผสานจะดำเนินการตามปกติ

สิ่งนี้จะช่วยให้ผู้ใช้มีโอกาสตรวจสอบข้อผูกพันที่แตกต่างกันก่อนที่จะพยายามรวมพวกเขาและบังคับให้พวกเขาตัดสินใจเกี่ยวกับวิธีจัดการที่ดีที่สุดในการรวมพวกเขา ฉันสามารถรีบูตไปข้างหน้าด้วยการผสาน (ใช้git merge --no-ffเพื่อข้ามการกำหนดค่า) หรือฉันสามารถชะลอการรวมการเปลี่ยนแปลงของฉันตอนนี้และจัดการในภายหลัง ฉันคิดว่าการชนความเร็วเล็กน้อยนี้จะช่วยให้ทีมของคุณหลีกเลี่ยงการตัดสินใจผิดเกี่ยวกับการรวม คุณสามารถให้ทีมของคุณปิดได้เมื่อพวกเขาทำได้ดีกว่าในการจัดการการรวม

ฉันผ่าน SVN เดียวกัน -> ประสบการณ์คอมไพล์ที่ บริษัท ของฉันและจากประสบการณ์ของฉันการรักษาเพียงอย่างเดียวคือเวลา ให้ผู้คนคุ้นเคยกับเครื่องมือปล่อยให้พวกเขาทำผิดแสดงวิธีแก้ไขให้พวกเขา ความเร็วของคุณจะต้องทนทุกข์ทรมานสักพักหนึ่งและผู้คนจะสูญเสียงานและทุกคนจะค่อนข้างยุ่งเหยิง แต่นั่นคือธรรมชาติของการเปลี่ยนแปลงบางอย่างที่เป็นพื้นฐานของ VCS ของคุณ

ที่กล่าวว่าฉันเห็นด้วยกับทุกคนที่มีความเห็นว่า TortoiseGit เป็นอุปสรรคมากกว่าความช่วยเหลือดังนั้นในช่วงต้นของการเปลี่ยนแปลง TortoiseGit คือ ... ไม่ใช่ GUI ที่ยอดเยี่ยมในช่วงเวลาที่ดีที่สุดและด้วยการปิดบังว่า git ทำงานอย่างไรในชื่อของความเรียบง่ายมันยังป้องกันไม่ให้เพื่อนร่วมงานของคุณได้รับความเข้าใจแนวคิดหลัก git เช่นการผูกมัดสองเฟส

เราได้ทำการตัดสินใจ (ค่อนข้างรุนแรง) เพื่อบังคับให้ devs ใช้ command-line (git bash หรือposh-git ) เป็นเวลาหนึ่งสัปดาห์และนั่นก็เป็นสิ่งมหัศจรรย์สำหรับความเข้าใจว่า git ทำงานอย่างไรและแตกต่างจาก SVN อย่างไร มันอาจฟังดูรุนแรง แต่ฉันขอแนะนำให้คุณลองใช้เพราะมันสร้างความเข้าใจในแบบจำลอง git - และเมื่อพวกเขาทำสิ่งนั้นไม่ได้เพื่อนร่วมงานของคุณสามารถเริ่มใช้หน้า GUI ใดก็ได้บน git ที่พวกเขาต้องการ

หมายเหตุสุดท้าย: จะมีเพื่อนร่วมงานของคุณบางคนที่คร่ำครวญว่าคอมไพล์ทำงานได้อย่างไรในทันทีและจะมีบางคนที่ไม่เคยจะทำ กลุ่มหลังคุณเพียงแค่ต้องสอนคาถาลึกลับเพื่อให้โค้ดของพวกเขาได้รับจากเครื่องท้องถิ่นไปยังเซิร์ฟเวอร์เพื่อให้ทุกคนสามารถเห็นได้

เมื่อไม่นานมานี้ฉันได้ปรับเวิร์กโฟลว์ต่อไปนี้เพื่อไม่ให้ f * ck เป็นสาขาหลัก:

1) ทุกคนใช้สาขาของตนเองซึ่งคัดลอกมาจากสาขาหลักอย่างตั้งใจ

มาตั้งชื่อสาขาหลักว่า "master" และสาขาของตัวเอง "my_master"

ฉันเพิ่งสร้างสาขาจากเจ้านายดังนั้นมันจึงเหมือนกันทุกประการ ฉันเริ่มทำงานกับคุณสมบัติใหม่ในสาขาของตัวเองและเมื่อเสร็จแล้วฉันจะทำสิ่งต่อไปนี้

ไปที่สาขาของฉันเพิ่งเสร็จสิ้นการเข้ารหัส

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

หากทุกคนติดตามสิ่งนี้สาขาหลักจะสะอาด

ดังนั้นเราจึงมีทีมที่เปลี่ยนจาก TFS เป็นคอมไพล์และรักษาวิธีคิดเก่า ๆ ไว้ กฎทั่วไปของการดำเนินการจะเหมือนกันมากหรือน้อย

ใช่มันหมายความว่าทุกคนทำงานได้ดี มันไม่ได้แย่ขนาดนั้น และทีมที่เคยใช้ TFS หรือ SVN จะพบสิ่งนี้เป็นธรรมชาติที่สุด

ขั้นตอนทั่วไปเพื่อทำให้ไม่เจ็บปวดเท่าที่จะเป็นไปได้:

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.

หากทุกคนทำงานกับอาจารย์ไม่มีอะไรที่คุณสามารถทำได้ สิ่งที่จะทำให้สับสนได้อย่างหลีกเลี่ยงไม่ได้

คุณควรใช้หลักสำหรับผลิตภัณฑ์ที่สมบูรณ์ที่ส่งถึงลูกค้า คุณควรใช้การพัฒนาเพื่อการพัฒนาอย่างต่อเนื่องและคุณไม่ควรอนุญาตให้ใครก็ตามผลักดันการพัฒนา มาตรฐานคือทุกคนแยกสาขาจาก dev ทำการเปลี่ยนแปลงพุชพวกเขาจากโลคัลไปยังสาขาของพวกเขาบนเซิร์ฟเวอร์และออกคำร้องขอพุช จากนั้นมีคนรีวิวการเปลี่ยนแปลงและรวมเข้ากับการพัฒนา

เพื่อหลีกเลี่ยงความขัดแย้งทุกคนผสานการพัฒนาเข้ากับสาขาของตัวเองก่อนที่จะผลักดันและแก้ไขความขัดแย้งในระยะนั้น หากการรวมเข้ากับการพัฒนาจะทำให้เกิดข้อขัดแย้งก็จะไม่ถูกรวมเข้าด้วยกัน - ผู้พัฒนาจะรวมการพัฒนาเข้ากับสาขาของพวกเขาอีกครั้งและส่งไปยังเซิร์ฟเวอร์อีกครั้งและจากนั้นจะมีการตรวจสอบอีกครั้ง

คุณสามารถใช้ sourcetree เพื่อทำให้งานนี้โดยไม่เจ็บปวด