วิธีแก้จุดบกพร่องรหัสอย่างมีประสิทธิภาพมากที่สุด? [ปิด]

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

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

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

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

คลาสสิกเกี่ยวกับการพัฒนาซอฟต์แวร์อย่างPragmatic ProgrammerและCode Completeนั้นเป็นสิ่งที่โต้แย้งกันในแนวทางเดียวกัน:ข้อผิดพลาดทุกคนมีโอกาสที่จะได้เรียนรู้เกือบเสมอเกี่ยวกับตัวเอง (เพราะเพียงเริ่มต้นตำหนิคอมไพเลอร์ / คอมพิวเตอร์เครื่องแรก)

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

หนึ่งบันทึกล่าสุด - ฉันชอบเรียกข้อผิดพลาด "ข้อผิดพลาด" และไม่ใช่ "ข้อบกพร่อง" - Dijkstra chided เพื่อนร่วมงานของเขาสำหรับการใช้คำหลังเพราะมันไม่สุจริตสนับสนุนความคิดที่ผิดพลาดและนางฟ้าไม่แน่นอนปลูกแมลงในโปรแกรมของเราในขณะที่เรา อย่ามองแทนที่จะอยู่ที่นั่นเพราะความคิดของเรา (เลอะเทอะ): http://www.cs.utexas.edu/users/EWD/transcriptions/EWD10xx/EWD1036.html

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

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

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

3. พูดคุยเกี่ยวกับคนที่เกี่ยวกับปัญหาของคุณแม้ว่าจะเป็นเพียงduckie ยาง บังคับให้คุณแสดงปัญหาที่คุณกำลังทำด้วยปาฏิหาริย์จริงๆ

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

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

มีหนังสือยอดเยี่ยมที่ฉันอ่านในหัวข้อนี้ชื่อว่าWhy Programs Failซึ่งสรุปกลยุทธ์ต่าง ๆ สำหรับการค้นหาข้อบกพร่องตั้งแต่การใช้วิธีการทางวิทยาศาสตร์เพื่อแยกและแก้ไขข้อบกพร่องไปจนถึงการดีบักเดลต้า ส่วนที่น่าสนใจอื่น ๆ ของหนังสือเล่มนี้ก็คือมันจะไปด้วยคำว่า 'บั๊ก' วิธีการของ Zeller คือ:

(1) โปรแกรมเมอร์สร้างข้อบกพร่องในรหัส (2) ข้อบกพร่องทำให้เกิดการติดเชื้อ (3) การติดเชื้อแพร่กระจาย (4) การติดเชื้อทำให้เกิดความล้มเหลว

หากคุณต้องการพัฒนาทักษะการแก้จุดบกพร่องของคุณฉันขอแนะนำหนังสือเล่มนี้

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

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

Limist พูดถึงหนังสือThe Pragmatic Programmerซึ่งมีเนื้อหาที่น่าสนใจในการแก้ไขข้อบกพร่อง จากตัวอย่างที่ฉันให้ไว้ในย่อหน้าก่อนหน้าฉันจะดูที่นี่: Software Entrophyที่มีการใช้การเปรียบเทียบของหญิงม่ายที่เสีย หากหน้าต่างแตกหักสองบานปรากฏขึ้นทีมของคุณอาจไม่แยแสต่อการแก้ไขหากคุณไม่ได้ใช้ท่าทางเชิงรุก

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

1. คิดออกว่าการรับรู้ปัญหาคืออะไร: แปลจากลูกค้า 'Bob ยังไม่อยู่ในระบบ' เป็น 'เมื่อฉันพยายามสร้างระเบียนผู้ใช้สำหรับ Bob มันล้มเหลวด้วยข้อยกเว้นคีย์ซ้ำแม้ว่า Bob ยังไม่ได้ ในนั้น'
2. ลองคิดดูว่ามันเป็นปัญหาจริงหรือเป็นเพียงความเข้าใจผิด (จริง ๆ แล้วบ๊อบไม่ได้อยู่ที่นั่นไม่มีใครเรียกบ็อบและส่วนแทรกควรจะทำงานได้)
3. พยายามทำตามขั้นตอนที่เชื่อถือได้น้อยที่สุดที่คุณสามารถทำตามเพื่อจำลองปัญหา - เช่น 'ให้ระบบที่มีบันทึกผู้ใช้' บรูซ 'เมื่อแทรกเร็กคอร์ดผู้ใช้' บ๊อบ 'จากนั้นข้อยกเว้นจะเกิดขึ้น'
4. นี่คือการทดสอบของคุณ - ถ้าเป็นไปได้วางไว้ในชุดทดสอบอัตโนมัติที่คุณสามารถเรียกใช้ซ้ำแล้วซ้ำอีกซึ่งจะเป็นประโยชน์อย่างมากเมื่อทำการดีบัก คุณสามารถทำให้เป็นส่วนหนึ่งของชุดทดสอบเพื่อให้แน่ใจว่าปัญหานั้นจะไม่เกิดขึ้นอีกในภายหลัง
5. นำดีบักเกอร์ออกแล้วเริ่มวางเบรกพอยต์ - หาเส้นทางของรหัสเมื่อคุณทำการทดสอบและระบุว่ามีอะไรผิดปกติ ในขณะที่ทำเช่นนั้นคุณสามารถปรับแต่งการทดสอบให้แคบที่สุดเท่าที่จะทำได้ - เป็นการทดสอบแบบหน่วย
6. แก้ไข - ตรวจสอบการทดสอบของคุณผ่าน
7. ตรวจสอบว่าปัญหาดั้งเดิมตามที่อธิบายโดยลูกค้าได้รับการแก้ไขด้วย (สำคัญมาก - คุณอาจแก้ไขเซตย่อยของปัญหา) ตรวจสอบว่าคุณไม่ได้แนะนำการถดถอยในด้านอื่น ๆ ของโปรแกรม

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

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

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

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

