หนึ่งในความท้าทายมากๆ สำหรับ developer ที่เริ่มฝึกตามแนวคิด Test-Driven Development (TDD)
นั่นก็คือ การทำงานหรือเขียน code แบบ small step หรือ ก้าวไปทีละก้าวเล็กๆ
แล้ว small step นั้นมันเป็นอย่างไรล่ะ ? มาดูกันหน่อยสิ
จากหนังสือ The System Bible ของคุณ John Gall
อธิบายไว้ว่า
A complex system that works is invariably found to have evolved from a simple system that worked.
แปลได้ว่า ระบบที่ซับซ้อน ล้วนมีวิวัฒนาการมาจากระบบที่เรียบง่ายทั้งนั้น
ถ้ามาเทียบกับการพัฒนา software แล้วนั้น
หมายความว่าระบบใหญ่ๆ ที่สร้างขึ้นมาล้วยเกิดมาจากระบบเล็กๆ ที่ไม่ซับซ้อน
บางคนอาจจะบอกว่า หลังจากที่เราทำให้ test แรกผ่านแล้ว
นั่นหมายถึง คุณอยู่ในการ maintain ระบบ หรือ code ล่ะนะ
ซึ่งมันคือกระบวนการวิวัฒนาการพฤติกรรมของระบบงานต่างๆ
โดยยังต้องทำให้พฤติกรรมก่อนหน้าที่มันทำงานได้ยังคงอยู่เช่นเดิม
จากหนังสือ The System Bible ของคุณ John Gall
ได้บอกไว้อีกว่า
A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.
นั่นคือระบบที่ถุกออกแบบให้ซับซ้อนตั้งแต่ต้นไม่มีทางทำงานได้
ถ้าปราศจาคการ patch ในเรื่องต่างๆ
ดังนั้นทางที่ดี คุณควรที่จะสร้างจากระบบที่เรียบง่ายไปเรื่อยๆ
แล้วมันเกี่ยวอะไรกับ small step ใน TDD ล่ะ ?
ปกติเรามักจะทำการพัฒนาแบบ เขียน code ครั้งเดียว
เพื่อจัดการปัญหาใหญ่ หรือ หลายๆ ปัญหา
ส่วนใหญ่จะได้ code ที่ไม่มีการทดสอบ หรือ ไม่มี unit test อะไรเลย
ดังนั้น เมื่อมี bug กลับมาเรามักจะทำการค้นหา bug
แบบ small step หรือ step-by-step ด้วยการ debug code !!
โดยวิธีการนี้เรียกว่า Debug Later Programming (DLP) ซึ่งไม่สนุกเลยใช่ไหม ?
แสดงดังรูป
จากรูปด้านบน
มันทำให้เราเสียเวลาอย่างมากในการทำ debug code
เพื่อทำการหาจุดที่เกิดปัญหา และบ่อยครั้ง คุณมักจะต้องเขียน test ขึ้นมา
ในแต่ละขั้นตอนของการ debug code
เพื่อทดสอบในส่วนที่คุณทำการ debug แล้ว
เพราะว่าคุณคงไม่ต้องการทำการ debug ซ้ำแล้วซ้ำเล่าอีกใช่ไหม ?
ซึ่งตรงนี้เอง ทำให้คุณเริ่มเห็นว่าการเขียน test มันก็มีประโยชน์บ้างนะ
และให้เริ่มเขียนด้วย test แบบง่ายๆ เพื่อทำให้คุณมั่นใจขึ้นไปเรื่อยๆ ทีละ step-by-step หรือ small step
ดังนั้น แทนที่คุณมาเขียน test หลังจากที่งานเสร็จ หรือ จากการแก้ไข bug
ก็ให้เริ่มมาทำงานแบบ Proactive ดีกว่า นั่นคือ ทำการป้องกันไม่ให้เกิด bug ดีกว่าตามแก้ไข bug
ด้วยแนวคิด Test-Driven Development (TDD) ดังรูปดีกว่าไหม ?
เริ่มสร้างระบบจากสิ่งที่เรียบง่ายๆ ไปเรื่อยๆ นั่นคือ วิธีการที่น่าดีกว่าเดิมนะ ว่าหรือเปล่า ?
มาถึงตรงนี้คุณน่าจะรู้แล้วว่า Small step นั้นเป็นอย่างไร …
หนึ่งในนั้นคือ ขั้นตอนเล็กๆ ที่คุณทำในการ debug code
หนึ่งในนั้นคือขั้นตอนที่เรียบง่าย
ปล. คำว่า Small step ของแต่ละคนไม่เหมือนกันนะครับ
ต้องทำการค้นหาด้วยตัวเอง ด้วยวิธีการที่ถูกต้อง !!
