สรุปสิ่งที่ developer ที่ดีควรต้องรู้และเข้าใจ
เพื่อลดปัญหาต่าง ๆ ที่จะเกิดขึ้นมา
และน่าจะทำให้การพัฒนา software สนุกขึ้นมา
มันอาจจะเป็นเรื่องที่ยากสักหน่อย
แต่เชื่อว่ามันจะช่วย developer ได้นะ
1. Don’t Repeat Yourself (DRY)
ลองคิดดูสิว่าถ้า developer ต้องอยู่ในสถานการณ์
ที่ต้องเข้าไปเพิ่ม feature ที่เหมือนว่าจะมีอยู่แล้ว
คำถามคือ คุณจะทำอย่างไร
ระหว่างเขียน code ขึ้นมาใหม่ กับแก้ไข code เดิม ?
ทางที่ดีกว่าคือ แก้ไข code เดิมสิ
แต่ด้วยเหตุผลร้อยแปด
ทั้งอ่าน code ไม่รู้เรื่อง
ทั้งเวลาที่จำกัดซึ่งทาง project manager ได้กำหนดไว้แล้ว !!
ทั้งต้องทำการ regression test อีก
ดังนั้น developer มักจะบอกว่า เขียนใหม่เถอะ !!
สิ่งที่ตามมาคืออะไร ?
code เก่าและใหม่ทำงานคล้าย ๆ กัน
ซึ่งทำให้เกิด code ที่เหมือนกัน หรืออาจจะ duplicate กันเลย (Code duplication is Evil !!)
หนักไปกว่านั้น เราอาจจะพบว่า
ทั้ง code เก่าและ code ใหม่ถูกใช้งานจากส่วนต่าง ๆ อีกด้วย
ดังนั้นเมื่อมี requirement เปลี่ยน
ปัญหาก็จะตามมาอีก !!
ดังนั้นสิ่งที่ developer ควรรู้และเข้าใจก็คือ
การสร้าง duplication code อาจจะเป็นเส้นทางที่ง่ายและใช้เวลาน้อย
แต่สิ่งที่ตามมาก็คือ ค่าใช้จ่ายสูงที่ตามมาในอนาคตอันใกล้
ดังนั้นสิ่งแรกที่ควรจำไว้คือ Don’t Repeat Yourself
2. งานอะไรที่มันต้องทำซ้ำ ๆ ก็ให้ทันทำงานแบบอัตโนมัติซะเถอะ
สิ่งใดที่ developer ต้องทำซ้ำ ๆ ซ้ำแล้วซ้ำอีก เช่น การทดสอบ และ การ deploy
แน่นอนว่า เราต้องทำการทดสอบในทุก ๆ test case เสมอ
เมื่อทำการเพิ่มและแก้ไข code หรือ feature
ดังนั้นลดสิ่งเหล่านี้ด้วยระบบแบบอัตโนมัติซะ
ฟังดูเหมือนดีนะ แต่ทางหัวหน้าหรือทาง manager
อาจจะไม่เห็นดีเห็นงามด้วย
เพราะว่า ไม่มีทั้งเวลา ค่าใช้จ่ายให้หรอกนะ
แต่สิ่งที่ developer ต้องสื่อสารออกไปก็คือ
เมื่อใดก็ตามที่ให้คนมานั่งทำงานเดิม ๆ ซ้ำซาก
มักจะก่อให้เกิดข้อผิดพลาดได้เสมอ
และมีแนวโน้มจะเกิดปัญหาขึ้นเรื่อย ๆ
เพราะว่า ระบบงานยิ่งมากขึ้น feature มากขึ้น
ความซับซ้อนมากขึ้น
test case ก็มากขึ้นไปด้วย
ดังนั้นเวลาที่ใช้ไปก็มากขึ้นตามเช่นกัน
บางครั้ง developer ก็ชอบทำหน้าเคร่งเครียดหน้าจอ
บางครั้ง developer ก็ชอบพิมพ์ keyboard เสียงดัง ๆ
เพื่อแสดงหรือบอกให้รู้ว่าทำงานนะ
เพื่อแสดงหรือบอกให้รู้ว่างานเยอะนะ
แต่ผลที่ออกมาคือ ไม่ได้งานเป็นชิ้นเป็นอัน
หรือไม่เสร็จอะไรสักอย่าง
ได้แต่ bug หรือ ข้อผิดพลาดจำนวนมากมายมาทดแทน !!
ดังนั้น developer ที่ดี
ไม่น่าจะทำแบบนี้
ไม่น่าจะเสียเวลาไปกับสิ่งที่ไม่เกิดประโยชน์
ไม่น่าจะเสียเวลาไปกับสิ่งที่ต้องทำซ้ำ ๆ
ดังนั้นมาหาวิธีลดกันเถอะนะ
ถ้าทำด้วยวิธีแบบเดิม ๆ ก็ได้ผลแบบเดิม ๆ นั่นแหละ
3. Safety First
สิ่งที่ developer ที่ดีต้องมีคือ Safety First หรือ ปลอดภัยไว้ก่อน
ลองคิดดูสิว่า
ถ้า developer เปรียบได้กับแพทย์รักษาคนไข้แล้ว
ถ้าแพทย์ตรวจ วินิจฉัย และ รักษาผิดจะเกิดอะไรขึ้น
อาจจะทำให้ผู้ป่วยไม่หาย เกิดผลข้างเคียง หรือ เสียชีวิตได้
เช่นเดียวกับกับ developer ถ้า code ที่เขียนไปนั้น
โดยไม่ระมัดระวังก็อาจจะทำให้
code ส่วนอื่น ๆ ทำงานผิดพลาด หรือระบบพังได้เลย
ดังนั้น developer ลองกลับมาดูสิว่า
เราทำงานอยู่ในสภาวะแวดล้อมที่ปลอดภัยไหม ?
เช่น
มีชุดการทดสอบที่ดีและครอบคลุมหรือไม่ ?
มี server ที่พร้อมหรือไม่ ?
มีระบบการ deploy ที่ดีหรือไม่ ?
มีระบบรอบข้างที่พร้อมหรือไม่ ?
มี regression test ที่ดีหรือไม่ ?
เนื่องจากเมื่อเกิดปัญหาขึ้นมาแล้ว
เรามักอ้างว่า requirement ไม่ชัดบ้างล่ะ
เรามักอ้างว่าการประเมินเวลาผิดพลาดบ้างล่ะ
แต่มักไม่อ้างว่าสิ่งแวดล้อมมันไม่ปลอดภัยนะ
หรือพูดไปแล้วไม่สนใจ เพราะว่า ปกติมันเป็นแบบนั้นอยู่แล้ว !!
ดังนั้นสิ่งที่ developer ที่ดีควรคำนึงคือ Safety First
อย่างน้อยก็ต้องเขียนชุดการทดสอบบ้างล่ะนะ
ไม่ใช่ debug กันทั้งวัน
ทั้ง ๆ ที่ code เหล่านั้นเราก็เขียนขึ้นมาเอง !!
4. YAGNI
อย่าสร้างหรือเขียน code อะไรที่เกินความจำเป็น
แต่ให้ค่อย ๆ เพิ่ม code ขึ้นมาตาม requirement แทน
เนื่องจาก developer นั้นชอบทำเผื่อ !!
ดังนั้น ลด ล่ะ เลิกบ้างนะครับ
จากประสบการณ์พบว่า
สิ่งที่เผื่อไว้ส่วนใหญ่มักจะไม่ถูกนำไปใช้งานเลย
หรือใช้ก็น้อยมาก ๆ
หรือใช้ก็ผิดอีก
โดยข้อแนะนำต่าง ๆ เหล่านี้ใช่ว่าจะใช้ได้ในทุกสถานการณ์นะ !!
ดังนั้นก่อนนำไปใช้งาน ก็ให้คิด วิเคราะห์ แยกแยะด้วย
แต่จากประสบการณ์ที่ผ่านมา
น่าจะพอช่วยทำให้ชีวิตของ developer ดีขึ้นกว่าเดิมแน่นอน
รวมทั้งส่งผลดีต่อระบบที่พัฒนาด้วย
การรับมือต่อการเปลี่ยนแปลงของ requirement ที่ว่ารับมือยากแล้ว
การเปลี่ยนแปลงนิสัยของ develooper ที่มีมาอย่างยาวนาน ยิ่งยากกว่า
ดังนั้นลองมาปรับเปลี่ยนกันดูครับ
