ควรใช้เวลากับบั๊กกับการพัฒนาเริ่มต้นเท่าไหร่? [ปิด]

คำถามนี้เป็นนามธรรมเล็กน้อย แต่ฉันหวังว่าบางคนสามารถชี้ฉันในทิศทางที่ถูกต้อง

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

ตัวอย่างเช่นหากโครงการ A ใช้เวลา 40 ชั่วโมงในการดำเนินการและแก้ไขข้อบกพร่องเพิ่มเติม 10 รายการโครงการนี้จะมีอัตราส่วน 4: 1

หากโครงการอื่น (B) ใช้เวลา 10 ชั่วโมงเพื่อให้เสร็จสมบูรณ์ แต่อีก 8 ข้อบกพร่องนั้นจะมีอัตราส่วน 5: 4

นี่เป็นแนวคิด / เอกสารที่วิจัยแล้วหรือไม่?

UPDATE

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

เปอร์เซ็นต์ความสมดุลของความจุทั้งหมดที่จัดสรรให้กับข้อบกพร่องการตรึงเท่ากับอัตราการฉีดข้อบกพร่อง

มีหลายปัจจัยที่อาจส่งผลกระทบต่ออัตรานี้แน่นอนว่าพวกเขากำลังพัฒนาผลิตภัณฑ์ชนิดใดเทคโนโลยีและวิธีปฏิบัติทางเทคนิคที่ใช้ระดับทักษะของทีมวัฒนธรรมของ บริษัท เป็นต้น

เมื่อพิจารณาทีม B หากพวกเขาสร้างงานทำซ้ำโดยเฉลี่ย 8 หน่วยสำหรับทุก ๆ 10 งานที่ทำเสร็จงานที่ทำงานทั้ง 8 หน่วยจะสร้างงานทำใหม่ 6.4 หน่วย เราสามารถประเมินความพยายามทั้งหมดที่พวกเขาจะต้องใช้ในที่สุดในฐานะผลรวมของความก้าวหน้าทางเรขาคณิต:

10 + 8 + 6.4 + 5.12 + ...

จำนวนข้อผิดพลาดจะลดลงตามระยะเวลา แต่ทีม B มีค่าสัมประสิทธิ์ในการยกกำลังที่จะเป็นศูนย์ช้ามาก ที่จริงแล้วผลรวมของสามคำแรกในซีรีส์ข้างต้นมีเพียง 24.4 เท่านั้น จากห้าข้อแรก 33.6; จาก 10, 45 อันดับแรก ของทั้งชุด 50 ดังนั้นสรุปทีม B: อัตราการฉีดบกพร่อง, 0.8; การพัฒนาคุณสมบัติ 10/50 = 20%; แก้ไขข้อบกพร่อง 80% 20/80 เป็นการจัดสรรกำลังการผลิตอย่างยั่งยืน

ในทางตรงกันข้ามทีม A นั้นมีรูปร่างที่ดีกว่ามาก ความก้าวหน้าของพวกเขามีลักษณะเช่นนี้:

40 + 10 + 2.5 + 0.625 + ...

ผลรวมของซีรี่ส์นี้คือ 53 1/3 ดังนั้นการจัดสรรการพัฒนาคุณสมบัติของทีม A คือ 40 / (53 1/3) = 75% และการจัดสรรการแก้ไขข้อบกพร่องคือ 25% ซึ่งตรงกับอัตราการฉีดของข้อบกพร่อง 10/40 = 0.25 .

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

ฉันคิดเกี่ยวกับความเท่าเทียมกันนี้ในขณะที่อ่านหนังสือเล่มใหม่ของดาวิดเดอร์สัน "Kanban" (หนังสือเล่มนี้มีเนื้อหาที่แตกต่างออกไป แต่ก็เน้นเรื่องคุณภาพด้วย) เมื่อพูดถึงคุณภาพของซอฟต์แวร์แอนเดอร์สันเสนอราคาหนังสือเล่มนี้โดย Capers Jones "การประเมินซอฟต์แวร์มาตรฐานและแนวทางปฏิบัติที่ดีที่สุด" :

