สรุปการแบ่งปันเรื่อง Coding with Quality

มีโอกาสได้ไปแบ่งปันเรื่องของ Code with Quality มา 2 วัน คุณลักษณะของ Code ที่มีคุณภาพนั้นประกอบไปด้วย

1. Efficiency
2. Performance
3. Integrity
4. Recoverability
5. Simplicity
6. Maintainability
7. Flexibility
8. Valuable (Value to customer/user)

โดยสิ่งที่ไปแบ่งปันนั้น จะเน้นไปที่ Maintainability, Simplicity และ Efficiency จึงสรุปรวมให้เป็น Coding for Human ไปเลย นั่นคือ มาเขียน code สำหรับคนอื่น ๆ กัน ว่าจะเป็นอย่างไรบ้าง

เริ่มด้วยเป้าหมายของการ coding

ว่าเราเขียน code เพื่ออะไร ? ว่าเราเขียน code ไปทำอะไร ? code ที่เราเขียนออกมานั้นเป็นอย่างไร ? แก้ไขปัญหาที่เราต้องการได้หรือไม่ ? ทำงานได้อย่างถูกต้อง ตามที่คาดหวัง ? สามารถดูแลรักษาได้ง่าย ? สามารถอ่านและทำความเข้าใจได้ง่าย ? ถ้ามีการเปลี่ยนแปลงแล้ว เราสามารถรู้ได้ทันทีว่า การเปลี่ยนแปลงเหล่านั้น ส่งผลต่อระบบเดิมอย่างไร ?

ถ้า code เราไม่ตอบโจทย์ต่าง ๆ เหล่านี้แล้ว คิดว่า น่าจะเป็น code ที่ก่อให้เกิดปัญหา มากกว่า ประโยชน์หรือไม่ ? อันนี้ก็ขึ้นอยู่กับตัวบุคคลแล้วนะ

สำหรับการแบ่งปันในครั้งนี้ จะเน้นไปที่การเขียน code ที่ง่ายต่อทำความเข้าใจ เขียน code แบบตรงไปตรงมา เขียน code ให้ตรงกับ requirement เขียน code เพื่อให้ทำงานได้

Make it Work Make it Right

โดยปัญหาที่นักพัฒนาพบเจอมาก ๆ คือ

เรามักจะต้องไปดูแล code ที่ตัวเองไม่ได้เขียน แน่นอนว่า เมื่อเปิด code ขึ้นมาดูครั้งแรก อาจจะร้องอุทานว่า code ... อะไรเนี่ย ... สิ้นดี จากนั้นสิ่งที่เราทำคืออะไร ? แก้ไขให้มันดีขึ้น ? เขียนใหม่ ? ทำแบบเดิมต่อไป ? หรือออกไปที่อื่นดีกว่า ? กลับมาที่ปัญหากัน เรามักใช้เวลาในการอ่านและทำความเข้าใจกับ code นานมาก ๆ เนื่องจากอ่านเข้าใจยาก แถมซับซ้อนอีกด้วย

เรามักจะบอกว่า เดี๋ยวค่อยกลับมาแก้ไขก็ได้ แบบนี้มันก็ทำงานได้อยู่นะ ผลที่ตามมาคือ code ชุดนี้มันจะคงอยู่ตลอดไป เพราะว่า Later == Never อย่างแน่นอน

ที่สำคัญ เรามักจะยุ่งเสมอ ไม่มีเวลาทำอะไร เพราะว่ามีแต่งานเร่งด้วยและด่วนมาก ๆ และด่วนที่สุด หรือทำเดี๋ยวนี้เลย ทำให้เราเดินหน้าไปเรื่อย ๆ ไม่เคยหยุดหรือมาดูสิ่งที่สร้างกันเลย เปรียบเหมือนกับการขุดหลุมหรือเดินเข้าไปไปเรื่อย ยิ่งขุดยิ่งลึก ยิ่งเดินเข้าไป ยิ่งลึก สุดท้ายแล้วก็พบว่า เราอยู่ในหลุ่มที่ลึกมาก ๆ ขึ้นมาไม่ได้ หรืออยู่ในป่าลึก จนหาทางออกไม่ได้ สุดท้ายแล้วเราจะทำอย่างไร ? ดังนั้นอยากขอแนะนำว่า อย่าทำกันเลยนะ มาทำแบบที่ดี ๆ กันดีกว่า

