ใช้เวลาในการดีบักมากเกินไป


24

เมื่อวานฉันเปิดตัวโครงการเว็บ v1.0 ที่ฉันใช้เวลาทำงานประมาณ 6 สัปดาห์ (เปิดและปิดนั่นคือ) ฉันไม่ได้ทำบันทึกเวลาที่แน่นอน แต่จากประสบการณ์ของฉันฉันจะประเมินว่าตลอดเวลาที่ฉันใช้การเขียนโปรแกรมครึ่งหนึ่งนั้นใช้การดีบัก ฉันคาดการณ์ว่าจะใช้เวลาในการดีบักประมาณ 15-20 ชั่วโมงซึ่งเป็นเวลาอันมีค่าที่ดีกว่าที่จะใช้การเขียนโค้ดใหม่หรือทำโครงการให้เสร็จเร็วขึ้น โดยเฉพาะอย่างยิ่งมันไม่ได้ช่วยว่าฉันจะเป็นนักศึกษาใหม่ในวิทยาลัยใน 5 สัปดาห์

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

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


22
เมื่อฉันเป็นน้องใหม่ฉันก็เป็นนักเขียนรหัสช้าเช่นกัน แค่ให้มัน 20 ปี
งาน

27
เอ่อใช่ขอให้โชคดี "ถ้าการดีบั๊กเป็นกระบวนการลบบั๊กการเขียนโปรแกรมจะต้องเป็นขั้นตอนการใส่บั๊ก" -Edsger Dijkstra
Matt

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

5
สิ่งนี้เรียกว่า "ประสบการณ์" และจะช่วยคุณในโครงการต่อไปของคุณ

4
เมื่อพูดถึงช่วงปลายทศวรรษที่ 1940 Maurice Wilkes เขียนว่า: "ทันทีที่เราเริ่มเขียนโปรแกรมเราพบว่าเราประหลาดใจที่มันไม่ง่ายที่จะทำให้โปรแกรมถูกต้องตามที่เราคิดการแก้จุดบกพร่องจำเป็นต้องถูกค้นพบ การเดินทางของฉันระหว่างห้อง EDSAC และอุปกรณ์เจาะที่ 'ลังเลที่มุมของบันได' การรับรู้เกิดขึ้นกับฉันอย่างเต็มที่ว่าส่วนที่ดีของชีวิตที่เหลืออยู่ของฉันกำลังจะถูกใช้ไปเพื่อค้นหาข้อผิดพลาดในโปรแกรมของฉันเอง "
เทรเวอร์พาวเวลล์

คำตอบ:


35

คุณกำลังขอ Holy Grail ของวิศวกรรมซอฟต์แวร์และยังไม่มีใครตอบคำถามนี้ได้

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

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

ข้อบกพร่องขั้นตอนการออกแบบ

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

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

ข้อผิดพลาดในการเข้ารหัส

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

หากคุณกำลังเขียนโปรแกรมใน C ให้เปิดคำเตือนคอมไพเลอร์ทั้งหมดใช้ semantic checker like lintและใช้เครื่องมือเช่นvalgrindเพื่อตรวจจับปัญหาที่เกี่ยวข้องกับหน่วยความจำแบบไดนามิกทั่วไป

หากคุณกำลังเขียนโปรแกรม Perl เปิดstrictและwarningsและระวังสิ่งที่กล่าว

ไม่ว่าคุณจะใช้ภาษาใดอาจมีเครื่องมือมากมายที่ช่วยคุณตรวจจับข้อผิดพลาดทั่วไปก่อนที่คุณจะถึงขั้นตอนการดีบัก

บูรณาการข้อบกพร่องขั้นตอน

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

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

และอื่น ๆ ...

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

สิ่งที่เกือบทุกอย่างทยอยลงคือการมีเวลาน้อยและการทำงานล่วงหน้าจ่ายเป็นเงินปันผลจำนวนมหาศาลในภายหลังในกระบวนการพัฒนา / วางจำหน่าย

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


