คุณ Robert C. Martin หรือ Uncle Bob กล่าวไว้ว่า
“Duplication may be the root of all evil in software.”
ดังนั้นในฐานนะของนักพัฒนา software
เมื่อพบเจอว่า code ส่วนไหนที่มัน duplicate หรือ ซ้ำซ้อน กัน
ก็ควรกำจัด code ส่วนนั้นออกไปจากระบบ
แต่สิ่งที่เราพบเจอในโลกความเป็นจริง คือ
ทุกๆ ระบบมี code ที่มัน duplicate จำนวนมากมาย
มันหมายความว่าอะไรกัน ?
นักพัฒนา software ทำไมถึงทำอย่างนั้นล่ะ ?
รู้ทั้งรู้ว่า duplicate code มันน่ากลัวเพียงใด หรือว่า
นักพัฒนา software ละเลย
นักพัฒนา software ทำงานแบบสุกเอาเผากิน
นักพัฒนา software ไม่ได้ใส่ใจกับ code เลย
นักพัฒนา software ไม่ได้เป็นมืออาชีพเลย
หรือว่า …
แต่อาจจะเกิดจากความไม่รู้ก็ได้นะ
เช่นไม่รู้ว่า code ของระบบมัน duplicate ตรงไหนบ้าง ?
เช่นไม่รู้ว่า code ของระบบมีอะไรบ้าง เกิดมาทำอยู๋แค่ตรง module ที่รับผิดชอบ ?
เช่นไม่รู้ว่า duplicate code เป็นอย่างไร ?
เช่นไม่รู้ว่า จะทำการแก้ไขมันอย่างไร ?
ดังนั้นเรามาเรียนรู้ และ ทำความรู้จักกับ duplicate code กันหน่อย
จากหนังสือ Refactoring ของคุณ Martin Fowler กล่าวไว้ว่า
“If you see the same code structure in more than one place”
และ
“You can be sure that your program will be better if you can find a way to unify them.”
แปลง่ายๆ ได้ว่า
ถ้าคุณเจอ code ชุดเดียวกันซ้ำๆ ในเรื่องของโครงสร้าง
ให้ทำการแก้ไขให้มันดีขึ้น ด้วยการรวบมาอยู่ด้วยกันซะ …
หรือว่าคุณทำเป็นไม่รู้ไม่ชี้ เมื่อเจอ duplicate code !!
จะแก้ไขไปทำไม ในเมื่อระบบมันทำงานได้ดี !!
แต่นั่นไม่ใช่แนวคิดของนักพัฒนา software ที่ดีนะครับ
ดังนั้น นักพัฒนา software
ควรมีความสามารถในการหา duplicate code
และมีวิธีการแก้ไข เช่น แยกออกมาเป็น method หรือ class ใหม่
มีขั้นตอนดังนี้
1. เมื่อเจอ duplicate code ด่าในใจก่อนว่า ………
2. จากนั้นหาวิธีการแก้ไข เช่น แยกออกมาเป็น method ใหม่ และแยกไปอยู่ class ใหม่ดังรูป
ให้เชื่อเถอะว่า มันดีกว่าเดิมแน่นอน
ปล. การแก้ไข duplicate code โดยไม่รู้ว่าระบบยังทำงานได้หรือไม่
มันเป็นแนวทางที่น่ากลัวมากๆ หรือ บาปมากๆ
ดังนั้น เรื่องของ unit test จึงสำคัญมากๆ
หรือไม่เช่นนั้น ก็ควรใช้ความสามารถของ IDE นะครับ
จะได้ช่วยลดความเสี่ยงลงไป
เพราะว่า เมื่อใดก็ตามที่เราลงมือเขียน code เราเริ่มสร้าง bug แล้วนะ !!
จากหนังสือ Refactoring นั้น
จะพูดถึง structure ของ code ที่มัน duplicate
ซึ่ง duplicate code นั้นไม่ใช่ code ที่มีหน้าตาเหมือนกันหมดอย่างเดียว
แค่มีโครงสร้างการทำงานที่เหมือน หรือ คล้ายกันก็ duplicate แล้วนะ
ดังนั้น เรามาดูกันหน่อยสิว่า ไอ้ Struture ที่มัน duplicate เป็นอย่างไร ?
code ในแต่ละบรรทัดเป็นการรวมตัวของ element ต่างๆ
แต่ละบรรทัดจะเรียงลำดับการทำงาน
มีการควบคุมขั้นตอนการทำงานด้วย loop, recursive เป็นต้น
ในแต่ะละ method เกิดจาก code หลายๆ บรรทัดที่ทำงานเดียวกัน
ในแต่ละ class ก็มีหลายๆ method ที่ทำงานด้วยกัน
ระหว่าง class ก็มีความสัมพันธ์กันทางแบบทางตรง และ ทางอ้อม
ซึ่งเรื่องเหล่านี้ มันประกอบออกมาเป็นแต่ละ Line of Code (LoC)
เป็นที่มาของ duplicate code นั่นเอง
ยิ่ง code มีความสัมพันธ์กันมากเท่าไร
จำนวนของ duplicate code ยิ่งมากขึ้นเท่านั้น !!
คำถาม
เราสามารถสรุปได้แบบนี้จริงๆ หรือ ?
มาดูตัวอย่างของ Struture duplication กันหน่อยสิ
แสดงดังรูป
คำอธิบาย
จะเห็นได้ว่า method a(), b() และ c() นั้น
เรียกใช้งาน method e(), f(), g(), h() และ i()
ซึ่ง method ทั้งสามอาจจะเรียกใช้งาน method ทั้ง 5
ด้วยลำดับที่แตกต่างกัน หรือ เหมือนกันก็ได้
เมื่อเจอปัญหาดังกล่าว
เราควรไปดูว่าทั้งใน method a(), b() และ c() นั้น
ควรจะมีลำดับการทำงานเหมือนกันไหม
ถ้าสามารถทำได้ จะดีมากๆ
เพราะว่า เราสามารถสร้าง method ใหม่ขึ้นมา
ทำหน้าที่ร้อยเรียงการทำงานของ method a(), b() และ c() ขึ้นมาใหม่
เพื่อลด duplicate code ลงไปนั่นเอง
แสดงดังรูป
จะเห็นได้ว่า โครงสร้างของ code ได้เปลี่ยนไปในทางที่ดีกว่าเดิมนะ !!
แต่มันมาด้วยค่าใช้จ่ายนะ
นั่นคือ code ของคุณจะลึกลับซับซ้อน หรือ มีลำดับชั้นมากขึ้น
จากเดิมมี 2 ชั้น เพิ่มมาเป็น 3 ชั้น
แน่นอนว่า ถ้าจำนวนลำดับชึ้น มันสูงขึ้น
ปัญหาที่ตามมาก็คือ เพิ่มความเสี่ยงให้เกิด Ripple effect ได้มากขึ้น
แต่เมื่อมาเทียบกับการลดลงของ duplicate code
ซึ่งเป็นต้นตอใหญ่ของปัญหาในการพัฒนา software แล้ว
มันน่าจะคุ้มค่ามากกว่านะครับ …
ดังนั้นในวันนี้คุณทำการลด duplicate code ลงกันหรือยังครับ ?
ถ้ายังไม่ยอมทำสักที สักวันหนึ่ง code ชุดนั้น
มันอาจจะกลับมาทำร้ายคุณ และ business ได้นะครับ
ลองกลับไปดู code ของคุณสิว่ามี duplicate code มากน้อยเพียงใด ?
แล้วเชิญทำลายมันซะ
อย่าผลักวันประกันพรุ่งนะครับ