1. ตรวจสอบว่ามีข้อผิดพลาดจริง ๆ ข้อบกพร่องคือความแตกต่างระหว่างพฤติกรรมของระบบและข้อกำหนดเสมอ ผู้ทดสอบควรจะสามารถแสดงพฤติกรรมที่คาดหวังและที่เกิดขึ้นจริง หากเขาไม่สามารถให้การสนับสนุนสำหรับพฤติกรรมที่คาดหวังก็ไม่มีข้อกำหนดและไม่มีข้อผิดพลาด - แค่ความเห็นของใครบางคน ส่งกลับ

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

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

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

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

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

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

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

1. เขียนการทดสอบหน่วยที่ทำให้เกิดปัญหาและล้มเหลว

2. โดยไม่ต้องแก้ไขการทดสอบหน่วยทำให้ผ่าน (โดยการแก้ไขรหัสแอปพลิเคชัน)

3. เก็บการทดสอบหน่วยในชุดทดสอบของคุณเพื่อป้องกัน / ตรวจสอบการถดถอย

นี่คือวิธีที่ฉันทำ:

1. ใช้วิธีการเดียวกันทุกครั้งเพื่อค้นหาปัญหา วิธีนี้จะปรับปรุงเวลาตอบสนองของคุณต่อข้อผิดพลาด
2. วิธีที่ดีที่สุดน่าจะเป็นการอ่านรหัส นี่เป็นเพราะข้อมูลทั้งหมดที่มีอยู่ในรหัส คุณเพียงต้องการวิธีที่มีประสิทธิภาพในการค้นหาตำแหน่งที่ถูกต้องและความสามารถในการทำความเข้าใจรายละเอียดทั้งหมด
3. การดีบักเป็นวิธีที่ช้ามากและจำเป็นเฉพาะถ้าโปรแกรมเมอร์ของคุณยังไม่เข้าใจว่าคอมพิวเตอร์ดำเนินการตามคำสั่ง asm / ไม่สามารถเข้าใจ call stack และสิ่งพื้นฐานได้
4. พยายามพัฒนาเทคนิคการพิสูจน์เช่นการใช้ฟังก์ชั่นต้นแบบเพื่อเหตุผลเกี่ยวกับพฤติกรรมของโปรแกรม สิ่งนี้จะช่วยในการค้นหาตำแหน่งที่ถูกต้องเร็วขึ้น

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

สมมติว่าคุณอยู่ในสภาพแวดล้อมการผลิตนี่คือสิ่งที่คุณต้องทำ:

1. อธิบายถึง "ข้อผิดพลาด" อย่างถูกต้องและระบุเหตุการณ์ที่ทำให้เกิดขึ้น

2. ตรวจสอบว่า "ข้อผิดพลาด" เป็นข้อผิดพลาดของรหัสหรือข้อผิดพลาดของข้อกำหนด ตัวอย่างเช่นการป้อนชื่อ 1 ตัวอักษรอาจถือเป็นข้อผิดพลาดในบางระบบ แต่พฤติกรรมที่ยอมรับได้สำหรับระบบอื่น บางครั้งผู้ใช้จะรายงานข้อผิดพลาดที่เขา / เธอคิดว่าเป็นปัญหา แต่ความคาดหวังของผู้ใช้สำหรับพฤติกรรมของระบบไม่ได้เป็นส่วนหนึ่งของข้อกำหนด

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

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

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

6. จัดทำเอกสารตอนอย่างเพียงพอ

7. ปล่อยการแก้ไข (หรือรุ่นใหม่)