เมื่อไหร่ที่จะตอบกลับยิ่งใหญ่คำตอบ?


278

เพียงอ่านคำถามเกี่ยวกับการเขียนซ้ำครั้งใหญ่และฉันจำคำถามที่ฉันต้องการตอบเอง

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

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

TL; DR เมื่อใดคำตอบใหญ่ ๆ จะเขียนอีกครั้งและคุณสามารถใช้อาร์กิวเมนต์ใดในการสนับสนุน


1
นอกจากนี้ยังเกี่ยวข้องกับ: programmers.stackexchange.com/questions/20246/ …
IAbstract

6
มันเก่า แต่มันคลาสสิก - โจเอล "สิ่งที่คุณไม่ควรทำตอนที่ฉัน" joelonsoftware.com/articles/fog0000000069.html
Mawg

นี่เป็นคำถามที่ยอดเยี่ยม มีความเกี่ยวข้องมากสถานการณ์นี้เกิดขึ้นบ่อยครั้งในวิศวกรรมซอฟต์แวร์
แบรดโธมัส

คำตอบ:


325

ขออภัยนี่จะใช้เวลานาน แต่ก็ขึ้นอยู่กับประสบการณ์ส่วนตัวของทั้งสถาปนิกและนักพัฒนาในหลาย ๆ โครงการที่เขียนใหม่

เงื่อนไขต่อไปนี้ควรทำให้คุณต้องพิจารณาการเขียนใหม่บางประเภท ฉันจะพูดเกี่ยวกับวิธีการตัดสินใจที่จะทำหลังจากนั้น

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

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

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

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

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

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

กลยุทธ์บางอย่างเพื่อความสำเร็จ:

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

25
ฉันคิดว่าประเด็นของ Joel คือการเขียนใหม่คุณจะสูญเสียความรู้ที่สะสมในรหัสเก่า
quant_dev

14
@quant_dev ส่วนหนึ่งใช่ แต่เมื่อคุณเขียนใหม่บางครั้งคุณก็ตระหนักว่ามีข้อบกพร่องหลายอย่างในระบบเก่าเป็นเพราะวิธีการที่ระบบเก่าทำงานไม่ได้เป็นตรรกะที่เกี่ยวข้องกับการทำงานของระบบในอุดมคติ
Tjaart

13
Joel บอกว่ามันจะล้มเหลวเพราะในระหว่างที่เขียนใหม่คุณจะไม่เพิ่มฟังก์ชันการทำงานใหม่ให้กับแอปพลิเคชันของคุณ จุดประสงค์เดียวของการเขียนซ้ำคือการกำจัดหนี้ทางเทคนิคบางส่วนหรือทั้งหมด จริงอยู่ที่นี่ไม่ใช่เรื่องเล็ก แต่มีความเสี่ยงหากคู่แข่งของคุณกำลังเพิ่มคุณสมบัติและฟังก์ชั่นใหม่ ๆ ลงในซอฟต์แวร์ของพวกเขาในขณะที่คุณแค่กำจัดหนี้ทางเทคนิคในตัวคุณ
Robert Harvey

25
ฉันได้ทำงานกับ codebase ที่ตรงกับเกณฑ์เหล่านี้ทั้งหมด + และยังมีการเขียนซ้ำครั้งใหญ่ยังคงล้มเหลวและในบางวิธีทำให้สิ่งเลวร้ายยิ่งขึ้นด้วยการให้โค้ด "ข้อตกลงใหม่" แก่เราในการใช้งานครึ่งหนึ่ง จัดการได้มากขึ้น IMO เฉพาะในกรณีที่เป็นไปไม่ได้อีกครั้งที่จะทำการปรับเปลี่ยนอย่างสมบูรณ์หากคุณลบโฟกัสทั้งหมดออกจากการเพิ่มคุณสมบัติและแก้ไขข้อบกพร่องที่ทำให้คุณต้องเสียเงินลูกค้าในปัจจุบัน หากคุณไม่ได้พูดถึงรหัสที่ถอดรหัสไม่ได้จริงๆทีมที่ไม่สามารถดึงบิตแบบแยกส่วนออกเพื่อนำมาใช้ใหม่ได้ง่ายขึ้นในขณะที่คุณไปอาจไม่สามารถสร้างสถาปัตยกรรมที่ดีพอสำหรับการใช้งานขนาดใหญ่
Erik Reppen

11
นี่เป็นคำตอบที่มีประโยชน์ แต่ยังห่างไกลจากการรังผึ้งเพราะมันให้ความรู้สึกที่ผิดในบางสิ่ง ตัวอย่างเช่น"โปรดทราบว่าค่าใช้จ่ายโดยรวมของการ redesiging ที่เพิ่มขึ้นจะสูงกว่าการเขียนใหม่ทั้งหมด" - คำว่า "เสมอ" ในประโยคนั้นผิดเพราะ "redesiging ที่เพิ่มขึ้น" เปิดโอกาสให้คุณนำชิ้นส่วนมาใช้ใหม่อย่างน้อย ของการออกแบบที่มีอยู่ในขณะที่ "เขียนใหม่เสร็จสมบูรณ์" ไม่ได้ให้คุณ ฉันรู้ว่าแน่นอนเพราะฉันเคยอยู่ในสถานการณ์จริงที่เราเขียนแอปพลิเคชัน> 100K LOC บางส่วนในแบบเต็ม แต่ไม่ได้บางส่วน
Doc Brown

