บ่อยครั้งที่ developer มักจะต้อง ทนอยู่ หรือ อยู่ทน
กับระบบที่ maintain ได้ยาก หรือ ไม่สามารถปรับเปลี่ยนอะไรได้เลย
ทำได้เพียงแค่ทำให้มันไม่ล่ม ทำงานได้ไปวันๆ เท่านั้นเอง !!
คุณอาจจะต้องใช้เวลาหลายชั่วดมง หลายวัน หรือ เป็นเดือน
เพื่อทำความเข้าในระบบ เข้าใจ code ว่ามันทำงานอย่างไร
จากนั้นจึงเริ่มทำการแก้ไข
บ่อยครั้งพบว่ามันมักทำให้เกิดความผิดพลาดมากมาย
ทั้งๆ ที่คุณทำความเข้าใจ code ก่อนแก้ไขแล้วนะ !!
ทำไมกันนะ ?
หรือว่าเรายังไม่ความรู้ไม่พอ
หรือว่าเราพลาดตรงไหน
หรือว่าเรามันความรู้น้อยเกินไป
หรือว่าระบบมันยุ่งเหยิง ซับซ้อนไปหมด
ให้เชื่อเถอะว่า You’ll Never Walk Alone
ดังนั้น ถ้าอะไรที่เราไม่ชอบ เราก็ไม่ควรสร้างมันขึ้นมาอีกใช่ไหม ?
แต่แปลกนะ !!
อะไรที่ developer ชอบบ่น
developer ก็มักจะสร้างสิ่งนั้นขึ้นมาอยู่อย่างเสมอ
แต่ถ้าเราต้องการเป็น developer ที่ดี
ควรรู้จักการควบคุม หรือ ลดความซับซ้อน (Complexity) ของ code ลงไปนะ
เนื่องจาก complexity มันคือต้นเหตุของปัญหาต่างๆ มากมาย
ที่เกิดขึ้นกับการพัฒนา software เช่น
- ความน่าเชื่อถือของระบบที่ต่ำติดดิน
- การส่งมอบงานที่ล่าช้าเสมอ
- ความอ่อนด้อยในเรื่องของความปลอดภัย
- ประสิทธิภาพการทำงานที่แย่
ทำไม complexity มันถึงทำให้เราอยู่ในอันตรายล่ะ ?
ถ้าคุณต้องการหลีกเลี่ยงกันปัญหา
ก็ควรที่จะทำความเข้าใจกับปัญหาในรูปแบบต่างๆ กันนะ
เพื่อทำให้คุณเข้าใจกับการทำงานของระบบมากขึ้น และ ง่ายขึ้น
สาเหตุของ complexity นั้นมันมาจาก
- State ของการทำงาน
- Control flow ของระบบงาน
- จำนวนของ code
ตัวแรกคือ state
ให้ลด ละ เลิก การใช้งาน global variable
เพื่อเก็บ state การทำงานของระบบซะ
เพราะว่า มันมักก่อให้เกิด complexity และ bug มากมาย
เนื่องจากคุณจะไม่รู้เลยว่ามันถูกเปลี่ยนแปลงค่าอะไรไปบ้าง
ดังคำกล่าว
“A global variable is like a box of chocolates,
you never know what you’re gonna get.”
และยิ่งถ้ามี global variable เยอะๆ
มันก็ยากต่อการทดสอบเช่นกัน
เนื่องจากพฤติกรรมการทำงานมันเปลี่ยนไปตาม state !!
ดังนั้น ให้ลด scope ของตัวแปรลงมาซะ
ปัญหาก็จะลดตามมาเช่นกัน
คุณจะทำความเข้าใจต่อระบบได้ง่ายขึ้นมานะ
ตัวที่สอง คือ Control flow
ถ้าระบบคุณมีทางเลือกมากมาย
สิ่งที่คุณจะใช้คืออะไรล่ะ if-else, switch-case
และมันจะกลายเป็น ป่าดงอีฟ (if)
loop ซ้อน lopp ซ้อน loop ….
ทำให้ระบบมันยากต่อการทำความเข้าใจ
ทำให้ระบบมันนากต่อการดูแลรักษา
ดังนั้น ลด ละ เลิก เช่นกัน
มาทำให้ code มันอ่านง่าย เหมือนการอ่านหนังสือกัน
ตัวที่สาม คือ จำนวน code
แน่นอนว่า code ยิ่งมีจำนวน Line of Code (LoC) มาก
ก็ยิ่งมีความซับซ้อนสูง
ทั้งในระดับ method และ class
ดังนั้น ถ้าลดจำนวน LoC ลงไปได้
ก็จะช่วยลดความซับซ้อนลงไป
แต่ละส่วนจะทำงานอย่างใดอย่างหนึ่งไปเลย
ซึ่งช่วยทำให้การดูแลรักษา และ การทำความเข้าใจง่ายขึ้น
ถ้า code มีจำนวนมากขึ้น
มันจะส่งผลต่อสองข้อที่ผ่านมาอย่างแน่นอน
ที่สำคัญความซับซ้อนของระบบงาน
มันจะขึ้นเป็นแบบ exponential เสียด้วยนะครับ !!
ดังนั้น ถ้าคุณต้องการเป็น developer ที่ดี
ต้องพยายามลด ละ เลิก
ในการสร้าง 3 สิ่งนี้ขึ้นมานะ
นั่นคือ แนวทางที่เรียบง่าย นั่นเอง
ซึ่งแน่นอนว่า มันยาก แต่ใช่ว่าจะทำไม่ได้ !!
มาปรับปรุง และ เปลี่ยนแปลง ตัวเราเองให้ดีขึ้นกว่าเดิมดีกว่าครับ
