คำถามติดแท็ก code-quality

ในฐานะส่วนหนึ่งของการเขียน Iterator ฉันพบว่าตัวเองเขียนโค้ดต่อไปนี้ (การจัดการข้อผิดพลาดในการลอก) public T next() { try { return next; } finally { next = fetcher.fetchNext(next); } } พบว่าอ่านง่ายกว่าเล็กน้อย public T next() { T tmp = next; next = fetcher.fetchNext(next); return tmp; } ฉันรู้ว่ามันเป็นตัวอย่างง่ายๆที่ความแตกต่างของความสามารถในการอ่านอาจจะไม่มากนัก แต่ฉันสนใจในความคิดเห็นทั่วไปว่าไม่ดีที่จะลองใช้ในที่สุดในกรณีเช่นนี้ที่ไม่มีข้อยกเว้นที่เกี่ยวข้องหรือ ถ้ามันเป็นที่ต้องการจริง ๆ เมื่อมันลดความซับซ้อนของรหัส ถ้ามันไม่ดี: ทำไม สไตล์ประสิทธิภาพข้อผิดพลาด ... ? บทสรุป ขอบคุณคำตอบทั้งหมดของคุณ! ฉันเดาข้อสรุป (อย่างน้อยสำหรับฉัน) คือตัวอย่างแรกอาจอ่านง่ายกว่าถ้ามันเป็นรูปแบบทั่วไป …

30 java  code-quality  exceptions  readability 

คุณทำอะไรเมื่อคุณทำงานกับคนที่มีแนวโน้มที่จะเขียนโค้ดไม่ดีโวหาร รหัสที่ผมพูดถึงมักจะเป็นเทคนิคที่ถูกต้องมีโครงสร้างที่สมเหตุสมผลและแม้กระทั่งอาจจะสง่างามอัลกอริทึม แต่มันก็ดูน่าเกลียด เรามี: ส่วนผสมของอนุสัญญาการตั้งชื่อและชื่อที่แตกต่างกัน ( underscore_styleและcamelCaseและUpperCamelและCAPSทั้งหมดใช้มากหรือน้อยโดยการสุ่มกับตัวแปรต่าง ๆ ในฟังก์ชั่นเดียวกัน) ระยะห่างที่แปลกประหลาดและไม่สอดคล้องกันเช่น Functioncall (arg1 ,arg2,arg3 ); คำที่สะกดผิดจำนวนมากในความคิดเห็นและชื่อตัวแปร เรามีระบบตรวจสอบรหัสที่ดีที่ฉันทำงานอยู่ดังนั้นเราจะได้ตรวจสอบและแก้ไขสิ่งที่เลวร้ายที่สุด อย่างไรก็ตามมีความรู้สึกเล็กน้อยในการส่งบทวิจารณ์รหัสที่ประกอบด้วย 50 บรรทัดของ "เพิ่มช่องว่างที่นี่สะกด 'itarator' อย่างถูกต้องเปลี่ยนการใช้อักษรตัวพิมพ์ใหญ่นี้ ฯลฯ คุณจะสนับสนุนให้บุคคลนี้ระมัดระวังและสอดคล้องกับรายละเอียดเหล่านี้มากขึ้นอย่างไร

30 coding-style  code-quality  teamwork  code-reviews 

