อันตรายที่ซ่อนอยู่ของลำดับความสำคัญตัวดำเนินการในภาษา C
การค้นพบล่าสุดในโปรเจกต์โอเพ่นซอร์สอายุยาวนานได้จุดประเด็นอภิปรายอีกครั้งเกี่ยวกับหนึ่งในความท้าทายที่ยังคงมีอยู่ในการเขียนโปรแกรมภาษา C นั่นคือลำดับความสำคัญของตัวดำเนินการ (operator precedence) เมื่อไม่นานมานี้ นักพัฒนาค้นพบข้อบกพร่องที่แฝงตัวอยู่ในโค้ดของพวกเขามานานหลายปี ชุมชนนักเขียนโปรแกรมจึงตระหนักถึงรูปแบบที่คุ้นเคยซึ่งยังคงทำให้แม้แต่นักพัฒนาที่มีประสบการณ์ต้องผิดพลาดได้
เหตุการณ์นี้เริ่มต้นขึ้นเมื่อผู้ดูแลโปรเจกต์ mod_blog กำลังทำความสะอาดโค้ด โดยลบฟีเจอร์เก่าที่สะสมมานานกว่าทศวรรษ ในระหว่างการทำความสะอาดนี้ พวกเขาค้นพบข้อบกพร่องเล็กๆ ในฟังก์ชันถอดรหัส URL ซึ่งเป็นข้อบกพร่องที่หลบหนีการตรวจจับมาได้อย่างแม่นยำเพราะฟีเจอร์ที่มีโค้ดส่วนนี้ไม่ค่อยถูกใช้งาน ข้อผิดพลาดไม่ได้อยู่ในการทำงานทางธุรกิจที่ซับซ้อนหรืออัลกอริทึมล้ำสมัย แต่อยู่ในหนึ่งในแนวคิดพื้นฐานที่สุดของภาษา C นั่นคือวิธีการที่ตัวดำเนินการเชื่อมโยงกับตัวถูกดำเนินการ (operands)
หลุมพรางทางคณิตศาสตร์ของตัวชี้ (Pointer Arithmetic)
โค้ดที่มีปัญหานั้นเกี่ยวข้องกับการตรวจสอบเลขฐานสิบหกในสตริงที่เข้ารหัส URL การใช้งานดั้งเดิมใช้คณิตศาสตร์ของตัวชี้ (pointer arithmetic) ร่วมกับคำสั่ง assert แต่เมื่อถูกแปลงเป็นการจัดการข้อผิดพลาดที่เหมาะสม ข้อผิดพลาดลำดับความสำคัญที่สำคัญก็แทรกซึมเข้ามา บรรทัด if (!isxdigit(*src+1)) ถูกแจงส่วนโดยคอมไพเลอร์เป็น (*src) + 1 แทนที่จะเป็น *(src + 1) ตามที่ตั้งใจไว้ ซึ่งมีความแตกต่างระหว่างการเข้าถึงตัวอักษรปัจจุบันบวกหนึ่ง กับการเข้าถึงตัวอักษรถัดไปในหน่วยความจำ
ปัญหาลำดับความสำคัญเฉพาะนี้มีต้นเหตุมาจากลำดับชั้นตัวดำเนินการของภาษา C ซึ่งตัวดำเนินการ dereference (*) มีลำดับความสำคัญสูงกว่าการบวก (+) แม้ว่านี่อาจดูเหมือนชัดเจนสำหรับบางคน แต่การอภิปรายในชุมชนเผยให้เห็นว่ากฎลำดับความสำคัญนั้นไม่ใช่สิ่งที่เข้าใจได้ง่ายสำหรับทุกคน ตามที่ผู้แสดงความคิดเห็นหนึ่งคนระบุ กฎลำดับความสำคัญเป็นโครงสร้างที่กำหนดขึ้นตามอำเภอใจ โดยมักจะขึ้นอยู่กับสิ่งที่ผู้สร้างกฎมองว่าสะดวกกว่า ซึ่งการรับรู้จะแตกต่างกันไปในแต่ละบุคคล
วงเล็บนั้นฟรีและทำให้ความตั้งใจของคุณชัดเจนอย่างแน่นอน
วิธีแก้ปัญหา ดังที่หลายคนในชุมชนชี้ให้เห็น คือการใช้สัญกรณ์การเข้าถึงอาร์เรย์ (src[1]) แทนคณิตศาสตร์ของตัวชี้ ซึ่งไม่เพียงแต่ขจัดความกำกวมของลำดับความสำคัญ แต่ยังทำให้โค้ดอ่านง่ายและบำรุงรักษาได้ง่ายขึ้น ความจริงที่ว่า a[b] ถูกกำหนดให้เป็น syntactic sugar สำหรับ *(a + b) ในมาตรฐานภาษา C หมายความว่าไม่มีบทลงทางด้านประสิทธิภาพในการเลือกความชัดเจนแทนความฉลาดหลักแหลม
การเปรียบเทียบโค้ด:
- โค้ดที่มีปัญหา:
if (!isxdigit(*src+1))(แปลงเป็น(*src) + 1) - โค้ดที่ถูกต้อง:
if (!isxdigit(src[1]))หรือif (!isxdigit(*(src+1))) - รูปแบบอาร์เรย์
src[1]มีค่าเทียบเท่ากับรูปแบบพอยน์เตอร์*(src+1)ตามมาตรฐาน C
ก้าวข้ามไปกว่าการแก้ไขเฉพาะหน้า
การอภิปรายขยายตัวอย่างรวดเร็วเกินกว่าข้อบกพร่องเฉพาะนี้ไปสู่แนวทางการเขียนโค้ดในวงกว้าง นักพัฒนาหลายคนสนับสนุนเทคนิคการเขียนโปรแกรมแบบป้องกัน (defensive programming) ซึ่งรวมถึงการใช้วงเล็บอย่างสม่ำเสมอเพื่อทำให้ลำดับความสำคัญชัดเจน แม้ในกรณีที่โดยเทคนิคแล้วไม่จำเป็น คนอื่นๆ ชี้ให้เห็นว่าเครื่องมือจัดรูปแบบอัตโนมัติอาจเป็นมาตรการปกป้องจากข้อผิดพลาดดังกล่าว
ที่น่าสนใจคือ การสนทนาเปิดเผยว่าด้านการเขียนโปรแกรมที่แตกต่างกันได้พัฒนาข้อตกลงของตนเองขึ้นมา นักพัฒนาบางคนพบว่า src[1] ดูเป็นธรรมชาติมากกว่าสำหรับการเข้าถึงแบบอาร์เรย์ ในขณะที่บางคนชอบ *(src + 1) สำหรับการจัดการตัวชี้แบบ iterator ความหลากหลายของแนวทางนี้ชี้ให้เห็นว่าข้อตกลงของทีมและแนวทางสไตล์ที่สม่ำเสมออาจมีความสำคัญเท่ากับความเข้าใจในกฎภาษาของแต่ละบุคคล
เหตุการณ์นี้ยังเน้นย้ำว่าบริบทการพัฒนาส่งผลต่อคุณภาพของโค้ดอย่างไร ข้อบกพร่องยังคงไม่ถูกค้นพบอย่างเฉพาะเจาะจงเพราะเส้นทางการทำงานของโค้ดที่ได้รับผลกระทบนั้นไม่ค่อยถูกใช้งาน ซึ่งเป็นสถานการณ์ทั่วไปในระบบรุ่นเก่าที่ฟีเจอร์สะสมแต่ไม่ได้รับการบำรุงรักษาเป็นประจำ สิ่งนี้ทำหน้าที่เป็นเครื่องเตือนใจว่าการทดสอบที่ครอบคลุมควรรวมถึงแม้แต่เส้นทางโค้ดที่ใช้น้อยที่สุด
แนวปฏิบัติที่ดีที่สุดที่ชุมชนแนะนำ:
- ใช้รูปแบบการอ้างอิงตำแหน่งอาร์เรย์แทนการคำนวณพอยน์เตอร์เพื่อความชัดเจน
- ใช้วงเล็บเพื่อทำให้ลำดับความสำคัญของตัวดำเนินการชัดเจน
- ใช้เครื่องมือจัดรูปแบบอัตโนมัติ (clang-format, GNU indent)
- ดำเนินการตรวจสอบโค้ดอย่างสม่ำเสมอโดยเน้นที่พื้นฐานของภาษา
- ทดสอบเส้นทางโค้ดที่ไม่ค่อยได้ใช้ในระหว่างการบำรุงรักษา
บทเรียนสำหรับการพัฒนาในยุคสมัยใหม่
ในขณะที่ข้อบกพร่องเฉพาะอยู่ในโค้ดภาษา C แต่บทเรียนพื้นฐานนั้นใช้ได้กับภาษาการเขียนโปรแกรมต่างๆ ปัญหาลำดับความสำคัญของตัวดำเนินการปรากฏในรูปแบบต่างๆ ตั้งแต่การแสดงผลแบบมีเงื่อนไขของ Python ไปจนถึงกฎการบังคับประเภท (type coercion) ของ JavaScript แต่ละภาษามีลักษณะเฉพาะของตัวเองที่สามารถดักจับผู้ที่ไม่ระวังได้
ฉันทามติของชุมชนแนะนำแนวทางปฏิบัติหลายประการ: การใช้สัญกรณ์การเข้าถึงอาร์เรย์แทนคณิตศาสตร์ของตัวชี้เมื่อเป็นไปได้ การใช้เครื่องมือวิเคราะห์แบบสถิต (static analysis tools) เพื่อตรวจจับปัญหาที่อาจเกิดขึ้น และการกำหนดขอบเขตของทีมที่ชัดเจนเกี่ยวกับการใช้งานตัวดำเนินการ บางทีที่สำคัญที่สุด การอภิปรายเน้นย้ำว่าโค้ดที่อ่านได้คือโค้ดที่บำรุงรักษาได้ ซึ่งเป็นหลักการที่อยู่เหนือภาษาโปรแกรมหรือกระบวนทัศน์เฉพาะใดๆ
ขณะที่แนวปฏิบัติในการพัฒนาวิวัฒนาการไป เหตุการณ์เช่นนี้ทำหน้าที่เป็นเครื่องเตือนใจที่มีคุณค่าว่าความรู้พื้นฐานเกี่ยวกับภาษายังคงจำเป็น ไม่ว่าจะทำงานบนฟีเจอร์ใหม่หรือบำรุงรักษาโค้ดรุ่นเก่า การทำความเข้าใจว่าคุณเครื่องมือของคุณทำงานอย่างไรจริงๆ สามารถป้องกันข้อบกพร่องเล็กๆ น้อยๆ ไม่ให้กลายเป็นปัญหาที่คงอยู่ ความจริงที่ว่าปัญหาพื้นฐานเช่นนี้สามารถซ่อนตัวอยู่ในที่เปิดเผยมานานหลายปี ตอกย้ำว่าทำไมการเรียนรู้อย่างต่อเนื่องและการตรวจสอบโค้ดจึงยังคงเป็นส่วนสำคัญของการพัฒนาซอฟต์แวร์
อ้างอิง: The Boston Diaries