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

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

21 python  code-quality  modules 

ฉันมักจะใช้รูปแบบที่ฉันใช้วิธีการผูกมัดการตั้งค่าวัตถุคล้ายกับBuilderหรือPrototypeรูปแบบ แต่ไม่ได้สร้างวัตถุใหม่ที่มีการเรียกแต่ละวิธีแทนการปรับเปลี่ยนวัตถุเดิม ตัวอย่าง: new Menu().withItem("Eggs").withItem("Hash Browns").withStyle("Diner"); เพียงแค่สงสัยว่ามีชื่อสำหรับรูปแบบนี้หรือไม่และพิจารณาว่าเป็นรูปแบบการต่อต้านหรือไม่เพราะถึงแม้ว่ามันจะสามารถอ่านได้อย่างคล่องแคล่วมากขึ้นก็สามารถนำไปสู่โซ่วิธียาว

21 design-patterns  coding-style  code-quality  patterns-and-practices  method-chaining 

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

21 code-quality  future-proof 

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

21 version-control  code-quality 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ทางลัดภาษามักใช้เพื่อทำให้รหัสกระชับยิ่งขึ้น ตัวอย่างเช่นตัวดำเนินการ ternary และ null รวมตัวกันสามารถลดจำนวนของโค้ดได้ ใน C #: Person newGuy = new Person(); if (boss == null) { newGuy.Boss = GetDefaultBoss(); } else { newGuy.Boss = boss; } มีหน้าที่เทียบเท่ากับ: Person newGuy = new Person(); newGuy.Boss = boss ?? GetDefaultBoss(); แต่เห็นได้ชัดว่า verbose มากขึ้น …

21 code-quality  readability 

