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

ตัวอย่างด้านล่างเป็นสิ่งประดิษฐ์โดยสิ้นเชิงและจุดประสงค์เพียงอย่างเดียวคือเพื่อให้ได้จุดของฉัน สมมติว่าฉันมีตาราง SQL: CREATE TABLE rectangles ( width int, height int ); ระดับโดเมน: public class Rectangle { private int width; private int height; /* My business logic */ public int area() { return width * height; } } ตอนนี้สมมติว่าฉันมีความต้องการที่จะแสดงให้ผู้ใช้เห็นพื้นที่ทั้งหมดของรูปสี่เหลี่ยมผืนผ้าทั้งหมดในฐานข้อมูล ฉันสามารถทำได้โดยดึงแถวทั้งหมดของตารางเปลี่ยนเป็นวัตถุและวนซ้ำไปมา แต่มันดูโง่มากเพราะฉันมีรูปสี่เหลี่ยมผืนผ้ามากมายในตาราง ดังนั้นฉันทำสิ่งนี้: SELECT sum(r.width * r.height) FROM rectangles r ง่ายรวดเร็วและใช้จุดแข็งของฐานข้อมูล …

21 architecture  maintainability 

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

21 java  object-oriented  teamwork  communication  maintainability 

สมมติว่าคุณทำงานให้กับ บริษัท และสิ่งที่คุณทำคือการพัฒนาซอฟต์แวร์สำหรับพวกเขา คุณไม่มีความคิดในภาพรวมหรืออาจจะเล็กน้อย สิ่งที่คุณมีคืองานที่มอบหมายให้คุณผ่านระบบติดตามปัญหา คุณได้รับงานคุณทำให้งานเป็นไปตามที่งานอธิบายคุณส่งงานกลับมา ชอบเพิ่ม 2 จำนวนเต็ม: function add(a,b){return a + b;} แต่ต่อมาเมื่อโครงการดำเนินไปข้างหน้าคุณจะสังเกตเห็นว่าในขณะที่addมีความซับซ้อนมากขึ้นคุณรู้ว่ามันควรจะต้องมีรูปแบบของสถาปัตยกรรมมากกว่าฟังก์ชั่นที่เพิ่มพารามิเตอร์และส่งกลับค่า อย่างไรก็ตามคุณไม่ทราบว่า addในสถานที่แรกทั้งหมดที่พวกเขาต้องการก็คือง่ายๆที่ คุณไม่ได้คาดหวังว่าการเพิ่มจะซับซ้อนนัก โครงการดำเนินไปด้วยคุณสมบัติที่มากขึ้นซึ่งคุณไม่ได้คาดหวังไว้ตั้งแต่แรก และในที่สุดคุณก็เก็บซ้อนแฮ็คและเลเยอร์ตามเลเยอร์ของฟังก์ชั่นเพื่อหลีกเลี่ยงการทำลาย / เขียนรหัสที่มีอยู่ใหม่ คุณรับมือกับสถานการณ์เหล่านี้อย่างไร? คุณต่อสู้กับหนี้ทางเทคนิคในฐานะ "ผู้พัฒนาที่ต่ำที่สุด" ได้อย่างไร? ชี้แจง: คุณคือ "implementer" ซึ่งต่ำที่สุดในลำดับชั้น คุณเห็นปัญหา แต่ไม่ได้พูดกับเรื่องนี้ ฉันไม่ได้ระบุปริมาณหนี้ทางเทคนิคหรือมองหาเครื่องมือ เกี่ยวกับ"ซ้ำ" ที่สาม การ Refactoring & Rewrite - คุณถูกล็อคในงานของคุณ คุณไม่ได้รับค่าตอบแทนในการทำสิ่งพิเศษ ภาพรวมสถาปัตยกรรม - คุณรู้ระบบโดยรวม แต่ไม่มีแนวคิดเกี่ยวกับสถาปัตยกรรม Code Freeze - ไม่ใช่การโทรของคุณ …