109

ฉันมีส่วนร่วมในการเขียนใหญ่สองครั้ง ครั้งแรกเป็นโครงการขนาดเล็ก ประการที่สองคือผลิตภัณฑ์หลักของ บริษัท ซอฟต์แวร์

มีข้อผิดพลาดหลายประการ:

  • การเขียนซ้ำจะใช้เวลานานกว่าที่คาดไว้เสมอ
  • การเขียนซ้ำไม่มีผลกระทบ / ผลประโยชน์โดยตรงต่อลูกค้า
  • ความจุที่อุทิศให้กับการเขียนใหม่ไม่ได้ใช้เพื่อสนับสนุนลูกค้า
  • คุณจะสูญเสียฟังก์ชันการทำงานด้วยการเขียนใหม่ยกเว้นว่าคุณมีเอกสาร 100%

การเขียนซ้ำไม่ค่อยเป็นคำตอบที่แท้จริง คุณสามารถปรับโครงสร้างโค้ดได้มากโดยไม่สูญเสียอะไรและไม่มีความเสี่ยง

การเขียนซ้ำอาจเป็นคำตอบหาก:

  • คุณกำลังเปลี่ยนเป็นภาษาหรือแพลตฟอร์มอื่น
  • คุณกำลังเปลี่ยนเฟรมเวิร์ก / ส่วนประกอบภายนอก
  • codebase ที่มีอยู่ไม่สามารถบำรุงรักษาได้อีกต่อไป

แต่ฉันขอแนะนำวิธีการช้าโดยใช้ refactoring มันมีความเสี่ยงน้อยกว่าและทำให้ลูกค้าของคุณมีความสุข


11
+1 สำหรับวิธีการรีแฟคเตอร์ มีหลายครั้งที่เวลาหรือเวลาในการเขียนและบำรุงรักษาระบบที่มีอยู่ไม่เพียงพอ
Ryan Hayes

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

4
@ จอห์น: ในฐานะผู้บริหารฉันจะมีเวลาที่ยากลำบากมากในการเขียนแอปพลิเคชันที่ทีมขายของฉันยังไม่ได้รับลูกค้า ในความซื่อสัตย์ทั้งหมดฉันจะให้เวลากับมันและตัดสินใจว่าจะทำอะไร หากไม่มีความสนใจฉันจะทิ้งทุกอย่างและเลือกอย่างอื่นที่จะทำ
NotMe

4
ฉันเพิ่งเขียนแอปพลิเคชัน Visual Basic ใหม่ใน Java สิ่งนี้ทำให้มันสามารถเรียกใช้เป็นบริการภายใต้ Windows (ไม่มี Java GUI) - เป็นประโยชน์ต่อลูกค้า

4
"การเขียนซ้ำไม่มีผลกระทบโดยตรง / ผลประโยชน์สำหรับลูกค้า" - นี่มักเป็นตำนานเนื่องจากกรอบการทำงานใหม่ให้ "ปรับปรุง" ประสิทธิภาพการผลิตจำนวนมากซึ่งเป็นไปไม่ได้หรือแพงเกินไปที่จะนำไปใช้ ตัวอย่างหนึ่งการอัปเกรดแอป vb6 เป็นแอพ. net ช่วยให้ผู้ใช้เปิดไฟล์ขนาดใหญ่ (เนื่องจากสถาปัตยกรรม 64 บิต) ซึ่งหมายความว่าผู้ใช้ปลายทางไม่ต้องแยกงานของตนออก
สตีเฟ่น

72

ได้เวลาเขียนใหม่เมื่อ:

ค่าใช้จ่ายในการเขียนแอปพลิเคชัน + การบำรุงรักษาแอปพลิเคชันที่เขียนใหม่นั้นน้อยกว่าค่าใช้จ่ายในการบำรุงรักษาระบบปัจจุบันเมื่อเวลาผ่านไป

ปัจจัยบางประการที่ทำให้การบำรุงรักษาปัจจุบันมีราคาแพงกว่า:

  • ภาษานั้นเก่ามากคุณต้องจ่ายคนที่รู้ว่ามีเงินมากมายในการเขียนโปรแกรม (ภาษาโคบอล)
  • (จากประสบการณ์ที่น่าเสียดาย) ระบบนี้อยู่ในสถาปัตยกรรมฮาร์ดแวร์ที่เก่าแก่มากซึ่งพวกเขาต้องกัดเซาะ Ebay และ COLLECT เพื่อที่จะเพิ่มลงในเครื่องที่ใช้งานเพราะมันไม่ได้ทำอีกต่อไป สิ่งนี้เรียกว่า "การช่วยชีวิตของฮาร์ดแวร์" และมีราคาแพงเพราะเมื่อบางส่วนมีจำนวนมากขึ้นพวกเขา (อาจ) ขึ้นราคาหรือไม่ก็จะหมดไปในที่สุด
  • มันซับซ้อนมากจน//Here be dragons.ความคิดเห็นนั้นเกินรหัสของคุณ
  • คุณไม่สามารถเขียนโครงการอื่น ๆ และเพิ่มมูลค่าใหม่ให้กับ บริษัท เพราะคุณมักจะแก้ไขสัตว์ร้ายที่น่าเกลียดนี้

