คำถามติดแท็ก debugging

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

267 testing  teamwork  debugging  bug 

ฉันเพิ่งเริ่มงานใหม่เมื่อไม่นานมานี้ซึ่งฉันกำลังทำงานกับแอปพลิเคชันขนาดใหญ่มาก (15M loc) ในงานก่อนหน้าของฉันเรามีแอปพลิเคชั่นขนาดใหญ่คล้าย ๆ กัน แต่ (เพื่อให้ดีขึ้นหรือแย่ลง) เราใช้ OSGi ซึ่งหมายความว่าแอปพลิเคชันนั้นถูกแบ่งออกเป็นไมโครไซต์จำนวนมากที่สามารถเปลี่ยนแปลงรวบรวมและนำไปใช้ได้อย่างอิสระ แอปพลิเคชันใหม่เป็นเพียงฐานรหัสขนาดใหญ่เพียงฐานเดียว ดังนั้นฉันจึงต้องเปลี่ยนอินเทอร์เฟซของคลาสนี้เพราะนั่นคือสิ่งที่เจ้านายของฉันขอให้ฉันทำ ตอนแรกพวกเขาเขียนด้วยสมมติฐานบางอย่างที่ไม่ได้พูดคุยกันดีเกินไปและในขณะที่พวกเขาหลีกเลี่ยงปัญหาของการปรับโครงสร้างใหม่เพราะมันเชื่อมโยงอย่างแน่นหนา ฉันเปลี่ยนอินเทอร์เฟซและตอนนี้มีข้อผิดพลาดมากกว่า 25,000 ข้อ ข้อผิดพลาดบางอย่างอยู่ในคลาสที่มีชื่อการทำให้เกิดเสียงที่สำคัญเช่น "XYZPriceCalculator" ซึ่งได้รับการตรวจสอบใหม่ไม่ควรทำลาย แต่ฉันไม่สามารถเริ่มแอปพลิเคชันเพื่อตรวจสอบว่ามันทำงานได้หรือไม่จนกว่าข้อผิดพลาดทั้งหมดจะได้รับการแก้ไข และหน่วยทดสอบจำนวนมากทดสอบโดยตรงว่าอินเตอร์เฟสหรือเชื่อมต่อกับคลาสพื้นฐานซึ่งอ้างอิงอินเตอร์เฟสนั้นดังนั้นการแก้ไขสิ่งเหล่านั้นจึงเป็นงานที่ใหญ่มากในตัวมันเอง นอกจากนี้ฉันไม่ทราบว่าชิ้นส่วนเหล่านี้เข้ากันได้อย่างไรดังนั้นแม้ว่าฉันจะเริ่มต้นได้ฉันก็ไม่รู้จริงๆว่ามันจะเป็นอย่างไรถ้าสิ่งต่าง ๆ แตกหัก ฉันไม่เคยประสบปัญหาเช่นนี้ในงานสุดท้ายของฉัน ฉันจะทำอย่างไร

166 interfaces  debugging  coupling  errors 

เจ้านายของฉันเพิ่งบอกฉันว่าฉันจะได้รับการตรวจสอบประสิทธิภาพเชิงลบในวันจันทร์ เขาต้องการพูดคุยกับฉันเกี่ยวกับสาเหตุที่ฉันช้ามากและทำไมอัตราการแก้ไขข้อบกพร่องของฉันจึงต่ำมาก ฉันรักการเขียนโปรแกรมและการแก้ปัญหา แต่จริง ๆ แล้วฉันหางานของฉันได้ยากจริงๆ ฉันเป็นโปรแกรมเมอร์มาประมาณ 10 ปีแล้ว แต่นี่เป็นงานลินุกซ์ฝังตัวแบบมัลติเธรดครั้งแรกของฉัน - ฉันอยู่ที่นี่มา 2 ปีแล้วและเห็นได้ชัดว่าทุกคนยังคงดิ้นรนอยู่ และฉันคิดว่าฉันกลายเป็นคนขวัญเสียและรู้สึกว่าด้อยโอกาสฉันได้สูญเสียไฟจำนวนมากที่เกิดขึ้นตอนเริ่มงาน มีใครเคยอยู่ในสถานการณ์ที่คล้ายคลึงกันและคุณจะเพิ่มอัตราการแก้ไขข้อบกพร่องอย่างไร? อัปเดต: ฉันมีความเห็น ฉันได้รับ 'โปรแกรมการพัฒนาพนักงาน' 3 เดือน (ประเภทที่ Dunk กล่าวถึง) ไม่แน่ใจว่าฉันจะหันไปทางนี้ได้ไหม แต่ถึงแม้ว่าฉันต้องเดินหน้าต่อไปฉันก็ได้เรียนรู้มากมายจากประสบการณ์นี้ การปรับปรุงอื่น ตอนนี้ประมาณ 6 สัปดาห์ตั้งแต่รีวิวครั้งแรก คำแนะนำของฉันกับทุกคนที่เผชิญสถานการณ์เดียวกันคือการอ่อนน้อมถ่อมตนพอที่จะวิจารณ์และเรียนรู้จากความผิดพลาด และไม่ต้องกลัวที่จะดูโง่ ถามคำถามมากมาย บอกให้ทุกคนรู้ว่าคุณกำลังพยายามเรียนรู้และถามต่อไปจนกว่าคุณจะเข้าใจ แต่ต้องเตรียมพร้อมสำหรับมันที่จะไม่ออกไปทำงาน ฉันกำลังสร้างแฟ้มสะสมผลงานของรหัส ... รวมทั้งให้ภาพที่ดีที่สุดของฉัน ยังเป็นอีกหนึ่งการปรับปรุง ฉันลังเลที่จะใส่สิ่งนี้ไว้ที่นี่เนื่องจากฉันกังวลว่าฉันจะไม่สามารถอ้างถึงนายจ้างในอนาคตไปยังโปรไฟล์สแต็คโอเวอร์โฟลว์ของฉัน ... แต่อย่างไรก็ตามมันอาจจะเป็นที่สนใจสำหรับใครบางคนที่อ่านคำถามนี้ งานไม่กี่สัปดาห์ที่ผ่านมา ฉันอยู่ท่ามกลางการแปรงของทักษะทั้งหมดที่ฉันต้องการ - ฉันได้รับมากจากคำแนะนำที่ได้รับที่นี่