20 architecture  software  scalability  maintainability  technical-debt 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว การบำรุงรักษาเป็นส่วนสำคัญของการพัฒนาซอฟต์แวร์มืออาชีพ อันที่จริงการบำรุงรักษาเกือบตลอดเวลาเป็นส่วนที่ยาวที่สุดของวัฏจักรชีวิตของซอฟต์แวร์เนื่องจากมันกินเวลาตั้งแต่การเปิดตัวโครงการจนถึงเวลาสิ้นสุด นอกจากนี้โครงการที่อยู่ระหว่างการบำรุงรักษาถือเป็นโครงการใหญ่โดยรวม ตามhttp://www.vlegaci.com/298/interesting-statistics-%E2%80%93-numbers-of-programmers-in-maintenance-vs-development/สัดส่วนของโครงการที่อยู่ในการบำรุงรักษาประมาณ 2 / 3 ฉันเพิ่งเจอคำถามนี้ที่ผู้ชายดูประหลาดใจสวยค้นพบว่างานของเขาส่วนใหญ่เกี่ยวกับการบำรุงรักษา ฉันจึงตัดสินใจเปิดการสนทนา (ภาษาฝรั่งเศส)บนเว็บไซต์หลักของชุมชนผู้เชี่ยวชาญด้านการพัฒนาซอฟต์แวร์ของฝรั่งเศส ( http://www.developpez.com/ ) การอภิปรายนี้มีชื่อว่า "นักเรียนได้รับการฝึกฝนอย่างดีพอกับความเป็นจริงของการพัฒนาซอฟต์แวร์มืออาชีพหรือไม่" และส่วนใหญ่เกี่ยวกับการบำรุงรักษา ชี้ให้เห็นว่าอย่างน้อยในฝรั่งเศสผู้คนไม่พร้อมที่จะเผชิญกับการบำรุงรักษาทั้งสองด้าน: รักษารหัสที่มีอยู่ ทำให้รหัสบำรุงรักษา คำถามของฉันที่นี่สะท้อนถึงการสนทนานี้และมุ่งหวังที่จะหาวิธีที่ดีในการสอนการบำรุงรักษา เราจะสอนการบำรุงรักษาได้อย่างไร คุณจะแนะนำการออกกำลังกายแบบไหน? หากคุณได้รับการฝึกอบรมอย่างดีเกี่ยวกับการบำรุงรักษาหลักสูตรใดที่คุณเรียนโดยเฉพาะ [แก้ไข] หลังจากความเข้าใจผิดฉันคิดว่าฉันต้องชี้แจงคำถามของฉัน ในฐานะผู้นำโครงการและนักพัฒนาซอฟต์แวร์ฉันมักทำงานกับผู้ฝึกอบรมหรือนักเรียนที่เพิ่งจบใหม่ ฉันจบการศึกษาครั้งใหม่ด้วยตัวเอง สิ่งที่นักเรียนมักจะไม่คุ้นเคยกับหลักการเช่น SOLID ที่เพิ่มการบำรุงรักษาของโครงการ บ่อยครั้งที่เราประสบปัญหาที่สำคัญในการพัฒนาโครงการ (การบำรุงรักษาต่ำ) สิ่งที่ฉันกำลังมองหาที่นี่คือตัวอย่างที่เป็นรูปธรรมของการสอนที่ประสบความสำเร็จเกี่ยวกับความสำคัญของการบำรุงรักษาและวิธีการสร้างรหัสที่ดีขึ้นเกี่ยวกับประเด็นนี้โดยเฉพาะ หรือข้อเสนอแนะที่เป็นไปได้เพื่อปรับปรุงวิธีการฝึกอบรมของนักเรียน

18 programming-practices  education  maintenance  maintainability 

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

17 java  documentation  source-code  comments  maintainability 

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

16 unit-testing  language-agnostic  user-interface  maintainability 

