เมื่อวานมีโอกาสแบ่งปันความรู้เรื่องการใช้งาน Version Control ด้วย Git ไป
การ commit หรือบันทึกการเปลี่ยนแปลง
การ push หรือการส่งการเปลี่ยนแปลงไปยัง remote repository
การ pull หรือการดึงการเปลี่ยนแปลงจาก remote repository มายังเครื่องเรา
ทั้งหมดนี้คือ การพูดคุยและการทำงานร่วมกันของทีมพัฒนา
ยิ่งทำการ commit/push/pull บ่อย ๆ มากเพียงใด
ปัญหาที่เกิดก็จะน้อยลงไป !!
ลองคิดสิว่าระหว่าง commit บ่อย ๆ กับนาน ๆ ครั้ง
แบบไหนจะดีกว่ากัน ?
ก่อนที่จะทำการ commit code ต้องทำอะไรบ้าง ?
เป็นสิ่งที่นักพัฒนาหลาย ๆ คนมักจะหลงลืมหรือละเลยไป
ซึ่งมักจะทำให้เกิดปัญหามากมายตามมา
ทั้งที่ทำการ commit บ่อย ๆ แล้วก็ตาม
ดังนั้นมาดูกันว่า ต้องทำอะไรกันบ้าง
1. Code ที่ทำการแก้ไข compile ผ่านหรือไม่ ?
บ่อยครั้งพบว่า เมื่อแก้ไข code แล้ว
code เหล่านั้นไม่สามารถ compile ได้
เป็นสิ่งที่นักพัฒนาห้ามพลาด
2. สิ่งที่เปลี่ยนแปลงทำงานถูกต้องและไม่ส่งผลกระทบต่อส่วนอื่น ๆ หรือไม่ ?
เป็นขั้นตอนที่สำคัญมาก ๆ
ถ้าทำไปตามแต่ใจตนเอง
สิ่งที่ตามมาคือ ผลกระทบที่รุนแรงมาก ๆ
ไม่ทั้งต่อตนเอง คนอื่น ๆ ในทีม และระบบงาน
ดังนั้นการทดสอบจึงสำคัญมาก ๆ
ปล. ถ้าไม่ทำ นักพัฒนาจะพูดได้อย่างไรว่า งานนี้เสร็จแล้ว
3. ถ้าใน code มีการเขียน comment ต้องทำการแก้ไข ตาม code ที่เปลี่ยนไปด้วย
การเขียน comment เพื่ออธิบายว่า การทำงานของ code เป็นอย่างไร
ดังนั้นถ้าทำการแก้ไข code ในส่วนนั้น
ก็ต้องทำการแก้ไข comment เหล่านั้นด้วยเสมอ
มิเช่นนั้น comment จะไร้ค่าทันที
4. ทำการปรับปรุง code ด้วยหรือยัง ?
ทั้งรูปแบบของ code ให้ตรงตามที่ตกลงกันไว้ เช่น coding standard
ทั้งการแก้ไขโครงสร้าง code
ทั้งลบ code ที่ซ้ำซ้อน
ทั้งลบ code ที่ไม่ถูกใช้งาน
มันช่วยทำให้ชีวิตเราดีขึ้น
แต่ส่วนใหญ่มักไม่ทำ !!
5. ทำการเพิ่มหรือลบไฟล์จาก repository ให้ครบด้วยนะ !!
ในแต่ละ commit หรือการเปลี่ยนแปลง
ควรทำการเพิ่มหรือลบไฟล์ที่ต้องการให้ครบด้วย
มิเช่นนั้นจะเกิดปัญหาหนักตามมา
เช่นเอา code ขึ้นไม่ครบ !!
เพียงเท่านี้ก็จะทำให้เรามั่นใจได้ว่า
ในแต่ละ commit หรือการเปลี่ยนแปลงนั้น
มันทำงานได้อย่างถูกต้อง สมบูรณ์ตามที่เราคาดหวัง
เพื่อลดปัญหาที่จะเกิดตามมา
พยายามทำให้เป็นแบบอัตโนมัติมากที่เท่าที่จะทำได้
เพื่อลดเวลาที่ต้องเสียไป
เอาเวลาไปทำอย่างอื่นดีกว่านะครับ
คำถาม ปัจจุบันก่อน commit code เราทำอะไรกันบ้าง ?