"... ในปี 2000 ... คุณภาพซอฟต์แวร์ที่วัดได้สำหรับทีมในอเมริกาเหนือ ... อยู่ในช่วงตั้งแต่ 6 ข้อบกพร่องต่อจุดทำงานไปจนถึงน้อยกว่า 3 ต่อ 100 จุดทำงานช่วงตั้งแต่ 200 ถึง 1 จุดกึ่งกลางอยู่ที่ประมาณ 1 ข้อบกพร่องต่อ 0.6 ถึง 1.0 ฟังก์ชั่นคะแนนซึ่งหมายความว่าเป็นเรื่องปกติที่ทีมจะใช้จ่ายมากกว่า 90 เปอร์เซ็นต์ของความพยายามในการแก้ไขข้อบกพร่อง "เขาอ้างถึงตัวอย่างจากหนึ่งในเพื่อนร่วมงานของ บริษัท ที่ใช้เวลา 90% ในการแก้ไขข้อบกพร่อง .

ความคล่องแคล่วที่แอนเดอร์สันเริ่มต้นจากอัตราการฉีดข้อบกพร่องไปจนถึงการจัดสรรความสามารถในการกำหนดค่า defext ( ความต้องการความล้มเหลวเป็นคำศัพท์สำหรับมัน) แสดงให้เห็นว่าความเท่าเทียมกันของสองสิ่งนี้เป็นที่รู้จักกันดี .

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

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

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

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

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

ใช้เมทริกซ์ดังต่อไปนี้ (แนวนอน - เวลาที่ต้องใช้ในการแก้ไขข้อบกพร่องประเภทของข้อบกพร่อง - แนวตั้ง - ส่งผลกระทบต่อผู้ใช้)

              | Few hours | Many hours
--------------+-----------+-------------------------
Minor problem | Might fix | Fix only if time permits
--------------+-----------+-------------------------
Major problem | Fix       | Fix

ตัวอย่างของปัญหา:

              | Few hours                            | Many hours
--------------+--------------------------------------+---------------------------------
              | Window moves 1px every 10            | Windows is painted incorrectly 
Minor problem | times when you open the application. | every 100th time the app is open.
              | Fix is: handle window resize event   | Fix: Change the graphical engine.
--------------+--------------------------------------+---------------------------------
Major problem | Application crashes when opening     | Poor performance when >100 users 
              | SQL connection.                      | are connected (unusable app)
              | Fix: Fix invalid query + add nice    | Fix: change architecture + DB
              | message                              |

เมทริกซ์นั้นซับซ้อนกว่าโดยมีระดับความรุนแรงความพยายามความเสี่ยงและระดับที่แตกต่างกัน

คุณสามารถสร้างอันดับสำหรับแต่ละข้อบกพร่องและแก้ไขได้ตามอันดับ สิ่งที่ต้องการ:

Bug priority = Risk x Severity x Effort

* อาจเป็น (1-x) สำหรับตัวถูกดำเนินการบางตัวขึ้นอยู่กับขนาดที่คุณเลือก :)

ดังนั้นเพื่อตอบคำถามของคุณ: ขึ้นอยู่กับประเภทของข้อบกพร่องเวลา / งบประมาณที่มีอยู่และอื่น ๆ

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

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

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

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

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

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

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

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

สำหรับซอฟต์แวร์ที่สำคัญอัตราส่วน A 1: 1 ไม่ได้ผิดปกติ สำหรับการทดสอบหน่วยเดียวฉันเห็นตัวบ่งชี้ที่กล่าวถึง 1 วันของการทดสอบหน่วยสำหรับรหัส 10 บรรทัดทุกบรรทัด

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

นักพัฒนาที่ดีจะไม่ใช้เวลาในการดีบักรหัสเนื่องจากรหัสของเขาจะไม่มีข้อผิดพลาดตั้งแต่เริ่มต้น นักพัฒนาที่ไม่ดีจะใช้เวลาในการดีบักรหัสของเขาเนื่องจากเขาไม่สามารถสร้าง abstractions ที่เหมาะสมเพื่อแก้ปัญหาจริง

โปรดทราบว่านักพัฒนาหน่วยควรทดสอบโค้ดของตัวเอง เป็นหน้าที่ของพวกเขาในการส่งรหัสปราศจากข้อบกพร่อง ดังนั้นจึงเป็นการยากที่จะแยกการเข้ารหัสจากการดีบัก

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

ดังนั้นแทนที่จะพูดถึง "เวลาที่ใช้กับข้อบกพร่อง" คุณควรพูดถึง "เวลาที่ใช้ในการทดสอบ" (การทดสอบการรวมการทดสอบการยอมรับของผู้ใช้ ... )

ฉันคิดว่าคุณพูดถูก - คุณจะไม่ได้ตัวชี้วัดที่มีความหมายใด ๆ เนื่องจากจำนวนปัจจัยที่มีอิทธิพลต่อเชอร์

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

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

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