การวัดความซับซ้อนของซอฟต์แวร์
- ผู้เสนอ
- Thomas J. McCabe
- ปี
- 1976
- ประเภท
- quantitative measurement
- กลุ่มวิธี
- Code quality assessment
ข้อความนี้เป็นการแปลด้วยเครื่องและยังไม่ได้รับการตรวจทาน อ่านต้นฉบับภาษาอังกฤษ
ใช้ทำอะไร?
การวัดความซับซ้อนของซอฟต์แวร์เป็นการวัดปริมาณความยากของโครงสร้างและการทำงานของโค้ดผ่านการวัดเชิงปริมาณ ความซับซ้อนเชิงวัฏจักร (cyclomatic complexity) ซึ่งถูกนำเสนอโดย Thomas McCabe ในปี 1976 กลายเป็นแนวทางพื้นฐาน การวัดเหล่านี้ประเมินความสามารถในการบำรุงรักษา ความสามารถในการทดสอบ และความเสี่ยงของข้อบกพร่อง ช่วยให้ทีมสามารถระบุส่วนของโค้ดที่มีปัญหาและนำทางการปรับปรุงโครงสร้างโค้ด (refactoring) ได้
แนวคิดเบื้องหลังวิธีการ
การวัดความซับซ้อนของซอฟต์แวร์บ่งบอกว่าโค้ดมีความซับซ้อน พันเกี่ยวกัน และยุ่งเหยิงเพียงใดเมื่อมีการพัฒนา โค้ดที่ง่ายกว่าจะเข้าใจ ทดสอบ และแก้ไขได้ง่ายกว่า การวัดเหล่านี้จับเอาสัญชาตญาณนี้มาเป็นตัวเลขโดยการนับจุดตัดสินใจ การพึ่งพาอาศัยกัน และลักษณะโครงสร้าง ความซับซ้อนที่สูงบ่งชี้ถึงความเสี่ยงในการบำรุงรักษาและคาดการณ์โอกาสเกิดข้อบกพร่อง
ประวัติศาสตร์
Thomas McCabe ได้นำเสนอความซับซ้อนเชิงวัฏจักรในปี 1976 โดยวัดโครงสร้างการตัดสินใจของโค้ดผ่านกราฟการไหลของการควบคุม (control flow graphs) ในทศวรรษต่อมาได้มีการปรับปรุง: การวัดแบบ Halstead ได้วัดคุณสมบัติระดับโทเค็น, Chidamber และ Kemerer ได้พัฒนาการวัดเชิงวัตถุ (WMC, DIT, CBO, RFC) และเครื่องมือสมัยใหม่ (SonarQube, CAST, Understand) ได้ทำให้การวัดในระดับอุตสาหกรรมเป็นไปโดยอัตโนมัติ สาขานี้ได้พัฒนาจากทฤษฎีทางวิชาการไปสู่การปฏิบัติที่จำเป็นใน DevOps และคุณภาพ
ควรใช้เมื่อใด
ใช้การวัดความซับซ้อนระหว่างการทบทวนโค้ด การประเมินสถาปัตยกรรม และการควบคุมคุณภาพในไปป์ไลน์การรวมอย่างต่อเนื่อง (continuous integration pipelines) ใช้เมื่อระบุโมดูลที่มีความเสี่ยงสูงสำหรับการจัดลำดับความสำคัญในการทดสอบ หรือการวางแผนการปรับปรุงโครงสร้างโค้ด การวัดเหล่านี้มีประโยชน์ในการประเมินระบบเดิม (legacy systems) และการปฐมนิเทศทีมเพื่อทำความเข้าใจความยากของฐานโค้ด สมมติว่าการวัดที่ง่ายกว่า (เช่น จำนวนบรรทัดโค้ดเพียงอย่างเดียว) ไม่เพียงพอ ให้ใช้การวัดแบบผสมผสานเพื่อให้ได้ข้อมูลเชิงลึกที่ดีขึ้น
ข้อจำกัดและข้อควรพิจารณา
- การวัดที่แตกต่างกันมักวัดแง่มุมที่แตกต่างกัน ไม่มีข้อตกลงสากลเกี่ยวกับชุดการวัดที่เหมาะสมที่สุด
- ต้องใช้บริบทและความเชี่ยวชาญเฉพาะด้านเพื่อการตีความค่าขีดจำกัด (threshold values) ที่มีความหมาย
- อาจไม่ครอบคลุมมิติความซับซ้อนที่เกี่ยวข้องทั้งหมด (เช่น ความซับซ้อนเชิงแนวคิด ความยากของโดเมน)
- ความแตกต่างเฉพาะภาษาในโครงสร้างโค้ดส่งผลต่อความเหมาะสมของการวัดในระบบที่มีหลายภาษา
เงื่อนไขจากแหล่งที่มาไม่สามารถใช้แทนการทบทวนทางวิทยาศาสตร์ที่เป็นอิสระหรือการตรวจสอบโดยเอนจินวิเคราะห์ได้
จุดแข็ง
- ให้การวัดเชิงปริมาณที่เป็นวัตถุวิสัย โดยไม่ขึ้นกับการตัดสินใจเชิงอัตวิสัย
- ช่วยให้สามารถตรวจจับส่วนของโค้ดที่มีปัญหาได้โดยอัตโนมัติในวงกว้าง
- มีความสัมพันธ์อย่างมากกับต้นทุนการบำรุงรักษาและโอกาสเกิดข้อบกพร่อง
- สนับสนุนการจัดลำดับความสำคัญของการปรับปรุงโครงสร้างโค้ดตามข้อมูลและการจัดสรรทรัพยากร
การประยุกต์ใช้
- การระบุโมดูลเดิม (legacy modules) ที่ไม่สามารถบำรุงรักษาได้เพื่อการปรับปรุงโครงสร้างโค้ดในระบบการเงินที่ต้นทุนการบำรุงรักษาเป็นส่วนสำคัญของงบประมาณโครงการ
- การคาดการณ์จุดที่มีข้อบกพร่องสูงในซอฟต์แวร์ที่สำคัญต่อความปลอดภัย (การบินและอวกาศ อุปกรณ์ทางการแพทย์) เพื่อนำทางการสร้างกรณีทดสอบและภาระงานในการทบทวนโค้ด
- การจัดลำดับความสำคัญของคำเตือนจากเครื่องมือวิเคราะห์แบบสถิตในไปป์ไลน์การรวมอย่างต่อเนื่องที่ประมวลผลโค้ดหลายล้านบรรทัดต่อวัน
- การฝึกโมเดลความเสี่ยงในไปป์ไลน์การเรียนรู้ของเครื่อง (machine learning pipelines) ที่คาดการณ์ว่า pull requests ใดต้องการการตรวจสอบเพิ่มเติมก่อนการรวม (merge)
วิธีการทำงาน
วิธีการทำงาน
รวบรวมซอร์สโค้ดและโครงสร้างไวยากรณ์นามธรรม (abstract syntax tree - AST) จากที่เก็บการควบคุมเวอร์ชัน (version control repositories) หรือการส่งโค้ดโดยตรง
แยกวิเคราะห์โค้ดเป็นรูปแบบที่เป็นมาตรฐานเดียวกัน ปรับปรุงรูปแบบการตั้งชื่อและมาตรฐานการเขียนโค้ดเพื่อการวิเคราะห์ที่สอดคล้องกัน
คำนวณค่าการวัด (ความซับซ้อนเชิงวัฏจักร, จำนวนบรรทัดโค้ด, ระดับการซ้อน, การพึ่งพากัน (coupling), ความเกาะเกี่ยวกัน (cohesion)) ผ่านการวิเคราะห์แบบสถิต (static analysis)
หาความสัมพันธ์ระหว่างค่าการวัดแต่ละค่ากับข้อมูลข้อบกพร่องในอดีตและภาระงานในการบำรุงรักษา เพื่อสร้างแบบจำลองการคาดการณ์
จับคู่ผลลัพธ์การวัดกับหมวดหมู่ความเสี่ยง และสร้างคำแนะนำที่นำไปปฏิบัติได้สำหรับการปรับปรุงโครงสร้างโค้ดหรือสถาปัตยกรรม
ข้อผิดพลาดที่พบบ่อย
- การปฏิบัติต่อการวัดเพียงค่าเดียวว่าเป็นตัวกำหนด; ควรใช้การวัดหลายอย่างที่เสริมกันเสมอ
- การกำหนดขีดจำกัดความซับซ้อนตามอำเภอใจโดยไม่มีการตรวจสอบกับประวัติข้อบกพร่องหรือการบำรุงรักษาจริง
- การละเลยบริบทขององค์กร; ขีดจำกัดที่ได้ผลในทีมหนึ่งอาจไม่สามารถนำไปใช้กับที่อื่นได้
- การสันนิษฐานว่าค่าการวัดที่ต่ำกว่าบ่งชี้ถึงโค้ดที่ดีกว่าเสมอไป บางครั้งความซับซ้อนที่ตั้งใจไว้ก็มีเหตุผลจากตรรกะทางธุรกิจ
คำถามที่พบบ่อย
ความซับซ้อนเชิงวัฏจักรคืออะไรและฉันจะคำนวณได้อย่างไร?
ความซับซ้อนเชิงวัฏจักรนับจำนวนเส้นทางอิสระเชิงเส้นผ่านโค้ดโดยใช้สูตร: M = E - N + 2P โดยที่ E คือจำนวนเส้นเชื่อม (edges) ในกราฟการไหลของการควบคุม N คือจำนวนจุดยอด (nodes) และ P คือจำนวนส่วนประกอบที่เชื่อมต่อกัน สำหรับฟังก์ชันง่ายๆ ให้นับจุดตัดสินใจ (if, while, for, case) แล้วบวก 1 ค่าที่สูงขึ้นบ่งชี้ว่าต้องการกรณีทดสอบมากขึ้น
ฉันควรกำหนดขีดจำกัดความซับซ้อนเท่าใดในฐานโค้ดของฉัน?
ไม่มีขีดจำกัดสากล ช่วงทั่วไปคือ 1-10 (ง่าย) 10-20 (ปานกลาง) สูงกว่า 20 (ซับซ้อน) เริ่มต้นด้วยการวัดฐานโค้ดปัจจุบันของคุณ หาความสัมพันธ์ระหว่างการวัดกับประวัติข้อบกพร่องที่ทราบ และปรับเทียบขีดจำกัดกับความอดทนต่อความเสี่ยงขององค์กรของคุณ เครื่องมือเช่น SonarQube มีค่าเริ่มต้นที่ขีดจำกัด 10
การวัดความซับซ้อนเกี่ยวข้องกับข้อบกพร่องและต้นทุนการบำรุงรักษาอย่างไร?
การศึกษาเชิงประจักษ์แสดงให้เห็นความสัมพันธ์ปานกลางระหว่างความซับซ้อนสูงกับอัตราข้อบกพร่องที่เพิ่มขึ้น (r = 0.3–0.5) ที่สำคัญกว่านั้น โค้ดที่ซับซ้อนต้องใช้ความพยายามทางปัญญามากขึ้นในการทำความเข้าใจ แก้จุดบกพร่อง และแก้ไข ซึ่งเพิ่มภาระงานในการบำรุงรักษา ความสัมพันธ์ไม่เป็นเชิงเส้น: ความซับซ้อนเพิ่มความเสี่ยงของข้อบกพร่องและเวลาในการแก้ไขแบบทวีคูณ
ฉันสามารถใช้การวัดความซับซ้อนเพื่อคาดการณ์ประสิทธิภาพได้หรือไม่?
การวัดความซับซ้อนวัดความยากของโครงสร้าง ไม่ใช่ประสิทธิภาพขณะทำงาน ความซับซ้อนเชิงอัลกอริทึม (Big O notation) และความซับซ้อนของโครงสร้างโค้ดนั้นแตกต่างกัน อย่างไรก็ตาม โค้ดที่ซับซ้อนโดยไม่จำเป็นมักมีประสิทธิภาพต่ำกว่าเนื่องจากการสูญเสียแคชของ CPU และการล้างท่อคำสั่ง (instruction pipeline flushes) ใช้การวัดเพื่อความสามารถในการบำรุงรักษา ใช้การวิเคราะห์เชิงอัลกอริทึมเพื่อประสิทธิภาพ
วิธีการที่เกี่ยวข้อง
แหล่งอ้างอิง
McCabe, T. J. (1976). A complexity measure. IEEE Transactions on Software Engineering, 2(4), 308–320.
เปิดเอกสารอ้างอิง DOIคัดลอกแล้วChidamber, S. R., & Kemerer, C. F. (1994). A metrics suite for object-oriented design. IEEE Transactions on Software Engineering, 20(6), 476–493.
เปิดเอกสารอ้างอิง DOIคัดลอกแล้วHalstead, M. H. (1977). Elements of Software Science. Elsevier.
เปิดเอกสารอ้างอิงสิ่งพิมพ์คัดลอกแล้ว