129 career-development  debugging  bug 

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

101 debugging 

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

70 testing  debugging  bug  technical-support  defect 

ทุกครั้งที่ฉันมองหา IDE (ปัจจุบันฉันกำลังใช้งาน Go) ฉันจะพบกระทู้ที่เต็มไปด้วยผู้คนที่แนะนำ Vi, Emacs, Notepad ++ เป็นต้น ฉันไม่เคยทำการพัฒนาใด ๆ นอกเหนือจาก IDE; ฉันคิดว่าฉันใจแตก คุณจะดีบักโดยไม่มี IDE ได้อย่างไร คุณ จำกัด การเข้าสู่ระบบหรือไม่?

61 ide  debugging 

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

59 testing  debugging 

gdb นำการสนับสนุนสำหรับการดีบักแบบย้อนกลับในปี 2009 (ด้วย gdb 7.0) ฉันไม่เคยได้ยินมาก่อนจนกระทั่งปี 2012 ตอนนี้ฉันพบว่ามีประโยชน์อย่างมากสำหรับปัญหาการดีบักบางประเภท ฉันหวังว่าฉันเคยได้ยินมาก่อน แก้ไขให้ถูกต้องหากฉันผิด แต่ความประทับใจของฉันคือเทคนิคยังไม่ค่อยมีใครใช้และคนส่วนใหญ่ไม่รู้ว่ามีอยู่จริง ทำไม? คุณรู้จักชุมชนการเขียนโปรแกรมใด ๆ ที่มีการใช้การดีบักแบบย้อนกลับหรือไม่? ข้อมูลพื้นฐาน: Stackoverflow: การดีบักแบบย้อนกลับทำงานอย่างไร gdb ใช้คำว่า "reverse debugging" แต่ผู้ขายรายอื่นใช้คำอื่น ๆ สำหรับเทคนิคที่เหมือนกันหรือคล้ายกัน: Microsoft เรียกมันว่าIntelliTraceหรือ "Historical Debugging" มี Java reverse debugger ที่เรียกว่าOmniscient Debuggerแม้ว่ามันอาจจะไม่ทำงานใน Java 6 อีกต่อไป มีตัวแก้ไขการย้อนกลับ Java อื่น ๆ ดีบักเกอร์ของ OCaml (ocamldebug) เรียกมันว่าการเดินทางข้ามเวลา

56 debugging 

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

53 unit-testing  tdd  debugging 

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

48 interview  skills  debugging 

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

45 testing  development-process  debugging 