พื้นหลัง ฉันกำลังทำงานในโครงการ C # ต่อเนื่อง ฉันไม่ใช่โปรแกรมเมอร์ C # ซึ่งส่วนใหญ่เป็นโปรแกรมเมอร์ C ++ ดังนั้นฉันจึงได้รับมอบหมายงานที่ง่ายและเป็นโครงสร้างใหม่ รหัสเป็นระเบียบ มันเป็นโครงการขนาดใหญ่ เนื่องจากลูกค้าของเราเรียกร้องให้มีการเปิดตัวคุณสมบัติใหม่ ๆ และการแก้ไขข้อผิดพลาดบ่อยครั้งนักพัฒนาอื่น ๆ ทั้งหมดจึงถูกบังคับให้ใช้วิธีการเดรัจฉานบังคับในขณะที่เข้ารหัส รหัสไม่สามารถรักษาได้สูงนักและผู้พัฒนารายอื่นก็เห็นด้วย ฉันไม่ได้มาที่นี่เพื่ออภิปรายว่าพวกเขาทำถูกหรือไม่ ขณะที่ฉันกำลังปรับโครงสร้างใหม่ฉันสงสัยว่าฉันกำลังทำอย่างถูกวิธีเพราะรหัสการปรับโครงสร้างใหม่ของฉันดูเหมือนจะซับซ้อน! นี่คืองานของฉันเป็นตัวอย่างง่ายๆ ปัญหา มีหกชั้นเรียน: A, B, C, D, และE ทุกชั้นเรียนมีฟังก์ชั่นF ExecJob()การใช้งานทั้งหกแบบนั้นคล้ายคลึงกันมาก โดยทั่วไปในตอนแรกA::ExecJob()เขียน จากนั้นรุ่นที่แตกต่างกันเล็กน้อยที่ถูกต้องซึ่งได้ดำเนินการในB::ExecJob()โดย A::ExecJob()copy-paste-การเปลี่ยนแปลงของ เมื่อจำเป็นต้องใช้เวอร์ชันอื่นที่แตกต่างกันเล็กน้อยC::ExecJob()เขียนขึ้นและต่อไป การใช้งานทั้งหกมีรหัสทั่วไปบางส่วนจากนั้นบางบรรทัดที่แตกต่างกันรหัสแล้วอีกบางรหัสทั่วไปและอื่น ๆ นี่เป็นตัวอย่างง่ายๆของการใช้งาน: A::ExecJob() { S1; S2; S3; S4; S5; } B::ExecJob() { S1; …

16 self-improvement  refactoring  maintainability 

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

