ฉันจะตรวจสอบรหัสของตัวเองได้อย่างไร [ปิด]

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

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

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

หลักสูตรนี้มีประโยชน์เมื่อคุณตรวจสอบรหัสอื่นเช่นกัน

ดูที่เว็บไซต์Code Exchange Stack การตรวจสอบ มันเป็นรหัสสำหรับการแบ่งปันจากโครงการที่คุณกำลังทำงานในการทบทวน :

Code Review Stack Exchangeเป็นคำถามและคำตอบสำหรับการค้นหาการตรวจทานโค้ดของคุณ เรากำลังทำงานร่วมกันเพื่อพัฒนาทักษะของโปรแกรมเมอร์ทั่วโลกโดยใช้รหัสการทำงานและทำให้ดีขึ้น

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

• แนวทางปฏิบัติที่ดีที่สุดและการใช้รูปแบบการออกแบบ
• ปัญหาด้านความปลอดภัย
• ประสิทธิภาพ
• ความถูกต้องในกรณีที่ไม่คาดคิด

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

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

ฉันขอแนะนำวิธีการของฉัน

ป.ล. เขาไม่ได้ล้อเล่น

ฉันเห็นด้วยเล็กน้อยความเห็น jk-s ว่าการวิจารณ์แบบคนเดียวไม่ได้มีประสิทธิภาพเท่ากับการรีวิว 2 คน อย่างไรก็ตามคุณสามารถพยายามทำให้ดีที่สุด:

ตรวจสอบระยะสั้น (ไม่นานหลังจากที่ผลิตรหัส)

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

ก่อนที่ฉันจะเช็คอินฉันจะเปรียบเทียบสิ่งที่ฉันเปลี่ยนไปในโค้ดและทบทวนใหม่:

• ตัวแปร / เมธอด / ชื่อคลาสยังสะท้อนถึงสิ่งที่ใช้

การทบทวนระยะยาว (6 เดือนหลังจากสร้างรหัส)

ฉันถามตัวเอง:

• ฉันสามารถอธิบายในหนึ่งประโยคว่าคลาส / วิธี / ตัวแปรทำอะไรได้บ้าง?
• มันง่ายแค่ไหนที่จะใช้คลาสในการแยก (การแบ่งคลาสอื่น ๆ ) หรือเขียน unittest สำหรับ?

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

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

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

เปลี่ยนเทคนิคการดีบักนี้เป็นเทคนิคการตรวจสอบรหัส: http://en.wikipedia.org/wiki/Rubber_duck_debugging

แนวคิดนี้ใช้งานได้อย่างมหัศจรรย์ในการทำให้คุณมีความคิดที่เหมาะสมในการทำงานผ่านโค้ดราวกับว่ามันเป็นสิ่งใหม่

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

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

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

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

นี่คือเคล็ดลับจากประสบการณ์ไม่กี่ปีของฉัน:

• มีรายการตรวจสอบคร่าวๆที่มีประโยชน์ นี่คือสิ่งที่คุณต้องการตั้งค่าสถานะในขณะที่คุณอ่านรหัสของคุณ
• ตรวจสอบรหัสของคุณออฟไลน์ มันอาจฟังดูไร้ประโยชน์ แต่ใช้งานพิมพ์ที่คุณสามารถใส่คำอธิบายประกอบและพลิกกลับไปกลับมาหรือเทียบเท่าดิจิตอลของไฟล์ PDF ที่ไฮไลต์อย่างที่ซิงค์ไว้กับ iPad ซึ่งออฟไลน์อยู่ ออกไปจากโต๊ะทำงานเพื่อที่คุณจะได้ตรวจสอบสิ่งที่ทำให้ไขว้เขวรหัสของคุณฟรี
• ทำตอนเช้าตรู่แทนที่จะจบวันทำงาน ดวงตาคู่สวยสดจะดีกว่า ในความเป็นจริงมันอาจช่วยให้ห่างจากรหัสหนึ่งวันก่อนที่จะทบทวนอีกครั้ง

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