ฉันได้พัฒนาระบบที่เกิดขึ้นพร้อมกันมาหลายปีแล้วและฉันก็เข้าใจดีในเรื่องนี้แม้จะขาดการฝึกอบรมอย่างเป็นทางการ (เช่นไม่มีระดับ) มีภาษาใหม่ไม่กี่ภาษาที่ได้รับความนิยมอย่างน้อยพูดถึงเมื่อเร็ว ๆ นี้ซึ่งได้รับการออกแบบมาเพื่อทำให้การทำงานพร้อมกันง่ายขึ้นเช่น Erlang และ Go ดูเหมือนว่าวิธีการของพวกเขาในการทำงานพร้อมกันนั้นสะท้อนถึงประสบการณ์ของฉันเองว่าจะทำให้ระบบปรับขนาดได้และใช้ประโยชน์จากหลายคอร์ / โปรเซสเซอร์ / เครื่อง อย่างไรก็ตามฉันพบว่ามีเครื่องมือน้อยมากที่จะช่วยให้เห็นภาพสิ่งที่คุณตั้งใจจะทำและยืนยันว่าอย่างน้อยคุณก็ใกล้เคียงกับวิสัยทัศน์ดั้งเดิมของคุณ การดีบักโค้ดที่เกิดขึ้นพร้อมกันอาจเป็นฝันร้ายที่มีภาษาที่ไม่ได้ออกแบบมาสำหรับการทำงานพร้อมกัน (เช่น C / C ++, C #, Java, ฯลฯ ) โดยเฉพาะอย่างยิ่งมันเป็นไปไม่ได้ที่จะสร้างเงื่อนไขที่เกิดขึ้นใหม่ในระบบเดียวในสภาพแวดล้อมการพัฒนาของคุณ ดังนั้นอะไรคือแนวทางของคุณในการออกแบบระบบเพื่อจัดการกับการทำงานพร้อมกันและการประมวลผลแบบขนาน? ตัวอย่าง: คุณคิดได้อย่างไรว่าอะไรจะเกิดขึ้นพร้อมกันกับสิ่งที่ต้องเรียงตามลำดับ? คุณจะสร้างเงื่อนไขข้อผิดพลาดและดูว่าเกิดอะไรขึ้นเมื่อแอปพลิเคชันดำเนินการอย่างไร คุณเห็นภาพปฏิสัมพันธ์ระหว่างส่วนต่าง ๆ ที่เกิดขึ้นพร้อมกันของแอปพลิเคชันอย่างไร ฉันมีคำตอบของตัวเองสำหรับสิ่งเหล่านี้ แต่ฉันก็ต้องการที่จะเรียนรู้เพิ่มเติมอีกเล็กน้อย แก้ไข จนถึงตอนนี้เรามีข้อมูลที่ดีมากมาย บทความหลายบทความที่เชื่อมโยงนั้นดีมากและฉันได้อ่านมาแล้วบางส่วน ประสบการณ์ส่วนตัวของฉันกับการเขียนโปรแกรมพร้อมกันทำให้ฉันเชื่อว่าคุณต้องการความคิดที่แตกต่างจากการเขียนโปรแกรมตามลำดับ ความแตกแยกทางจิตใจนั้นกว้างพอ ๆ กับความแตกต่างระหว่างการเขียนโปรแกรมเชิงวัตถุและการโปรแกรมเชิงกระบวนวิธี ฉันต้องการชุดคำถามนี้เพื่อมุ่งเน้นที่กระบวนการคิดที่จำเป็น (เช่นทฤษฎี) เพื่อเข้าหาคำตอบอย่างเป็นระบบ เมื่อให้คำตอบที่เป็นรูปธรรมมากขึ้นมันจะช่วยยกตัวอย่าง - สิ่งที่คุณต้องผ่านเป็นการส่วนตัว เป้าหมายสำหรับค่าหัว อย่าบอกฉันว่าฉันควรทำอย่างไร …

37 design  debugging  parallelism  concurrency 

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

35 debugging 

ฉันเป็นแฟนตัวยงของการassertตรวจสอบการเขียนในรหัส C ++ เป็นวิธีการตรวจสอบกรณีในระหว่างการพัฒนาที่ไม่สามารถเกิดขึ้นได้ แต่จะเกิดขึ้นเพราะข้อบกพร่องตรรกะในโปรแกรมของฉัน เป็นการปฏิบัติที่ดีโดยทั่วไป อย่างไรก็ตามฉันสังเกตเห็นว่าบางฟังก์ชั่นที่ฉันเขียน (ซึ่งเป็นส่วนหนึ่งของคลาสที่ซับซ้อน) มีการยืนยันมากกว่า 5+ ครั้งซึ่งรู้สึกว่ามันอาจเป็นการฝึกเขียนโปรแกรมที่ไม่ดีในแง่ของความสามารถในการอ่านและการบำรุงรักษา ฉันคิดว่ามันยังยอดเยี่ยมเพราะแต่ละคนต้องการให้ฉันคิดเกี่ยวกับฟังก์ชั่นก่อนและหลังการทำงานและพวกเขาช่วยดักจับแมลง อย่างไรก็ตามฉันแค่อยากจะเอามันออกไปถามว่ามีกระบวนทัศน์ที่ดีกว่าสำหรับการจับข้อผิดพลาดทางตรรกะในกรณีที่จำเป็นต้องใช้เช็คจำนวนมากหรือไม่ ความเห็นของ Emacs : เนื่องจาก Emacs เป็นตัวเลือกของฉันฉันจึงขอแสดงความคิดเห็นเล็กน้อยซึ่งช่วยลดความรู้สึกรกรุงรังที่พวกเขาสามารถให้ได้ นี่คือสิ่งที่ฉันเพิ่มลงในไฟล์. emacs ของฉัน: ; gray out the "assert(...)" wrapper (add-hook 'c-mode-common-hook (lambda () (font-lock-add-keywords nil '(("\\<\\(assert\(.*\);\\)" 1 '(:foreground "#444444") t))))) ; gray out the stuff inside parenthesis with a slightly lighter …

33 c++  debugging  error-handling  assertions 

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

33 debugging