มีโอกาสได้ไปแบ่งปันเรื่องของ 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 ครับ