เรื่องที่ 24 ที่นักพัฒนาควรรู้ และ เข้าใจก็คือ When Programmers and Testers Collaborate
เมื่อนักพัฒนา กับ tester สามารถทำงานร่วมกันได้ดี
มันมักจะมีสิ่งดีๆ ที่คุณไม่เคยคาดฝันเกิดขึ้นมามากมาย
คุณเชื่อไหมล่ะ ?
นี่คือภาพเดิมๆ ที่มันทำให้เกิดปัญหา ลด ละ เลิก !!!
บางทีมมี tester เข้ามาในทีมก็เจอปัญหา ลด ละ เลิก !!
เมื่อทำงานในรูปแบบนี้ จะมีสิ่งดีๆ เกิดขึ้นมาดังนี้
- เวลาในการส่ง หรือ แจ้ง bug ที่ลดลง
- ลดเวลาในการหา และ แก้ไข bug
- มีเวลาในการพัฒนาเยอะขึ้น
- มีเวลาในการปรับปรุงมากขึ้น
- ส่งผลให้งานดี และ มีคุณภาพสูงขึ้น
คุณแปลกใจไหม ?
คุณเชื่อไหมว่า มันมีสิ่งดีๆ เกิดขึ้นมากมายเมื่อทำงานร่วมกัน ?
ขั้นตอนที่มันควรจะเกิดขึ้น คือ
ก่อนเริ่มต้นพัฒนา
ทาง tester สามารถเข้าไปช่วยลูกค้าสร้าง และ เขียน automate acceptance test
ด้วยภาษาเฉพาะทางที่เหมาะสมกับงานนั้นๆ และเข้าใจง่าย เช่น Robotframeowork เป็นต้น
จากนั้น
ทาง tester ก็ส่งชุด automate acceptance test ให้กับทางทีมพัฒนา
สังเกตได้ว่า ทีมพัฒนาจะได้ชุดของการทดสอบก่อนการพัฒนา
ทำให้ทีมพัฒนาไม่ต้องเดาว่าจะทดสอบอะไร ?
รวมทั้งรู้ได้ชัดเจนว่า จะพัฒนาระบบออกมาอย่างไร ?
ดังนั้น
ทั้งทีม คือ ทีมพัฒนา และ tester จะต้องทำการฝึกหัด และ เรียนรู้ สิ่งที่เรียกว่า
Acceptance Test-Driven Development (ATDD)
โดยทีมพัฒนา และ tester สามารถสั่งให้ชึดการทดสอบนี้ได้เอง
หรือทำงานแบบอัตโนมัติได้
ซึ่งมันจะช่วยให้ทีมลดเวลาการทำ regression test ลงไป
ทีมพัฒนาก็ไปเริ่มต้นพัฒนาด้วยแนวคิด Test-Driven Development
ส่วน tester นั้นมีชุดการทดสอบในระดับ functional แล้ว
ดังนั้น จึงเอาเวลาไปทดสอบส่วนอื่นๆ ได้ เช่น
- Exploratory testing
- ภาพรวมต่างๆ ของระบบ
สิ่งที่ tester สามารถเข้ามาช่วยเหลือทีมพัฒนาได้ดี
ก่อนที่ทีมพัฒนาจะเริ่มเขียน code นั้น
สิ่งที่ยากมากๆ สำหรับนักพัฒนาก็คือ จะทดสอบระบบอย่างไรดี ?
ปัญหานี้
ทาง tester สามารถเข้ามาช่วยให้แนวคิด แนะนำ เกี่ยวกับการทดสอบแต่ละงาน
เพื่อให้ทางทีมพัฒนาเข้าใจว่า
ปัญหาคืออะไร ?
จะทดสอบอะไร อย่างไร ?
ต้องทดสอบอะไรบ้าง เพื่อให้มันครอบคลุมงานทั้งหมด ?
เมื่อทีมพัฒนาเข้าใจงานต่างๆ ชัดเจนแล้ว จึงเริ่มต้นการเขียน code
วิธีการเหล่านี้มันคือ การป้องกัน (Prevent) เพื่อไม่ให้เกิด bug
หรือให้เกิดขึ้นน้อยที่สุด
หรือเมื่อเกิดขึ้นแล้ว รู้ได้ทันทีว่ามีปัญหาจากตรงไหน
ซึ่งมันช่วยลดเวลาที่เปล่าประโยชน์ได้เยอะเลยใช่ไหม ?
สิ่งที่ทีมพัฒนาช่วยเหลือ tester ได้ดี คือ การสร้างระบบทดสอบแบบอัตโนมัติ (Automation)
เนื่องจากทางทีมพัฒนาจะรู้และเข้าใจดีว่า แนวปฏิบัติในการ coding ที่ดีเป็นอย่างไร
และสามารถช่วย tester สร้างระบบการทดสอบแบบอัตโนมัติที่ดีขึ้นมา
ซึ่งระบบนี้มันช่วยทั้งทีมพัฒนา และ tester เลยนะ (win-win)
บ่อยครั้ง มักพบว่าระบบการทดสอบแบบอัตโนมัติมักจะไม่ประสบความสำเร็จ
เนื่องจากการออกแบบโครงสร้างของชุดการทดสอบไม่ดี
เนื่องจากชุดการทดสอบเยอะเกินไป
เนื่องจากทาง tester ไม่เข้าใจเทคโนโลยีที่นำมาใช้
เนื่องจากชุดการทดสอบมันผูกมัดกันจนเกินไป
เนื่องจากเข้าใจผิด หรือ ทำผิด จนทำให้ทีมพัฒนาคิดว่า tester เป็นปัญหาคอขวดของการพัฒนา
ดังนั้นขอแนะนำว่า
การทำงานร่วมกับ tester นั้นจะช่วยทำให้ทีมพัฒนาเข้าใจสิ่งที่จะทำตั้งแต่เนิ่นๆ
ดังนั้นเครื่องมือที่นำมาใช้งานควรจะเป็นสิ่งที่ง่ายๆ (Simple Simple)
ทำให้สร้างมันขึ้นมาได้ง่าย
ส่งผลให้เราได้ feedback กลับมาได้รวดเร็ว
เพื่อทำการแก้ไข ปรับปรุง สิ่งที่จะส่งมอบให้ลูกค้าได้ดีขึ้นกว่าเดิม
สุดท้ายแล้ว
ทาง tester ต้องเลิกคิดว่า
- จะหา bug ให้ได้มากที่สุดจาก code ที่ทีมพัฒนาสร้างขึ้นมา
- จะทำอย่างไรให้ระบบมันหยุดทำงานให้ได้
ทางทีมพัฒนา ต้องเลิกคิดว่า
- tester เป็นศัตรูของเรา
- code ที่เขียนขึ้นมาไม่ต้องทดสอบหรอกนะ เรามี tester แล้วนะ
ดังนั้น เมื่อทีมพัฒนารู้ว่าจะต้องสร้างอะไร ทดสอบอะไร
รวมทั้งต้องสร้าง code ที่มีคุณภาพขึ้นมาเสมอ
นั่นคือต้องทำการทดสอบเองเสมอ
แสดงว่า code ที่เขียนต้องทดสอบได้ง่าย
มันจะสะท้อนไปยังระบบที่สร้างใช่ไหม ? ดีไหมล่ะ ?
และ ทีม สามารถทำการ regresstion test แบบอัตโนมัติได้เลย
สะดวกไหมล่ะ ?
รวดเร็วไหมล่ะ ?
คำว่าการทำงานเป็นทีม (Teamwork) มันจึงเกิดขึ้นมาใช่ไหมล่ะ ?
ส่งท้ายด้วยว่า การทดสอบมันคือ Activity หรือ กิจกรรมที่เกิดขึ้นอยู่ตลอดเวลานะครับ
ไม่ใช่เป็น phase เหมือนเดิม หรือ ที่คุณทำมาหรือทำอยู่กันนะครับ
Reference Website
Slide :: What is Agile Tester ?
