วันนี้เริ่มนำกิจกรรมเข้าจังหวะ ชื่อว่า Refactoring Code Retreat
มาให้ทีมลองเล่น และ ฝึกฝน การ refactor code กัน
ทำให้ต้องกลับไปอ่านเรื่อง refactoring แล้วพบว่า
มีกฎที่น่าสนใจในการ refactoring ชื่อว่า Rule of Three
ดังนั้น มาทำความรู้จักกับมันหน่อยสิ
Rule of Three คืออะไร ?
จาก Wikipedia อธิบายว่า
มันคือกฎที่มีไว้เพื่อ ตัดสินใจเพื่อจะทำการ refactor code นั่นเอง
กล่าวคือ
เมื่อ code มันชุดเดิมมันซ้ำกันมากกว่า 2 ที่
ให้ทำการ extract หรือแยกออกมาเป็น method ใหม่ซะ
ดังนั้น คุณมีโอกาส copy code ได้เพียงครั้งเดียวเท่านั้นนะ
โดยกฎนี้ถูกพูดถึงในหนังสือ Refactoring: Improving the Design of Existing Code
และคุณ Edsger W. Dijkstra ก็ได้พูดไว้ใน paper เรื่อง two or more, use a for เช่นกัน
สามารถอธิบายได้ง่ายๆ คือ
ครั้งแรก
ถ้าคุณทำบางสิ่งบางอย่าง ให้ลงมือทำไปเลย
ครั้งที่สอง
ถ้าคุณทำบางสิ่งบางอย่างที่เหมือนข้อหนึ่งแล้ว
อนุโลมให้สิ่งที่ทำนั้นมันเกิด duplicate หรือซ้ำซ้อนได้
แต่คุณน่าจะรู้สึกตัวได้แล้วนะ …
ครั้งที่สาม
ถ้าคุณยังทำสิ่งที่คล้ายๆ เดิมจากสองครั้งแรก ก็ได้เวลาที่คุณต้อง refactor แล้วนะ !!
หรือเรียกว่า Truely duplication
โดยการ refactoring นั้นสามารถทำได้เมื่อ
- ทำการเพิ่ม feature ใหม่ๆ เข้าไป
- ทำการแก้ไข bug
- ทำการ refactor เพื่อให้คุณเข้าใจระบบมากยิ่งขึ้น
แต่ก่อนที่จะทำการ refactor code ได้นั้น
คุณควรที่จะมี test คลุมเสมอนะครับ
เพื่อให้คุณมีความมั่นใจในสิ่งที่ทำลงไป
แต่ถ้าไม่มี test จริงๆ แนะนำให้ใช้ความสามารถของ IDE ที่ใช้นะครับ
เช่น Eclipse, IntelliJ เป็นต้น
ซึ่งมันจะไม่มีทางทำให้ code พังอย่างแน่นอน
ในโลกของการพัฒนา software นั้น
Duplication ถือว่าเป็นสิ่งที่น่ากลัวมากๆ
เพราะว่ามันทำให้ code ยากต่อการดูแลรักษาอย่างมาก
นั่นคือ cost ในการดูแลมันสูงมากๆ (Cost of change)
แต่การที่จะ refactor code ที่มัน duplicate เป็นเรื่องที่ยาก (ซ้ำกัน 2 ที่)
และต้องใช้เวลาที่สูงมาก ดังนั้นเราสามารถปล่อยให้เกิดไปก่อนได้นะ
แต่เมื่อมันมีการซ้ำครั้งที่ 3 ขึ้นมาแล้ว
เมื่อนั้นแหละ ที่ code ในระบบของคุณมันจะดูแลยากมากๆ
เพราะว่า ต้องแก้อย่างต่ำก็ 3 ที่เลยนะ !!
ดังนั้น คุณก็ควรที่จะหยุด และ refactor code ซะ
เพื่อลด code ที่มันซ้ำซ้อนลงไป
ซึ่งมันจะมีคุณค่าที่สูงกว่าการซ้ำเพียง 2 ที่นะ
(แต่ถ้าเห็นว่ามันซ้ำก็ควรจะ refactoring ได้แล้วนะ)
โดยที่กฎนี้ก็นำไปประยุกต์ใช้กับการเขียน code
เพื่อลดจำนวน Line of Code ลงไปได้เช่น
ถ้ามีการเรียกใช้ method เดิมซ้ำๆ กัน
เช่น
methodA(); methodA(); methodA(); methodA();
เราก็สามารถนำ loop มาใช้งานแทนได้
เพื่อลดบรรทัดของ code ลงไปเหลือบรรทัดเดียว
กฎนี้ก็สามารถนำไปใช้กับการ reuse ได้อีกนะ ดังนี้
- ถ้าเราต้องสร้าง component ซ้ำกันถึง 3 ครั้ง มันยากนะ ดังนั้นสร้างเพียง component เดียวดีไหม ?
- Component ที่จะ reuse นั้น ควรเป็นส่วนที่ทำงานมาจาก 3 ที่ก่อนนะ เพื่อให้รู้ว่ามันซ้ำกันจริงๆ ทั้งการทำงาน และ การใช้งาน (Truely reusable)
ดังนั้น Rule of Threee นั้นเป็นสิ่งที่น่าสนใจ และลองนำไปใช้งานดูครับ
มี VDO มาฝาก คือ 3 is a magic number
