ว่าด้วยการปรับปรุงคุณภาพของ code ให้ดีขึ้น

มีคำถามที่น่าสนใจมาก ๆ คือ
เราต้องทำอย่างไรบ้างเพื่อดูแลรักษาคุณภาพของ code ?
เราต้องทำอย่างไรบ้างเพื่อปรับปรุงคุณภาพของ code ให้ดีขึ้น ?

ลองมาหาตอบคำถามกันหน่อยสิ

1. เริ่มต้นด้วยการเขียน Unit test ที่มีประโยชน์

โดยที่การเขียน unit test นั้นย่อมมี learning curve อยู่แล้ว
แต่มันไม่ใช่ปัญหาใหญ่อะไรมากไปกว่าการไม่เขียน
เป็นสิ่งที่ developer ต้องสนใจ ใส่ใจและฝึกฝน
เพื่อให้เกิดเป็นทักษะของตนเอง
จนทำให้กลายเป็นนิสัยของเราไปเอง

ผลที่จะได้รับกลับมาก็คือ คุณภาพของ code ที่ดีขึ้นกว่าเดิม
เนื่องจาก unit test จะบังคับให้เราเขียน code ที่ง่ายต่อการทดสอบ
นั่นก็คือ code แต่ละส่วนจะไม่ผูกมัดกันแน่นหรือเรียกว่า Tight coulping นั่นเอง
ซึ่งทำให้การออกแบบมันดีขึ้นตามไปด้วย

การเขียน unit test นั้นต้องพิจารณาถึงความคุ้มค่าด้วยนะ
แต่สำหรับผู้เริ่มต้นให้เขียนเยอะ ๆ เข้าไว้นะครับ
จะทำให้เรารู้ว่าควรหรือไม่ควรเขียนอะไร

อย่ามานั่งเถียงกันว่าจะเขียนหรือไม่เขียนดี
ซึ่งมันเสียเวลาโดยเปล่าประโยชน์

2. แยกส่วนการทำงานออกจากกันอย่างเหมาะสม

สิ่งที่ developer ต้องให้ความสนใจก็คือ
การจัดการเรื่อง dependency graph ที่เกิดขึ้นภายใน code ที่พัฒนา
ว่าเราจัดการได้ดีเพียงใด
ส่วนใหญ่มักจะแยกออกเป็นส่วนเล็ก ๆ แยกตามหน้าที่การทำงาน
เช่น module และ namespace เป็นต้น

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

มีคำถามที่ต้องตอบให้ได้ในการออกแบบและเขียน code คือ
ในส่วนการทำงาน A ต้องการ B จริง ๆ หรือไม่ ?

3. หัดเขียน code เพื่อคนอื่น ๆ บ้าง

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

ดังนั้นแทนที่ code จะออกมาดีตามที่คาดหวัง
กลับกลายว่าเกิดปัญหามากมายตามมาไป !!

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

ของดีแต่อยู่ผิดที่ มันก็แย่ได้เช่นกัน

4. ลดความซับซ้อนของ code ลงซะบ้าง

ค่าความซับซ้อนของ code วัดด้วยค่า Cyclomatic complexity
เพื่อวัดดูว่าใน code มีเส้นทางที่เป็นไปได้กี่เส้นทาง
ดังนั้น code ที่ดีมาก ๆ คือ ค่าความซับซ้อนเท่ากับ 1 !!

แต่ในความเป็นจริงเรากลับพบเงื่อนไข และ เส้นทางมากมายใน code
เช่น if-else ก็เกิด 2 เส้นทางแล้ว
ลองคิดดูสิว่า เรามี if-elseif-else กันเยอะไหม ?
ลองคิดดูสิว่า เรามี loop ซ้อน loop กันเยอะไหม ?

ซึ่งก่อให้เกิดปัญหามากมาย
ส่งผลต่อเวลาในการพัฒนา
ส่งผลต่อเวลาในการทดสอบ
ส่งผลต่อจำนวน bug ที่เยอะขึ้น
ส่งผลต่อเวลาในการ debug !!
ส่งผลต่อเวลาในการเพิ่ม แก้ไข code
รวมทั้งส่งผลต่อคุณภาพของ code ด้วย

ดังนั้นควรลดค่าความซับซ้อนของ code ให้ต่ำมาก ๆ นะครับ

5. ตั้งชื่อให้ชัดเจน สื่อสารถึงหน้าที่การทำงาน

เป็นสิ่งที่ developer บอกว่ายากมาก ๆ
แต่มันกลับส่งผลต่อคุณภาพของ code อย่างมากเช่นกัน
ดังนั้นต้องฝึก อ่าน และ เขียนเยอะ ๆ

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

ตัวอย่างเช่นยังมีคนเข้าใจว่า Java กับ Javascript มันเหมือนกันอยู่เลย !!

โดยสิ่งต่าง ๆ เหล่านี้เป็นสิ่งที่ยากน่าดู

แต่คิดว่าไม่น่าเกินความสามารถของ developer อย่างแน่นอน
เพียงแค่ต้องใช้เวลาในการฝึกฝนความสามารถ
เพียงแค่ต้องใช้เวลาในการสร้างวินัย
เพียงแค่ต้องใช้เวลาในการสร้างจนเป็นนิสัย
เท่านั้นเอง
แล้วผลที่ตามมาก็คือ code ที่มีคุณภาพสูงขึ้น

สุดท้ายแล้ว Developer ทั้งหลายจะตอบคำถามนี้กันอย่างไรบ้าง ?
มาแบ่งปันความคิดเห็นกันหน่อยสิครับ