12 code-quality  maintainability 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน6 ปีที่ผ่านมา ฉันเป็นผู้สนับสนุนให้ความเห็นเกี่ยวกับซอร์สโค้ดและการทำเอกสารผลิตภัณฑ์ซอฟต์แวร์ มันเป็นประสบการณ์ส่วนตัวและการสังเกตของฉันว่าการทำงานกับซอร์สโค้ดที่แสดงความคิดเห็นอย่างจริงจังได้ช่วยฉันในรูปแบบที่แตกต่างกันเมื่อฉันต้องเติบโตซอฟต์แวร์หรือบำรุงรักษามัน อย่างไรก็ตามมีอีกค่ายหนึ่งที่กล่าวว่าการแสดงความคิดเห็นนั้นไร้ค่าในที่สุดหรือคุณค่าของมันนั้นน่าสงสัย ผู้เสนอการเข้ารหัสจำนวนมากโดยไม่แสดงความเห็นแย้งว่า: หากโค้ดหนึ่งชิ้นเขียนได้ดีก็จะเป็นการอธิบายตนเองและไม่จำเป็นต้องแสดงความคิดเห็น หากโค้ดหนึ่งชิ้นไม่สามารถอธิบายตัวเองได้ให้ทำการรีแฟคเตอร์ใหม่และทำให้มันอธิบายได้ด้วยตนเองเพื่อที่ว่ามันจะไม่ต้องการความคิดเห็นใด ๆ ชุดทดสอบของคุณคือเอกสารสด เมื่อเวลาผ่านไปรหัสและความคิดเห็นไม่ซิงค์กันและจะกลายเป็นแหล่งที่มาของอาการปวดหัว Agile กล่าวว่ารหัสการทำงานสำคัญกว่ากองเอกสารดังนั้นเราจึงสามารถละเว้นการเขียนความคิดเห็นได้อย่างปลอดภัย สำหรับฉันนี่เป็นเพียงความเชื่อ อีกครั้งการสังเกตส่วนตัวของฉันคือซอฟต์แวร์ที่เขียนโดยทีมนักพัฒนาที่ชาญฉลาดและมีประสบการณ์ท้ายที่สุดก็จบลงด้วยรหัสจำนวนมากที่ไม่ได้อธิบายตัวเอง อีกครั้งที่ Java API, Cocoa API, Android API ฯลฯ แสดงว่าหากคุณต้องการเขียนและดูแลรักษาเอกสารที่มีคุณภาพเป็นไปได้ การพูดถึงสิ่งเหล่านี้การสนทนาเกี่ยวกับข้อดีข้อเสียของการจัดทำเอกสารและการแสดงความคิดเห็นในซอร์สโค้ดที่อิงตามความเชื่อส่วนตัวมักจะไม่จบลงและนำไปสู่ข้อสรุปที่ไม่พึงพอใจ ดังนั้นฉันกำลังมองหาเอกสารทางวิชาการและการศึกษาเชิงประจักษ์เกี่ยวกับผลกระทบของเอกสารประกอบซอฟต์แวร์โดยเฉพาะการแสดงความคิดเห็นซอร์สโค้ดต่อคุณภาพและการบำรุงรักษารวมถึงผลกระทบต่อประสิทธิภาพการทำงานของทีม คุณได้สะดุดกับบทความดังกล่าวและสิ่งที่เป็นผลของพวกเขาถ้ามี?

11 productivity  documentation  code-quality  maintainability  engineering 

สิ่งใดที่จะถือว่าได้รับการบำรุงรักษามากขึ้น if (a == b) c = true; else c = false; หรือ c = (a == b); ฉันลองดูใน Code Complete แต่ไม่พบคำตอบ ฉันคิดว่าอันแรกสามารถอ่านได้มากขึ้น (คุณสามารถอ่านออกเสียงออกมาได้ดัง ๆ ) ซึ่งฉันคิดว่าทำให้สามารถบำรุงรักษาได้มากขึ้น อันที่สองมีความเหมาะสมมากกว่าและลดรหัส แต่ฉันไม่แน่ใจว่ามันจะบำรุงรักษาได้สำหรับนักพัฒนา C # (ฉันคาดว่าจะเห็นสำนวนนี้มากขึ้นเช่น Python)

11 .net  code-quality  readability  maintainability  clean-code 

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

11 testing  refactoring  decisions  maintainability  scope 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันเจอเงื่อนไขต่อไปนี้ในโปรแกรมที่ฉันได้ยึดครองจากผู้พัฒนารายอื่น: if (obj.Performance <= LOW_PERFORMANCE) { obj.NeedsChange = true; } else { obj.NeedsChange = false; } ฉันเชื่อว่ารหัสนี้ซ้ำซ้อนและน่าเกลียดดังนั้นฉันจึงเปลี่ยนเป็นสิ่งที่ฉันคิดว่าเป็นการมอบหมายบูลีนอย่างง่ายจากการเปรียบเทียบ: obj.NeedsChange = obj.Performance <= LOW_PERFORMANCE; เมื่อเห็นสิ่งนี้มีคนกำลังตรวจสอบรหัสของฉันแสดงความคิดเห็นว่าแม้ว่าการเปลี่ยนแปลงของฉันจะถูกต้องตามหน้าที่ แต่อาจทำให้ผู้อื่นดูสับสน เขาเชื่อว่าการใช้ผู้ประกอบการสามคนทำให้การบ้านนี้ชัดเจนยิ่งขึ้นในขณะที่ฉันไม่ชอบการเพิ่มรหัสซ้ำซ้อนเพิ่มเติม: obj.NeedsChange = (obj.Performance <= LOW_PERFORMANCE) ? true : false; เหตุผลของเขาคือการทำบางสิ่งด้วยวิธีที่รัดกุมที่สุดนั้นไม่คุ้มค่าถ้ามันทำให้ผู้พัฒนารายอื่นต้องหยุดและไขปริศนาสิ่งที่คุณทำ คำถามจริงที่นี่คือวิธีใดในสามวิธีในการกำหนดค่าให้กับบูลีนobj.NeedsChangeที่ชัดเจนที่สุดและสามารถบำรุงรักษาได้มากที่สุด