ฉันกำลังพูดถึงวิธีที่เราเขียนกิจวัตรง่าย ๆ เพื่อปรับปรุงประสิทธิภาพโดยไม่ทำให้โค้ดของคุณอ่านยากขึ้นตัวอย่างเช่นนี่เป็นเรื่องปกติสำหรับเราที่ได้เรียนรู้: for(int i = 0; i < collection.length(); i++ ){ // stuff here } แต่ฉันมักจะทำสิ่งนี้เมื่อforeachไม่สามารถใช้ได้: for(int i = 0, j = collection.length(); i < j; i++ ){ // stuff here } ฉันคิดว่านี่เป็นวิธีที่ดีกว่าเพราะจะเรียกlengthวิธีการนี้เพียงครั้งเดียว ... แฟนของฉันบอกว่ามันเป็นความลับ มีเคล็ดลับง่าย ๆ ที่คุณใช้ในการพัฒนาของคุณเอง?

21 code-quality  performance 

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

20 code-quality  coding-style 

หากฉันมีรหัสบางส่วนที่มีการทดสอบครอบคลุม 80% (การทดสอบทั้งหมดผ่าน) เป็นไปได้ไหมที่จะบอกว่ามันมีคุณภาพสูงกว่ารหัสที่ไม่มีการครอบคลุมการทดสอบหรือไม่ หรือมันยุติธรรมที่จะพูดว่ามันบำรุงรักษาได้มากขึ้น?

20 code-quality  test-coverage 

มีวัตถุประสงค์ในการประกาศinit()วิธีการสำหรับประเภทใด ๆ ? ฉันไม่ได้ถามว่าเราควรจะต้องการinit()มากกว่านวกรรมิกหรือวิธีการหลีกเลี่ยงการประกาศinit() ฉันถามว่ามีเหตุผลใด ๆ ที่อยู่เบื้องหลังการประกาศinit()วิธีการ (ดูว่ามันเป็นเรื่องธรรมดา) หรือไม่ถ้ามันเป็นกลิ่นรหัสและควรหลีกเลี่ยง init()สำนวนเป็นเรื่องธรรมดามาก แต่ผมยังไม่เห็นประโยชน์ที่แท้จริงใด ๆ ฉันกำลังพูดถึงประเภทที่สนับสนุนการเริ่มต้นด้วยวิธีการ: class Demo { public void init() { //... } } สิ่งนี้จะใช้ในรหัสการผลิตเมื่อใด ฉันรู้สึกว่ามันอาจจะเป็นกลิ่นรหัสเพราะมันบอกว่านวกรรมิกไม่เริ่มต้นวัตถุอย่างสมบูรณ์ทำให้วัตถุที่สร้างขึ้นบางส่วน วัตถุไม่ควรมีอยู่หากไม่ได้ตั้งสถานะ นี่ทำให้ฉันเชื่อว่ามันอาจเป็นส่วนหนึ่งของเทคนิคบางชนิดที่ใช้เพื่อเพิ่มความเร็วในการผลิตในแง่ของการใช้งานระดับองค์กร มันเป็นเหตุผลเดียวที่ฉันคิดได้ว่ามีสำนวนแบบนี้ฉันไม่แน่ใจว่ามันจะมีประโยชน์อย่างไรถ้าเป็นเช่นนั้น

20 java  object-oriented  object-oriented-design  code-quality  code-smell 

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

19 testing  code-quality  tdd  code-smell  assertions 

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

19 code-quality  static-analysis 

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

19 testing  code-quality  tdd  code-smell  dependency-injection 

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

18 java  programming-practices  testing  code-quality  source-code 

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

18 code-quality  static-analysis 

ฉันถูกขอให้ดูโครงการที่เสร็จสิ้นการพัฒนาหลักเมื่อห้าเดือนที่แล้ว แต่ก็ยังมีข้อบกพร่องในระดับสูง มีการแก้ไขข้อผิดพลาดอะไรบ้างประมาณ 10 ข้อเราเพิ่มอย่างน้อย 4 ข้อและในบางกรณี 8 ข้อบกพร่อง ฉันเชื่อว่าการเขียนโค้ดที่ผู้ขายไม่ดีและมีข้อตกลงทั่วไปเกี่ยวกับเรื่องนี้ อย่างไรก็ตามฉันสงสัยว่ามีปัญหาเชิงโครงสร้างกับซอฟต์แวร์หรือไม่ ความหนาแน่นของข้อบกพร่องเป็นวิธีการวัดที่มีประโยชน์ แต่ยิ่งถ้าซอฟต์แวร์หลักเขียนไม่ดีแล้วผู้ขายทั้งหมดที่ทำอยู่ก็กำลังเปลี่ยนปัญหาเกี่ยวกับ ในโครงสร้างพื้นฐานจะมีการกำหนดมากขึ้นหากมีสิ่งใดที่สร้างไม่ดีคุณสามารถใช้การวัดใดสำหรับซอฟต์แวร์ที่อยู่ข้างข้อบกพร่องต่อ LOC ผลิตภัณฑ์อยู่ในช่วงการซ่อมแซมข้อบกพร่องเป็นเวลา 4 เดือนและยังไม่สามารถแก้ไขข้อบกพร่องที่สำคัญได้เพียงพอ เราไม่ได้ฉีดฟังก์ชันการทำงานใหม่เพียงแก้ไขปัญหาการถดถอย สิ่งนี้บ่งบอกถึงปัญหาคุณภาพการพัฒนาที่ไม่เป็นที่พึงพอใจ อย่างไรก็ตามหากผลิตภัณฑ์มีข้อบกพร่องพื้นฐานนั่นคือปัญหาที่แตกต่างกัน ความกังวลเกี่ยวกับการเป็นฐานรหัสหลักได้รับการเขียนไม่ดีและมีเอกสาร จำกัด ผู้พัฒนาภายนอกทั้งหมดกำลังทำคือการเปลี่ยนปัญหาจาก A ถึง B เมื่อทีมพัฒนาภายในใช้เวลามากกว่าฉันกังวลว่าพวกเขาจะต้องเขียนรหัสใหม่เพื่อ ทำให้มันใช้งานได้ ดังนั้นเมื่อคุณยอมรับผลิตภัณฑ์จากบุคคลที่สามและถูกขอให้สนับสนุนผลิตภัณฑ์คุณจะใช้เกณฑ์การยอมรับใดในการกำหนดมาตรฐาน นอกเหนือจากการทำให้ผู้พัฒนานำของเราทำการตรวจทานโค้ดต่อรุ่นแล้วไม่แน่ใจว่าสามารถทำอะไรได้บ้าง

18 code-quality  metrics