การตรวจสอบรหัสเป็นเรื่องส่วนตัวหรือวัตถุประสงค์ (เชิงปริมาณ) หรือไม่


55

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

เราใช้TFSสำหรับการควบคุมแหล่งข้อมูล (เราใช้สำหรับการติดตามงาน / ข้อบกพร่อง / การจัดการโครงการเช่นกัน แต่เราย้ายข้อมูลไปยังJIRA ) ด้วย Visual Studio 2008 เพื่อการพัฒนา

สิ่งที่คุณมองหาเมื่อทำการตรวจสอบรหัสคืออะไร?

  • นี่คือสิ่งที่ฉันคิดขึ้นมา
    1. บังคับใช้กฎFxCop (เราเป็นร้านค้าของ Microsoft)
    2. ตรวจสอบประสิทธิภาพ (เครื่องมือใด ๆ ) และความปลอดภัย (คิดถึงการใช้ OWASP - โปรแกรมรวบรวมข้อมูลโค้ด ) และความปลอดภัยของเธรด
    3. ยึดมั่นในการตั้งชื่ออนุสัญญา
    4. รหัสควรครอบคลุมกรณีขอบและเงื่อนไขขอบเขต
    5. ควรจัดการข้อยกเว้นอย่างถูกต้อง (อย่ากลืนข้อยกเว้น)
    6. ตรวจสอบว่าการทำงานซ้ำซ้อนที่อื่นหรือไม่
    7. ร่างกายวิธีการควรมีขนาดเล็ก (20-30 บรรทัด) และวิธีการควรทำสิ่งหนึ่งและสิ่งเดียวเท่านั้น (ไม่มีผลข้างเคียงและหลีกเลี่ยงการมีเพศสัมพันธ์ชั่วคราว -)
    8. ห้ามส่ง / คืนค่า null ในเมธอด
    9. หลีกเลี่ยงรหัสที่ตายแล้ว
    10. เอกสารสาธารณะและวิธีการป้องกัน / คุณสมบัติ / ตัวแปร

สิ่งอื่น ๆ ที่เราควรระวัง

ฉันพยายามที่จะดูว่าเราสามารถหาจำนวนกระบวนการตรวจสอบ (มันจะผลิตผลลัพธ์ที่เหมือนกันเมื่อตรวจสอบโดยบุคคลที่แตกต่างกัน) ตัวอย่าง: การพูดว่า "ร่างกายวิธีการควรจะไม่เกิน 20-30 บรรทัดของรหัส" ตรงกันข้ามกับว่า ร่างกายควรมีขนาดเล็ก "

หรือการตรวจสอบรหัสเป็นเรื่องส่วนตัวมาก (และอาจแตกต่างจากผู้ตรวจสอบคนหนึ่งไปยังอีกคนหนึ่ง)?

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

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

อ้างอิงหนังสือ: รหัสสะอาด: คู่มือของซอฟต์แวร์เปรียวฝีมือโดยโรเบิร์ตมาร์ติน


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

4
หากเราหลีกเลี่ยงการคืนค่า Null เราสามารถข้ามการตรวจสอบ Null เมื่อลูกค้า / แอพ / ไลบรารีที่เรียกใช้เมธอดของเรา จาก Clean Code โดย Robert Martin - บทที่ 7 (การจัดการข้อผิดพลาด) pp: 110 "เมื่อเราคืนค่า Null เราจะสร้างงานให้กับตัวเองและสร้างปัญหาให้กับผู้โทรของเราสิ่งที่ต้องทำคือการตรวจสอบ Null ที่ไม่มีอยู่ ของการควบคุม "

3
คุณช่วยอธิบายให้คนที่ไม่ต้องการซื้อหนังสืออ่านหน้าเดียวได้ไหม? ดูเหมือนว่าสำหรับโปรแกรม C # ส่วนใหญ่การหลีกเลี่ยง NULL จะทำให้โค้ดมีความซับซ้อนมากขึ้นซึ่งจะเป็นสูตรสำหรับข้อผิดพลาดเพิ่มเติม ...