เทคนิคกระบวนการซอฟต์แวร์ส่วนบุคคลสำหรับการตรวจทานอาจมีประโยชน์แม้ว่าจะขึ้นอยู่กับการมีข้อมูลประวัติเกี่ยวกับงานและคุณภาพของผลิตภัณฑ์

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

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

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

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

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

1. BDD หมายถึงการเขียนการทดสอบรหัสก่อน สิ่งนี้ทำให้มั่นใจได้ว่ารหัสทั้งหมดของคุณครอบคลุมโดยการทดสอบ
2. BDD เป็นหลัก TDD แต่ด้วยความแตกต่างเล็กน้อยและ "ภาษา" สิ่งนี้หมายถึงคือคุณปรับโครงสร้างรหัสของคุณใหม่อย่างต่อเนื่องในขณะที่ทำงานและใช้การทดสอบของคุณเพื่อให้มั่นใจว่ามีความพยายามในการปรับโครงสร้างใหม่อย่างต่อเนื่องเพื่อให้แน่ใจว่ารหัสของคุณตรงตามข้อกำหนดผลิตภัณฑ์
3. ภาษา BDD ส่งเสริมการทดสอบที่จะเขียนในรูปแบบของข้อความที่จำเป็นต้องเข้ารหัสความต้องการในการทดสอบหน่วย

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

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

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

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

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

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

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

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

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

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

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

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

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

แต่วิธีปฏิบัติที่ดีที่สุดคือทบทวนตัวคุณเองและต่อมามีคนอื่นอย่างน้อยสองคนเข้ามาทบทวนด้วยบทบาทที่แตกต่าง

ลองทำการตรวจสอบ Fagan ด้วยตัวเอง - คุณจะต้องปรับกระบวนการเพราะตัวคุณเอง แต่คุณควรจะได้รับประโยชน์จากมันบ้าง เคล็ดลับคือการค้นหา "ruleset" ที่ถูกต้องเพื่อประเมินโค้ดของคุณในฐานะนักพัฒนาเดี่ยวและจากนั้นให้มีระเบียบวินัยในการถามคำถามเหล่านั้นในกรอบการวิเคราะห์เชิงจิตใจที่ไร้ความปราณีทุกครั้ง ฉันสงสัยว่าคุณอาจต้องการระดมสมองคำถามที่สำคัญ 4-5 ข้อของคุณเองเพื่อเริ่มต้นจากนั้นค่อยพัฒนาไปตามกาลเวลา บางคนขัดต่อการตรวจสอบอย่างเป็นทางการเพราะดูเหมือนว่าพวกเขาจะใช้เวลามาก ... ก่อนที่คุณจะตัดสินใจว่าพวกเขามีราคาแพงเกินไปโปรดจำไว้ว่าหลักฐานทางสถิติทั้งหมดว่าการตรวจสอบอย่างถูกต้องลดเวลาโครงการอย่างแท้จริง นี่คือลิงค์ Wikipedia ที่คุณสามารถเริ่มการวิจัยเพิ่มเติมด้วย:

http://en.wikipedia.org/wiki/Software_inspection

มีหนังสืออยู่สองสามเล่มเช่น Google สำหรับ "กระบวนการตรวจสอบซอฟต์แวร์" โดย Strauss และ Ebenau

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

http://www.javaspecialists.eu/

นอกเหนือจากคำแนะนำทั้งหมดสำหรับการตรวจสอบโค้ดแล้วคุณสามารถใช้เครื่องมือเช่น PMD และ findBug เพื่อสร้างสติระดับแรกให้กับรหัสของคุณ

สิ่งนี้ยังไม่ได้ถูกวางไว้ในคำตอบ (แต่ถูกเพิ่มเป็นความคิดเห็นในคำตอบที่มีอยู่)

ตรวจสอบรหัสของคุณหลังจากนอนหลับฝันดีเช่นเริ่มต้นวันใหม่ด้วยการตรวจสอบรหัสที่คุณเขียนเมื่อวันก่อน

แน่นอนว่านี่จะไม่ทำให้คุณได้รับประสบการณ์แบบกลุ่มโดยรวม แต่จะให้คุณตรวจสอบโค้ดจากมุมมองใหม่

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

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