นั่นคือสิ่งที่กระตุ้นเตือนให้ฉันเขียนใหม่ที่ฉันเข้าร่วม รหัสที่ตามมาก็เพื่อที่เปราะบางและค่าใช้จ่ายของการเพิ่มคุณสมบัติใหม่เพื่อให้สูงที่ไม่ได้เขียนใหม่ก็ไม่ได้เป็นตัวเลือก
Frank Shearar

16
ฉันหัวเราะคิกคักที่นี่เกี่ยวกับจุด # 2
พอลนาธาน

4
@ พอล: ฉันก็ทำเหมือนกันเมื่อลูกค้าบอกฉันว่าจากนั้นฉันก็พบว่าพวกเขาจริงจัง ... และฉันจะทำตามความต้องการเพื่อรวบรวมเขียน ช่างเป็นวันที่น่าตื่นเต้นมาก
Ryan Hayes

3
ปัญหาคือวิธีที่คุณวัดค่าใช้จ่าย

2
ฉันชอบคำตอบนี้ตลกและเป็นจริง ฉันต้องการเพิ่ม "quantifiably" ก่อน "less" หลาย ๆ ครั้งมันง่ายที่จะทำการเคลม แต่มันสำคัญที่จะต้องใช้เวลาที่สูญเปล่า
Kevin Hsu

17

หากคุณต้องการการเปลี่ยนแปลงพื้นฐานในสถาปัตยกรรมของโครงการอาจถึงเวลาที่จะเริ่มต้นใหม่อีกครั้ง

แม้ว่าจะมีรหัสจำนวนมากที่ยังคงคุ้มค่าที่จะใช้ซ้ำในโครงการใหม่ของคุณ

ระวังฟังคำเตือนอย่างยุติธรรม โครงการปัจจุบันจะมีกฎเกณฑ์ทางธุรกิจที่ผ่านการทดสอบและขัดเกลาด้วยจำนวนชั่วโมงการใช้งานจริงที่นับไม่ถ้วน

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


3
คุณต้องระวังให้มาก 'กำหนดรหัสขนาดใหญ่ใหม่' ซึ่งจะนำไปสู่รหัสดั้งเดิมที่ไม่ได้ใช้และโครงสร้างรหัสที่ไม่ดี การปรับโครงสร้างใหม่เป็นทางออกที่ดีกว่าในความคิดของฉัน
mrwooster

1
ตกลง ส่วนหนึ่งของข้อความนั้นควรตีความว่าเป็น 'refactor' ในโครงการ 'ใหม่' ของคุณ นั่นคือถ้าคุณมีความมุ่งมั่นในเส้นทางที่รุนแรงนั้นแล้ว ดังที่คนอื่นพูดถึงนี่เป็นสิ่งที่หายากสุดขีดที่แทบจะไม่เคยเกิดขึ้นเลย
ด่าน McGrath

1
+1 นอกจากนี้การเขียนใหม่จะใช้เวลาในระหว่างการบำรุงรักษาที่จะต้องทำ แต่การเปลี่ยนแปลงเดียวกันจะต้องทำในรหัสฐานทั้งสอง
Larry Coleman

12

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

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


+1 สำหรับการกล่าวขวัญกฎหมาย Hofstadter ของ
Baelnorn

11

หยุด! การเขียนใหม่แทบไม่เคยมีคำตอบเลย บ่อยครั้งที่การปรับโครงสร้างซ้ำเป็นวิธีที่ดีกว่า


แน่นอนว่ายังมีบางครั้งเมื่อเขียนเป็นธรรม:

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

เพื่อให้เข้าใจว่าทำไมฉันแนะนำ refactoring over rewriting ลองพิจารณาสิ่งที่เกี่ยวข้องกับการเขียนใหม่ คุณต้อง:

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

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

ข้อดีของการปรับโครงสร้างใหม่คือ:

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

จำไว้เช่นกันว่าถ้าคุณเขียนใหม่คุณจะรับประกันว่าจะมีข้อบกพร่องใหม่ ๆ มากมายและสับสนในฐานรหัสใหม่


2
คุณสามารถขยายคำตอบนี้โดยอธิบายว่าทำไมการปรับโครงสร้างบ่อยครั้งมากกว่าไม่ดีกว่าการเขียนใหม่? และเมื่อใดที่การเขียนจะเป็นคำตอบ?
gablin

เมื่อพิจารณาจากความจริงที่ว่าการเขียนซ้ำบ่อยที่สุดนั้นเป็นเพียงความยุ่งเหยิงที่เหมือนกันในชุดที่แตกต่างกันคุณพูดถูก หากคุณสามารถขจัดปัญหาเดียวนั่นแสดงว่าคุณผิด ไม่มีข้อสรุปใด ๆ เมื่อคนที่เหมาะสมทำ
JensG

10

กราฟิกนี้สามารถช่วยได้มันเป็นฟังก์ชั่นของคุณภาพฐานรหัสและมูลค่าทางธุรกิจของแอปพลิเคชัน:

ป้อนคำอธิบายรูปภาพที่นี่

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


4
ทำไมคุณถึงลงทุนในการเขียนโครงการที่มีมูลค่าทางธุรกิจต่ำ แค่เศษมัน!
Jørgen Fogh