1
นี่เป็นคำตอบที่ดี แต่ IMHO เป็นคำถามที่แตกต่างกันเล็กน้อย OP บอกว่าฉันใช้เวลา 6 สัปดาห์ในการเปิด / ปิดการเขียนบางสิ่งบางอย่างและฉันต้องใช้เวลาในการดีบั๊กมาก เราไม่รู้อะไรเลยเกี่ยวกับคุณภาพความสามารถในการบำรุงรักษาความสามารถในการปรับขนาดของผลิตภัณฑ์ของเขา หากเราถือว่า TDD การออกแบบที่ดีการติดตามข้อผิดพลาดยังคงมีคำถามว่าเราจะเขียนโค้ดอย่างไร (รวมถึงรหัสทดสอบที่จำเป็นต้องทำการดีบั๊ก) ด้วยข้อบกพร่องที่น้อยลง การเปิดคำเตือนการใช้ผ้าสำลี ฯลฯ เป็นคำแนะนำที่ดี มีผู้คนจำนวนมากที่มาจากโรงเรียนแห่งการเคาะอย่างแรงหรือไม่? :-)
Guy Sirton

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

37

เขียนการทดสอบหน่วย

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

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

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


+1 สำหรับการทดสอบหน่วย - ก่อนหน้านี้ในกระบวนการพัฒนาที่ข้อบกพร่องถูกจับได้ถูกกว่าและง่ายกว่าที่จะแก้ไข
Paul R

26

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

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

มีบางสิ่งที่คุณสามารถทำได้เพื่อลดเวลาในการดีบัก:

  • รหัสแก้ปัญหาได้เขียน ซึ่งหมายความว่า: การจัดการข้อผิดพลาดที่เหมาะสม (ด้วยความคิดบางอย่างใส่ไว้) จัดโครงสร้างโค้ดของคุณเพื่อให้ง่ายต่อการติดตามใช้การติดตามการติดตามและอะไรก็ตามที่สามารถทำให้ชีวิตของดีบักเกอร์ง่ายขึ้น หลีกเลี่ยงเส้นที่ซับซ้อน ควรแยกบรรทัดที่มีสิ่งต่าง ๆ มากกว่าหนึ่งอย่างออกมา
  • รหัสทดสอบเขียน แยกรหัสของคุณออกเป็นฟังก์ชั่นง่าย ๆ (หรือภาษาอื่นที่คุณเลือกรองรับ); หลีกเลี่ยงผลข้างเคียงเนื่องจากยากต่อการจับในการทดสอบหน่วย ออกแบบฟังก์ชั่นของคุณเพื่อให้สามารถทำงานแยกกันได้ หลีกเลี่ยงฟังก์ชั่นเอนกประสงค์ หลีกเลี่ยงกรณีขอบ จัดทำเอกสารสิ่งที่ฟังก์ชั่นของคุณควรทำ
  • ทดสอบเขียน การมีการทดสอบหน่วยหมายความว่าคุณรู้ว่าฟังก์ชั่นของคุณทำงานอย่างน้อยหนึ่งส่วนย่อยของอินพุต นอกจากนี้ยังหมายถึงคุณมีการตรวจสอบสติเพื่อยืนยันการเปลี่ยนแปลงของคุณไม่ทำลายอะไร ตรวจสอบให้แน่ใจว่าคุณเข้าใจแนวคิดของการครอบคลุมโค้ดและความครอบคลุมอินพุตรวมถึงข้อ จำกัด ของการทดสอบหน่วย
  • ตั้งค่า 'ปรับแต่ง' วิธีการที่คุณทำเช่นนี้ขึ้นอยู่กับภาษา บางภาษาเช่น Python หรือ Haskell มาพร้อมกับล่ามแบบโต้ตอบและคุณสามารถโหลดรหัสที่มีอยู่ของคุณลงในนั้นเพื่อเล่นกับมัน นี่คือสิ่งที่สมบูรณ์แบบเนื่องจากคุณสามารถเรียกใช้งานฟังก์ชั่นของคุณในบริบทใด ๆ ที่คุณต้องการด้วยความพยายามน้อยที่สุด - เครื่องมือที่ทรงคุณค่าสำหรับการค้นหาและแยกข้อบกพร่อง ภาษาอื่นไม่มีความหรูหรานี้และคุณจะต้องเขียนโปรแกรมการทดสอบแบบโต้ตอบเล็กน้อย
  • รหัสที่อ่านเขียน ทำให้เป็นนิสัยในการเขียนรหัสของคุณเพื่อแสดงเจตจำนงของคุณอย่างชัดเจนที่สุด บันทึกเอกสารทุกอย่างที่ไม่ชัดเจนอย่างสมบูรณ์
  • รหัสที่ง่ายเขียน หากสมองของคุณมีปัญหาในการทำความเข้าใจรหัสฐานทั้งหมดนั่นก็ไม่ใช่เรื่องง่ายและเป็นไปไม่ได้ที่คนอื่นจะสามารถเข้าใจได้อย่างเต็มที่ คุณไม่สามารถดีบักรหัสได้อย่างมีประสิทธิภาพเว้นแต่คุณจะเข้าใจในสิ่งที่ควรทำ
  • เป็นเรื่องง่ายที่ปุ่ม 'ลบ' รหัสใด ๆ ที่คุณไม่ต้องการในตอนนี้อยู่ในถังขยะได้ หากคุณต้องการในภายหลังฟื้นจากการควบคุมแหล่ง (ประสบการณ์แสดงให้เห็นว่าสิ่งนี้หายากมาก) ยิ่งคุณทิ้งรหัสมากเท่าไหร่พื้นผิวการดีบักของคุณก็จะยิ่งเล็กลงเท่านั้น
  • Refactorเร็วและบ่อยครั้ง คุณจะไม่สามารถรักษารหัสของคุณให้อยู่ในสถานะที่สามารถแก้ไขได้ในขณะที่เพิ่มคุณสมบัติใหม่

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

