ทำไมสิ่งที่ออกแบบกับสิ่งที่สร้างมักแตกต่างกัน ?

วันนี้อ่านบทความเรื่อง Java legacy hairball: refactoring case-study
ทำการอธิบายถึงการ refactor legacy code
ว่ามีแนวคิดและขั้นตอนอย่างไรบ้าง ?
ซึ่งมีความน่าสนใจอย่างมาก
จึงนำมาสรุปไว้นิดหน่อย

สิ่งที่ผมชอบมาก ๆ คือ ทำไมสิ่งที่เราออกแบบมักจะแตกต่างจากสิ่งที่สร้างขึ้นมา ?

เริ่มด้วยสิ่งที่เราออกแบบ

ทำการแยกส่วนการทำงานของระบบชัดเจนมาก ทั้ง 2-tier, 3-tier หรือ n-tier
ทำการแยก service ออกเป็นกลุ่ม ๆ อย่างสวยงาม
มันสวยงามและเป็นระเบียบมาก เมื่ออยู่ในรูปแบบเอกสาร และ diagram ต่าง ๆ
แสดงดังรูป

แต่เมื่อทำการพัฒนาระบบจากสิ่งที่ออกแบบ กลับพบว่ามันต่างกันโดยสิ้นเชิง

ยกตัวอย่างเช่นในส่วนของ Business tier
โดย code ของแต่ละส่วนจะผูกมัดกันอย่างมากมาย (Tight coupling)
บางครั้งเรียกว่ายุ่งเหยิงเลยก็ว่าได้
แสดงดังรูป

คำถามก็คือ เราออกแบบไปทำไม ?

ทั้ง ๆ ที่การพัฒนาระบบไม่เหมือนการออกแบบเลย
หรือเราไม่สนใจว่าจะออกแบบมาแบบไหน
เราจะพัฒนาตามใจของฉันเอง
ทำให้มันเสร็จ ๆ ก็พอ

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

หรือว่าเราในฐานะนักพัฒนาไม่ได้ใส่ใจในการพัฒนาระบบเลย

สุดท้ายแล้วลองถามตัวเราเองสิว่า
สิ่งที่ออกแบบกับสิ่งที่สร้างหรือพัฒนาขึ้นมานั้น มันเหมือนหรือต่างกันอย่างไร ?

ในบทความยังอธิบายวิธีการ Refactoring Legacy Code

เพื่อเป็นแนวทางสำหรับการปรับปรุง code ของระบบให้ดีขึ้น
รวมทั้งมีตัวอย่าง VDO และ code ให้ศึกษาอีกด้วย
แสดงดังรูป