นั่นเป็นเหตุผลที่ statess "แทนที่หรือ ... " คุณสามารถแทนที่ด้วยสิ่งที่มีค่า หรือทำให้เป็นสิ่งที่มีค่า แต่คุณมีประเด็น ฉันจะแก้ไขเพื่อเพิ่มตัวเลือก "เรื่องที่สนใจ"
Tulains Córdova

8

ฉันคิดว่าฉันอยู่ในสถานการณ์เดียวในอาชีพการงานของฉันซึ่งคำตอบที่ยิ่งใหญ่คือ:

การรวม บริษัท การทับซ้อนกันอย่างมากในการทำงานของระบบ ระบบจำนวนมากหลายแห่งได้รับการผสานและเลิกใช้แล้วและส่วนอื่นยังคงอยู่ในกระบวนการ

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

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


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

7

ฉันทำงานให้กับ บริษัท ซอฟต์แวร์ขนาดเล็กที่มีแอพพลิเคชั่น DOS สองสามตัวที่ได้รับการอัพเกรดให้รองรับ Y2K เขียนใหม่เป็นแอพ Windows 16 บิตจากนั้นเขียนใหม่ทั้งหมดเป็นแอพ 32 บิตพร้อมฟีเจอร์ 'เล็ก' เพิ่มเติม ลูกค้ารายหนึ่ง) ที่ส่งผลกระทบต่อโครงสร้างทั้งหมด

การย้ายรหัส 16 บิตเป็น 32 สามารถทำได้ในหนึ่งเดือนโดยบุคคลเดียว แต่ NOOOOOOOOO เราต้องเขียนใหม่เพื่อให้เป็น Soooooooooo ดีกว่ามาก สิ่งนี้สามารถปรับให้เหมาะกับอุตสาหกรรมอื่น ๆ จะมีสเป็คเต็มรูปแบบและรหัส psuedo ก่อนที่พวกเขาจะเริ่มต้น รายละเอียดถูกสร้างขึ้น แต่ใช้เวลานานมากในการเขียนรหัสจริง มันเปิดตัวช้ามีข้อผิดพลาดมากกว่า 16 บิต 'เริ่มต้น' ด้วย (ใน v.3.0 และในที่สุดก็ถึงจุดที่เราเกือบทำสัปดาห์โดยไม่มีใครรายงานข้อผิดพลาดใหม่)

คุณคิดว่าการเขียนแอปพลิเคชั่นเดิมซ้ำอีก 3-4 ครั้งจะทำให้การปรับปรุงดีขึ้น แต่ฉันไม่คิดว่าส่วนหน้าของ GUI สามารถพิสูจน์ได้ว่ามากขนาดนั้น

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


5

ฉันมีกรณีที่คล้ายกับของคุณมากรหัสเท่านั้นไม่ได้ใช้ Struts สิ่งที่ฉันทำก็คือพื้นที่เป้าหมายที่โดยเฉพาะเส็งเคร็งและก่อให้เกิดปัญหามากมาย วิธีการกำหนดเป้าหมายนี้ทำให้เราดีขึ้นทีละน้อย

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

เราไม่เคยเขียนสิ่งใหม่ทั้งหมด เราหยุดใช้แพลตฟอร์มนั้นสำหรับงานใหม่และตั้งแพลตฟอร์มใหม่ใหม่สำหรับโครงการใหม่ที่ยิ่งใหญ่ ที่ได้รับการอนุมัติและเราส่งมอบผลิตภัณฑ์ที่ยอดเยี่ยมในเวลาที่เหมาะสม


5

ดังนั้นที่นี่ฉันนั่งอยู่ที่โต๊ะทำงานฉันเริ่มเขียนโค้ดใหม่สำหรับไฟล์ aspx ขนาดใหญ่หนึ่งไฟล์ฐานข้อมูลด้านหลังและแทนที่ส่วนต่อประสาน MS Access เป็น MsSQL

โปรแกรม asp นี้เต็มไปด้วยสิ่งต่าง ๆ เช่น

  • include(close.aspx) ภายในมีรหัสหนึ่งบรรทัดที่ปิดการเชื่อมต่อฐานข้อมูลเปิดครั้งสุดท้าย
  • รหัสเดิมแสดงความคิดเห็นแบบสุ่ม
  • ไม่มีการพิจารณาเรื่องความปลอดภัย
  • สปาเก็ตตี้โค้ดหลายพันเส้น ทั้งหมดในไฟล์เดียว
  • ฟังก์ชั่นและตัวแปรที่ไม่มีความหมายชัดเจนหลังชื่อของพวกเขา

หากเราจำเป็นต้องทำการเปลี่ยนแปลงเล็กน้อยมันก็เหมือนกับการเล่นห้าเกมพร้อมกันของ kal-toh ในโหมด nightmare

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

หากเราไม่ต้องการขายผลิตภัณฑ์พวกเขาอาจไม่จำเป็นต้องเขียนซ้ำเนื่องจากมันเป็นสิ่งที่พวกเขาต้องการ - อาจจะไม่หรูหรา แต่ก็ไม่รอบคอบที่จะใช้จ่ายเงินเพื่อสร้างรหัสที่ดี 'ทำสิ่งเดียวกัน'


4

Joel Spolsky มีบทความที่ยอดเยี่ยมเกี่ยวกับเรื่องนี้: สิ่งที่คุณไม่ควรทำตอนที่ 1

