วิธีปฏิบัติที่ดีก่อนที่จะตรวจสอบในซอร์สโค้ดคืออะไร [ปิด]

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

ฉันต้องการทราบวิธีปฏิบัติที่ดีก่อนที่จะตรวจสอบรหัสใน - ฉันไม่ต้องการทำผิดประเภทนี้อีกครั้ง

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

คุณไม่ควรเช็คอินรหัสออกความคิดเห็น หากคุณมีรหัสที่จำเป็นต้องแสดงความคิดเห็นก่อนทำการเช็คอินแสดงว่าคุณทำผิด

สำหรับกฎ:

1. รับล่าสุด
2. แก้ไขข้อขัดแย้งในการผสาน

3. สร้าง

   3.1 แก้ไขข้อผิดพลาดของบิลด์

4. ทำการทดสอบ

   4.1 แก้ไขการทดสอบที่เสียหาย

5. ไปที่ 1 (จนกว่าจะไม่มีอะไรใหม่ที่จะได้รับ)

เช็คอินเมื่อทุกขั้นตอนเสร็จสมบูรณ์เท่านั้น

ดูการเช็คอินในการเต้นรำ

แนวปฏิบัติที่ดีอื่น ๆ :

• ตรวจสอบรายชื่อไฟล์ที่จะเช็คอินเพื่อให้แน่ใจว่าเป็นไฟล์ที่คาดหวัง
• ตรวจสอบการเปลี่ยนแปลงสำหรับแต่ละไฟล์ (ลบ / เพิ่มเติม / diffs)

ฉันไม่ได้พยายามที่จะเป็นกางเกงขายาวมากเกินไปที่นี่ แต่ข้อสมมติฐานในคำถามนี้ (และทั้งหมดยกเว้นหนึ่งในคำตอบ) ส่วนใหญ่นำไปใช้กับ VCS ส่วนกลางเช่น TFS, SVN, Perforce ฯลฯ
ยุติธรรมพอมันเป็นอะไร OP กำลังใช้งาน

อย่างไรก็ตามในขณะที่ใช้ DVCS (เช่น Mercurial และ Git) คุณไม่ควรรอ checkin และสิ่งต่าง ๆ ที่กล่าวถึงในคำตอบ - เช่น diffs, รับล่าสุด, ผสานและอื่น ๆ ไม่จำเป็น . แม้แต่สิ่งต่าง ๆ เช่นการตรวจสอบโค้ดและการทดสอบจะทำได้ดีกว่าหลังจากเช็คอิน (แม้ว่าอาจจะก่อนที่จะผลักดันขึ้นอยู่กับ ... )
ข้อยกเว้นอย่างหนึ่งที่ฉันเห็นที่นี่ (จนถึง) คือการเชื่อมโยงกับรายการงาน แน่นอนว่าการแสดงความคิดเห็นต่อเช็คอินก็ดีเช่นกัน ...

สามสิ่งที่ฉันไม่เห็นในคำตอบอื่น ๆ :

รวมไฟล์ใหม่

• ค้นหาไฟล์ใหม่ที่ไม่ได้เป็นส่วนหนึ่งของรายการการเปลี่ยนแปลงของคุณ
• อาจเฉพาะเจาะจงกับ SCM เช่น Perforce - คุณต้องบอกทุกอย่างที่อยู่ในการเปลี่ยนแปลงของคุณ

ย้อนกลับไฟล์ที่ไม่เปลี่ยนแปลง

• ฉันเกลียดเมื่อฉันดูการเปลี่ยนแปลงของคนอื่นและมีรายการเปลี่ยนแปลงเก้าไฟล์ แต่มีเพียงสามไฟล์เท่านั้นที่ได้รับการแก้ไข
• ฉันยังย้อนกลับไฟล์ด้วยช่องว่างหรือการเปลี่ยนแปลงที่ไม่มีความหมาย

ตรวจสอบการกระทำที่คุณส่ง

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

สองสิ่งเมื่อฉันใช้ Git:

ความมุ่งมั่นของอะตอม:

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

ดูต่างกันในขณะที่สรุป

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

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

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

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

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

ค้นหาและแทนที่คำสาป ;-)

หากคุณกำลังเช็คอินจาก Windows ให้ตรวจสอบว่ารหัสของคุณไม่มีตัวอักษรที่มองไม่เห็น ^ M - ตัวแก้ไขใน UNIX มักจะเป็นสาเหตุของข้อผิดพลาด / คำเตือนของสิ่งนั้น

นอกจากนี้ลองและแทนที่แท็บ - ผู้ใช้ที่แตกต่างกันจะเห็นแท็บหยุดแตกต่างกันบางส่วนด้วยช่องว่าง 4 ช่อง 8 ช่องและไม่เหมาะสำหรับการอ่านรหัส

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

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

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

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