2
+1 ฉันจะบอกว่าการใช้ความพยายามในการดีบักเพียง 50% นั้นค่อนข้างต่ำโดยเฉพาะอย่างยิ่ง แต่ไม่เพียง แต่ในฐานข้อมูลที่กำหนด ถ้าฉันได้รับมอบหมายบั๊กเว้นแต่ว่ามันต้องการการเขียนใหม่ที่สมบูรณ์ของส่วนต่าง ๆ ที่เกี่ยวข้องของรหัส (ไม่น่าเป็นไปได้) ฉันอาจใช้เวลามากกว่าเศษส่วนของเวลาทั้งหมดเพียงแค่หาสิ่งที่ผิดพลาดจากนั้นทดสอบการแก้ไข การแก้ไขตัวเองมักจะรวดเร็วซึ่งมักจะเป็นจำนวนโค้ดที่เปลี่ยนแปลงเพียงหนึ่งหรือสองบรรทัด
CVn

@ ThorbjørnRavnAndersen Hell ใช่โดยเฉพาะกับโครงการบนเว็บเช่น OP กล่าวถึง เรากำลังมีดีเวลาที่มีการเข้ารหัสตัวอักษรในสัปดาห์นี้ในที่ทำงาน ...
Izkata

5

การวางแผนเพิ่มเติม

เป็นเรื่องที่หลีกเลี่ยงไม่ได้ที่คุณจะใช้เวลาในการดีบั๊ก 10% เป็นเป้าหมายที่ทะเยอทะยาน แม้ว่าหนึ่งในวิธีที่ดีที่สุดในการลดเวลาในการดีบักและการพัฒนาคือการใช้เวลามากขึ้นในขั้นตอนการวางแผน

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


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

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

5

ทำงานอย่างระมัดระวังมากขึ้น

นี่เป็นซอฟต์แวร์ที่เทียบเท่ากับ "การวัดการตัดสองครั้งครั้งเดียว":

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

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


4

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