จากชื่อที่คุณสามารถบอกได้ว่ามันเป็นด้านเดียว (เขาพูดถึงว่าทำไมคุณไม่ควรโยนรหัส) IMO มีความจริงมากมายฉันเพิ่งเห็นวิดีโอ channel9 ในวันครบรอบ 25 ปีของ Excel ที่นักพัฒนาบางคนพูดว่าอย่างไร แม้กระทั่งทุกวันนี้หากคุณมองเข้าไปในแหล่งข้อมูลคุณจะตรวจสอบการแก้ไขและกลับไปสู่โค้ดที่ excel ใช้ซึ่งเขียนขึ้นเมื่อ 20 ปีก่อน

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

เพื่อให้คำตอบที่เป็นรูปธรรมฉันแค่บอกว่าคุณต้องทำการวิเคราะห์ต้นทุนและมูลค่าอย่างละเอียด

โลกแห่งความเป็นจริงของฉัน: แอป Silverlight ฉันกำลังพัฒนา v0.6 จนถึงขณะนี้มีการเรียก async ที่ทำให้รหัสสับสน ตั้งแต่ฉันค้นพบส่วนขยายที่เกิดปฏิกิริยาในสัปดาห์นี้ฉันต้องการเขียนโค้ดใหม่เกือบทั้งหมด แต่ตอนนี้ฉันจะบอกลูกค้าอย่างไร โปรแกรมทำงานได้อย่างสมบูรณ์แบบ (กับบางหน่วยความจำรั่วไหล) แต่พวกเขาไม่สนใจ? ฉันไม่สามารถบอกได้ว่าพวกเขาโอ้ฉันใช้เวลาอีก 2-3 สัปดาห์เพราะฉันต้องการทำอะไรใหม่ อย่างไรก็ตามฉันจะแยกรหัสและเขียนใหม่ / เล่นกับมันในเวลาว่างของฉัน

เพียง 2 เซ็นต์ของฉันตกลง!


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

+1 สำหรับการแตกแขนง ผู้คนมากมายพูดว่า "อย่าเขียนซ้ำ" เพราะดูเหมือนว่าคุณกำลังทิ้งรหัสเก่า แต่คุณไม่ใช่ คุณสามารถมีฐานรหัสแบบขนาน
lunchmeat317

หากคุณเป็นคนที่ขอคำแนะนำจาก Joel Spolsky คุณไม่ควรเขียนใหม่ทั้งหมด :-) และมิฉะนั้นคุณควรเขียนใหม่หากคุณสามารถโน้มน้าวผู้มีส่วนได้ส่วนเสียทุกคนทำไมข้อโต้แย้งของ Joel ถึงไม่นับ ในกรณีเฉพาะของคุณ
gnasher729

3

โซลูชันที่มีอยู่ไม่ได้ปรับขนาด

ฉันมองไปที่คุณ MS Access


ฉันไม่แน่ใจว่าคุณกำลังมองหาคนที่ใช่หรือไม่ เจ็ตเรดไม่ได้ตั้งใจจะขยายขนาด AFAIK
JensG

คำถามนี้ถามคำถามนี้อย่างไร
ริ้น

3

Joel กล่าวว่าการเขียนซ้ำครั้งใหญ่เป็นความผิดพลาดเชิงกลยุทธ์ที่เลวร้ายที่สุดที่ บริษัท สามารถทำได้:

สิ่งที่คุณไม่ควรทำตอนที่ 1

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

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


5
ใช่. ฉันกำลังมองหาโต้เถียงบางอย่างเพื่อที่ ต้องทำบางครั้ง
Jonn

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

บทความ Joels นั้นดีเพราะอธิบายอย่างละเอียดว่าสิ่งเลวร้ายสามารถเกิดขึ้นได้อย่างไร

6
Joel ใช้ตัวอย่างของเบราว์เซอร์ Netscape Navigator นั่นเป็นผลิตภัณฑ์สำหรับผู้บริโภคที่อยู่ในช่วงโค้งการเติบโตที่ใหญ่โตเมื่อเทียบกับการแข่งขันด้วยงบประมาณที่มาก มันเป็นความผิดพลาดเชิงกลยุทธ์สำหรับ Netscape ในทางตรงกันข้ามโครงการซอฟต์แวร์ "องค์กร" ภายในที่กำหนดเองนั้นแตกต่างกัน คุณไม่รีบหาส่วนแบ่งตลาด ไม่มีอันตรายใด ๆ จากผู้ใช้ของคุณที่จะออกจากผลิตภัณฑ์คู่แข่ง มันมาจากการตัดสินใจทางธุรกิจ: ค่าใช้จ่ายของการเขียนใหม่จะจ่ายสำหรับตัวเองในระยะยาวและ / หรือเป็นวิธีที่ดีที่สุดในการบรรลุเป้าหมายทางธุรกิจหรือไม่
Scott Whitlock

ฉันคิดว่าโจเอลตีแนวคิดหลักของ "คุณไม่เคยรู้ว่าการตัดสินใจยังไม่ได้รับการบันทึกไว้ว่าคุณจะต้องเรียนรู้วิธีที่ยาก"
MathAttack

2

อย่าคิดทบทวนซ้ำอยู่เสมอ - ความจริงก็คือถ้าคุณเขียนรหัสนั้นขึ้นมา - คุณจะไม่สามารถทำได้ดีกว่านี้อีก

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

