จากหนังสือ Beyond Legacy Code นั้น
แนะนำวิธีการเพื่อลดความเสี่ยงของการพัฒนา software
แน่นอนว่า ช่วยลดค่าใช้จ่ายลงไปด้วย
เนื่องจาก software นั้นมันไม่มีรูปแบบที่แน่นอน
ยากต่อการทำความเข้าใจ
ยิ่งเมื่อมีหลายๆ ระบบทำงานด้วยกันยิ่งน่ากลัว
ความเสี่ยงก็เพิ่มมากขึ้นไปอีก
ดังนั้น ในขั้นตอนการพัฒนา software ที่ดี
ควรสนใจในการลดความเสี่ยงต่างๆ ลงไป
โดยการค้นหาปัญหาตั้งแต่เนิ่น หรือ ตั้งแต่เริ่มพัฒนา
เพื่อทำให้เรามีเวลาในการแก้ไข และ ปรับปรุงให้ดีขึ้น
มาดูกันว่า วิธีการลดความเสี่ยงมีอะไรบ้าง ?
1. Integrate continuously
ในการพัฒนา software นั้น
สิ่งแรกที่ควรทำก่อนอันดับแรกคือ การ integration ส่วนการทำงานต่างๆเข้าด้วยกัน
เพื่อทำให้เรารู้ว่ามีปัญหาอะไรบ้าง
นั่นคือ การลดความเสี่ยงในการพัฒนา software นั่นเอง
ลองคิดดูสิ ว่าปกติที่เราพัฒนา software นั้น
มักจะทำการ integrate ส่วนการทำงานต่างๆ เข้าด้วยกันเมื่อปลายการพัฒนา
ซึ่งเราพบว่า มันก่อให้เกิดปัญหาต่างๆ มากมาย
แต่มีการทำ risk management นะ !!
ดังนั้น มาทำการ integrate ส่วนการทำงานต่างๆ ของ software กันเร็วๆ เถอะนะ
2. Avoid branching
ถ้าคุณมี code เพียงชุดเดียว ความเสี่ยงก็จะน้อยลงไปมาก หรือ ไม่มีเลย
ลองคิดดูสิว่า ถ้าคุณมีหลาย component
แต่ละ component ก็มี code หลาย branch
แต่ละ component ก็ไม่ทำการ integrate กันสักที
ไปทำการ integrate ตอนสุดท้ายอีกเช่นเคย
ความเสี่ยงก็มากมาย ทั้งสิ่งที่เรารู้และไม่รู้
ดังนั้นแทนที่จะใช้ branch ก็เปลี่ยนไปใช้ feature flag หรือ feature toggle ดีกว่านะ
เพราะว่า เราจะทำการ integrate อยู๋ตลอดเวลา
เพียงแต่ไม่เปิดให้ใช้งานเท่านั้นเอง
3. Invest in automated tests
ในการตรวจสอบความถูกต้อง
ในการทำงานต่างของการพัฒนาที่มันซ้ำๆ
แนะนำให้ลดการทำงานแบบ manual หรือ การใช้คนซะ
ด้วยการสร้างระบบการทำงานแบบอัตโนมัติซะ
ตัวอย่างเช่น
การทดสอบแบบอัตโนมัติ คุณสามารถสั่งให้มันทำงานได้ทุกเมื่อที่ต้องการ
นั่นคือ ทำให้เรารู้ว่าสิ่งที่กำลังสร้างมันยังทำงานได้อย่างถูกต้องหรือไม่
แต่ถ้าระบบที่คุณสร้างมันไม่สามารถสร้างระบบทำงานแบบอัตโนมัติได้
นั่นแสดงว่า การออกแบบระบบของคุณมีปัญหาแล้วนะ
เช่น ถ้ามันทดสอบยาก คุณก็ควรทำการแก้ไขซะ
อย่าปล่อยไว้นาน ไม่เช่นนั้นมันจะกลับมาทำร้ายคุณ
4. Identify areas of risk
ความเสี่ยงต่างๆ ในการพัฒนา software มักจะมาจากสิ่งที่เราไม่รู้
หรือสิ่งที่เราไม่สามารถควบคุมได้
ดังนั้น เราจึงเริ่มต้นถามว่า มีสิ่งใดบ้างที่จะทำให้เราทำความผิดพลาดขึ้นมาได้
เพื่อหาวิธีการแก้ไข และ แยกส่วนนั้นๆ ออกมา
5. Work through unknowns
เมื่อคุณรู้ว่า สิ่งที่คุณไม่รู้มีอะไรบ้าง
ก็สามารถทำการเรียนรู้ และ ตอบคำถามเหล่านั้นในช่วงเวลาสั้นๆ
เพื่อทำให้เรารู้ว่า สิ่งที่เราไม่รู้เป็นอย่างไร
เพื่อหลีกเลี่ยงปัญหาที่จะพบเจอในอนาคต หรือ ไม่ต้องไปเสียเวลากับสิ่งเหล่านั้น
ดังนั้น ให้เริ่มต้นการพัฒนา software
ด้วยการแยกสิ่งที่รู้ และ ไม่รู้ ออกจากกันซะ
โดยเรื่องที่ไม่รู้ ให้แยกเป็นเรื่องเล็กๆ ด้วยนะ
6. Build the smallest pieces that show value
ปัญหาเล็ก นั้นเข้าใจง่ายกว่า ปัญหาใหญ่
ปัญหาเล็ก นั้นแก้ไขง่ายกว่า ปัญหาใหญ่
ปัญหาเล็ก นั้นดูแลง่ายกว่า ปัญหาใหญ่
ปัญหาสำคัญคือ คำว่าเล็กมันเป็นอย่างไรล่ะ ?
สิ่งเล็กๆ เหล่านั้น มันต้องมีคุณค่าต่อลูกค้า และ ทีมพัฒนาด้วยเสมอ
บางคนอาจจะใช้กฎ 80:20 ก็ได้นะ
7. Validate often
ลูกค้า หรือ ผู้ใช้งาน จะไม่รู้ว่าตัวเองต้องการอะไร จนกว่าจะเห็นและลองใช้
ดังนั้น ถ้าเราสร้าง software และนำมาให้ลูกค้าเห็น และ ใช้งานตั้งแต่เนิ่นๆ และ บ่อยๆ
มันจะช่วยทำให้เรารู้ว่า สิ่งที่กำลังสร้างมานั่นมันใช่หรือไม่
แต่ถ้าไม่ใช่ เราก็พร้อมที่ปรับเปลี่ยนได้ง่าย
ไม่เชื่อก็ลองทำดูสิ …
สุดท้ายแล้ว
การลดความเสี่ยงในการพัฒนา software นั้น จะทำให้เรามั่นใจว่า
- กำลังสร้างสิ่งที่ถูกต้อง (Build the right things)
- กำลังสร้างด้วยวิธีการที่ถูกต้อง (Build the things right)
เราจะรู้ว่าสิ่งที่สร้างมันคือสิ่งที่ถูกต้อง ก็ต่อเมื่อ
ได้รับ feedback กลับมาจากลูกค้า หรือ ผู้ใช้งาน
อย่างรวดเร็ว และ บ่อยๆ
เราจะรู้ว่าวิธีการสร้างมันถูกต้อง ก็ต่อเมื่อ
เราทำการ integration ระบบเมื่อทำการแก้ไข หรือ เปลี่ยนแปลง
เพื่อทำให้เรารู้ว่า วิธีการที่เรากำลังทำมันเหมาะสมนะ
เมื่อคุณทำสองสิ่งนี้แล้ว
มั่นใจได้เลยว่า มันจะช่วยทำให้การพัฒนา software มีความสำเร็จมากยิ่งขึ้น
