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

พื้นหลัง ฉันกำลังทำงานในโครงการ 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 

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

16 refactoring  skills  bad-code  reinventing-the-wheel 

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

16 refactoring 

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

15 testing  refactoring  tdd  legacy-code 

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

15 programming-practices  refactoring  anti-patterns  regular-expressions  single-responsibility 

ปัญหา สมมติว่าฉันมีคลาสที่เรียกว่าDataSourceมีReadDataวิธี (และบางทีคนอื่น ๆ แต่ให้สิ่งที่ง่าย) เพื่ออ่านข้อมูลจาก.mdbไฟล์: var source = new DataSource("myFile.mdb"); var data = source.ReadData(); ไม่กี่ปีต่อมาฉันตัดสินใจว่าฉันต้องการให้สามารถรองรับ.xmlไฟล์เพิ่มเติมจาก.mdbไฟล์เป็นแหล่งข้อมูล การนำไปใช้สำหรับ "การอ่านข้อมูล" นั้นค่อนข้างแตกต่างกันสำหรับ.xmlและ.mdbไฟล์ ดังนั้นถ้าฉันจะออกแบบระบบตั้งแต่เริ่มต้นฉันจะนิยามมันดังนี้: abstract class DataSource { abstract Data ReadData(); static DataSource OpenDataSource(string fileName) { // return MdbDataSource or XmlDataSource, as appropriate } } class MdbDataSource : DataSource { override Data ReadData() { …

15 c#  design-patterns  refactoring  factory-method 

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

15 project-management  refactoring  issue-tracking 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว บริบท: มันเป็นโครงการภายใน (ที่ฉันไม่คิดว่ามีผู้ใช้งานมากมาย) มันเก่า เรากำลังอัพเดท ประเด็น: มันละเมิดเฟรมเวิร์ก mvc (ไม่ใช้รุ่น, ตรรกะทางธุรกิจในมุมมอง, ฯลฯ ) สิ่งที่เรากำลังขอให้ทำมีขนาดเล็ก แต่เนื่องจากการติดต่อกันต่ำเรามีสองตัวเลือก: ทำสิ่งต่อไปให้เรียบร้อย ย้ายชิ้นโค้ดขนาดใหญ่ไปรอบ ๆ หรือเขียนสิ่งใหม่ การแก้ปัญหา (ฉันเห็น): ทำงานกับมันต่อไปอย่าเพิกเฉยแนวปฏิบัติที่ดีที่สุดเพื่อไม่ให้ถูกทำเร็ว ๆ นี้และไม่แนะนำข้อบกพร่องใหม่ด้วยการเปลี่ยน / เขียนใหม่ refactor / เขียน ฉันเดาว่าคำถามของฉันเป็นจริง: ถ้าฉันต้องการเปลี่ยนแปลงโครงการขนาดใหญ่ฉันจะเสนอได้อย่างไรโดยไม่ดูถูกใคร หรือมันจะดีกว่าถ้าฉันจะไปกับการไหลแม้ว่าบางครั้งจะหมายถึง (อุปมา) ท่อเทป?

15 refactoring  communication  internship  rewrite 

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

15 code-quality  bad-code  refactoring  maintenance 

สมมติว่าเรามีลูกค้า 1001 รายที่สร้างการพึ่งพาโดยตรงแทนที่จะยอมรับการฉีด Refactoring the 1001 ไม่ใช่ตัวเลือกตามที่เจ้านายของเรา จริงๆแล้วเราไม่ได้รับอนุญาตให้เข้าถึงแหล่งข้อมูลของพวกเขาเพียงแค่ไฟล์คลาส สิ่งที่เราควรจะทำคือ "ปรับปรุง" ระบบที่ลูกค้า 1001 เหล่านี้ผ่านให้ได้ เราสามารถ refactor ที่เราชอบ การพึ่งพาเป็นส่วนหนึ่งของระบบนั้น และการพึ่งพาเหล่านั้นบางอย่างเราควรเปลี่ยนไปใช้การติดตั้งใหม่ สิ่งที่เราต้องการจะทำคือมีความสามารถในการกำหนดค่าการใช้งานที่แตกต่างกันของการอ้างอิงเพื่อตอบสนองลูกค้าจำนวนมากนี้ น่าเสียดายที่ DI ไม่ได้ดูตัวเลือกเนื่องจากลูกค้าไม่ยอมรับการฉีดด้วยตัวสร้างหรือผู้ตั้งค่า ตัวเลือก: 1) Refactor การปรับใช้บริการที่ลูกค้าใช้เพื่อให้เป็นไปตามที่ลูกค้าต้องการ ปังเราเสร็จแล้ว ไม่ยืดหยุ่น ไม่ซับซ้อน 2) ปรับโครงสร้างการนำไปใช้ใหม่เพื่อให้ผู้รับมอบสิทธิ์สามารถทำงานให้กับการพึ่งพาอื่นที่ได้มาจากโรงงาน ตอนนี้เราสามารถควบคุมว่าการใช้งานแบบใดที่พวกเขาใช้โดยการปรับโครงสร้างโรงงานอีกครั้ง 3) ปรับโครงสร้างการนำไปใช้ใหม่เพื่อให้ผู้รับมอบสิทธิ์สามารถทำงานได้กับการพึ่งพาอื่นที่ได้รับผ่านตัวระบุบริการ ตอนนี้เราสามารถควบคุมได้ว่าการใช้งานใดที่พวกเขาใช้โดยการกำหนดค่าบริการตัวระบุตำแหน่งซึ่งอาจเป็นhashmapสตริงของวัตถุที่มีการแคสต์เล็กน้อย 4) บางสิ่งที่ฉันยังไม่ได้คิดเลย วัตถุประสงค์: ลดความเสียหายที่เกิดจากการออกแบบโดยการลากรหัสลูกค้าเก่าที่ออกแบบมาไม่ดีในอนาคตโดยไม่เพิ่มความซับซ้อนที่ไม่มีจุดหมาย ลูกค้าไม่ควรจะรู้หรือควบคุมการดำเนินงานของการอ้างอิงของพวกเขา newแต่พวกเขายืนยันในการสร้างพวกเขาด้วย เราไม่สามารถควบคุมได้newแต่เราควบคุมชั้นเรียนที่พวกเขากำลังสร้าง คำถามของฉัน: ฉันไม่ได้พิจารณาอะไร คำถามจาก Doc Brown คุณต้องการความเป็นไปได้ที่จะกำหนดค่าระหว่างการใช้งานที่แตกต่างกันหรือไม่? เพื่อจุดประสงค์อะไร? ความว่องไว …