ทุกอย่างควรได้รับการออกแบบเป็นกล่องดำ Modular, Simple API สิ่งที่อยู่ข้างใน ... มันสำคัญน้อยกว่า :) ถ้าคุณมีสปาเก็ตตี้คุณอาจจะสามารถปิดมันในกล่องดำได้ดังนั้นมันจะไม่ปนเปื้อนโค้ดที่ดี



+1 ฉันชอบความคิดเห็นของคุณต้องการทราบความคิดเห็นของคุณเกี่ยวกับการเขียนใหม่ไปยังชุด API ที่ใหม่กว่าหรือไม่ (ดูคำตอบของฉันด้านล่าง)
gideon

ใช่สิ่งเหล่านี้เป็นจุดที่ดี Microsoft เขียนรหัส winXP และพวกเขาไม่สามารถแม้แต่จะลบ / คัดลอกไฟล์ได้ในรุ่นแรกของ Vista ในขณะที่พวกเขาเพิ่งจะพัฒนาฐานรหัสของพวกเขาเราจะได้รับคุณภาพที่ดีขึ้นอย่างต่อเนื่อง (W3.11 => W95 => W98 => ME => XP) Vista ที่พวกเขาเขียนส่วนแกนหลักหลายแห่งเป็นหายนะ สำหรับ API ใหม่ ... ฉันต้องการแยกรหัสปัจจุบันให้มากที่สุดเท่าที่จะเป็นไปได้และใช้ API ใหม่บนเลเยอร์ที่สูงขึ้น เช่น. คลาสหลักของคุณยังคงเหมือนเดิม แต่การรวมจะดำเนินการโดยใช้ API ใหม่ เว้นแต่ว่าทุกอย่างยุ่งจนไม่มีอะไรสามารถทำได้นอกจากเริ่มต้นจาก 0
Slawek

1
"... ความจริงก็คือถ้าคุณเขียนโค้ด - คุณจะไม่สามารถทำได้ดีกว่านี้" จะลงคะแนนโพสต์นี้ถ้าฉันมีตัวแทนเพียงพอ นั่นคือความพ่ายแพ้ไม่สมจริงและหมายความว่าผู้คนไม่สามารถก้าวไปถึงจุดนั้นได้รหัสที่พวกเขาเขียนคือการปรับปรุงโค้ดที่พวกเขาเขียนในอดีต
JᴀʏMᴇᴇ

1
@ JᴀʏMᴇᴇ: เห็นด้วย - ถ้าคุณไม่ได้เรียนรู้อะไรและไม่ได้รับประสบการณ์เมื่อใช้งานเป็นครั้งแรกและ / หรือถ้าคุณไม่สามารถทำงานได้ดีขึ้นในตอนนี้ที่คุณมีความรู้ / ประสบการณ์ / การเข้าใจย้อนหลังมากกว่า; ถ้าอย่างนั้นคุณก็เป็นมันฝรั่งไม่ใช่โปรแกรมเมอร์
เบรนแดน

2

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


2

มีเรื่องตลกคลาสสิกเกี่ยวกับ "ถ้าฉันจะไปที่ XI จะไม่เริ่มจากที่นี่"

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

  • แรงกดดันมากเกินไปที่จะเพิ่มฟังก์ชั่นการบำรุงรักษาและเพิ่มความแข็งแกร่งให้กับสัตว์ร้าย

  • ความสามารถน้อยเกินไปในแผนก

  • บาย - อินจากลูกค้าหรือผู้บริหารน้อยเกินไปสำหรับการทำงานที่เพิ่มขึ้น

หรืออะไรก็ตามและสิ่งนี้ทำให้เกิดปัญหาไปจนถึงปัญหาจนอยู่ในระดับที่ทนไม่ได้

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


2

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

การเขียนซ้ำมักจะเกิดขึ้นเพื่อลดความกังวลด้านการจัดการ:

  • ทุกอย่างควรอยู่ใน. NET
  • นักพัฒนาของเราบอกว่ารหัสของเราแย่
  • เรากำลังตกหลุมทางเทคนิค
  • เราจะไม่สามารถค้นหาทรัพยากรเพื่อสนับสนุนระบบของเราหรือบ่อยครั้งมาก
  • มันเป็นเวลาสิบปีแล้วดังนั้นมันถึงเวลาแล้ว

ความกังวลเหล่านี้ส่วนใหญ่จะไม่เกิดขึ้นจริงและหากทำได้ก็สามารถจัดการได้ อย่างไรก็ตามอันสุดท้ายนั้นเลวร้ายที่สุด เป็นหลัก: เราไม่มีเหตุผล

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

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

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


ดูเหมือนว่าคุณควรจะสามารถ refactor ในทิศทางนั้น เมื่อทำการปรับโครงสร้างใหม่คุณมีความคิดที่จะสร้างความยืดหยุ่นที่คุณต้องการเพื่อให้คุณสมบัติถัดไปนั้นง่ายต่อการเขียน
Ian

1

เมื่อย้ายไปใช้เทคโนโลยีใหม่อย่างสมบูรณ์ก็จำเป็นต้องมีฟังก์ชั่นที่ต้องการ