(นี่คือนอกเหนือจากการตรวจสอบความแตกต่างของการเปลี่ยนแปลงของฉัน)

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

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

หากต้องการรวมคำตอบทั้งหมดที่นี่และให้รายการตรวจสอบที่สมบูรณ์

1. [เช็คอิน / เช็คเอาท์] คุณไม่ควรเช็คอินโดยตรงกับสตรีมที่คนอื่นกำลังทำงานอยู่คุณควรมีกลยุทธ์สตรีม: เช่นสตรีมต่อนักพัฒนาที่คุณสามารถเช็คอินและเช็คเอาท์โดยอิสระโดยไม่รบกวนคนอื่น: งานของคุณจะ ปลอดภัย แต่อยู่ในกระแสการพัฒนาของคุณเองดังนั้น [เฉพาะในกระแสการพัฒนาของคุณเอง] ทุกครั้งที่เช็คอินคุณเชื่อมโยงกับบันทึกการเปลี่ยนแปลงเพื่อให้การเปลี่ยนแปลงของคุณเป็นแบบอะตอมมิกกับการเปลี่ยนแปลงนั้นเรียกว่าชุดการเปลี่ยนแปลง (เพื่อให้คุณสามารถแจกจ่าย rfc / / บั๊กแต่ละรายการโดยไม่ต้องส่ง 'ทุกสิ่ง')

2. [จากนั้นให้รีบูทด้วยสตรีมทีมของคุณ] หมายความว่าคุณได้รับการเปลี่ยนแปลงจากผู้อื่นในสตรีมของคุณเอง ในระหว่างการดำเนินการนั้นคุณสามารถเห็นได้ในกล่องโต้ตอบการรวมทั้งหมด "diffs" และผ่านพวกเขาหรือ ... หากมีหลายพันและ / หรือคุณใช้รหัสไม่ แต่ยังเช่นรุ่นข้อมูล / โครงการ siebel เป็นต้น ... ขึ้นอยู่กับทั้ง การรวมกันที่ไม่ใช่เรื่องเล็ก ๆ น้อย ๆ การรวมกลุ่มแบบแมนนวลโดยอัตโนมัติและเรื่องไม่สำคัญหมวดหมู่สุดท้ายมีเนื้อหาที่ยาก โปรดจำไว้ว่าคุณยังคงทำงานในกระแสของคุณเอง

3. [รีบูทสมบูรณ์] หากทุกอย่างเรียบร้อยแล้วให้ตรวจสอบการเปลี่ยนแปลงทั้งหมดที่คุณเพิ่งได้รับจากสตรีมทีม: สตรีมของคุณเป็นปัจจุบันแล้ว

4. [ส่งมอบ] ส่งมอบงานของคุณให้กับสตรีมของทีม หากคุณไม่ต้องการส่งมอบทุกสิ่งคุณสามารถเลือกเช่น RFC เฉพาะ 1 ตัวพร้อมไฟล์เฉพาะรุ่นนั้นหรือชุดของ RFC / แก้ไขข้อบกพร่อง

5. [ทดสอบการส่ง] มันก็โอเค แต่เนื่องจากมีโอกาสที่มีคนในการเปลี่ยนแปลงที่ส่งมอบในขณะเดียวกัน: คุณสามารถทดสอบว่างานของคุณทำงานกับการเปลี่ยนแปลงล่าสุดในกระแสทีมหรือไม่ ด้วยกล่องโต้ตอบการผสานเดียวกันแสดงความแตกต่าง

6. [การส่งมอบที่สมบูรณ์] ทำให้การส่งมอบของคุณเสร็จสมบูรณ์และงานของคุณตอนนี้อยู่ในกระแสของทีม

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

