จะทำอย่างไรเมื่อรหัสที่ส่งมาเพื่อตรวจสอบรหัสมีความซับซ้อนเกินไป

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

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

หากไม่สามารถตรวจสอบได้จะไม่สามารถผ่านการตรวจสอบได้

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

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

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

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

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

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

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

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

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

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

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

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

คำตอบอีกข้อหนึ่งกล่าวว่ารหัสของบางคนสามารถปรับเปลี่ยนได้ 10 ครั้งและสามารถอ่านได้มากขึ้นในแต่ละครั้ง นั่นเป็นเรื่องน่าเศร้า นั่นคือนักพัฒนาที่ควรมองหางานอื่น

รหัสเก่านี้มีการเปลี่ยนแปลงเล็กน้อยหรือไม่? (รหัส 100 บรรทัดที่เปลี่ยนแปลงใน codebase 10,000 บรรทัดยังคงมีการเปลี่ยนแปลงเล็กน้อย) บางครั้งมีข้อ จำกัด เวลาและนักพัฒนาถูกบังคับให้อยู่ในกรอบเก่าและไม่สะดวกเพียงเพราะการเขียนใหม่ทั้งหมดจะใช้เวลานานกว่าและเป็นงบประมาณ . + มักจะมีความเสี่ยงที่เกี่ยวข้องซึ่งอาจมีค่าใช้จ่ายหลายล้านดอลลาร์เมื่อประเมินอย่างไม่ถูกต้อง หากเป็นรหัสเก่าในกรณีส่วนใหญ่คุณจะต้องอยู่กับมัน หากคุณไม่เข้าใจด้วยตนเองให้พูดคุยกับพวกเขาและฟังสิ่งที่พวกเขาพูดพยายามทำความเข้าใจ จำไว้ว่าการติดตามคุณอาจทำได้ยาก แต่ก็ดีสำหรับคนอื่น เอาด้านของพวกเขาดูจากจุดสิ้นสุดของพวกเขา

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

บ่อยครั้งแพทช์ / ผู้เปลี่ยนแปลงที่ "ซับซ้อน" นั้นเป็นคนที่ทำสิ่งต่าง ๆ มากมายในคราวเดียว มีรหัสใหม่รหัสที่ถูกลบรหัส refactored รหัสย้ายการทดสอบขยาย; มันทำให้ยากที่จะเห็นภาพรวม

เบาะแสที่พบบ่อยคือแพทช์มีขนาดใหญ่ แต่คำอธิบายนั้นเล็กมาก: "ใช้ $ FOO"

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

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

สำหรับฟังก์ชันการทำงานที่ต้องใช้รหัสใหม่จำนวนมากรหัสใหม่มักจะสามารถนำมาใช้ในชิ้นทดสอบที่ไม่เปลี่ยนพฤติกรรมของผลิตภัณฑ์จนกว่าแพทช์สุดท้ายในชุดจริงเรียกรหัสใหม่ (พลิกธง)

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

ดังนั้น patch ขนาดใหญ่เช่น "Implement $ FOO" จะกลายเป็นชุดข้อมูลแก้ไขดังนี้:

1. แนะนำ Frobnicate รุ่นใหม่ที่ใช้ตัววนซ้ำคู่หนึ่งเพราะฉันจะต้องเรียกมันด้วยลำดับอื่นนอกเหนือจากเวกเตอร์เพื่อใช้ $ FOO
2. สลับผู้โทรที่มีอยู่ทั้งหมดของ Frobnicate ให้ใช้เวอร์ชั่นใหม่
3. ลบ Frobnicate เก่า
4. Frobnicate กำลังทำมากเกินไป แยกขั้นตอน refrumple เป็นวิธีการของตนเองและเพิ่มการทดสอบสำหรับสิ่งนั้น
5. แนะนำ Zerzify พร้อมการทดสอบ ยังไม่ได้ใช้ แต่ฉันจะต้องใช้ $ FOO
6. ดำเนินการ $ FOO ในแง่ของ Zerzify และ Frobnicate ใหม่

โปรดทราบว่าขั้นตอนที่ 1-5 ไม่มีการเปลี่ยนแปลงการทำงานกับผลิตภัณฑ์ พวกเขาตรวจสอบได้เล็กน้อยรวมถึงการทำให้แน่ใจว่าคุณมีการทดสอบที่ถูกต้องทั้งหมด แม้ว่าขั้นตอนที่ 6 จะยังคง "ซับซ้อน" อย่างน้อยก็จะเน้นไปที่ $ FOO และบันทึกจะช่วยให้คุณมีความคิดที่ดีขึ้นเกี่ยวกับวิธีการใช้ $ FOO (และทำไม Frobnicate จึงเปลี่ยน)

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

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

หากความซับซ้อนถูกแยกออกเป็นระดับวิธีการที่มักจะสามารถแก้ไขซ้ำแล้วซ้ำอีกและมีการทดสอบอัตโนมัติที่ดี

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

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

การทดสอบคืออะไร? ควรมีความชัดเจนเรียบง่ายและอ่านง่ายโดยมีเพียงหนึ่งข้อเท่านั้น การทดสอบควรบันทึกไว้อย่างชัดเจนถึงพฤติกรรมที่ตั้งใจและใช้กรณีของรหัส

หากยังไม่ผ่านการทดสอบก็เป็นจุดเริ่มต้นที่ดีในการตรวจสอบ