ถ้า developer สร้าง code ชุดหนึ่งขึ้นมา
ก็น่าจะต้องเดินตามเส้นทางของ code
เพื่อดูว่าพฤติกรรม และ ผลการทำงานเป็นอย่างไร ?
และเป็นไปตามที่คาดหวัง หรือ ตกลงไว้หรือไม่ ?
นั่นคือ การทดสอบ (Testing)
แต่ทำไม developer ส่วนใหญ่
ถึงไม่ชอบทดสอบ code ที่ตัวเองเขียนขึ้นมา ?
นั่นจึงเป็นเหตุผลหนึ่งว่า
ทำไมต้องมี Tester/QA มานั่นเอง !!
หลาย ๆ คนจึงมองว่า
Developer คือ ผู้สร้าง code และ ผู้สร้างปัญหา ในคน ๆ เดียวกัน
Tester/QA คือ ผู้คอยตรวจหาข้อผิดพลาด
ทั้งสองเหมือนแมวไล่จับหนู
สุดท้ายก็โดนหมากัดตายทั้งคู่ !!
ในตอนนี้จึงทำให้เกิด
2 กลุ่มคนที่แยกออกจากกัน
2 มุมมองที่แตกต่างกัน
ปัญหาที่เกิดขึ้นมา คือ เล่นซ่อนหากันระหว่าง 2 กลุ่ม
คือ ฝ่ายหนึ่งพยายามจะซ่อน ส่วนอีกฝ่ายพยายามที่จะหา !!
มันไม่น่าจะส่งผลดีต่อใครเลยใช่ไหม ?
ลองมาเริ่มกันใหม่ดีกว่านะ !!
Developer ลองถามตัวเองหน่อยสิว่า
ทำไมเราถึงไม่ทดสอบ code ที่เขียนขึ้นมาเอง ?
บางคนอาจจะบอกว่า ทดสอบแล้วนะ แต่ …
บางคนอาจจะบอกว่า ไม่มีเวลาทดสอบ แสดงว่าสิ่งที่บอกว่าเสร็จ มันคือคำโกหกนะสิ
บางคนอาจจะบอกว่า งานเยอะนะ ทำไม่ทันหรอก แสดงว่ารู้ปัญหานะ !!
บางคนอาจจะบอกว่า ไม่รู้จะทดสอบอะไร อย่างไร ? น่าสนใจ
บางคนอาจจะบอกว่า ระบบที่สร้างมันทดสอบไม่ได้หรอกนะ !! แล้วรู้ได้อย่างไรว่ามัน work !!
ดังนั้น
เราน่าจะหาใครที่เหมาะสม
ที่มีความรู้มาทดสอบแทนดีกว่านะ !!
ดูเหมือนว่า มันคือการโยนงานออกจากตัวมากกว่านะ
ลองคิดดูสิว่า
ใครกันที่จะรู้ปัญหาได้ดีกว่า คนสร้าง ?
ใครกันที่จะช่วยลดขอบเขตของปัญหาได้ดีกว่า คนสร้าง ?
ใครกันที่จะรู้ และ เข้าใจได้ดีไปกว่า คนสร้าง ?
ดังนั้น ผู้สร้าง หรือ developer มาเรียนรู้เพื่อที่จะทดสอบ code ตัวเองกันเถอะนะ
มาดูกันหน่อยว่า มีเทคนิคอะไรที่มาช่วยให้การทดสอบดีขึ้น
เริ่มต้นด้วย
ต้องมีความรู้ความเข้าใจเกี่ยวกับ Software testing บ้างนะ
เช่น test technique ต่าง ๆ
รวมทั้งข้อมูลการทดสอบต้องมีความหมายด้วย
ยกตัวอย่างเช่น
ระบบรองรับข้อมูลจำนวนไม่เกิน 10,000
คำถามคือ คุณจะทดสอบด้วยข้อมูลอะไรบ้าง ?
คำตอบมันง่ายมาก ๆ คือ
- 9,999
- 10,000
- 10,001
ไงล่ะ ง่ายจะตาย !!
แต่เดี๋ยวก่อนนะ ลองหยุดคิดกันก่อนไหม ว่า
9,999 และ 10,001 มันเป็นข้อมูลที่มีความหมายอะไรหรือ ?
ผมเลือก 5,500 กับ 48,000 ก็ได้ไม่ใช่หรือ ?
มันน่าจะมีความหมายที่ดีขึ้นไหมนะ ?
ลองคิดกันดูนะครับ
ต้องมีความรู้ความเข้าใจในสิ่งที่ตัวเองกำลังจะทำ
ไม่ใช่มั่วไปเรื่อย ๆ หรือ ถามไปเรื่อย ๆ
คิด ก่อน ลงมือเสมอ
แต่ให้อยู่ในกรอบเวลาสั้น ๆ นะ
ไม่เช่นนั้น จะคิดไปเรื่อย โดยไม่ลงมือทำอะไรเลย
ควรมีความรู้ ความเข้าใจ
เกี่ยวกับข้อผิดพลาดต่าง ๆ ที่ผู้ใช้งานทั่วไปมักจะทำ
เพื่อทำให้คุณรู้ว่า จะต้องทดสอบอะไร
เพื่อทำให้คุณรู้ว่า จะต้องป้องกันอะไรบ้าง
สุดท้ายมันจะไม่เกิดข้อผิดพลาดแบบง่าย ๆ ขึ้นมา
หรือสิ่งที่ไม่คาดฝัน เป็นต้น
เรื่องต่าง ๆ เหล่านี้
Developer ทุกคน ควรเริ่มฝึกฝนให้เป็นนิสัย
แล้วมันจะกลายเป็นสิ่งที่คุณต้องทำไปโดยธรรมชาติ
ไม่ต้องมานั่งเผื่อเวลาสำหรับการทดสอบอีกต่อไป
เพราะว่า มันคือหนึ่งในสิ่งที่คุณต้องทำในการพัฒนาอยู่แล้วนะ
ความสามารถนี้ Developer ควรมีติดตัว
และมันมีคุณค่าอย่างยิ่งสำหรับตัวคุณเอง
สุดท้าย บางคนอาจจะถามว่า
ถ้า developer ทำการทดสอบได้เองแล้ว
จะมี Tester/QA ทำไมล่ะ ?
มันเกิด duplicate ในการทำงานนะ ?
ในมุมมองของผม
Developer ต้องทำการทดสอบแบบ
- Automation หรือ อัตโนมัติ
- Transparency คือ ใคร ๆ ก็สามารถเห็น และ นำไป run หรือ ทดสอบได้
ดังนั้นไม่ว่าใครหน้าไหน
ทั้ง Tester/QA จะเห็นชุดการทดสอบเหล่านี้
และสามารถ run เพื่อทดสอบได้
หลังจากนั้น Tester/QA ที่ดี
มักจะมีความคิดสร้างสรร และ ค้นหาวิธีการทดสอบแบบคาดไม่ถึง
รวมทั้งจะเป็นกลุ่มที่ช่วยบอก ชี้แนะ อธิบาย
ให้ทาง developer ด้วยว่า ควรจะทดสอบอะไรบ้าง
แต่ถ้า developer ปีกกล้าขาแข็งมากพอแล้ว
คุณอาจจะไม่ต้องการ Tester/QA เลยก็เป็นไปได้ …
แล้วคุณล่ะ มีความคิดเห็นอย่างไรบ้าง ?
