การจัดการกับคำขอดึงขนาดใหญ่

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

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

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

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

เป็นวิธีที่ดีที่สุดในการจัดการกับสถานการณ์เช่นนี้ที่สาขาหนึ่งอยู่ห่างจากคนอื่น ๆ จริงๆ?

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

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

เพื่อตอบคำถามที่แท้จริง: วิธีที่ดีที่สุดในการจัดการกับสถานการณ์แบบนี้คือไม่ได้อยู่ในสถานการณ์แบบนั้น

เราจะหลีกเลี่ยงวิธีใดที่จะทำให้สาขาได้รับภาระผูกพันจำนวนมากในอนาคต?

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

ตรวจสอบให้แน่ใจว่าคนรู้ว่าพวกเขาสามารถดึงจากอาจารย์เพื่อติดตามการเปลี่ยนแปลงของผู้อื่น

"หากคุณรวมทุกวันทันใดนั้นคุณจะไม่มีทางไปถึงจุดที่คุณมีความขัดแย้งขนาดใหญ่ซึ่งยากที่จะแก้ไข" - Linus Torvalds

ที่อ้างมาจากการพูดคุยเขาให้ที่ Google, นี่เป็นหลักฐานและนี่คือวิดีโอ

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

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

1. สร้างสาขาใหม่และเชอร์รี่เลือกรับความมุ่งมั่นที่ดีผสานกับหลัก
2. พยายามที่จะลดการกระทำที่ไม่พึงประสงค์ไปด้านบน (อาจสาขาใหม่เพื่อความปลอดภัย)

สำหรับวิธีการป้องกันลองกำหนดกฎของทีมที่ตลก ๆ เช่น "กฎที่ไม่รวมกับอาจารย์ภายในหนึ่งสัปดาห์จะสั่งพิซซ่าเป็นเวลาหนึ่งเดือน"

ก่อนอื่นให้ดูว่ามีการผูกพันแยกกันอย่างแท้จริงที่สามารถผสานหรือคัดสรรโดยเชอร์รี่ได้หรือไม่เช่นแนะนำโดย @Maciej Chalpuk หากเป็นกรณีนี้สถานการณ์จะไม่แย่และฉันจะไม่กังวลมากเกินไปในอนาคต

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

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

นี่เป็นวิธีง่ายๆ

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

ขอผมทำลายมันลงในรูปแบบของตัวอย่าง

ให้: สาขา A เป็นสาขาจากต้นแบบ A + = สาขา A + คุณลักษณะใหม่ 1 สาขา A ++ = สาขา A + คุณลักษณะใหม่ 2 เป็นต้นไปเรื่อย ๆ

สิ่งที่คุณต้องทำคือกลับไปที่: สาขา A +

นำ Branch A + ไปรวมกับ Master

ตอนนี้ไปที่สาขา A ++ แล้วรวมเข้ากับ (Master + Branch A +)

ทำซ้ำจนกว่าคุณจะมาถึงสาขาสุดท้าย A + ... + ที่เสถียร

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

เราจะหลีกเลี่ยงวิธีใดที่จะทำให้สาขาได้รับภาระผูกพันจำนวนมากในอนาคต?

ฉันคิดว่าวิธีการแก้ปัญหาของฉันข้างต้นบ่งชี้ว่าคุณควรจะใช้วิธีใดในอนาคต ไปกับคุณลักษณะต่อหรือวิธีงานสำหรับแต่ละสาขา

ฉันขอแนะนำให้ใช้วิธีการ:

พรีมาสเตอร์และมาสเตอร์

ต้นแบบ: ระดับสุดท้าย / ระดับการผลิต มีการปรับเปลี่ยนไม่บ่อย ถือว่ามีความเสถียรอยู่เสมอ

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

คุณควรลองใช้คุณสมบัติการรวมกลุ่มและตั้งเป้าหมายสำหรับการกำหนดเวอร์ชั่นเป้าหมาย

การกำหนดเวอร์ชั่นเป้าหมาย: ระบุหมายเลขโดยพลการที่จะทำหน้าที่เป็นตัวยึดตำแหน่งสำหรับสาขาหลัก "ใน V1.0.0 เราจะต้องบรรลุคุณสมบัติ X, Y, Z V1.0.0 จะมีฟังก์ชั่นเหล่านี้ทั้งหมด: ... "

โดยการคงเวอร์ชันไว้กับต้นแบบมันก็สามารถเป็นวิธีที่ทำให้ "ต้นแบบ" มีความเสถียรและพร้อมสำหรับการผลิตตลอดเวลา

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

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

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

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

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