สมมติว่าฉันมีส่วนของรหัสเพื่อเชื่อมต่อกับอินเทอร์เน็ตและแสดงผลลัพธ์การเชื่อมต่อเช่น: HttpRequest* httpRequest=new HttpRequest(); httpRequest->setUrl("(some domain .com)"); httpRequest->setRequestType(HttpRequest::Type::POST); httpRequest->setRequestData("(something like name=?&age=30&...)"); httpRequest->setResponseCallback([=](HttpClient* client, HttpResponse* response){ string responseString=response->getResponseDataString(); if(response->getErrorCode()!=200){ if(response->getErrorCode()==404){ Alert* alert=new Alert(); alert->setFontSize(30); alert->setFontColor(255,255,255); alert->setPosition(Screen.MIDDLE); alert->show("Connection Error","Not Found"); }else if((some other different cases)){ (some other alert) }else Alert* alert=new Alert(); alert->setFontSize(30); alert->setPosition(Screen.MIDDLE); alert->setFontColor(255,255,255); alert->show("Connection Error","unknown error"); } }else{ (other handle …

29 object-oriented  code-quality 

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

29 code-quality  refactoring  clean-code  technical-debt 

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

28 code-quality  static-analysis  legacy-code 

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

28 design  programming-practices  coding-style  code-quality  performance 

มันเป็นไปได้ที่จะคาดหวังความคุ้มครองรหัส 100% ในการใช้งานเว็บ jquery / backbonejs หนัก? มันสมเหตุสมผลที่จะล้มเหลวในการวิ่งเนื่องจากความครอบคลุม 100% ไม่พบเมื่อครอบคลุมรหัสจริงวนเวียนอยู่รอบ ๆ 92% -95% ใน javascript / jquery?

28 code-quality  tdd  bdd 

ฉันจะไม่เรียกตัวเองว่าเป็นนักแสดงระดับแนวหน้า แต่เป็นคนที่ค่อนข้างมีประสบการณ์ ฉันพยายามที่จะรักษาคุณภาพของโค้ดให้อยู่ในระดับสูงและมองหาวิธีการปรับปรุงสไตล์การเขียนโค้ดของฉันอยู่เสมอพยายามที่จะทำให้โค้ดมีประสิทธิภาพอ่านง่ายและสม่ำเสมอรวมทั้งสนับสนุนให้ทีมทำตามรูปแบบและวิธีการ ฉันยังเข้าใจถึงความจำเป็นของความสมดุลระหว่างทั้งคุณภาพและความเร็ว เพื่อให้บรรลุเป้าหมายนี้ฉันได้แนะนำแนวคิดเรื่องการตรวจสอบโดยเพื่อนร่วมทีมของฉัน ยกนิ้วขึ้นสองนิ้วใน GitHub ดึงคำขอสำหรับการผสาน ยอดเยี่ยม - แต่ไม่ใช่ในความคิดของฉันหากปราศจากอาการสะอึก ฉันมักจะเห็นความเห็นทบทวนเพื่อนร่วมงานจากเพื่อนร่วมงานเดียวกันเช่น - คงจะเป็นการดีถ้าจะเพิ่มช่องว่างหลังจากนั้น <INSERT SOMETHING HERE> บรรทัดที่ไม่ต้องการพิเศษระหว่างเมธอด ควรใช้การหยุดแบบเต็มเมื่อสิ้นสุดความคิดเห็นใน docblock ตอนนี้จากมุมมองของฉัน - ผู้ตรวจทานมองเผินๆเกี่ยวกับความสวยงามของรหัส - และไม่ได้ทำการตรวจสอบโค้ด การตรวจสอบรหัสเครื่องสำอางทำให้ฉันมีความคิดที่หยิ่งผยอง / ชนชั้นนำ มันขาดสาร แต่คุณไม่สามารถจริงๆเถียงมากเกินไปกับมันเพราะวิจารณ์เป็นเทคนิคที่ถูกต้อง ฉันจะค่อนข้างจะเห็นน้อยกว่าความคิดเห็นประเภทข้างต้นและความคิดเห็นเพิ่มเติมดังนี้: คุณสามารถลดความซับซ้อนของวัฏจักรโดย ... ออกจากต้นและหลีกเลี่ยงถ้า / อื่น สรุปแบบสอบถาม DB ของคุณไปยังที่เก็บ ตรรกะนี้ไม่ได้อยู่ที่นี่จริงๆ อย่าทำซ้ำตัวเอง - นามธรรมและนำมาใช้ใหม่ อะไรจะเกิดขึ้นถ้าXถูกส่งผ่านเป็นอาร์กิวเมนต์วิธีY? การทดสอบหน่วยสำหรับสิ่งนี้อยู่ที่ไหน ฉันพบว่าเป็นคนประเภทเดียวกันที่ให้ความเห็นประเภทเครื่องสำอางและผู้คนประเภทเดียวกันซึ่งในความคิดเห็นของฉันให้ความเห็นแบบ "Quality & Logic" อะไรคือวิธีที่ถูกต้องในการตรวจสอบโดยเพื่อน …

27 code-quality  code-reviews  leadership 

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

27 project-management  unit-testing  code-quality  integration-testing 

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

27 development-process  code-quality  source-code  code-smell  code-ownership 

คำเตือน: ฉันเป็นผู้มาใหม่ (นี่เป็นวันที่สามของการทำงาน) และเพื่อนร่วมทีมส่วนใหญ่ของฉันมีประสบการณ์มากกว่าฉัน เมื่อฉันดูรหัสของฉันฉันเห็นกลิ่นของรหัสและวิธีปฏิบัติทางวิศวกรรมที่ไม่ดีเช่นดังต่อไปนี้: หลักเกณฑ์การตั้งชื่อค่อนข้างไม่สอดคล้องกัน คุณสมบัติไม่ถูกทำเครื่องหมายว่าอ่านได้อย่างเดียวเมื่อเป็นไปได้ คลาสขนาดใหญ่ - ฉันสังเกตเห็นคลาสยูทิลิตี้ที่ประกอบด้วยวิธีการขยายหลายร้อยรายการ (สำหรับหลายประเภท) มันยาวกว่า 2,500 บรรทัด! วิธีการขนาดใหญ่ - ฉันกำลังพยายามปรับวิธีการที่มีความยาว 150 บรรทัด สองหลังดูเหมือนจะเป็นปัญหาจริง ฉันต้องการโน้มน้าวให้เพื่อนร่วมทีมใช้คลาสและวิธีการที่เล็กลง แต่ฉันควรทำอย่างนั้น? ถ้าใช่แล้วได้อย่างไร ทีมของฉันได้รับที่ปรึกษาจากทีมหลัก (เราเป็นทีมดาวเทียม) ฉันควรไปหาเขาก่อนไหม UPDATE : เนื่องจากคำตอบบางอย่างถามเกี่ยวกับโครงการโปรดทราบว่าเป็นโครงการที่ทำงานได้ และ IMHO คลาส / วิธีการขนาดใหญ่นั้นไม่ดีเสมอไป ยังไงก็ตามฉันไม่ต้องการที่จะฉี่ทีมของฉันออก นั่นเป็นเหตุผลที่ฉันถาม - ฉันควรทำอย่างนั้นหรือไม่และถ้าใช่แล้วฉันจะทำอย่างนั้นเบา ๆ ? UPDATE : ฉันตัดสินใจที่จะทำบางสิ่งตามคำตอบที่ยอมรับ: เพราะฉันเป็นผู้มาใหม่ดังนั้นฉันจึงเห็นทุกอย่างใน "ตาสด" ฉันจะจดบันทึกทุกรหัสกลิ่นที่ฉันพบ (ตำแหน่งทำไมมันแย่เราจะทำอย่างไร ดีกว่า ... ) …

27 .net  code-quality  team  refactoring 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ตัวระบุสั้น ๆ ไม่ดีหรือไม่? ความยาวของตัวระบุมีความสัมพันธ์กับความเข้าใจโค้ดอย่างไร ปัจจัยอื่นใด (นอกเหนือจากความเข้าใจโค้ด) อาจมีการพิจารณาเมื่อพูดถึงตัวระบุชื่อ เพื่อพยายามรักษาคุณภาพของคำตอบโปรดทราบว่ามีงานวิจัยบางอย่างเกี่ยวกับเรื่องนี้อยู่แล้ว! แก้ไข อยากรู้ว่าทุกคนไม่คิดว่าความยาวนั้นมีความเกี่ยวข้องหรือมีแนวโน้มที่จะชอบตัวระบุที่ใหญ่กว่าเมื่อลิงก์ทั้งสองที่ฉันระบุระบุว่าตัวระบุขนาดใหญ่เป็นอันตราย! ลิงค์เสีย ลิงค์ด้านล่างชี้ไปที่งานวิจัยเกี่ยวกับเรื่องนี้ แต่ตอนนี้มันพังฉันไม่ได้มีสำเนาของกระดาษไว้กับฉันและฉันจำไม่ได้ว่ามันคืออะไร ฉันจะทิ้งไว้ที่นี่ในกรณีที่มีคนคิดออก http://evergreen.loyola.edu/chm/www/Papers/SCP2009.pdf

26 code-quality  coding-style 

ฉันได้พูดคุยกับเพื่อนร่วมงานเกี่ยวกับการทำลายreturnคำสั่งและคำสั่งที่คำนวณค่าส่งคืนในสองบรรทัด ตัวอย่างเช่น private string GetFormattedValue() { var formattedString = format != null ? string.Format(format, value) : value.ToString(); return formattedString; } แทน private string GetFormattedValue() { return format != null ? string.Format(format, value) : value.ToString(); } รหัสฉลาดฉันไม่เห็นคุณค่าในตัวแปรแรก สำหรับฉันหลังมีความชัดเจนโดยเฉพาะอย่างยิ่งสำหรับวิธีการที่สั้น ข้อโต้แย้งของเขาไม่ว่าอะไรก็ตามที่ตัวแปรในอดีตนั้นง่ายต่อการตรวจแก้จุดบกพร่อง - ซึ่งค่อนข้างจะเป็นข้อดีเล็กน้อยเนื่องจาก VisualStudio ช่วยให้เราสามารถตรวจสอบข้อความได้อย่างละเอียดมากเมื่อการดำเนินการหยุดลงเนื่องจากจุดแตกหัก คำถามของฉันคือถ้ามันยังคงเป็นจุดที่ถูกต้องในการเขียนรหัสที่ชัดเจนน้อยลงเพียงเพื่อให้การดีบักการเหลือบง่ายขึ้น? มีข้อโต้แย้งเพิ่มเติมสำหรับตัวแปรที่มีการคำนวณแยกและreturnคำสั่งหรือไม่

26 coding-style  code-quality  debugging 

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

26 c#  .net  code-quality  static-analysis 

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

26 programming-practices  code-quality