นักพัฒนาใหม่ไม่สามารถติดตามการรวมสาขาได้

ฉันเป็นนักพัฒนาใหม่ - นี่คือตำแหน่งการเขียนโปรแกรมครั้งแรกของฉัน

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

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

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

ดังนั้นเพื่อลดโอกาสในการรวมความขัดแย้งคุณสามารถลองผสานก่อนหน้านี้เพื่อให้เพื่อนร่วมงานของคุณเปลี่ยนบรรทัดน้อยลงในระหว่างนี้หรือคุณสามารถลองเปลี่ยนสายน้อยลงด้วยตัวเอง

หากต้องการเปลี่ยนบรรทัดให้น้อยลงตรวจสอบให้แน่ใจว่าได้ทำการเปลี่ยนแปลงที่เกี่ยวข้องกับงานของคุณเท่านั้น

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

นอกจากนี้ยังมีคำสั่ง Git บางอย่างที่สามารถช่วยให้คุณเปลี่ยนบรรทัดได้น้อยที่สุด:

• git diffและgit diff --stagedเพื่อดูว่าคุณเปลี่ยนสายอะไร
• git add -p เพื่อเพิ่มการเปลี่ยนแปลงของคุณในไฟล์เท่านั้น
• git commit --amendและgit rebase -iเพื่อปรับแต่งให้คุณทำในสาขาฟีเจอร์ท้องถิ่นของคุณก่อนที่จะผลักดันพวกเขาไปยังที่เก็บ Git อื่น ๆ

(เปลี่ยนเส้นน้อยที่สุดยังสามารถทำให้มันง่ายต่อการตรวจสอบการทำงานของคุณหรือที่จะใช้เครื่องมือที่ทำงานบนความแตกต่างระหว่างการกระทำเช่นgit cherry-pick, git rebase, git bisectและgit blame.)

แต่แม้ว่าคุณจะลดความเป็นไปได้ของการรวมความขัดแย้งคุณจะยังคงพบข้อขัดแย้งในการผสานในบางครั้ง ดังนั้นอย่ากลัวพวกเขา แต่เรียนรู้วิธีแก้ไขข้อขัดแย้ง

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

หากคุณเรียกใช้มันทุกวันคุณอาจไม่จำเป็นต้องมีส่วนโต้ตอบ ปล่อยให้มันทำในสิ่งที่มันทำ

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

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

แก้ไข:

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

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

คำตอบที่ยอมรับได้ฉันคิดว่าเป็นวิธีการใช้ Git ที่ดีกว่าเทคนิคฉันคิดว่านี่เป็นปัญหาของทีมมากกว่าปัญหาทางวิศวกรรมหรือการใช้เครื่องมือ

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

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

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

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

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

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

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

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

หากคุณมีข้อขัดแย้งให้รับเครื่องมือ diff ที่ดีเพื่อให้คุณสามารถเปรียบเทียบสาขาการพัฒนาก่อนที่จะผสานรหัสของคุณก่อนการผสานรหัสเดิมของคุณและรหัสที่ผสานและผสานด้วยมือ

กรณีที่เลวร้ายที่สุด: คุณไม่ได้ละทิ้งงานของคุณ แต่ใช้เครื่องมือ diff ที่ดีเพื่อค้นหาการเปลี่ยนแปลงที่คุณทำแตกสาขาจากการพัฒนาและใช้การเปลี่ยนแปลงทั้งหมดที่คุณทำด้วยตนเองแทนการพิมพ์ซ้ำ

ตามเวลาที่ฉันพร้อมที่จะผสานสาขาของฉันกลับไปสู่การพัฒนา (เน้นที่เหมือง)

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

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

ฉันจะแนะนำเทคนิคต่าง ๆ ให้คุณ แต่พวกเขาสามารถช่วยให้การผสานง่ายขึ้นกว่าการทำงานให้เป็นอัตโนมัติ

