เรื่องที่ 19 ที่นักพัฒนาควรรู้ และ เข้าใจก็คือ Know Your Next Commit
รู้ว่าสิ่งที่กำลังทำ และ สิ่งที่จะทำต่อไปคืออะไร ?
นั่นคือรู้ตื่น รู้ตัว อยู่ตลอดเวลา
ในการเขียน code นั้น นักพัฒนาทุกคนควรจะรู้นะว่า
สิ่งที่ตัวเองกำลังทำอยู่ คืออะไร จะเสร็จตอนไหน ?
และงานต่อไปคืออะไร ?
เมื่อลองไปถามนักพัฒนา 3 คนเกี่ยวกับงานที่ทำอยู่
ได้คำตอบมาดังนี้
คนแรก ตอบว่า
กำลังทำการ refactoring code ของ method xxx อยู่นะ
คนที่สอง ตอบว่า
กำลังเพิ่ม parameter เข้าไปใน method yyy อยู่นะ
คนที่สาม ตอบว่า
กำลังทำการพัฒนา user story หรือ feature zzz อยู่นะ
คุณเห็นอะไรจากนักพัฒนาทั้งสามคนบ้าง ?
อย่างแรก
เห็นไหมว่าคนที่หนึ่งและสองนั้น รู้รายละเอียดของงานที่กำลังทำอยู่
ส่วนคนที่สามเห็นภาพใหญ่ของสิ่งที่กำลังทำ
คุณคิดว่าใคร focus กับงานมากกว่ากัน ?
อย่างที่สอง
ทำการถามต่อไปอีกว่า แล้วจะ commit code หรือ check in code เข้าไปยัง Version Control เมื่อไร ?
สองคนแรก ตอบว่าได้อย่างชัดเจนว่า
งานที่ทำอยู่น่าจะใช้เวลาไม่ถึงชั่วโมงน่าจะเสร็จ
ดังนั้นการ commit code ครั้งต่อไปไม่เกิน1 ชั่วโมงแน่นอน
ส่วนคนที่สาม ไม่สามารถตอบได้ชัดเจน
โดยบอกว่า น่าจะใช้เวลาประมาณ 1 วัน
เพราะว่า อาจจะมีการเปลี่ยนแปลง class และ service นะ
แปลกไหม !!
สองคนแรกนั้น อาจจะขาดการมองภาพรวมของงานที่ทำ
แต่รู้ว่ากำลังจะทำอะไรต่อไปในชั่วโมงถัดไป
เพื่อให้งานที่คาดหวังไว้เสร็จสิ้น
เมื่อทำการหนึ่งๆ เสร็จแล้ว ก็จะทำการเลือกงานต่อไปมาทำได้
และ code ที่เขียนขึ้นมามันเสร็จตามเป้าหมายที่ได้กำหนดไว้
ส่วนคนที่สามกลับไปแน่ใจในสิ่งที่ทำ
นั่นหมายความว่า ไม่ได้ทำการแตกงานหรือปัญหาย่อยๆ ออกมา
ทำงานใหญ่ๆ ให้มันเสร็จในครั้งเดียวเลย !!
เหมือนการทำงานของนักพัฒนาส่วนใหญ่หรือเปล่านะ ?
เพราะว่า มันคือพื้นฐานของนักพัฒนาเกือบทุกคน
และคาดหวังว่าจะทำการ commit code เมื่อทุกอย่างมันเสร็จสิ้น
ดังนั้น มักจะพบปัญหาจาก code ส่วนนี้มากๆ
เนื่องจากใช้เวลาในพัฒนาเหลือเกิน กว่าจะทำการ commit เข้ามา
อาจจะก่อให้เกิด code conflict กับคนอื่นๆ ทำให้ต้องมีการ merge ขนาดใหญ่
และมันก็ก่อให้เกิดปัญหาตามมา ถ้าทำการ merge code ไม่ครบ
หรือ code ที่เขียนขึ้นมามันอาจจะแย่ หรือ เป็นวิธีการแก้ไขที่แย่ๆ ก็ได้
หรือเกิดการเปลี่ยนแปลง requirement ในช่วงท้ายๆ
ลองคิดดูสิว่า
ถ้าคุณมาเจอปัญหาเหล่านี้หลังจากที่พัฒนาเสร็จแล้ว
คุณคิดว่านักพัฒนาเหล่านั้น จะทำการแก้ไขหรือไม่ ?
ตอบได้ง่ายๆ ไม่ต้องคิดเลยว่า
- ไม่แก้ไขหรอกนะ
- ไม่ลบ code ทิ้งหรอกนะ
เพราะว่า มันจะเสียเวลามากๆ
และแล้ว code ส่วนนั้นมันก็ถูก commit เข้ามา …ขอให้โชคดี !!
ดังนั้น สิ่งที่นักพัฒนาควรต้องเรียนรู้คือ
- เรียนรู้ที่จะเข้าใจภาพรวมของงานที่ทำ
- เรียนรู้ที่จะแยกงาน หรือ ปัญหาออกมาแก้ไข เป็นงานย่อยๆ
- เรียนรู้ว่า code ที่เขียนสามารถแยกออกมาพัฒนาได้อย่างไร
และจะต้องเรียนรู้ว่า
สิ่งที่คุณจะ commit ต่อไปในอีกชั่วโมงคืออะไร ?
แต่ถ้าคุณยังไม่รู้ ให้พยายามทำให้รู้ซะ
เพื่อให้คุณมีเป้าหมายในการทำงาน ไม่ใช่ทำมั่วไปหมด
และถ้าสิ่งที่คุณวางแผนไว้มันไม่เสร็จในกรอบเวลาที่กำหนด
ให้ทำการโยนงานนั้นทิ้งไป
แล้วกลับมาแยกงานนั้นใหม่ เพื่อให้มันเล็กลง
เล็กเท่าที่คุณสามารถแก้ไขได้ใน 1 ชั่วโมง
ถ้าไม่เชื่อลองทำดูนะครับ !!
เท่าที่สัมผัสมาพบว่า นักพัฒนาส่วนใหญ่ไม่สามารถแตกงานย่อยๆ ออกมาได้
ซึ่งผมคิดว่ามันเป็นเรื่องปกตินะ
เนื่องจากนักพัฒนาถูกสอนมาอย่างนั้น
แต่ก็ควรที่ปรับปรุง และ เปลี่ยนแปลงกันได้แล้วนะ
สุดท้ายแล้ว
อย่าทำการ commit code ที่คุณไม่รู้
อย่าทำการ commit code ที่คุณใช้การคาดเดา
แต่ให้ commit code ที่คุณรู้ และ วางแผนไว้แล้วเท่านั้น
และที่สำคัญคือ รู้ขีดจำกัดของตัวเองด้วย
แนะนำให้ลองอ่านวิธีการพัฒนา Commit-Driven Development ดูครับ