"ใหม่โดยสมบูรณ์": หากคุณวางแผนที่จะเขียนใหม่ แต่ใช้แพลตฟอร์มเดียวกันการเปลี่ยนโครงสร้างใหม่และการปรับโครงสร้างอย่างรอบคอบนั้นเป็นทางออกที่ดีกว่า "Platform" ที่ใช้ในที่นี้ค่อนข้างคลุมเครือ - พิจารณาให้รวมภาษาและบางที OS (ขยายจาก Linux เป็น Windows หรือในทางกลับกันก็นึกถึง) แต่อาจไม่ใช่ Framework (เช่นแทนที่ Struts กับ Spring)

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

ถึงกระนั้นฉันก็ยังไม่แน่ใจว่าฉันจะทำการเขียนใหม่ยกเว้นว่าฉันมีความรู้อย่างละเอียดเกี่ยวกับพฤติกรรมของระบบในปัจจุบันและเป็นรหัสที่ค่อนข้างสะอาดซึ่งไม่ได้พัฒนาหูดจำนวนมากใน 11 ปีของชีวิต


0

ในการตัดสินใจในจุดที่คุณควรเริ่มต้นใหม่คุณต้องทำงานโดยที่มูลค่าของโครงการปัจจุบันของคุณยังไม่ถึงจุดเริ่มต้น

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


0

ด้วยการวัดของฉันคุณต้องปฏิบัติตามสองเงื่อนไขเพื่อปรับการเขียนซ้ำ:

  1. หลังจากเขียนคุณสมบัติใหม่จะง่ายขึ้น / เร็วขึ้น / บั๊กน้อยลงในการเขียน
  2. การเขียนใหม่จะใช้เวลาน้อยกว่าหรือเท่ากับการเพิ่มคุณสมบัติใหม่ในปัจจุบัน

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

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

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


0

OP ไม่ได้ระบุขอบเขตของโครงการ แต่เบาะแสหลักที่ฉันใช้คือ "เขียนในภาษา [ภาษา / ภาษาถิ่น] โดยใช้ [libs]" ซึ่งสำหรับฉันนั้นเป็นตัวขับเคลื่อนหลักของการเขียนใหม่ ในความเป็นจริงโครงการส่วนใหญ่ที่ฉันใช้อยู่ในตลาดที่ยืนยาวอย่างมีนัยสำคัญในที่สุดก็ตระหนักว่าการปรับปรุงการรวบรวมคอมไพเลอร์ / ล่าม / ระบบปฏิบัติการเป็นงานสำคัญในการรักษาฐานรหัส

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


0

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

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

== การปรับโครงสร้างใหม่ให้ดีขึ้นและสิ่งต่าง ๆ ==

การปรับเปลี่ยนรหัสดั้งเดิมด้วยวิธีการเพิ่มเก่าแบบปกติ

  1. หากคุณมีโอกาสแปลงเป็น UML และจัดทำเอกสารสถาปัตยกรรม knarly เล็ก ๆ น้อย ๆ
  2. หากคุณอยู่ในการควบคุมเวอร์ชันมองหาการสร้างรายงานการปั่นโค้ดและการหาไฟล์และส่วนของไฟล์ที่มีการเปลี่ยนแปลงบ่อยที่สุด จดบันทึกสิ่งเหล่านี้เนื่องจากอาจเป็นพื้นที่ที่คุณต้องการจัดการก่อน
  3. ก่อนที่คุณจะเปลี่ยนรหัสใด ๆ พยายามที่จะเพิ่มการครอบคลุมการทดสอบบางอย่างเสมอ ถ้าคุณจัดการกับโค้ดลอจิกที่ยุ่งวุ่นวายขนาดใหญ่คุณจะต้องเปลี่ยนวิธีหรือฟังก์ชั่นที่ตั้งชื่ออย่างสมเหตุสมผลและถ้าเป็นไปได้ให้เพิ่มกรณีทดสอบบางอย่างที่ยืนยันวิธีการใหม่ของคุณ ทำการแฮ็กอันยิ่งใหญ่ที่คุณต้องทำและหากเป็นไปได้ทำให้การเปลี่ยนแปลงกลายเป็นเรื่องปกติหากมันเป็นสิ่งที่ปรับแต่งโดยทั่วไปเช่นความกว้างของขอบหรือชื่อเรื่อง
  4. ใช้รูปแบบอะแดปเตอร์และทำงานเพื่อซ่อนบิตรหัสอัศวินอย่างละเอียดภายใต้พรมของคลาสที่มีชื่อตามหลักเหตุผลและวิธีการเพื่อให้งานทั่วไปส่วนใหญ่ที่คุณและนักพัฒนาคนอื่นทำคุณไม่ต้องกังวลเกี่ยวกับบิตที่น่ากลัวที่เกิดขึ้น ด้านหลังของคุณอยู่เบื้องหลังวิธีการทำความสะอาดและชั้นเรียนเล็ก ๆ น้อย ๆ ที่คุณได้ซ่อนไว้ซึ่งรหัสดั้งเดิมที่อยู่เบื้องหลัง - เช่นครอบครัวที่ดีที่เก็บซอมบี้อดีตสมาชิกในครอบครัวไว้ในโรงนาเพื่อให้พวกเขาไม่เสียวันต่อวันของ ฟาร์ม . . ปกติ
  5. ในขณะที่คุณยังคงลดลงและทำความสะอาดส่วนของรหัสต่อไปเพื่อเพิ่มความครอบคลุมการทดสอบของคุณ ตอนนี้คุณสามารถขุดลึกลงไปอีกและ "เขียนซ้ำ" โค้ดได้มากขึ้นเมื่อต้องการ / ต้องการด้วยความมั่นใจที่เพิ่มมากขึ้น
  6. ทำซ้ำหรือใช้วิธีการเปลี่ยนโครงสร้างเพิ่มเติมเพื่อดำเนินการปรับปรุง codebase ของคุณต่อไป