14 design  refactoring  dependency-injection  factory-method  service-locator 

สำหรับฉันแล้วรหัสสำเร็จรูปนั้นแย่มาก อย่างไรก็ตามฉันได้พบกับนักพัฒนาที่แสดงความต้านทานในความพยายามใด ๆ เพื่อลดสำเร็จรูป ฉันรู้ว่าฉันไม่ได้มีรูปแบบที่พร้อมและคิดว่าการโต้แย้งที่ผ่านมาความเกลียดชังที่ฉันได้พัฒนามันเมื่อเวลาผ่านไป เพื่อที่ฉันจะได้สร้างข้อโต้แย้งที่น่าเชื่อถือสำหรับการสร้างหม้อไอน้ำให้น้อยลง กล่าวอีกนัยหนึ่งคืออะไรข้อโต้แย้ง (ถ้ามี) ในความโปรดปรานของสำเร็จรูป? (ฉันหมายถึงสิ่งที่ฉันคิดว่ามีความหมายโดยทั่วไปโดยสำเร็จรูป แต่ตัวอย่างที่ดีคือ getters และ setters ใน Java.)

14 programming-languages  programming-practices  coding-style  refactoring 

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

14 project-management  refactoring 

ฉันชอบที่การเขียน Python, Ruby หรือ Javascript ต้องใช้สำเร็จรูปน้อยมาก ฉันชอบโครงสร้างที่ใช้งานง่าย ฉันชอบไวยากรณ์ที่สะอาดและเรียบง่าย อย่างไรก็ตามมีสามสิ่งที่ฉันไม่ดีจริง ๆ เมื่อพัฒนาซอฟต์แวร์ขนาดใหญ่ในภาษาแบบไดนามิก: การนำรหัส การระบุอินเทอร์เฟซของวัตถุที่ฉันใช้ การปรับโครงสร้างใหม่อย่างมีประสิทธิภาพ ฉันได้ลองใช้ตัวแก้ไขอย่างง่าย (เช่น Vim) และ IDE (Eclipse + PyDev) แต่ในทั้งสองกรณีฉันรู้สึกว่าฉันต้องผูกมัดกับหน่วยความจำและ / หรือ "grep" ตลอดเวลาและอ่านรหัสเพื่อระบุ อินเตอร์เฟส โดยเฉพาะอย่างยิ่งเมื่อทำงานกับ codebase ขนาดใหญ่ที่มีการขึ้นต่อกันหลายครั้ง สำหรับการเปลี่ยนโครงสร้างตัวอย่างเช่นการเปลี่ยนชื่อวิธีการนั้นจะขึ้นอยู่กับคุณภาพของการทดสอบหน่วยของฉันอย่างมาก และถ้าฉันพยายามแยกการทดสอบหน่วยของฉันโดย "ตัดพวกมันออก" ส่วนที่เหลือของแอปพลิเคชั่นนั้นไม่รับประกันว่าส่วนต่อประสานของต้นขั้วของฉันจะยังคงทันสมัยอยู่กับวัตถุที่ฉันกำลังถูอยู่ ฉันแน่ใจว่ามีวิธีแก้ไขปัญหาสำหรับปัญหาเหล่านี้ คุณทำงานอย่างมีประสิทธิภาพใน Python, Ruby หรือ Javascript ได้อย่างไร

14 ide  refactoring  dynamic-typing 

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

14 design  maintenance  refactoring 

สำหรับพวกคุณที่โชคดีที่ไม่ได้ทำงานในภาษาที่มีขอบเขตแบบไดนามิกให้ฉันขอทบทวนเล็กน้อยเกี่ยวกับวิธีการทำงาน ลองนึกภาพภาษาเทียมที่เรียกว่า "RUBELLA" ซึ่งมีลักษณะดังนี้: function foo() { print(x); // not defined locally => uses whatever value `x` has in the calling context y = "tetanus"; } function bar() { x = "measles"; foo(); print(y); // not defined locally, but set by the call to `foo()` } bar(); // prints "measles" …

13 refactoring  scope  mumps