• คำตอบจาก histumness เกิดขึ้น 2 ครั้ง: ในขั้นตอนที่ 2 และ 6
• คำตอบจาก Oded ในการเช็คอินการเต้นรำ: idem แต่เป็นเลเยอร์พิเศษของการส่งและรีบูตเมื่อเช็คอิน / เช็คเอาต์เพื่อให้แน่ใจว่าคุณทำงานโดดเดี่ยวและข้อผิดพลาดสามารถนำออกมาได้อย่างง่ายดายแม้ในระยะต่อมา
• คำตอบจาก guildsbounty ที่ตอบแล้ว: รับล่าสุดคือขั้นตอนที่ 2 สำหรับบิลด์: มันขึ้นอยู่กับว่าคุณมีบิลด์ ... ในโลกของฉันคุณมีอินพุตจากโมเดลข้อมูล, เอกสารคำ, แผ่นคำสั่ง, ข้อมูลการกำหนดค่าจาก informatica, siebel, ฯลฯ .. และยังมีรหัส java,. net code ฯลฯ ... ที่ทุกคนควรปนกัน ดังนั้นจึงไม่มี "การสร้าง" ที่นี่ แต่มีการรวมที่สูงกว่าขึ้นอยู่กับว่าสิ่งเดียวเช่นการสร้างจาก "รหัส" ของคุณรวมกับส่วนที่เหลือทั้งหมดของสิ่งที่คุณไม่สามารถแน่ใจได้ว่ามันเป็นสิ่งที่บูรณาการและขึ้นอยู่กับ สภาพแวดล้อมการทดสอบของพวกเขามันอาจจะรวบรวมสิ่งที่จำเป็นหรือสูงกว่าการส่งมอบงานสร้างอื่นเพราะมันต้องการบางสิ่งบางอย่างจากทีมอื่น
• คำตอบจาก guildsbounty เกี่ยวกับการแสดงความคิดเห็นและจำเป็น: ฉันคิดว่าทุกสภาพแวดล้อมที่คุณไม่ได้รวมรุ่นและการเปลี่ยนแปลงในชุดการเปลี่ยนแปลง (และประเภท: ข้อบกพร่อง RFC, hotfi) ยังไม่ครบกำหนด ฉันคิดว่ามันเป็นความโกลาหลถ้าคุณไม่สามารถทำได้เช่นบันทึกการเปิดตัวโดยอัตโนมัติด้วยจำนวนข้อบกพร่องและ rfcs ที่ส่งซึ่งสามารถคลิกผ่านไปยังรุ่นที่แน่นอนที่สัมผัส (ตั้งแต่รุ่น 1 และรุ่นที่ 3 ของ hello.c สามารถส่งได้ดีมาก ไม่ควรส่ง 2 เนื่องจากเนื้อหาในนั้นจะเป็นส่วนหนึ่งของการเปิดตัวในภายหลัง แต่มีบาง noob ที่วางไว้แล้ว) (ดังนั้นจึงหมายถึงการตัดสินใจด้วยตนเองหากคุณต้องการกำจัด Hello รุ่น 3 ออกไปด้วย c แต่การเอาเวอร์ชั่น 3 ออกมาหมายความว่าคุณต้องเอาเวอร์ชั่นอื่นทั้งหมดที่สัมผัสโดย RFC / ข้อบกพร่องนั้นด้วยดังนั้นคุณจะต้องสามารถใช้เครื่องมือที่จะกำจัดสิ่งต่าง ๆ ได้อย่างง่ายดายและรวดเร็ว (แม้ว่านักพัฒนาหลายคนทำงานในส่วนของ RFC เดียวกันนั้น แต่อย่างน้อยคุณต้องมีสิ่งรอบ ๆ มันเพื่อตัดสินใจเลือก ฯลฯ ... ) เอกสารเพิ่มเติมมีประโยชน์เสมอ แต่ด้วยการเชื่อมโยงชุดการเปลี่ยนแปลงคุณจะได้รับวงกลมเต็ม: รุ่น <- ชุดการเปลี่ยนแปลง <- รายการงาน <- ตั๋ว / rfc / ข้อบกพร่อง <- ข้อกำหนด ความหมาย: คุณรู้ว่าข้อกำหนดใดที่ส่งมอบอย่างสมบูรณ์หรือสมบูรณ์: ข้อกำหนดหนึ่งข้อมีหลาย RFC หรือมีข้อบกพร่องหรืออะไรก็ตาม RFC มีรายการงานหลายรายการสำหรับหลายคน ไอเท็มงานนั้นสอดคล้องกับชุดการเปลี่ยนแปลงที่มีอยู่ในชุดของเวอร์ชัน (เช่นเวอร์ชัน 1 และ 3 ของ hello.c บนสตรีมการรวมที่เป็นของหลักสูตรไม่ใช่เวอร์ชัน 1,
• ความคิดเห็นจาก luis.espinal: อย่าทำลายโครงสร้างถูกตรวจสอบสองครั้งใน rebase และส่งมอบยัง ... มีการส่งมอบที่สูงขึ้นสำหรับ 'ผู้จัดการการปล่อยและสร้าง meisters' ที่ควรเห็นชุดการเปลี่ยนแปลงและพื้นฐานเป็นข้อมูลของพวกเขา "ไม่ทำงานโดยตรงกับสาขาหลัก" ใช่โครงสร้างสตรีมอาจใหญ่หรือเรียบง่าย แต่สำคัญ: นักพัฒนามีสตรีมของตัวเองพวกเขาส่งไปยังสตรีมทีมที่ส่งไปยังสตรีมรีลีส -> เพื่อให้การส่งมอบจากทุกทีม (เช่นทีมเอกสารทีมความต้องการทีมพัฒนา

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

บางอย่างต่อไปนี้ใช้มากกว่าคนอื่น ๆ (หรือในรูปแบบที่แตกต่างกัน) ขึ้นอยู่กับ SCM ของคุณดังนั้นพวกเขาไปที่นี่:

1. อย่าทำลายบิลด์ - ตรวจสอบโค้ดที่คอมไพล์แล้วเท่านั้น
2. แสดงความคิดเห็นเช็คอินของคุณ (และอาจเป็นไปได้ว่าการตรวจสอบของคุณถ้า SCM ของคุณให้ตัวเลือกนั้น)
3. อย่าทำให้สิ่งต่าง ๆ ไม่ถูกตรวจสอบเป็นเวลานาน
4. เช็คอินบ่อย ๆ (ถ้าเป็นไปได้หลายครั้งต่อวัน)
5. ฉลากอย่างมีความหมาย
6. ฉลากอย่างสม่ำเสมอ
7. ไม่ทำงานโดยตรงกับสาขาหลัก
8. การเปิดตัวสู่การผลิตทุกครั้งจะต้องมีฉลากของตนเอง (และสาขาแบบอ่านอย่างเดียวจะปิดสาขาหลักหากเป็นไปได้) เมื่อเป็นไปได้ให้ทำเช่นเดียวกันสำหรับการทดสอบ UAT / Integration / Pre-Production
9. คุณควรจะสามารถสร้างสิ่งที่อยู่ในการผลิตจากสิ่งที่อยู่ใน SCM ของคุณและจากฉลาก

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

มีรายการตรวจสอบส่วนบุคคล เริ่มมันว่างเปล่าเมื่อคุณเลอะที่รายการ เมื่อมันกลายเป็นลักษณะที่สองเอามันออกจากรายการ

ทำการทดสอบ หากพวกเขาผ่านการตรวจสอบสิ่งต่อไปนี้ถ้าคุณทำผิดพลาดและบางสิ่งผ่านการทดสอบ

เราทำสิ่งต่อไปนี้ ...

1. ทดสอบ - เราต้องการตรวจสอบให้แน่ใจว่ามันใช้งานได้ อย่างน้อยที่สุดเราต้องการรู้ว่ามันไม่ทำลายอะไรเลย

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

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

4. บางชั่วโมงหลังจากส่งหนังสือแจ้งล่วงหน้าจะทำการเช็คอินและกลุ่มจะแจ้งทางอีเมล ทุกคนในกลุ่มสามารถรู้ได้ว่าเมื่อใดที่งานในข้อผิดพลาดหรือคุณลักษณะเสร็จสิ้น

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

เรียกใช้การทดสอบหน่วยของคุณคุณทำงานอย่างขยันขันแข็ง เขียวดี

ตรวจสอบให้แน่ใจว่าโค้ดของคุณอยู่ในรูปแบบที่ถูกต้อง (เช่นสำหรับ Java: เลือกรหัสของคุณและกด Ctrl-Shift-F ใน Eclipse) แต่ระวังการทำเช่นเดียวกันสำหรับเอกสารทั้งหมด

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

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

ค้นหาส่วนต่าง ๆ ของการเปลี่ยนแปลงของคุณที่สามารถใช้เป็นแบบสแตนด์อโลน

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

ฉันชอบที่จะเช็คอินการรีแฟคเตอร์แต่ละครั้งแยกกันพร้อมคำอธิบายการเปลี่ยนแปลงของตัวเองเช่นนี้:

REFACTORING: เปลี่ยนชื่อ X เป็น Y

X มีเหตุผลมาก่อนเพราะ ... แต่ตอนนี้มันควรจะเป็น Y สิ่งนี้เกี่ยวข้องกับการทำงานสำหรับปัญหา # 9

จากนั้นเมื่อตรวจสอบการปรับสภาพที่ดีแต่ละครั้งแล้วการเปลี่ยนแปลงพฤติกรรมขั้นสุดท้ายมักเป็นเรื่องเล็กน้อย

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

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

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

ฉันเก็บ repo hg ท้องถิ่นสำหรับการทำงานของฉัน

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

ฉันไม่ได้อ้างว่าสิ่งเหล่านี้ดีที่สุด แต่พวกเขาก็ทำงานให้ฉันได้

เมื่อฉันเขียนโค้ดที่ฉันรู้ว่าไม่ได้ตั้งใจจะเช็คอินฉันจะเพิ่มบรรทัดก่อนที่จะมี "// TEMP:" และหลังจากนั้นด้วย "// END TEMP" สิ่งนี้พร้อมกับทำสิ่งต่าง ๆ ก่อนที่จะเช็คอินสัญญาว่าฉันจะไม่ตรวจสอบรหัสนั้นโดยไม่ได้ตั้งใจ

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

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