มาเขียน code ที่ดีกว่าเดิมกันดีกว่า

ช่วงวันหยุดยาวของผมคนเดียว
ได้นั่งอ่าน นั่งเขียน code บ้างเล็กน้อย
และเมื่อกลับไปอ่านและแก้ไข code เก่า ๆ
ก็พบปัญหาต่าง ๆ มากมาย ทั้ง ๆ ที่เราคิดว่ามันดีแล้วนะ

เมื่อลองนั่งคิดดูว่า นี่เป็น code ที่เราเขียนไว้ใช้งานเองยังขนาดนี้
ถ้าเป็น code ที่ดูแลกันหลายคนหรือเป็นทีม มันจะลำบากเพียงใด
ดังนั้นจึงลองแก้ไข และ สรุปสิ่งที่ควรจะทำ
เพื่อช่วยให้ code ของทีมดีขึ้น

มาดูกันหน่อย

1. กำหนด coding guildline ซะ แล้วนำ lint มาใช้งาน

เพื่อตกลงรูปแบบของ code ร่วมกัน
เพื่อให้มีรูปแบบเดียวกัน
จากนั้นนำเครื่องมือมาใช้
เพื่อช่วยจัดรูปแบบของ code ให้ หรือบอกจุดผิดพลาด

โดยตรงนี้ให้ทำการเขียน hook ใน git ก่อนการ commit ไปเลย (pre-commit)
นั่นหมายความว่า เราจะไม่ยอมให้ code ที่มีรูปแบบผิดจากที่ตกลงกัน
เข้ามาอยู่ใน repository ของทีมเลย

2. กำหนดรูปแบบของการตั้งชื่อสิ่งต่าง ๆ ซะ

จะใช้ camelCase หรือ snack_case ก็เอาสักทาง
คุยกันซะ

3. ชื่อที่สามารถสื่อสารได้อย่างชัดเจน (Communicative Name)

การตั้งชื่อมันบ่งบอกว่า เราเข้าใจปัญหาที่ต้องแก้ไขหรือไม่
แต่ถ้าหาคำดี ๆ ไม่ได้
แนะนำให้ทำการเขียน comment ที่อธิบายได้อย่างชัดเจนก็ได้

4. อย่าเขียน code ที่ซ้ำ ๆ (Don’t Repeat Yourself)

เป็นสิ่งที่น่ากลัวมาก ๆ สำหรับการพัฒนา software
ทั้งเสียเวลาในการสร้าง
ทั้งเสียเวลาในการดูแลรักษา

5. ระวังการเขียน code ที่มีจำนวนบรรทัดเยอะ !!

ในแต่ละไฟล์
ในแต่ละ class
ในแต่ละ method
ไม่ควรเขียน code จำนวนบรรทัดเยอะ ๆ นะ
เพราะว่าอ่านยาก
เพราะว่าเข้าใจยาก
เพราะว่าดูแลรักษายาก

6. พยายามแบ่งปัญหาใหญ่ ๆ ออกเป็นปัญหาย่อย ๆ (Work Breakdown)

ปัญหาของ code จำนวนมาก ๆ ในแต่ละ method
บ่อยครั้งมีต้นเหตุมาจาก การพยายามแก้ไขปัญหาขนาดใหญ่เพียงครั้งเดียว
ดังนั้นแนะนำให้หยุดคิดก่อนว่า
งานเหล่านั้น สามารถแบ่งออกเป็นงานเล็ก ๆ ย่อย ๆ ได้อย่างไรบ้าง
จากนั้นจึงเริ่มแก้ไขปัญหาเล็ก ๆ เหล่านั้นไปเรื่อย

โดยสิ่งนี้เป็นสิ่งที่นักพัฒนาควรฝึกกันไว้เยอะ ๆ

7. พยายามแยกการทำงานเป็นส่วนหรือไฟล์ย่อย ๆ

ระบบการทำงานยิ่งนานไป ขนาดและจำนวนของไฟล์ก็ยิ่งมากขึ้น
ดังนั้นการจัดโครงสร้างการทำงานจึงมีความสำคัญอย่างมาก
ให้แบ่งการทำงานเป็นส่วนเล็ก ๆ
ให้แบ่งการทำงานตามหน้าที่การทำงาน
ให้แบ่งการทำงานตาม feature
เพื่อการดูแลรักษาที่ง่ายขึ้น

เราไม่กลัวไฟล์จำนวนมาก
แต่จงกลัวไฟลงเดียวที่มีขนาดใหญ่มาก ๆ

8. พยายามเขียน code ที่ดูฉลาด ๆ ให้มันอ่านง่าย ๆ เข้าไว้

เรามักจะเจอ code ที่ดูฉลาดมาก ๆ
เช่น code สั้น ๆ
เช่น code ที่มี algorithm แปลก ๆ
เช่น code ที่ทำงานเร็ว ๆ
แต่กลับพบว่า code เหล่านี้เข้าใจได้ยากมาก ๆ
นั่นคือ แก้ไขยากเช่นกัน

ดังนั้นสิ่งที่ควรทำคือ ทำให้ code เหล่านี้มันอ่านง่าย ๆ

9. ทำการ refactor code กันอยู่อย่างสม่ำเสมอ

การ refactor code นั้นมันไม่ใช่งาน
แต่มันคือ หน้าที่ความรับผิดชอบของนักพัฒนาทุกคนที่พึงกระทำ
เพื่อปรับปรุง code ให้ดีอยู่อย่างตลอดเวลา
เพื่อทำให้ code ง่ายต่อการเปลี่ยนแปลง เช่นการเพิ่มความสามารถใหม่ ๆ

10. ลบ code กันบ้างนะ

code อะไรที่ comment ไว้ก็ลบไปบ้าง
code อะไรที่ไม่จำเป็นก็ลบไปบ้าง
code อะไรที่ไม่ถูกเรียกใช้ก็ลบไปบ้าง

อย่าลืมว่าเราใช้ version control กันนะ

สุดท้ายแล้ว

การเขียน code ที่นั้นสิ่งแรกเลยคือ
คนเขียนต้องเขียนและอ่านอย่างเข้าใจก่อน
แต่สิ่งที่ต้องจำไว้คือ code เหล่านั้น ไม่ได้มีเพียงเราคนเดียวที่ใช้งานหรือทำงานด้วย

ดังนั้นสิ่งที่ต้องตกลงร่วมกันคือ
รูปแบบการทำงานร่วมกัน
รูปแบบของ code ที่จะเขียนด้วยกัน
ซึ่งจะทำให้ทีมง่ายต่อการเขียน อ่าน review และดูแลรักษาต่อไป

ดังนั้น code ของทีมจะเน้นไปที่
consistency, simplicity และ readability

ขอให้สนุกกับการเขียน code ครับ