10 clean-code  maintainability  boolean 

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

10 programming-practices  git  project  maintainability 

ในกรอบแอปพลิเคชันเมื่อผลกระทบต่อประสิทธิภาพการทำงานสามารถถูกเพิกเฉยได้ (10-20 เหตุการณ์ต่อวินาทีสูงสุด) อะไรคือการบำรุงรักษาและความยืดหยุ่นในการใช้เป็นสื่อที่ต้องการสำหรับการสื่อสารระหว่างโมดูล - เหตุการณ์หรืออนาคต / สัญญา / Monads ? บ่อยครั้งที่มีการกล่าวกันว่ากิจกรรม (pub / sub, ผู้ไกล่เกลี่ย) อนุญาตให้มีเพศสัมพันธ์แบบหลวม ๆ - แอปที่บำรุงรักษาได้ดีกว่า ... ประสบการณ์ของฉันปฏิเสธสิ่งนี้: เมื่อคุณมีเหตุการณ์มากกว่า 20 เหตุการณ์ - การแก้ไขข้อบกพร่องกลายเป็นเรื่องยาก เพราะมันยากมากที่จะเห็น: ใครเมื่อไหร่และทำไมใช้อะไร สัญญา (ฉันกำลังเข้ารหัสใน Javascript) มีความน่าเกลียดและโง่กว่าเหตุการณ์มาก แต่: คุณสามารถเห็นการเชื่อมต่อระหว่างการเรียกใช้ฟังก์ชั่นได้อย่างชัดเจนดังนั้นตรรกะของแอปพลิเคชันจะกลายเป็นสิ่งที่ตรงไปตรงมามากขึ้น สิ่งที่ฉันกลัว แม้ว่าจะเป็นสัญญาที่จะนำการแต่งงานที่ยากขึ้นกับพวกเขา ... ป.ล. : คำตอบไม่จำเป็นต้องอิงจาก JS ประสบการณ์จากภาษาอื่น ๆ ที่ใช้งานได้ดี

10 architecture  maintainability  async  event-programming  monad 

ฉันมีอัลกอริธึมเข้มข้นแบบลอจิคัลที่ฉันต้องการรหัสในสองภาษา (จริง ๆ แล้วฉันเสร็จในภาษาหนึ่งที่น่าพอใจและกำลังจะเริ่มเขียนโค้ดในภาษาอื่น) โดยความเข้มข้นของลอจิกผมหมายถึงอัลกอริทึมนั้นไม่สำคัญต้องมีความเข้าใจอย่างรอบคอบและที่สำคัญอาจมีข้อบกพร่อง (เนื่องจากความซับซ้อนและความประมาทคุณรู้) ซึ่งจะต้องได้รับการแก้ไขในอนาคต นอกจากนี้ฉันต้องการตรวจสอบให้แน่ใจว่าเมื่อรหัสนี้เปลี่ยนมือในที่สุดจะต้องไม่ครอบงำโปรแกรมเมอร์ใหม่ ในสถานการณ์นี้วิธีใดบ้างที่จะช่วยรักษาฐานรหัสและทำให้ข้อมูลตรงกัน ฉันหมายถึงเครื่องมือซอฟต์แวร์แนวปฏิบัติที่ดีที่สุด ฯลฯ FYI ทั้งสองภาษาคือ C ++ และ Java C ++ สำหรับ Windows / Linux และ Java สำหรับ "ทุกอย่างอื่น" รวมถึง Android

10 maintenance  maintainability