อ่านเจอบทความเรื่อง Make the Magic go away เขียนโดยคุณ Robert C. Martin หรือ Uncle Bob
ทำการอธิบายถึงการใช้งาน framework ต่าง ๆ ไว้อย่างน่าสนใจ
โดยก่อนที่จะนำมาใช้ เราควรเข้าใจมันก่อน !!
จะเข้าใจมันได้อย่างไร นั่นคือ คุณต้องเขียนขึ้นมาเองก่อน
จากนั้นจึงกลับไปดู framework ต่าง ๆ ว่ามันเหมาะกับงานของเราหรือไม่ ?
และเราสามารถอยู่ได้ หรือ พัฒนาระบบได้โดยไม่ต้องพึ่ง framework ได้ไหม ?
ดังนั้น จึงขอนำมาแปลในส่วนที่น่าสนใจดังนี้
ในบทความยกตัวอย่างของ rxJava
เป็น framework ขนาดเล็ก และ มีประโยชน์ต่อการพัฒนาระบบงานอย่างมาก
โดยที่ทุก ๆ อย่างสามารถถูก observe หรือ โดนเฝ้าติดตามการเปลี่ยนแปลงได้
และสามารถจัดการส่วนต่าง ๆ ผ่าน callback
คำถาม มันคือวิธีการใหม่ ๆ หรือไม่ ?
คำตอบ คือ ไม่
เนื่องจากมันเป็นแนวคิดของพวก data flow และ functionnal language
เป็นแนวคิดหนึ่งที่อยู่ในหนังสือ Design Pattern ของ GOF (Gang of Four)
นั่นก็คือ Observer pattern
แต่วิธีการนี้ไม่ได้รับความนิยมมากนัก
เนื่องจากมันทำงานแบบ indirect
หรือทำงานแบบไม่ตรงไปตรงมาน
ส่งผลให้ยากต่อการ debug/trace และ ทดสอบ
แต่ไม่ได้บอกว่า rxJava มันไม่ดีนะ
Framework ต่าง ๆ เกิดจากจุดอ่อนของภาษาโปรแกรมนั้น ๆ
ไม่ว่าจะเป็น rxJava, Spring, Hibernate, JSF, Spring และอื่น ๆ อีกมากมาย
ถูกสร้างมาเพื่อพยายามปรับปรุงตัวภาษาโปรแกรมนั่นเอง
ให้มันง่ายต่อการพัฒนาระบบงานน
ยิ่ง framework มีมากเท่าไร มันหมายถึง จุดอ่อนของภาษานั้น ๆ ก็เยอะเช่นกัน
แต่ถ้าสร้าง framework แล้วมันได้ผลออกมาไม่ดี หรือ ไม่เหมาะสม
จะทำให้เกิดการสร้างภาษาใหม่ ๆ ขึ้นมา
ดังนั้น ภาษาใหม่ ๆ เกิดขึ้นมาเพื่อชดเชย และ แก้ไขจุดอ่อนเหล่านั้นนั่นเอง
โดยที่ภาษา และ framework ใหม่มักจะบอกว่า
- มีความเร็วกว่า
- พัฒนาได้เร็วกว่า
- เขียนได้ง่ายกว่า
- สร้างระบบได้ง่ายกว่า
- ออกแบบมาได้ดีกว่า
แต่เมื่อนำมาใช้งานจริง กลับไม่แตกต่าง
แถมบางครั้งยากกว่าเดิมอีก (Magic มันเยอะมากมาย)
ส่วนการออกแบบระบบก็ยังแย่อยู่เหมือนเดิม
ภาษาใหม่ ๆ มักจะมีสิ่งที่เรียกว่า Magic มากมาย
ซึ่งมันเป็นสิ่งที่ดี ถ้าคนใช้งานเข้าใจว่า
มันถูกสร้างมาอย่างไร
มันถูกสร้างมาเพื่ออะไร
เมื่อทำงานผิดพลาด รู้สาเหตุ และ แก้ไขได้ทันที
แต่ส่วนใหญ่ มักจะไม่เข้าใจะนะสิ !!
จึงทำให้เกิดปัญหามากมายตามมา
ดังนั้น ก่อนจะเลือกใช้ framework หรือ ภาษาอะไร
ให้ลองคิดก่อนว่า ระบบของเราต้องการใช้งานอะไรบ้าง ?
ใช้เพียง framework หรือ วิธีการง่าย ๆ มันเพียงพอหรือไม่ ?
หรืออาจจะไม่ต้องใช้ framework เลยหรือไม่ ?
บางครั้งคุณเพียงเขียน code ขึ้นมาใช้เองก็ได้
ลองคิดดูหน่อยสิว่า
Code ที่คุณไม่ได้เขียนเอง
Code ที่คุณไม่ได้ควบคุมเอง
Code เหล่านั้นอาจจะไม่น่าไว้ใจก็ได้นะ !!
สรุปแล้ว ก่อนนำอะไรไปใช้งาน
อย่าเพิ่งวิ่งเข้าหาพวกภาษา และ framework ที่แจ่มๆ
แต่ให้ทำความเข้าใจความต้องการของระบบงานก่อนว่ามีอะไรบ้าง
จากนั้นจึงไปดูว่า
เราสามารถสร้างส่วนการทำงานนั้น ๆ ขึ้นมาได้เองหรือไม่
สร้างให้มันเรียบง่าย ตามความต้องการ
ไม่ต้องมาเผื่อโน่น นี่ นั่น (นักพัฒนาชอบการเผื่อ !!)
จากนั้นจึงกลับมาดู และ พิจารณา framework อีกรอบ
ว่ามันยัง ดี และ เหมาะสมกับงานของเราหรือไม่ ?
ลองกลับไปดูสิว่า
เราพัฒนาระบบงานโดยนำเอาภาษา และ framework เป็นตัวตั้งต้นหรือไม่ ?
ถ้าใช่ แนะนำให้ปรับเปลี่ยนการคิดก่อนเลย
ไม่เช่นนั้น คุณจะถูกล้อมกรอบความคิดอย่างแน่นอน
