อ่านเจอบทความที่น่าสนใจจาก jooq.org ว่าด้วยเรื่อง
Why You Should NOT Implement Layered Architectures
มาดูว่า แนวคิดรูปแบบนี้เป็นอย่างไร มีข้อดีอะไรบ้าง
โดยต้องใช้วิจารณญาณในการรับฟัง
เนื่องจากอาจจะไปกระตุ้นต่อมของใครหลายๆ คนก็เป็นได้
เรามาเริ่มกันเลยดีกว่า
เรื่องนี้มีการพูดคุยบน Reddit.com อย่างสนุกสนาน
ทำให้ได้แนวคิดในมุมมองต่างๆ ซึ่งเปิดหูเปิดตามากมาย ถ้าเปิดใจเพื่อยอมรับมัน
มาเริ่มต้นแปลกันดีกว่า
ในโลกของการพัฒนาระบบงาน หรือ software นั้น
เรามักจะได้ยินคำว่า Abstraction layer
มันจะเป็นสิ่งที่บอกว่า คุณควรจะทำอะไรในแต่ละส่วนงาน
และเป็นแนวคิดที่ดีมากๆ เพื่อแยกการสร้างหรือ implement จริงๆ ออกไปอีกส่วน
ทำให้ระบบงานไม่ผูกติดกันจนเกินไป
แต่เชื่อว่าระบบงานมากกว่าครึ่งนั้น ไม่ต้องการ Abstraction layer ที่มากเกินไป
ซึ่งถ้าเราสามารถลดจำนวนชั้นหรือส่วนการทำงานเหล่านี้ลงไป
ให้เหลือเฉพาะส่วนที่จำเป็นเท่านั้น
ก็จะทำให้การพัฒนา software เป็นเรื่องที่สนุกยิ่งขึ้น
และยังเพิ่ม productivity อีกด้วยนะ
คำถาม
ในการพัฒนา software เราจำเป็นต้องมีส่วนการทำงานอะไรบ้าง ?
คำตอบ
สิ่งที่จำเป็นมี 2 อย่างคือ ส่วนการเข้าถึงข้อมูล และ ส่วนการแสดงผล
เนื่องจากสองส่วนนี้ในทุกๆ ระบบต้องการเสมอและขาดไม่ได้เลย
นั่นคือ ข้อมูล และ ผู้ใช้งานข้อมูล
ดังนั้นเราไม่ต้องการ Abstraction layer มากมายหรอกนะ ดังรูป
หลายคนอาจจะบอกว่า เราต้องการ Abstraction layer เสมอนะ
เพราะว่ามันจะทำให้เราไม่ผูกติดกับการพัฒนาหรือสร้าง (implementation)
ทำให้เราสามารถเปลี่ยนแปลงการสร้างได้ง่ายนะเออ !!
ซึ่งมันก็เป็นความจริงด้วยสิ
แต่ลองมาดูในโลกแห่งความจริงกันหน่อย
ว่าเราสามารถเปลี่ยนการสร้าง หรือ implementation ได้จริงๆ หรือไม่
ตัวอย่างเช่น
- ใน Layer ของ SQL เราสามารถเปลี่ยนจาก Oracle ไปเป็น DB2 ได้ไหม ?
- ใน Layer ของ Database เราสามารถเปลี่ยนรูปแบบของข้อมูล จาก Relational เป็นยัง XML หรือ JSON ได้ไหม ?
- ใน Layer ของ JPA (Java Persistence API) เราสามารถเปลี่ยนจาก Hibernate ไปเป็น EclipseLink ได้ไหม ?
- ใน Layer ของส่วนการแสดงผล เราสามารถเปลี่ยนจาก HTML ไปเป็น Java Swing ได้ไหม ?
- ใน Layer การติดต่อสื่อสาร เราสามารถเปลี่ยนจาก HTTP ไปเป็น SOAP ได้ไหม ?
- ใน Layer การจัดการ transaction เราสามารถเปลี่ยนจาก JavaEE, Spring และ JDBC ได้ไหม ?
เชื่อเถอะว่า คุณไม่เคยเปลี่ยนมันหรอก
เพราะว่า Architecture ที่เลือกไว้แล้วจะไม่มีการเปลี่ยนแปลงใดๆ
จนกว่าจะถึงเวลา ที่คิดว่า อ๋อ เราคิดผิด !!!
ซึ่งนั่นก็อาจจะใช้เวลานานพอควร
แต่เมื่อมันมาถึง การเปลี่ยนแปลงนั้นมันมักจะมาพร้อม
การ refactor code ขนานใหญ่กันเลย
นั่นคือ การสร้างของเก่าขึ้นมาใหม่อีกรอบ มันไม่สนุกเลย
และเชื่อเถอะว่า Abstraction layer ไม่ได้ช่วยอะไรมากนัก
เนื่องจากปัญหาส่วนใหญ่มาจากรายละเอียดต่างๆ ของการสร้างทั้งนั้น
มักจะคิดว่า Layer คือ การประกันความปลอดภัย
ถ้าคุณยังมีความคิดในรูปแบบนี้ คือ
ในแต่ละ Layer จะต้องมีประกันความปลอดภัยทั้งหมด
เพื่อรับประกันว่าแต่ละ Layer สามารถเปลี่ยนแปลง หรือ สลับที่ไปมาได้ง่าย
ดังนั้นคุณจะมีการซื้อประกันให้ทุก Layer ไปด้วยเสมอ เช่น
- Legal insurance
- Third party insurance
- Reinsurance
- Shipping insurance
- Payment protection insurance
- และอื่นๆ อีกมากมาย
ดังนั้น คุณจะต้องจ่าย จ่าย และ จ่ายมากขึ้นเรื่อยๆ
ทั้งในรูปแบบของตัวเงิน และ แรงที่ต้องลงไปกับมัน
แต่เมื่อส่วนต่างๆ เกิดปัญหาขึ้นมาแล้ว สิ่งที่ต้องพอเจอคืออะไรล่ะ ?
- ไม่ซื้อ หรือต่อ ประกันภัยกับ X แต่ไปทำกับ Y แทน
- ประกันไม่ครอบคลุมเรื่อง X นะ
- คุณไม่อ่านนโยบาย หรือ รายละเอียดของประกันหรอ
- และมันก็วนเวียนไปๆ มาๆ เสมอ
ดังนั้นก็ลองคิดดู ว่าจะยังสร้าง Layer ขึ้นมาเยอะๆ อีกไหม !!!
ถ้าคิดว่าดี ก็ทำไปนะ ..
ทางที่ดี คุณความหยุดทำและคิดแบบนี้ซะ
ถ้าคุณมีเงินและเวลามากพอ ก็ทำไปซะ ไม่ผิดหรอก
แต่คุณเคยหันไปดูกับคู่แข่งในตลาดหรือเปล่า
ว่าเขาดี เร็ว กว่าคุณหรือไม่
และคุณเคยตามคู่แข่งทันหรือไม่
ดังนั้นลองมองดูตัวเองว่า
- สามารถปล่อย product ออกมาได้รวดเร็วกว่าคุณหรือไม่
- สามารถปล่อยของในระยะเวลาสั้นๆ ได้ไหม
- สามารถปล่อยของที่มีประสิทธิภาพหรือไม่
- ระบบงานอ่านง่าย และ เข้าใจง่าย หรือไม่
- ระบบงานสามารถแก้ไขได้ง่ายหรือไม่
- ระบบงานสามารถติดตั้งได้ง่ายหรือไม่
- ระบบงานทดสอบได้ง่ายหรือไม่
ถ้าตอบว่าได้ แสดงว่าคุณมี Architecture ของระบบที่แจ่มเลยนะ
มันไม่มากและไม่น้อยจนเกินไป นั่นคือ ความเหมาะสม
Architecture ที่ดี มันต้องสามารถตอบรับกับการเปลี่ยนแปลงได้ง่าย
ไม่ใช่เป็นสิ่งที่แตะต้องหรือเปลี่ยนแปลงไม่ได้
โดยบทความนี้ไม่ได้บอกว่า Abstraction layer ไม่ดี
แต่อย่ามีมากจนเกินความจำเป็น
หรือบางครั้งอาจจะเกิดการออกแบบที่เผื่อไปมากๆ (Design Up Front (DUF))
ซึ่งก็ควรลด ล่ะ เลิก เพราะว่า มันไม่ค่อยดีเลย ( YAGNI )
แต่ละ Layer ควรเกิดขึ้นมา เมื่อมันจำเป็นต้องใช้งานจริงๆ เท่านั้น