• ทรัพยากร / ไฟล์ภาษา ถ้าคุณมีสารเติมแต่งเปลี่ยนแปลงแฟ้มทรัพยากรให้แน่ใจว่าคุณมักจะย้ายไปยังจุดสิ้นสุดของแฟ้มเพื่อให้คุณสามารถจำของคุณเปลี่ยนแปลงเมื่อเทียบกับคนอื่น ๆการเปลี่ยนแปลง " คุณสามารถคัดลอกและวางการเปลี่ยนแปลงของคุณที่ด้านล่างหรือเพียงแค่ลบเครื่องหมายความขัดแย้ง
• ทำ. ไม่. อย่าง ฟอร์แมตใหม่ ทั้งคุณและเพื่อนนักพัฒนาของคุณจะไม่ทำการ "ฟอร์แมตโค้ดขนาดใหญ่" ในระหว่างการทำงานประจำวัน การจัดรูปแบบรหัสเพิ่มจำนวนของผลบวกที่ผิดพลาดมากเกินไปในการจัดการความขัดแย้ง สามารถทำการฟอร์แมตโค้ดใหม่ได้
  • เพิ่มขึ้นเช่นโดยนักพัฒนาทุกคนในทุกการกระทำทันทีที่พวกเขาใช้เครื่องมืออัตโนมัติ (เช่น Eclipse มีตัวเลือกในการฟอร์แมตการบันทึก Vanilla Visual Studio ไม่มี) นักพัฒนาซอฟต์แวร์ทุกคนจะต้องใช้มาตรฐานการจัดรูปแบบรหัสเดียวกันโดยเขียนเป็นไฟล์รูปแบบที่ IDE ของคุณกิน เพื่อให้ความคิดแก่คุณถ้ามันเป็น 4 ช่องว่างหรือ 2 แท็บมันไม่สำคัญ แต่มันสำคัญจริงๆถ้าทุกคนใช้เหมือนกัน
  • ก่อนปล่อยโดยหัวหน้าทีม หากมีการกระทำ "การปรับรูปแบบรหัส" เกิดขึ้นเมื่อคนไม่ทำงานในสาขาเช่นก่อนที่จะแยกสาขาสิ่งต่าง ๆ จะทำให้ง่ายขึ้น
• ตรวจสอบการแยกงานระหว่างเพื่อนร่วมงาน อันนี้เป็นส่วนที่วิศวกรรมส่วนใหญ่มา ดังที่คำตอบอื่น ๆ มันเป็นกลิ่นการออกแบบหากนักพัฒนาหลายคนทำงานที่แตกต่างกันต้องสัมผัสทรัพยากรเดียวกัน คุณอาจต้องพูดคุยกับหัวหน้าทีมของคุณเกี่ยวกับส่วนที่จะแก้ไขโดยผู้พัฒนาพร้อมกันแต่ละคน

ฉันเคยเห็นนิสัยที่ไม่ดีในเวิร์กโฟลว์ Git ในทีมของฉันด้วย บ่อยครั้งที่ผู้คน overcommit ไปยังสาขาของพวกเขา ฉันเห็นผู้พัฒนาเป็นการส่วนตัวเพิ่ม 10 ถึง 20 คอมมิทที่ระบุว่า "แก้ไข" แต่ละบรรทัดที่ทำหนึ่งหรือสองบรรทัด นโยบายของเราคือความมุ่งมั่นนั้นมีป้ายกำกับด้วยบัตร JIRA เพื่อให้ความคิดแก่คุณ

@JacobRobbins แนะนำให้git rebaseทำงานประจำวัน ฉันต้องการผลักดันวิธีการของเขาไปข้างหน้า

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

หากคุณมีคำถามเพิ่มเติมเกี่ยวกับงานเฉพาะอย่าลังเลที่จะค้นหาและถามใน Stackoverflow

[แก้ไข] เกี่ยวกับกฎการไม่ปฏิรูปและลูกเสือ ฉันจัดรูปแบบ RE reworded เล็กน้อยเพื่อเน้นว่าสิ่งที่ฉันหมายถึงคืองานการจัดรูปแบบตั้งแต่เริ่มต้นไฟล์ต้นฉบับทั้งหมดรวมถึงโค้ดที่คุณไม่ได้สัมผัส ตรงกันข้ามกับการจัดรูปแบบโค้ดของคุณซึ่งเป็นนักพัฒนาลูกเสือซึ่งเป็นนักพัฒนาจำนวนมากรวมถึงตัวผมเองใช้ในการฟอร์แมตไฟล์ทั้งหมดด้วยความสามารถของ IDE เมื่อผู้อื่นสัมผัสไฟล์แม้ว่าเส้นที่ได้รับผลกระทบจะไม่เปลี่ยนแปลงในเนื้อหาและความหมาย Git จะเห็นว่าไฟล์นั้นเป็นความขัดแย้ง ตัวแก้ไขภาษาที่ทรงพลังเท่านั้นที่สามารถแนะนำได้ว่าความขัดแย้งนั้นเกี่ยวข้องกับการจัดรูปแบบและรวมส่วนที่จัดรูปแบบที่ดีที่สุดโดยอัตโนมัติ แต่ฉันไม่มีหลักฐานของเครื่องมือดังกล่าว

