ลองนึกภาพคุณกำลังสร้างเครื่องเล่นวิดีโอใน JavaScript เครื่องเล่นวิดีโอนี้ลูปวิดีโอของผู้ใช้ซ้ำ ๆ โดยใช้ฟังก์ชั่นวนซ้ำและด้วยเหตุนี้เบราว์เซอร์จะทริกเกอร์too much recursion RangeErrorในบางครั้ง

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

• แก้ไขข้อบกพร่อง

• ออกจากบั๊ก

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

แก้ไข:

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

คุณจะต้องมีการปฏิบัติ

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

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

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

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

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

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

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

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

คุณต้องระบุสมมติฐานของคุณแล้วทดสอบสมมติฐานเหล่านั้นกับกรณีมุม

ดูตัวอย่างของคุณฉันเห็นสมมติฐานสองสามข้อ:

• วิธีการเรียกซ้ำจะทำให้เกิดข้อผิดพลาดในที่สุด
• ไม่มีใครเห็นข้อผิดพลาดนี้เนื่องจากวิดีโอใช้เวลาในการเล่นนานเกินขีด จำกัด

คนอื่น ๆ ได้พูดถึงข้อสันนิษฐานแรก แต่ดูที่ข้อสมมติฐานที่สอง: จะเกิดอะไรขึ้นถ้าวิดีโอของฉันยาวเพียงเสี้ยววินาที?

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

สมมติฐานที่ไม่ระบุชื่อเป็นแหล่งของแมลงขนาดใหญ่

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

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

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

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

แต่ส่วนใหญ่ของกระบวนการนั้นคือการระบุสมมติฐานของคุณก่อนแล้วจึงพยายามรับรู้ข้อยกเว้นของสมมติฐานเหล่านั้น

ฉันขอแนะนำให้คุณอ่านบทความต่อไปนี้:

ความน่าเชื่อถือและภัยคุกคาม: อนุกรมวิธาน

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

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

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

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

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

มันไม่ใช่เรื่องส่วนตัว มันเป็นเรื่องของธุรกิจ

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

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

คำตอบของคุณจะทำอย่างไร เป็นการตัดสินใจทางธุรกิจไม่ใช่วิศวกรรม:

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

โดยเฉพาะอย่างยิ่งใน บริษัท ใหญ่ ๆ (หรือโครงการขนาดใหญ่) มีวิธีปฏิบัติอย่างจริงจังในการสร้างสิ่งที่ต้องทำ

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

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

tl; dr นี่คือเหตุผลที่RESOLVED/WONTFIXเป็นสิ่ง อย่าเพิ่งทำมากเกินไป - หนี้ด้านเทคนิคอาจทำให้พอกพูนหากคุณไม่ระวัง นี่เป็นปัญหาพื้นฐานของการออกแบบของคุณและอาจทำให้เกิดปัญหาอื่น ๆ ในอนาคตหรือไม่ จากนั้นแก้ไขได้ มิฉะนั้น? ปล่อยไว้จนกว่ามันจะกลายเป็นลำดับความสำคัญ (ถ้าเคย)

มีสามข้อผิดพลาดจริง ๆ ในสถานการณ์ที่คุณอธิบาย:

1. การขาดกระบวนการประเมินข้อผิดพลาดที่บันทึกไว้ทั้งหมด (คุณได้บันทึกข้อผิดพลาดในตั๋ว / งานค้าง / ระบบใด ๆ ที่คุณมีอยู่ใช่ไหม?) เพื่อตรวจสอบว่าควรได้รับการแก้ไขหรือไม่ นี่คือการตัดสินใจของฝ่ายบริหาร

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

3. ปัญหาที่วิดีโออาจหยุดแสดงหลังจากผ่านไปนานมาก

ในสามข้อผิดพลาดเท่านั้น (3) อาจไม่จำเป็นต้องแก้ไข

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

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

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

มีสามสิ่งที่นี่:

หลักการ

นี่คือด้านหนึ่งของเหรียญ ในระดับหนึ่งฉันรู้สึกว่าเป็นการดีที่จะยืนยันในการแก้ไขข้อบกพร่อง (หรือการใช้งานที่ไม่ดีแม้ว่าพวกเขาจะ "ทำงาน") แม้ว่าจะไม่มีใครสังเกตเห็นก็ตาม

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

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

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

ปฏิบัตินิยม

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

ล้มเหลวเร็วล้มเหลวอย่างหนัก

หากมีข้อสงสัยให้ล้มเหลวอย่างรวดเร็วและล้มเหลวอย่างหนัก

ซึ่งหมายความว่ารหัสของคุณสังเกตเห็นเงื่อนไขข้อผิดพลาดไม่ใช่สภาพแวดล้อม

ในตัวอย่างนี้อย่างน้อยที่สุดที่คุณสามารถทำได้คือทำให้เกิดข้อผิดพลาดรันไทม์ฮาร์ด ("ความลึกสแต็กเกิน" หรืออะไรทำนองนั้น) ไม่เกิดขึ้นโดยการแทนที่ด้วยข้อยกเว้นอย่างหนักของคุณเอง ตัวอย่างเช่นคุณสามารถมีตัวนับทั่วโลกและตัดสินใจเองว่าจะประกันตัวหลังจากวิดีโอ 1,000 รายการ (หรือจำนวนใดก็ตามที่สูงพอที่จะไม่เกิดขึ้นในการใช้งานปกติและต่ำพอที่จะทำงานในเบราว์เซอร์ส่วนใหญ่) จากนั้นให้ข้อยกเว้นนั้น (ซึ่งอาจเป็นข้อยกเว้นทั่วไปเช่นRuntimeExceptionใน Java หรือสตริงธรรมดาใน JavaScript หรือ Ruby) ข้อความที่มีความหมาย คุณไม่จำเป็นต้องสร้างข้อยกเว้นแบบใหม่หรือสิ่งที่คุณทำในภาษาการเขียนโปรแกรมเฉพาะของคุณ

ด้วยวิธีนี้คุณมี

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

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

โพสต์มันบนโต๊ะทำงานของนักพัฒนาอาวุโสที่ที่ทำงานของฉันพูดว่า

มันช่วยใครได้บ้าง?

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

นึกถึงสามสิ่ง:

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

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

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

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

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

ความน่าจะเป็นที่น้อย / ผลที่ตามมาน้อย = แก้ไขได้ในราคาต่ำ

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

แต่สิ่งนี้ไม่สามารถกลายเป็นไม้ค้ำสำหรับนักพัฒนาที่ขี้เกียจ ...

• "การเกิดขึ้นน้อยมาก" หมายถึงอะไร
• "ผลที่ไม่รุนแรง" หมายถึงอะไร

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

นักพัฒนาส่วนใหญ่รู้สึกแปลกใจว่าสิ่งที่พวกเขาเคยคิดจะไม่เคยเกิดขึ้นจริงเกิดขึ้นมากมาย

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

เผชิญหน้ากับสัญชาตญาณของคุณด้วยข้อมูลโลกแห่งความจริง

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

ตัวอย่างของปัญหาเล็กน้อยและการควบคุม

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

ข้อสรุป

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

ฉันคิดว่าสิ่งนี้กำลังถามคำถามที่ผิดตั้งแต่ต้น

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

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

การแก้ไขข้อผิดพลาดเป็นเรื่องที่มากเกินไป

ลองจำแนกส่วนบั๊กก่อน

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

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

ดังนั้นโปรดอย่าพยายามที่จะเพียงแค่แก้ไขมัน

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

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

ป.ล. ขอโทษสำหรับมุมมองที่รุนแรง

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