โดยทั่วไปสำหรับการทำงานของซอฟต์แวร์ที่ไม่ใช่เรื่องเล็ก ๆ น้อย ๆคาดว่าจะใช้เวลาส่วนใหญ่ในการบำรุงรักษาและการดีบัก หากคุณกำลังพัฒนาระบบซอฟต์แวร์ที่ใช้งานจริงและใช้เวลาน้อยกว่า 80-90% ของเวลาในการบำรุงรักษาและแก้ไขจุดบกพร่องคุณทำได้ดี!

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

TL; DR:มันฟังดูง่ายเหมือนว่าคุณอาจมีภาพที่ไม่สมจริงเล็กน้อยเกี่ยวกับการเขียนโปรแกรมระบบที่ไม่เกี่ยวกับซอฟต์แวร์ ส่วนใหญ่ของความพยายามในการ finetuning, การบำรุงรักษา, refactoring, แก้ไขข้อบกพร่องและโดยทั่วไปการทำสิ่งที่จะมาภายใต้ "การแก้จุดบกพร่อง" (การบำรุงรักษา) - อย่างน้อยในความรู้สึกทั่วไป - เมื่อเทียบกับการทำงานใหม่ทั้งหมดโดยสิ้นเชิง เขียนรหัสใหม่สด


2

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

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


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

2

การบูรณาการอย่างต่อเนื่อง (CI) คือคำตอบ

การรวมอย่างต่อเนื่อง = ระบบการจัดการการกำหนดค่า (ได้แก่ , Git, Mercurial, SVN, ฯลฯ ) + เครื่องมือ CI + การทดสอบหน่วย + การทดสอบควัน

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


1

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

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


1

การพัฒนาการทดสอบขับเคลื่อนสามารถช่วยลดเวลาในการดีบักได้โดย:

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

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


1

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

คุณควรคุ้นเคยกับการเขียนโค้ดที่สะอาดและลบนิสัยที่ไม่ดีเช่นการคัดลอกโค้ดและการเขียนวิธีการที่ยาวเป็นต้น

นอกจากนี้คุณควรปรับรหัสของคุณใหม่เป็นครั้งคราว ฉันแนะนำให้คุณอ่านหนังสือของ Martin Fowler: Refactoring: ปรับปรุงการออกแบบของรหัสที่มีอยู่


1

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

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

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


0

คำตอบที่ดีข้างต้น แต่ไม่มีใครพูดถึงโดยตรงเลย

อ่านอ่านอ่านอ่านและที่คลื่นไส้ ...

ยิ่งคุณรู้จักมากเท่าไหร่คุณก็ยิ่งไม่รู้น้อยเท่านั้น ค่อนข้างน่าเบื่อ แต่ก็ยังเป็นความจริงพื้นฐาน

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

มันเป็นปัญหาในการตัดสินใจออกแบบหรือไม่? อ่านข้อมูลเกี่ยวกับรูปแบบการออกแบบ

มันขาดความรู้เกี่ยวกับกรอบหรือภาษาหรือไม่? ลองคิดดูสิ!

ฯลฯ

มีสองสิ่งที่นักพัฒนา (สด) ไม่สามารถหลบหนีได้: เปลี่ยน (เฉพาะค่าคงที่ใน IT) และ RTFMing ...


0

การทดสอบหน่วยและยืนยัน

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

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


0

เมื่อคุณเริ่มโครงการคุณจะระบุแนวทางอื่นกี่วิธี

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

จากนั้นที่สำคัญที่สุดคุณลดน้ำหนักความเรียบง่ายที่มีความสำคัญเป็นอย่างยิ่งหรือไม่?

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

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


0

ทุกครั้งที่คุณแก้ไขข้อผิดพลาดคุณต้องการหลีกเลี่ยงการทำผิดพลาดซ้ำอีกครั้ง ในการทำเช่นนั้นคุณสามารถทำสิ่งต่อไปนี้:

  • จดบันทึกลงในบันทึกการบันทึกข้อบกพร่องซึ่งรวมถึง:

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

  • รวมกฎการเข้ารหัสที่ปลอดภัยไว้ในกระบวนการตรวจสอบโค้ดของคุณ

  • เห็นภาพการควบคุมและข้อมูล

อ้างอิง

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.