เรื่องที่ 17 ที่นักพัฒนาควรรู้ และ เข้าใจก็คือ Deploy Early and Often
ปกติ software ที่คุณพัฒนากันนั้น
ทำการ deploy ระบบงานบน environment จริงๆ กันบ่อยไหม ?
หรือทำเพียงครั้งเดียว หลังจากที่พัฒนาระบบงานเสร็จ !!
เรื่องจริง แต่มันแปลก หรือว่า เรื่องแปลกแต่เราทำกันจริงๆ
บ่อยครั้งจะพบว่าการ deploy และ ติดตั้งระบบงาน
มีกจะทำหลังจากที่ระบบงานพัฒนาเสร็จสิ้นทั้งหมดแล้ว
และบ่อยครั้งเรามักจะได้ยินคำว่า debug ดูสิ ในขณะทำการ deploy !!
บางระบบดีหน่อย
เขียนเครื่องมือเพื่อช่วยเหลือในการติดตั้งในส่วนงานที่มันมักผิดพลาดบ่อยๆ
เพื่อให้ชีวิตมันง่ายขึ้น
และทำการ review และ ทดสอบการติดตั้งระบบงาน
บน environment ที่เราสร้างขึ้นมาเอง (ส่วนใหญ่ก็ไม่ใช่ environment จริงๆ หรอกนะ)
เพื่อให้มั่นใจว่าสิ่งที่เราติดตั้งไปนั้นทำงานได้อย่างถูกต้อง
แต่ทีมที่ทำการติดตั้ง
จะไม่เคยมีประสบการณ์ในการติดตั้งระบบนั้นๆ เลย
จนกว่าระบบมันจะเสร็จ
และส่วนใหญ่ก็มักจะเกิดเหตุการณ์ที่ไม่คาดฝัน
ตอนการติดตั้งบน production นี่แหละ
แต่มันก็สายเกินไปแล้ว ที่คุณจะทำการแก้ไข หรือ เปลี่ยนแปลงมัน !!
ขั้นตอนการติดตั้งนั้น คือ สิ่งแรกที่ลูกค้า หรือ ผู้ใช้งานจะเห็นระบบหรือไม่ ?
ถ้าคุณไม่ทำการติดตั้งระบบงาน บน environment จริงๆ
ผู้ใช้งานจะเห็น หรือ ใช้งานได้อย่างไร
ดังนั้น ถ้าคุณทำการติดตั้งระบบงานบน environment จริง
ตั้งแต่แรกเริ่มการพัฒนาระบบ มันจะง่ายกว่าไหม ?
ถ้าคุณติดตั้งระบบงาน และให้ผู้ใช้งานเข้ามาใช้งานจริงตั้งแต่แรกๆ
มันจะดีกว่า รอให้มาใช้ตอนพัฒนาเสร็จทีเดียวไหม ?
การทำงานในรูปแบบนี้ ไม่เพียงแต่ทำให้แน่ใจว่า ขั้นตอนการติดตั้งถูกต้อง
แต่มันคือการตั้งคำถามให้ใช้ผู้ใช้งานอีกว่า
สิ่งที่ทีมพัฒนากำลังสร้าง มันใช่สิ่งที่ผู้ใช้งานต้องการหรือไม่ ?
เมื่อเราเริ่มขั้นตอนการติดตั้งระบบ ตั้งแต่เริ่มพัฒนาระบบ
เราสามารถเปลี่ยนแปลง ปรับปรุง ขั้นตอนการติดตั้ง
รวมทั้งแก้ไข code เพื่อให้ง่ายต่อการติดตั้งอีกด้วย
การติดตั้งในช่วงท้ายๆ มันหมายความว่าอย่างไร ?
ขั้นตอนการติดตั้งระบบงานของคุณ มันจะต้องมีความซับซ้อนอย่างแน่นอน
การจะหาจุดผิดเป็นเรื่องที่ยากมาก
เชื่อได้เลยว่า
ทีมพัฒนาจะต้องมี IDE เทพๆ
ที่สามารถจัดการได้ทุกสิ่งทุกอย่างตามที่ต้องการ
ตั้งแต่การพัฒนายันการติดตั้งในแต่ละ environment
ยังไม่พอ การติดตั้งระบบงานจริงๆ ยังทำผ่าน IDE อีก
แล้วมันสนุกไหมล่ะ ?
คุณเท่านั้นที่สามารถตอบได้ดีที่สุด
ดังนั้น มันจะดีกว่าไหม ถ้าคุณรู้ปัญหาได้รวดเร็ว ?
ดีกว่ามารู้ในช่วงท้ายๆ ของการพัฒนา software
สิ่งที่มักเข้าใจผิด คือ คำว่า เราสามารถติดตั้งระบบได้ตลอดเวลา ?
มันอาจจะดูไม่มีคุณค่าทาง business เท่าไร
ถ้าคุณบอกว่า สามารถติดตั้งบนเครื่องของคุณ หรือ บน environment เสมือนจริง
หรือบางคนอาจจะบอกว่า บนเครื่องฉันมันทำงานได้นะ !!
แต่มันจะมีความหมายมากๆ ถ้าคุณทำการติดตั้งบน environment จริงๆ
หรือ environment ที่ตกลงไว้กับผู้ใช้งาน
มันน่าจะเป็นการส่งมอบคุณค่าทาง business แบบสุดๆ ใช่หรือไม่ ?
แต่ไม่ชอบทำกัน มันแปลกดีนะ !!
มีบางคนบอกว่า ทำไม่ได้หรอกนะ ระบบเราใหญ่ ขั้นตอนมันซับซ้อน
ถ้าขั้นตอนยิ่งมีความซับซ้อนเท่าไร
ความไม่นอนย่อมเกิดขึ้นมามากเท่านั้น
ดังนั้น ยิ่งมันยาก ซับซ้อน ก็ให้ทำมันบ่อยๆ สิ
ลองกลับไปมองการเขียน code สิ
คุณเริ่มด้วยการทดลอง ว่าทำได้หรือไม่
ต่อจากนั้นเริ่มลงมือเขียน code และทำการทดสอบ
ถ้า code ที่ออกมามันมีกลิ่นแปลกๆ ก็ทำการแก้ไข หรือ refactoring ซะ
แล้วคุณจะได้ code ที่ต้องการ
กับการติดตั้งระบบก็เหมือนกัน ทำไมเราไม่ refactoring ขั้นตอนล่ะ ?
เพื่อให้ได้วิธีการที่มีประสิทธิภาพ
และส่งผลดีต่อทีมพัฒนา และ ผู้ใช้งาน
จำไว้ว่า Deploy มันไม่เท่ากับ Release นะครับ
วันนี้คุณทำการติดตั้งระบบงานตอนไหนหรือ ?