2
นี่คือหนึ่งโพสต์บล็อกซึ่งอธิบายว่าทำไมการคืน null จึงเป็นความคิดที่ไม่ดี thehackerchickblog.com/2008/10/… . และอีกหนึ่งleedumond.com/blog/should-we-return-null-from-our-methods สิ่งที่บ๊อบแนะนำในหนังสือของเขาคือถ้าเราถูกล่อลวงให้คืนค่าเป็นโมฆะเราสามารถโยนข้อยกเว้นอ้างอิง Null หรือส่งคืนวัตถุ SPECIAL_CASE แทน คิดเกี่ยวกับการเรียกวิธีการผูกมัดthis.Foo().FooBar().FooBarBar(); หากวัตถุที่ส่งกลับมาที่นี่จาก Foo เป็นโมฆะแน่นอนคุณสามารถหลีกเลี่ยง "การอ้างอิงวัตถุไม่ได้ถูกตั้งค่าเป็นอินสแตนซ์ของวัตถุ" เมื่อเรียก FooBar ()

@SoloBold: และเพื่อชี้ให้เห็นพวกเขาเป็นเพียงแนวทาง หากมีเหตุผลที่น่าสนใจมากที่จะคืนค่า null (อาจเป็นในบางกรณี) การคืนค่า null จะสมเหตุสมผลกว่าการส่งคืนวัตถุ SPECIAL_CASE

คำตอบ:


25

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

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

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

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

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

ฉันพบสิ่งเหล่านี้มีประโยชน์:

1) ไม่มีสงครามสไตล์ ตำแหน่งที่เครื่องมือจัดฟันแบบหยิกเปิดควรอยู่ภายใต้การตรวจสอบความสอดคล้องในไฟล์ที่กำหนดเท่านั้น เหมือนกันทั้งหมด. ไม่เป็นไร Ditto ลึกเยื้อง ** และ ** ความกว้างของแท็บ องค์กรส่วนใหญ่พบว่าพวกเขาต้องการมาตรฐานทั่วไปสำหรับแท็บซึ่งใช้เป็นพื้นที่ขนาดใหญ่