ท้ายที่สุดกฎลูกเสือไม่ได้บังคับให้คุณทำความสะอาดความยุ่งเหยิงของคนอื่น เพียงแค่คุณ

ก่อนอื่นอย่าคิดว่าจะละทิ้งการเปลี่ยนแปลงของคุณ คุณจะสูญเสียโอกาสในการเรียนรู้กระบวนการผสาน

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

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

และสำหรับการหลีกเลี่ยงในอนาคต

• เป็นวิธีปฏิบัติที่ดีมากในการผสานสาขาการพัฒนาเข้ากับสาขาคุณลักษณะของคุณเป็นประจำ

• หากคุณเปิดใช้งาน CI ดูว่าเครื่องมือ CI มีการสร้างสาขาหรือไม่ สิ่งนี้ควรสร้างในทุกการเช็คอินที่คุณทำในสาขาฟีเจอร์ของคุณ แต่หลังจากผสานพัฒนาสาขา

คุณควรเรียกใช้คำสั่ง 'git fetch' เป็นประจำทุกวัน (ไม่ใช่ git pull) จากสาขาการพัฒนาของคุณ สิ่งนี้จะทำให้คนอื่น ๆ ยอมรับการเปลี่ยนแปลงและนำพวกเขาเข้าสู่สาขาฟีเจอร์ของคุณโดยไม่ต้องพยายามรวมการเปลี่ยนแปลงในสาขาของคุณ

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

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

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

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

ตามเวลาที่ฉันพร้อมที่จะรวมสาขาของฉันกลับไปสู่การพัฒนาอื่น ๆ ได้ทำการเปลี่ยนแปลงมากมายที่แก้ไขข้อขัดแย้งที่ครอบงำ

นี่เป็นสถานการณ์ที่เหมาะสำหรับการเขียนโปรแกรมคู่ !

ข้อมูลเพิ่มเติมเกี่ยวกับประโยชน์และแนวทางพื้นฐาน:
https://gds.blog.gov.uk/2018/02/06/how-to-pair-program-effectively-in-6-steps/

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

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

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

การนั่งกับผู้พัฒนาที่เร็วและมีประสบการณ์มากขึ้นจะช่วยให้:

• มีแนวโน้มที่จะลดความขัดแย้งในการผสานกับการทำงานกับคนที่มีประสบการณ์มากกว่านี้จะเพิ่มเวลาการดำเนินการให้เสร็จสิ้นเมื่อเทียบกับการทำงานของคุณคนเดียว
• เนื่องจากพวกเขาจะสอนคุณเป็นไปได้ว่าพวกเขาจะช้ากว่าที่พวกเขาจะทำงานคนเดียวดังนั้นจึงอาจยังมีข้อขัดแย้งที่ผสานกันและสามารถทำงานผ่านพวกเขากับคนที่มีประสบการณ์และอาจหยิบเคล็ดลับในการประหยัดเวลา ฯลฯ
• ช่วยให้คุณเห็นกลอุบายและวิธีการที่จะทำให้เร็วขึ้น (แม้ว่าความช้านั้นบางครั้งก็เป็นเพียงการขาดประสบการณ์แทนที่จะขาดการฝึกฝนที่ดี)
• สามารถถามคำถามได้ทันทีเมื่อบางสิ่งไม่สมเหตุสมผลหรือไม่ชัดเจน 100%
• การทำงาน 1: 1 มีค่าสำหรับการเรียนรู้เพราะบุคคลที่คุณต้องการความช่วยเหลือจากนั้นเข้าใจรหัสและสถานการณ์ที่แน่นอนขณะที่พวกเขากำลังทำงานอยู่โดยไม่ต้องเขียนโปรแกรมคู่คุณต้องอธิบายรหัสและสถานการณ์ซึ่งมักจะกลายเป็นปัญหาและ ดังนั้นคุณจะเสียเวลา / ความสนใจไปกับการรับคำแนะนำที่จำเป็นจริง ๆ
• ทำความรู้จักกับกระบวนการคิดของคนที่มีประสบการณ์และมีประสบการณ์มากขึ้นและด้วยการสื่อสารที่ดีคุณจะได้เรียนรู้สิ่งใหม่ ๆ อย่างแน่นอน

