เชื่อว่า Developer ทุกคนนั้นใช้เวลาส่วนใหญ่อยู่หน้า computer
บางคนใช้เวลามากกว่า 8 ชั่วโมงต่อวัน
เพื่อสร้างสรรค์สิ่งต่าง ๆ ขึ้นมา
ทั้งมีคุณค่า และ ไร้ซึ่งคุณค่า
มันเป็นโลกที่ใคร ๆ ก็สามารถสร้างได้
และสามารถพัฒนาต่อยอด เพื่อให้เติบโตขึ้นได้เรื่อย ๆ
และสามารถเชื่อมโยงกับระบบต่าง ๆ ได้อีกด้วย
แต่โลกใบนี้เราไม่ได้ทำอยู่คนเดียวนะ
การทำงานเหล่านี้ต้องทำงานกันเป็น TEAM
ดังนั้น จะทำอะไรต้องคิด และ ใส่ใจกันหน่อยสิ
ปล. พักผ่อนบ้างนะ
สิ่งที่เราสร้างต้องไปทำงานร่วมกับคนอื่น ๆ
สิ่งที่เราสร้างต้องแบ่งปันความรู้ให้กับคนอื่น ๆ
สิ่งที่เราสร้างต้องเติบโตไปพร้อมกัน
ดังนั้นในการเริ่มต้นก็เหมือนกัยการสร้างหมู่บ้าน สร้างเมือง สร้างประเทศ
มันต้องเริ่มจากส่วนเล็ก ๆ
มันต้องเริ่มจากความเรียบง่าย
มันต้องเริ่มจากสิ่งง่าย ๆ
เมื่อเวลาผ่านไป เริ่มพัฒนา เริ่มเติบโต
ไปเป็นหมู่บ้าน เมือง ปละ ประเทศต่อไป
ถ้าแต่ละส่วนมันทำงานได้อย่างดี
ถ้าแต่ละส่วนมันสะอาด
ถ้าแต่ละส่วนมันดูดี
ถ้าแต่ละส่วนเป็นอิสระแก่กัน
มันจะง่ายต่อการทำงานร่วมกัน
รวมทั้งทำให้เราสามารถส่งมอบได้ง่ายขึ้น
แม้จะอยู่ภายใต้แรงกดดันใด ๆ ก็ตาม
แต่ในความเป็นจริง มันกลับโหดร้าย !!
เนื่องจากสิ่งที่เราสร้างขึ้นมา มันขัดแย้งกันทั้งหมด
เนื่องจากสิ่งที่สร้างขึ้นมาเราไม่ได้ใส่ใจว่าจะดีหรือไม่
สนใจเพียงแค่ว่า มันทำงานได้นะ
ทำให้มันเสร็จ ๆ ไปเถอะ
ส่วนนั้นเราไม่ได้ทำ อย่างไปยุ่ง เดี๋ยวงานเข้า
ส่วนนี้ใครก็ไม่รู้ทำไว้ รู้ว่าไม่ดี แต่อย่ายุ่ง
เพราะว่า ไม่ใช่หน้าที่อะไรของเรา
เนื่องจากความกดดันจาก deadline
แปลกใจไหมว่า
เรามักจะรีบทำให้มันเสร็จ ๆ ไปก่อน
แต่เมื่อส่งมอบไปแล้ว กลับพบว่า
เราใช้เวลาในการแก้ไขเยอะกว่าการสร้างอย่างมาก
ซึ่งนั่นคือ ค่าใช้จ่ายที่สูงมาก ๆ
และเราจะอยู่ในวงจรนี้ไปตลอดชีวิต
ซ้ำแล้วซ้ำเล่าไม่รู้จบ
เราสนใจแต่การส่งมอบที่ตรงตามเวลา และ ครบถ้วน
มากกว่า คุณภาพ !!
และเราก็พบว่า ของที่ไร้คุณภาพมันเยอะมาก ๆ
มันหมายความว่าอย่างไรกันนะ ?
เรากำลังสร้างของที่มันแย่ ๆ ออกมากันหรือ ?
ดังนั้นจึงขอแนะนำแนวคิด 2 แบบ เพื่อทำให้คุณใส่ใจ code มากขึ้น
ซึ่งเคยเขียนอธิบายไว้แล้ว
แต่ขอหยิบมาย้ำเตือน developer ให้นำไปใช้กัน
แต่ประโยคแรกที่มักจะได้ยินเลยก็คือ
เราไม่มีเวลาปรับปรุงหรอกนะ
เราไม่มีคนพอ
…
แต่แปลกนะว่า เรามีเวลาแก้ไขสิ่งที่แย่ ๆ กัน
แต่ไม่มีเวลาสร้างสิ่งที่ดี ๆ ขึ้นมา
1. The Broken Window Theory
มันเป็นสิ่งที่บ่งบอกว่า
คนในสังคมมีความใส่ใจต่อกันและกันหรือไม่ ?
คนในสังคมมีความใสใจต่อสิ่งแวดล้อมรอบข้างหรือไม่ ?
เช่นเมื่อคุณเห็นเศษขยะ 1 ชิ้นตามท้องถนน
คุณจะทำอย่างไร ?
คุณจะทิ้งขยะอีกชิ้น หรือ จะเก็บขยะชิ้นนั้นไปทิ้งที่ถังขยะซะ ?
นี่คือ เป็นการบอกว่า ขยะเพียง 1 ชิ้นมันคือ ปัญหาเล็ก ๆ ที่แก้ไขได้ง่าย
แต่ถ้าเราไม่ทำการแก้ไขเหล่านี้
มันจะเริ่มเกิดปัญหาขึ้นมา เหมือนกับกระจกที่หน้าต่างมันร้าว มันแตกเล็ก ๆ
แต่เมื่อเวลาผ่านไป คนไม่สนใจ คนไม่ใส่ใจ
มันก็เริ่มเกิดการร้าวมากขึ้น ขยะมากขึ้นจนท่วมเมือง
กระจกของหน้าต่างหลาย ๆ บานเริ่มแตก เริ่มร้าว
สุดท้ายจากปัญหาเล็ก ๆ มันก็กลายเป็นปัญหาใหญ่
ที่ยากต่อการแก้ไข !!
ต้องใช้ตค่าใช้จ่ายสูงมากในการแก้ไข !!
คุ้น ๆ ไหมว่า ปัญหาในการพัฒนา software ก็เป็นแบบนี้เสมอ !!
ดังนั้น สำหรับ developer ที่ดี
ต้องไม่สร้าง code ที่แย่ ๆ ออกมา
แต่ถ้าสร้างขึ้นมา ก็ต้องทำการ refactor ทันที
แก้ไขเสียแต่เนิ่น ๆ มันจะง่าย ไม่ยุ่งยาก ใช้พลังงานน้อย
ช่วงแรก ๆ มันอาจจะช้าหน่อย
แต่ให้เชื่อเถอะว่า ต่อไปมันจะทำให้คุณไปได้เร็วอย่างคาดไม่ถึง
ดังนั้น เรื่องทัศนะคติของ developer และ ทีม ต้องสนใจเรื่องคุณภาพ
ซึ่งคุณภาพมันต่อรองไม่ได้
เพราะว่า มันถูกรวมเข้าไปกับสิ่งที่เราสร้างอยู่แล้ว
2. The Boy Scout rule
ทีมที่ดีควรทำตามกฎของลูกเสือ นะ
Always leave the campground cleaner than you found it
นั่นคือ
ทีมที่ดีต้องปรับปรุงสิ่งที่ต่าง ๆ
ให้มันดีขึ้นกว่าเดิม
ให้มันง่ายต่อการเพิ่มสิ่งใหม่ ๆ เข้าไป
ลองคิดดูสิว่า
ถ้าการเพิ่มสิ่งใหม่ ๆ เข้าไปในระบบนั้น มันยาก
แล้วคุณยังจะทำอีกหรอ
ทำไมไม่หยุดแก้ไขสิ่งเดิมให้มันดีขึ้น และ ง่ายต่อการเพิ่มล่ะ
ค่อย ๆ ทำให้ดีขึ้นแบบ step-by-step
มันก็จะทำให้สิ่งที่คุณสร้างดีขึ้นอยู่ตลอดเวลา
แต่แปลกนะว่า เรามักไม่หยุดแก้ไข
ทำตาม ๆ กันไปก็พอ !!
ดังนั้นลองปรับมาใช้กับทีมพัฒนา software เลยนะ
เริ่มง่าย ๆ ด้วย
อย่ากลัว code ที่มันยาก ๆ
อย่ากลัว code ที่เราไม่รู้เรื่อง
อย่ากลัว code ของคนอื่น หรือ แม้กระทั่ง code ของตัวเอง
อย่ากลัว code ที่เราจะบอกว่า มันคือ code ที่แย่
อย่ากลัว อย่าทำเป็นไม่สนใจ
จงเรียนรู้กับมัน
อย่างน้อย คุณก็รู้ว่า code เหล่านั้นมันไม่ดี
ก็อย่าสร้างมันขึ้นมาอีก
ก็อย่าสร้างตาม ๆ กันไป
เท่านี้เราก็ไม่สร้าง code ที่แย่ ๆ เพิ่มขึ้นมา
จากนั้นเริ่มทำการปรับปรุงส่วน code ที่มันแย่ ๆ ให้ดีขึ้น
อย่าเพียงแค่พูดว่า มันไม่ดี
จงทำให้เห็นว่า สิ่งที่ไม่ดีเหล่านั้น
จะทำให้ดีขึ้นอย่างไร
การพูดมันไม่เคยทำให้ code ดีขึ้น
แต่จงลงมือทำ ลงมือแก้ไขมันซะ
นี่คือ ความใส่ใจที่ Devleoper ต้องพึงมี และ พึงกระทำ
พอมองย้อนกลับมาในงานที่เราทำ พบว่า ปัญหามันเยอะมาก ๆ
ไม่รู้จะเริ่มแก้ไขตรงไหนเลย
เพราะว่า มองไปทางไหนก็เจอแต่ปัญหา
เพราะว่า มองไปทางไหนก็เจอแต่กระจกที่มันร้าว พร้อมจะระเบิดออกมา
ดังนั้น ถ้าคุณต้องการให้ระบบมันดีขึ้น
เริ่มต้นด้วยการพูดคุยกับทีมเดี๋ยวนี้เลย
เช่น
เริ่มต้นด้วยการพูดถึงชื่อ และ คำต่าง ๆ ที่ใช้ใน code ที่สื่อถึงความหมาย และ การทำงาน
เริ่มต้นด้วยการพูดถึงสถานะของ code ในปัจจุบัน ซึ่งให้อยู่ในกรอบเวลาสั้น ๆ นะ
เริ่มต้นด้วยการระบุรูปแบบ code ที่มันแย่ ๆ ออกมา ว่ามีอะไรบ้าง
เริ่มต้นด้วยการ refactor code ในส่วนที่ทีมต้องเข้าไปยุ่งเกี่ยวด้วย
ซึ่งมันทำให้เกิด การนำแนวคิดของ The Boy Scout rule มาใช้แบบอัตโนมัติ
ดังนั้น มาเริ่มใส่ใจ code กันเถอะครับ