กิ่งก้านโดย Abstraction

  1. กำหนดจุดที่เกิดปัญหาในรหัสที่คุณต้องการลบ (เลเยอร์คงอยู่, ตัวสร้าง pdf, กลไกการนับรวมใบแจ้งหนี้, ตัวสร้างวิดเจ็ต ฯลฯ )
  2. เรียกใช้ (เขียนหากจำเป็น) กรณีทดสอบการใช้งาน (อัตโนมัติหรือด้วยตนเอง แต่คุณรู้ว่าเป็นแบบอัตโนมัติ) เทียบกับรหัสฐานที่กำหนดเป้าหมายการทำงานนี้พร้อมกับพฤติกรรมทั่วไป
  3. แยกลอจิกที่เกี่ยวข้องกับส่วนประกอบนั้นจาก sourcebase ที่มีอยู่ไปยังคลาสที่มีอินเตอร์เฟสที่สมเหตุสมผล
  4. ตรวจสอบว่ารหัสทั้งหมดกำลังใช้อินเทอร์เฟซใหม่เพื่อดำเนินกิจกรรม X ซึ่งก่อนหน้านี้กระจายตัวแบบสุ่มไปทั่วทั้งรหัส (grep ฐานรหัสเพิ่มการสืบค้นกลับไปยังคลาสใหม่และตรวจสอบหน้าที่ควรจะเรียกมันเป็นต้น) และ คุณสามารถควบคุมการใช้งานซึ่งจะถูกใช้โดยการแก้ไขไฟล์เดียว (การลงทะเบียนวัตถุ, คลาสโรงงาน, IActivityXClass = Settings.AcitivtyXImplementer ();)
  5. เรียกใช้อีกครั้งกรณีทดสอบการใช้งานที่ตรวจสอบว่าทุกอย่างยังคงทำงานกับ Activity X ทั้งหมดที่อยู่ในคลาสใหม่ของคุณ
  6. เขียนการทดสอบหน่วยที่เป็นไปได้รอบคลาสกิจกรรม X wrapper ใหม่
  7. ใช้คลาสใหม่ที่มีตรรกะสปาเก็ตตี้น้อยกว่าการใช้งานแบบดั้งเดิมที่ยึดตามอินเทอร์เฟซเดียวกันกับคลาสดั้งเดิม
  8. ตรวจสอบว่าคลาสใหม่ผ่านการทดสอบหน่วยที่คุณเขียนสำหรับคลาสดั้งเดิม
  9. อัปเดตรหัสของคุณโดยเปลี่ยนรีจิสทรี / factorymethod / อะไรก็ตามที่ใช้คลาสใหม่แทนคลาสเก่า
  10. ตรวจสอบว่าการทดสอบการทำงานของคุณยังคงผ่าน

หลักการแบบเปิดที่ปิดและเลเยอร์ตรรกะทางธุรกิจ / การมีอยู่ของเลเยอร์

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

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

0

ฉันจะบอกว่ามีหมวดหมู่ที่สามใน Refactor vs Rewrite space ... และนั่นคือการอัปเดตเวอร์ชันภาษาคอมไพเลอร์และห้องสมุดของคุณ ... บางครั้งการใช้เทคนิคการเข้ารหัสที่ทันสมัยมีประโยชน์มาก

ยกตัวอย่างเช่น C #, โค้ด v7 เขียนสะอาดกว่าปลอดภัยกว่าและรัดกุมกว่า v2 .. สิ่งต่าง ๆ เช่นผู้ประกอบการ Elvis และ null รวมตัวกันช่วยตัน

การเปลี่ยนคอมไพเลอร์อาจทำให้ชีวิตใหม่เป็นรหัสที่เก่ากว่า ดังนั้นไลบรารีใหม่ที่อาจทำให้การทำงานและนำไปใช้ง่ายขึ้น ... การสร้างเครือข่ายเป็นตัวอย่างที่ดีของการใช้งานที่ยากลำบาก

ระบบลินุกซ์ในตัวอีกด้วย ... ลองนึกถึงการติดตั้งเครื่องมือใหม่ - เปลี่ยนเป็น git จาก svn หรือเพิ่ม Vi ลงในระบบของคุณเป็นต้น

ไม่จำเป็นต้องเป็น refactor vs rewrite เสมอไปสถาปัตยกรรมของคุณอาจต้องการการปรับปรุง แต่ก็ใช้งานได้ ... บางทีคุณอาจต้องคิดว่าโค้ดของคุณเขียนอย่างไร


-2

ฉันไม่คิดว่าฉันเคยเห็นผู้คนเขียนแอพที่เป็นมรดกมาก่อน

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

แต่นี่ไม่ใช่ "การเขียนซ้ำ" ของต้นฉบับในแง่ที่ว่าคุณพยายามที่จะบรรลุคุณลักษณะที่เท่าเทียมกัน

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.