โดยเรื่องของ Coding for Human นั้น สามารถสรุปด้วยรูปนี้

ช่วยทำให้เข้าใจได้ว่าพื้นฐานสำคัญคือ Clean Code จะเอื้อประโยชน์ให้สิ่งต่าง ๆ เกิดขึ้นมา ทั้ง

• SOLID แนวคิดในการออกแบบที่ดี
• Automated testing ชุดการทดสอบแบบอัตโนมัติเพื่อทำให้เรามั่นใจต่อ code
• Refactoring การปรับปรุงโครงสร้างของ code โดยไม่ส่งผลกระทบต่อคนใช้งาน
• DDD (Domain-Driven Design) การแบ่งงานออกเป็นกลุ่ม ๆ รวมทั้งการติดต่อสื่อสาร เป็นพื้นฐานของระบบแบบ modular มาก ๆ
• Design Pattern คือรูปแบบของการแก้ไขปัญหา ดังนั้นถ้ายังไม่เกิดปัญหาก็อย่าเพิ่งใช้
• TDD (Test-Driven Development) คือการคิดก่อนที่จะทำ

สิ่งที่จะเน้นมาก ๆ คือเรื่อง Clean Code, Automated testing และ Refactoring รวมไปถึงแนวคิด Simple Design Rule ประกอบไปด้วย

1. All test pass
2. Express intent
3. No duplication
4. Small part/function

โดยที่ผมหยิบเอา Simple Design Dynamo มาอธิบาย นั่นคือทุกกสิ่งอย่างมันจะเกิดจากการปรับปรุงชื่อ และ ลด code ที่ duplication แล้วจะจะก่อให้เกิดการเปลี่ยนแปลง ทั้งเรื่องของโครงสร้างและ abstraction layer ต่าง ๆ แต่จะทำได้อย่างปลอดภัยและมั่นใจ เราจะต้องมีชุดการทดสอบแบบที่ดีและเร็ว นั่นอาจจะพูดถึง Automated testing แบบอ้อม ๆ ก็ได้  

Workshop ที่ทำนั้นประกอบไปด้วย

• การ Refactoring code จาก Kata Tennis ลองไปฝึกกันดู สนุกมาก ๆ
• การ Refactoring Legacy Code โดยนำแนวคิด Simple Design Rule มาใช้งาน เริ่มตั้งแต่การลบ code ที่ไม่ใช้งานออกไปด้วย IDE/Editor จากนั้นทำการ review code ว่ามีอะไรที่แปลก ๆ ไหม ทั้งการ comment รวมไปถึงชื่อและ abstraction layer ต่าง ๆ และทำการทำความเข้าใจ Legacy code ด้วยการเขียน Automated test รวมถึงการนำ code coverage มาช่วยทำความเข้าใจ code และปลอดภัย สุดท้ายจึงลงมือ refactoring code ต่อไป

หนังสือที่แนะนำให้อ่าน มี 3 เล่มดังนี้

สิ่งที่อยากจะฝากไว้มีอยู่ 2 แนวคิดคือ

1. Boy Scouts Rule
2. No Broken Windows

ง่าย ๆ คือ ถ้าเห็นว่าอะไรมันไม่ดีแล้ว พูดได้ ว่าได้ ด่าได้ แต่คุณต้องทำให้มันดีขึ้นกว่าเดิมด้วย

ขอให้สนุกกับการ coding ครับ