จาก course Practical Go นั้นในช่วงเริ่มต้น
ทำการอธิบายเรื่องของ Principle guideline ของภาษา Go
ซึ่งประกอบไปด้วย 3 เรื่องคือ
- Clarify
- Simplicity
- Productivity
เรื่องนี้เคยเรียนและได้ยินจาก course Ultimate Go ที่เรียนเมื่อ 2 ปีก่อน
ทั้ง 3 เรื่องนี้มีความสำคัญมาก ๆ
เหมือนเป็นเข็มทิศนำทางของการพัฒนา software เลย
มาดูในรายละเอียดกัน
เริ่มด้วยสิ่งที่น่าสนใจอีกแล้วคือ
คำว่า Software programming กับ Software engineering
มีความแตกต่างกันอย่างไร ?
Software programming คือการพัฒนาระบบงานให้เสร็จไปตามหน้าที่
จากนั้นเดี๋ยวก็มีคนมารับไปทำหรือดูแลต่อไป
ส่วน Software engineering นั้นคือ การพัฒนาระบบงานไปโดยตลอด
อยู่กับมันไปตลอด อยู่ร่วมงานกับทีมไปตลอดไม่ว่าจะเกิดอะไรขึ้น
ทำการปรับเปลี่ยนไปตาม requirement ที่เปลี่ยน
เพิ่มหรือลบความสามารถต่าง ๆ ของระบบงาน
รวมทั้งการแก้ไข bug หรือข้อผิดพลาดต่าง ๆ
ซึ่งมันคือธรรมชาติของ Software engineering
คำถามคือ เรากำลังทำอะไร ?
กลับมาที่เรื่องของ Principle 3 ข้อ
- Clarify
- Simplicity
- Productivity
โดยจะไม่มีเรื่องของ performance และ concurrency เลย
เนื่องจากมันคือความสามารถภาษา
รวมทั้งความสำคัญของ 3 เรื่องข้างต้นจะมีความสำคัญกว่า
มาดูรายละเอียดของแต่ละเรื่องกัน
เรื่องที่ 1 Clarify หรือ ชัดเจน เข้าใจได้ง่าย
เนื่องจากในการเขียน code นั้น
เรามักจะใช้เวลาในการอ่านมาก และอ่านบ่อยมาก ๆ
ดังนั้นถ้า code ที่เขียนมานั้นมันชัดเจน เข้าใจได้ง่าย
ตามที่เราต้องการจริง ๆ น่าจะดีไม่ใช่น้อยนะ
มีคำพูดที่น่าสนใจคือ
เราเขียน code เพื่อให้คนอ่าน ไม่ใช่เพียงให้ machine เข้าใจและทำงานตามเท่านั้น
การเขียน code มันก็คือ communication skill
หรือเป็นความสามารถในการสื่อสารสิ่งที่คิดออกไป
เพื่อให้เราและคนอื่น ๆ เข้าใจ
ยิ่งถ้ามีความสามารถด้านนี้มาก ๆ
สิ่งที่ออกมาก็จะชัดเจนและเข้าใจได้ง่าย
แต่ปัญหาที่มักพบเจอคือ
ความสามารถด้านนี้จะแย่มาก ๆ
ทำให้ code ที่ได้ออกมานั้นดูเข้าใจยากมาก ๆ นั่นเอง
ส่งผลทำให้การดูแลรักษายากและมีค่าใช้จ่ายที่สูงมาก ๆ
ดังนั้นเป้าหมายหลักคือ
เรื่องของการดูแลรักษาที่ง่ายนั่นเอง
มิเช่นนั้น เราก็จะเข้าสู่วงจรเดิม ๆ
คือ เขียนใหม่ ทำใหม่ และทำใหม่วนไปเรื่อย ๆ
ไม่เดินไปข้างหน้าสักที !!
เรื่องที่ 2 Simplicity หรือความเรียบง่าย
ความเรียบง่ายนั้นพูดยากมาก ๆ ว่าเป็นอย่างไร
เพราะว่าระบบงานส่วนใหญ่
มันประกอบไปด้วยส่วนที่เรียบง่ายหลายอย่างมากรวมกันหรือทำงานด้วยกัน
ส่งผลให้ระบบงานมีความซับซ้อนสูงขึ้นเรื่อย ๆ
ประเด็นอยู่ที่ว่า
เราสามารถควบคุมความซับซ้อนนี้ได้หรือไม่ ?
ซึ่งเรื่องการควบคุมความซับซ้อนนี้ เป็นสิ่งที่จำเป็นมาก ๆ
ของการพัฒนาระบบงาน software
มิเช่นนั้น ระบบงานของเราก็จะไร้ซึ่งความน่าเชื่อถือ
บ่อยครั้งเรามักจะเจอเหตุการณ์
ไปอ่าน code ของระบบแล้วไม่เข้าใจเลยว่าทำอะไร ?
แต่ต้องทำการแก้ไขตามความต้องการ
ผลคือกลัว หรือ ไม่กล้าทำ
เพราะว่า ไม่รู้ว่ามันทำงานอย่างไร
แก้ไขไปแล้วจะกระทบตรงไหนบ้าง
หนักกว่านั้น เมื่อไม่เข้าใจ
ก็ไม่รู็จะไปแก้ไขตรงไหนอีก
นี่แหละเขาเรียกว่าระบบมีความซับซ้อน
ปัญหาเหล่านี้มันเป็นสิ่งที่ทำลายระบบงานของเราลงไปเรื่อย ๆ
ดังจะเห็นได้ในหลาย ๆ ระบบงานที่เราดูแลกันอยู่ !!
ดังนั้นเรื่องของ Simplicity จึงเป็นเป้าหมายหลักของการออกแบบภาษา Go
เรื่องที่ 3 Productivity
จาก 2 ข้อแรกนั้นเป็นแนวปฏิบัติพื้นฐานเลยของการออกแบบและพัฒนาระบบงาน
และมันส่งผลต่อ productivity ของการทำงาน
ในช่วงแรก ๆ ของการพัฒนาระบบงานใหม่ ๆ
ลองสังเกตว่า การทำงาน การพัฒนาส่วนต่าง ๆ จะเร็วมาก ๆ
แต่เมื่อจำนวน feature เยอะขึ้น code เยอะขึ้น คนเยอะขึ้น
ปัญหาที่เกิดขึ้นคือ เราทำงานได้ช้าลงมาก ๆ
ทั้งการเพิ่ม ทั้งการแก้ไข หนักกว่านั้นแก้หนึ่งที่ผิดหลายที่
ในการพัฒนานั้นต้องคิดไว้เสมอว่า
สิ่งที่เราสร้างในวันนี้ มันสามารถเปลี่ยนได้ง่ายหรือไม่
เพราะว่า การเปลี่ยนแปลงมันเกิดขึ้นได้ตลอดเวลา
ดังนั้นการรองรับการเปลี่ยนแปลงจึงเป็นเรื่องพื้นฐาน
เป้าหมายของภาษา Go เรื่อง productivity
จะพยายามลดสิ่งที่ไม่จำเป็นออกไป
อะไรที่ตรวจสอบให้ได้จะทำให้เลย
ทำให้นักพัฒนาสนใจไปที่การพัฒนาไปเลย
ทั้งเรื่องของการ debug
ทั้งเรื่องของการจัด format ของ code
ทั้งเรื่องการตรวจสอบสิ่งที่ไม่ได้ใช้
ทั้งเรื่องการ build และ deploy ที่ไม่ต้องเยอะ
โดยรวมแล้วเป้าหมายหลัก ๆ ของ productivity ของภาษา Go
คือเรื่องของการ scale
ทั้ง scale ของทีม
ทั้ง scale ของระบบ
ทั้ง scale ของ code
Principle 3 ข้อของการออกแบบและพัฒนาระบบด้วยภาษา Go เป็นเรื่องที่นักพัฒนาจำเป็นต้องเข้าใจด้วย เพราะว่า เพียงแค่เขียนให้ทำงานได้คงยังไม่พอ
