Developer ส่วนใหญ่ไม่รู้จัก Code Smell ?

จาก Newsletter ของคุณ Sandi Metz เป็นผู้เขียนหนังสือ Practical Object-Oriented Design in Ruby (POODR) ได้อธิบายเรื่องของ Code Smell ไว้อย่างน่าสนใจ จึงได้นำมาแปล และ สรุปไว้นิดหน่อย ซึ่งอ่านแล้วมันเจ็บแสบน่าดู แต่ผมเชื่อว่า มันคือเรื่องจริงนะ !!

เรื่องของ code ที่มันยากต่อการทำความเข้าใจ และ ยากต่อการเปลี่ยนแปลง !!

มันน่าจะเป็นเรื่องปกติของ developer เกือบทุกคน ที่มักจะบอกว่า มันก็ปกตินะ ที่มักจะบอกว่า มันก็เป็นแบบนี้แหละ แต่ผมคิดว่า มันผิดปกตินะ แถมมันคือ ต้นเหตุของความวอดวายในอนาคตอีกด้วย หรือใครหลาย ๆ คนน่าจะกำลังเผชิญกับมันอยู่ก็เป็นได้ สิ่งที่น่าสนใจสำหรับ code เหล่านี้คือ มักจะมีรูปแบบคล้าย ๆ กัน (Pattern) นั่นคือ ผิดเหมือน ๆ กัน นั่นคือ ผิดซ้ำ ๆ จนมองว่า มันคือเรื่องปกติ !! โดยรูปแบบเหล่านี้ ถูกเรียกว่า Code Smell

คำถามที่เกิดขึ้นมาในหัว คือ Developer รู้และเข้าใจเกี่ยวกับ Code Smell กันบ้างไหม ?

ถ้าใครบอกว่ารู้ ช่วยบอกชื่อของ Code Smell พร้อมกับเหตุผลด้วยว่า มันมีรูปแบบอย่างไร จงยกตัวอย่าง ? ทำไมมันถึงก่อให้เกิดปัญหา ? จะทำแก้ไขปัญหาเหล่านั้นอย่างไร แบบ step-by-step ? โดยขอสัก 5 อย่างนะ ... จากประสบการณ์ที่ผ่านมา พบว่า developer ตอบได้น้อยมาก ๆ หรือ ไม่รู้นั่นเอง นั่นมันอาจจะแสดงว่า code ที่สร้างจาก developer เหล่านั้นมันคืออะไร ? ไม่ได้ระวังเรื่องของ code smell เลยใช่ไหม ? ดังนั้น ถ้าต้องการปรับปรุง code หรือ refactoring มันจะทำได้หรือ ? เพราะว่า แม้แต่ปัญหาก็ยังไม่รู้ แล้วจะแก้ไขได้อย่างไร ? สรุปแล้ว developer เขียน code อะไรกันอยู่ !!

จาก paper เรื่อง When and Why Your Code Starts to Smell Bad

เป็นการนำข้อมูลการ commit จาก opensource project กว่า 200 project มาทำการทดลอง และ วิเคราะห์ เพื่อหาว่า Code Smell เกิดขึ้นตอนไหน อย่างไร รวมทั้งได้ทำแบบสำรวจเกี่ยวกับ Code Smell พบว่า

Developer ประมาณ 32% ไม่รู้จัก Code Smell หรือรู้เพียงเล็กน้อยเท่านั้น !!

โดยสิ่งเหล่านี้ มันคือปัญหาที่ยิ่งใหญ่มาก ๆ ในการทำงานนั้น developer มักจะพบเจอ code ที่มันยุ่งเหยิง ซึ่งมักเรียกว่า Legacy code หรือ Spaghetti code แน่นอนว่า code เหล่านี้มี Code Smell มากมาย และที่สำคัญมันมี Code Smell มากกว่า 1 รูปแบบแน่นอน ดังนั้นการแก้ไขควรแก้ไขทีละปัญหาไปเรื่อย ๆ เพื่อทำให้ code เหล่านั้นดีขึ้น แต่ถ้า developer ไม่รู้ และ เข้าใจเกี่ยวกับ Code Smell เลย ผลที่ได้คือ จะเห็นแต่ปัญหาใหญ่ ๆ ซึ่งการแก้ไขมันยากมาก ๆ รวมทั้งผลกระทบก็มหาศาล แล้วใครละที่จะกล้าแก้ไข เนื่องจากผลการแก้ไขมักจะเป็นดังรูป

ดังนั้น เหนือสิ่งอื่นใด Developer ควรรู้และเข้าใจเกี่ยวกับ Code Smell ก่อน

จากนั้นจะรู้และเข้าใจ Code Smell แต่ละตัว มีรูปแบบอย่างไร ? ก่อให้เกิดปัญหาอย่างไร ? ทำการแก้ไขอย่างไร หรือ มีขั้นตอนในการ refactor code อย่างไร ? มันจะทำให้ developer สามารถเห็นปัญหา และ ปรับปรุง code ได้ง่ายขึ้น

ในปัจจุบัน developer สามารถเรียนรู้เรื่อง Code Smell ได้ง่ายขึ้นแล้วนะ

ถ้าไม่เชื่อลองเข้าไปศึกษาได้จาก

• หนังสือ Refactoring ของคุณ Martin Fowler อยู่ในบทที่ 3
• Online catalog
• Code Smell Cheat Sheet

ยังไม่พอนะ ยังไม่คนแบ่งกลุ่มของ Code Smell ให้อีก ซึ่งทำให้ง่ายต่อการศึกษา และ ทำความเข้าใจอีกด้วย อยู่ที่ Code Smell Taxonomy ดังนี้

• Bloaters เช่น long method และ large class (God class)
• Object-Oriented Abusers เช่น Switch statement
• Change preventer เช่น Divergence change
• Dispensable เช่น Lazy class
• Coupler เช่น Feature envy

มาถึงตรงนี้ ถ้า Developer คนไหนอ่านแล้วงง ๆ

หรือไม่รู้ว่า มันเขียน หรือ อธิบายถึงเรื่องอะไร คำศัพท์ หรือ ชื่อเรียกเยอะไปหมดเลย ขอแนะนำให้ทำการศึกษาจาก Link ต่าง ๆ ข้างต้นได้เลย แล้วมันจะทำให้คุณรู้ และ เข้าใจมากขึ้น บางครั้งเมื่อกลับไปอ่าน code เก่า ๆ ที่เคยเขียน อาจจะพบกับ Code Smell เต็มไปหมดเลยก็เป็นได้ !! และสิ่งที่สำคัญมาก ๆ เกี่ยวกับ Code Smell คือ จงอย่าจำ แต่ให้เข้าใจ ด้วยการลงมือทำนั่นเอง

คำถาม คุณต้องการปรับปรุง code ให้ดีขึ้นหรือไม่ ?