มีกลยุทธ์ที่ฉันสามารถใช้นอกเหนือจาก 'ดีกว่ารหัส' หรือไม่? ฉันตั้งใจจะนำเรื่องนี้ขึ้นกับหัวหน้างานของฉันในสัปดาห์หน้า

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

มีปัญหาพื้นฐานบางอย่างที่นี่ การรวมปัญหาของคุณนั้นไม่ใช่ความผิดของคุณและมักเป็นอาการของการปฏิบัติที่ไม่ดี

1) หากเป็นการดีที่คุณจะรวมสาขาของคุณเข้ากับการพัฒนาทุกวัน พยายามที่จะมีรหัสการทำงานอย่างน้อยวันละครั้งที่ผ่านการทดสอบทั้งหมดเพื่อให้คุณสามารถผสานในการพัฒนา

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

3) ไฟล์โครงการของคุณมีขนาดใหญ่เกินไป หากมีข้อขัดแย้งในการผสานไฟล์หลายไฟล์มีคนจำนวนมากที่ทำงานกับไฟล์เดียว สิ่งที่ดีที่คนคนหนึ่งกำลังทำอยู่ควรแยกออกจากสิ่งที่คนอื่นกำลังทำ

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

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

6) ผู้คนอาจผลักดันการเปลี่ยนแปลงโดยตรงไปยังสาขาที่กำลังพัฒนา

นี่คือสิ่งที่คุณสามารถทำได้: 1) หากคุณไม่สามารถรวมเข้ากับการพัฒนาได้ทุกวันให้ทำการรวม / ลดจำนวนลงในสาขาของคุณทุกวัน (หรือบ่อยกว่า)
2) พยายามแยกรหัสของคุณออกจากรหัสของคนอื่น
3) พูดคุยกับทีมอื่น ๆ เกี่ยวกับคุณสมบัติที่มีขนาดเล็กมาตรฐานการเข้ารหัสที่สอดคล้องกันและการจัดระเบียบโค้ดที่ดีขึ้น

จริง ๆ แล้วมันดูเหมือนง่ายกว่าที่จะทิ้งงานของฉันและเริ่มงานใหม่ซึ่งแน่นอนว่าไม่ใช่วิธีแก้ปัญหาที่ยั่งยืน

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

ฉันยังพบว่าเมื่อฉันทำงานซ้ำฉันเขียนรหัสได้ดีขึ้น .....

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

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

หากคุณไม่ต้องการที่จะผสานการพัฒนาสาขาเข้าไปในสาขาที่คุณบ่อยเกินไปคุณจะได้รับซึ่งเป็นขั้นตอนการทำงานมากขึ้นเช่น svn git pull --rebaseโดยใช้ วิธีนี้จะดึงการคอมมิทใหม่และรีบูตการคอมมิทของคุณ ซึ่งหมายความว่าเมื่อคุณรวมสาขาของคุณเข้ากับการพัฒนามันจะเป็นการผสานอย่างรวดเร็ว (ราวกับว่าคุณได้เพิ่มการกระทำที่ผ่านมาทั้งหมดของคุณในเวลาเดียวกันหลังจากนั้นอีกครั้ง) และไม่มีความขัดแย้งผสานเพราะคุณแก้ไขพวกเขาทั้งหมดในระหว่างgit pull --rebase.

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

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

1. แบ่งงานอย่างอิสระ:

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

2. ผสานการกระทำที่ละเอียดบ่อยเป็นเม็ด:

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

3. Rebase สาขาของคุณบ่อยครั้ง:

   ฝึกฝนการรีบาวด์บ่อยครั้งไปยังสาขาในพื้นที่ของคุณด้วยรีโมตรีโมต คุณสามารถใช้คำสั่งด้านล่างเพื่อรีบูทสาขาในพื้นที่ของคุณด้วยรีโมต

   git pull --rebase #or
   git pull --rebase origin dev #when dev is remote branch
   

   นี่คือคำสั่ง git ที่มีประโยชน์ที่สุดสำหรับฉันในการพัฒนาชีวิตของฉัน

4. ทำงานอย่างใกล้ชิดกับเพื่อนร่วมทีม:

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

5. ใช้กับตัวเลือก git:

   ใช้พลังของเครื่องมือการรวมคอมไพล์ มีวิธีที่สะดวกมากมายในการแก้ไขข้อขัดแย้งขณะผสาน การผสานกลยุทธ์บางครั้งอาจช่วยได้มาก นำมาใช้เพื่อและไม่กลัวคำสั่ง git