2) `มอมแมม

   looking

ข้อความที่ไม่

   line up is hard to read 

สำหรับเนื้อหา '

BTW, K&Rย่อหน้าห้าช่องว่าง (FIVE) ดังนั้นการอุทธรณ์ต่อเจ้าหน้าที่จึงไม่มีค่า เพียงแค่ให้สอดคล้อง

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

4) ไม่มีการออกแบบบนการบิน หากมีปัญหาหรือปัญหาให้จดที่ตั้งและเคลื่อนตัวต่อไป

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

6) รูปแบบไฟล์ที่ไม่ใช่ASCIIเป็นที่ยอมรับหากมีการสร้างแสดงแก้ไข ฯลฯ มีเครื่องมือหรือสร้างขึ้นในช่วงต้นของการพัฒนา นี่เป็นอคติส่วนตัวของฉัน แต่ในโลกที่ระบบปฏิบัติการที่โดดเด่นไม่สามารถหลีกทางให้ตัวเองได้ด้วย RAM น้อยกว่า 1 กิกะไบต์ฉันไม่เข้าใจว่าทำไมไฟล์น้อยกว่าพูดว่า 10 เมกะไบต์ควรเป็นอะไรก็ได้ นอกเหนือจาก ASCII หรือรูปแบบอื่นที่สนับสนุนในเชิงพาณิชย์ มีมาตรฐานสำหรับกราฟิกเสียงภาพยนตร์ปฏิบัติการและเครื่องมือที่ไปกับพวกเขา ไม่มีข้อแก้ตัวสำหรับไฟล์ที่มีการแสดงเลขฐานสองของวัตถุจำนวนหนึ่ง

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

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

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

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

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

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

ในหลาย ๆ วิธีฉันคิดว่าเทคโนโลยีเป็นเรื่องเกี่ยวกับวัฒนธรรมและความคาดหวังเป็นอย่างมากเกี่ยวกับเครื่องมือเฉพาะ คิดว่าการปรับตัวแบบ " Swiss Family Robinson " / Flintstones / McGyver ทั้งหมดที่ทำให้หัวใจมีความสุขและท้าทายจิตใจ เราต้องการสิ่งที่เราจะทำงาน ไม่มีหนทางเดียวที่จะนำไปสู่ความเป็น "ปัญญา" ซึ่งอาจถูกทำให้เป็นนามธรรมและเป็นไปโดยอัตโนมัติโดยโปรแกรมAIปี 1960


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

25

จุดส่วนใหญ่ที่คุณอธิบายเป็นเพียงเรื่องของการจัดรูปแบบโค้ดหรือ "พื้นผิว":

  • ยึดมั่นในการตั้งชื่ออนุสัญญา
  • หลีกเลี่ยงรหัสที่ตายแล้ว
  • เอกสาร
  • ...

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

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


เครื่องมืออัตโนมัติสามารถ:

  • รวมเข้าไว้ในกระบวนการสร้างอัตโนมัติบางอย่างที่ทำงานทุกคืน
  • ส่งการรายงานทางอีเมล
    • คำเตือน(เช่นวิธีการมีความยาวมากกว่า 20 บรรทัด)
    • ข้อผิดพลาด(ตัวอย่างเช่นวิธีมีความยาวมากกว่า 50 บรรทัด)

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


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


การตรวจสอบโค้ดที่ทำโดยผู้พัฒนาที่มีประสบการณ์ก็มีข้อดีอีกอย่างที่คุณไม่ได้พูดถึง:

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

แต่สำหรับการตรวจสอบโค้ดที่ลึกกว่าการจัดรูปแบบโค้ดคุณจะต้องใช้เวลามากกว่าครึ่งชั่วโมง ...


เครื่องมือนี้สำหรับ. Net (ขณะนี้มีเพียง C # เท่านั้น) คือ StyleCop code.msdn.microsoft.com/sourceanalysis
Bryan Anderson

15

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

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


2
+1 สำหรับความคิดเห็นของคุณเกี่ยวกับการไม่ปล่อยให้สิ่งนี้กลายเป็นการเปรียบเทียบว่าใครดีกว่าในงานของพวกเขา มันจะไม่ดีสำหรับขวัญกำลังใจ!

2
@KarstenF: จริง DeveloperA อาจทำงานกับงานที่ซับซ้อนมากขึ้น (มีโค้ดมากกว่า) ในขณะที่ DeveloperB อาจทำงานในภารกิจง่าย ๆ และอาจทำคะแนนน้อยลง (ตามระดับคะแนน) มันจะไม่ยุติธรรมที่จะบอกว่า DevA ทำงานได้ไม่ดีเมื่อไม่มีวิธีที่จะทำให้งาน / งานของพวกเขากลับสู่ปกติ

2
นักพัฒนาบางคนอาจพยายามทำให้เสียชื่อเสียง

จุดนี้ถูกต้อง แนวคิดย่อย ๆ (เช่นการให้คะแนน) นำไปสู่ความใจแคบ
Dan Rosenstark

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

5

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

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


4

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

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


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

4

ตามกฎทั่วไปหลีกเลี่ยงการใช้เวลาในการตรวจสอบโค้ดโดยทำสิ่งที่เครื่องสามารถทำได้ ตัวอย่างเช่นรายการแรกของคุณคือ "บังคับใช้กฎ FxCop" แต่สันนิษฐานได้ว่า FxCop สามารถทำได้โดยที่มนุษย์ไม่ต้องทำเช่นนั้น


3

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


100 ชั่วโมงเพื่อให้เครื่องมือ 1,000 บันทึกโดยใช้มัน
Dan Rosenstark

3

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

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

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


2

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

รูปแบบทั่วไปที่ฉันชอบคือ:

  1. เรากำลังแก้ไขอะไร
  2. เกิดอะไรขึ้น (ดูรหัส)
  3. เราจะแก้ไขได้อย่างไร
  4. แสดงรหัสใหม่ให้ฉัน
  5. แสดงรหัสที่ใช้งานได้

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

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


ไม่ชัดเจนจากคำตอบของคุณ: FxCop ตรวจจับความบอบบางนั้นหรือไม่?
Dan Rosenstark

2

ความซับซ้อนของวัฏจักร (CC) เป็นวิธีหนึ่งในการประเมินโค้ดที่ 'ไม่เลว'

ในรหัสจริงที่มี CC สูงฉันมี "สิ่งที่เกิดขึ้นที่นี่ฉันจำไม่ได้" รหัส CC ที่ต่ำกว่าง่ายต่อการเข้าใจ

เห็นได้ชัดว่า caveats ปกติใช้สำหรับการวัด


1
@AfermeraInfo: เหรอ?
พอลนาธาน

1

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

สิ่งอื่น ๆ ที่ฉันจะมองหา:

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

1

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

คุณภาพของรหัส:

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

คุณสมบัติตามมาตรฐาน:

  1. การทบทวนข้อกำหนดคุณลักษณะและการเปลี่ยนแปลงใด ๆ ตั้งแต่ข้อกำหนดและ / หรือการทบทวนการออกแบบ
  2. สาธิตการใช้งานที่เกี่ยวข้องกับข้อกำหนดและตรวจสอบคุณสมบัติทีละรายการ
  3. อภิปรายข้อกำหนดเพิ่มเติมใด ๆ ในด้านอื่น ๆ ของซอฟต์แวร์ที่พบในระหว่างการนำไปใช้งาน (เช่นแผนการปรับใช้โครงสร้างพื้นฐานเป็นต้น)
  4. คำอธิบายของการเบี่ยงเบนใด ๆ จากข้อกำหนดถ้ามีตามจุดนั้น

หากคุณสามารถปกปิดตัวเองเกี่ยวกับการตรวจสอบโค้ดทั้งสองด้านได้แสดงว่าคุณเป็นคนสีทอง


1

ฉันจะเขียนวรรคสาม แต่ฉันเท่านั้นที่จะปัดสวะสิ่งที่คาร์ล Wiegers อธิบายใน"รีวิว Peer ในซอฟท์แว: คู่มือปฏิบัติการ" ฉันคิดว่าหนังสือของเขามีคำตอบที่ชัดเจนและกระชับสำหรับคำถามของคุณ (และอีกมากมาย)


1

มันขึ้นอยู่กับ.

บางส่วนของการตรวจสอบสามารถวัดปริมาณได้ง่าย (ไม่มีปัญหา FxCop ไม่มีข้อผิดพลาดStyleCopไม่มีข้อผิดพลาดCAT.NETและอื่น ๆ )

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

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


0

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

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

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


สิ่งที่นายอำเภอเกิดขึ้น

0

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


0
  • หากเครื่องสามารถตรวจสอบได้คนไม่ควร
  • รายการตรวจสอบหนึ่งรายการเท่านั้น: ทุกกรณีเกิดข้อผิดพลาดจัดการอย่างถูกต้องทุกที่หรือไม่?
  • ใช้บทวิจารณ์โค้ดเพื่อปรับปรุงคุณภาพและถ่ายโอนความรู้
  • อย่าใช้การตรวจสอบโค้ดเพื่อระบุนักพัฒนา "ไม่ดี"
  • ego dings มีประสิทธิภาพมากกว่าคะแนนที่ชัดเจน
  • ทำให้สั้น - 90 นาทีและ 500 บรรทัดมีขนาดใหญ่มาก
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.