Skip to content
กลับไปยังผลการค้นหา

การวัดความซับซ้อนของซอฟต์แวร์

ผู้เสนอ
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)

วิธีการทำงาน

วิธีการทำงาน

1

รวบรวมซอร์สโค้ดและโครงสร้างไวยากรณ์นามธรรม (abstract syntax tree - AST) จากที่เก็บการควบคุมเวอร์ชัน (version control repositories) หรือการส่งโค้ดโดยตรง

2

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

3

คำนวณค่าการวัด (ความซับซ้อนเชิงวัฏจักร, จำนวนบรรทัดโค้ด, ระดับการซ้อน, การพึ่งพากัน (coupling), ความเกาะเกี่ยวกัน (cohesion)) ผ่านการวิเคราะห์แบบสถิต (static analysis)

4

หาความสัมพันธ์ระหว่างค่าการวัดแต่ละค่ากับข้อมูลข้อบกพร่องในอดีตและภาระงานในการบำรุงรักษา เพื่อสร้างแบบจำลองการคาดการณ์

5

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

ข้อผิดพลาดที่พบบ่อย

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

คำถามที่พบบ่อย

ความซับซ้อนเชิงวัฏจักรคืออะไรและฉันจะคำนวณได้อย่างไร?

ความซับซ้อนเชิงวัฏจักรนับจำนวนเส้นทางอิสระเชิงเส้นผ่านโค้ดโดยใช้สูตร: 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) ใช้การวัดเพื่อความสามารถในการบำรุงรักษา ใช้การวิเคราะห์เชิงอัลกอริทึมเพื่อประสิทธิภาพ

วิธีการที่เกี่ยวข้อง

แหล่งอ้างอิง

  1. McCabe, T. J. (1976). A complexity measure. IEEE Transactions on Software Engineering, 2(4), 308–320.

    เปิดเอกสารอ้างอิง DOI
    คัดลอกแล้ว
  2. Chidamber, S. R., & Kemerer, C. F. (1994). A metrics suite for object-oriented design. IEEE Transactions on Software Engineering, 20(6), 476–493.

    เปิดเอกสารอ้างอิง DOI
    คัดลอกแล้ว
  3. Halstead, M. H. (1977). Elements of Software Science. Elsevier.

    เปิดเอกสารอ้างอิงสิ่งพิมพ์
    คัดลอกแล้ว