ได้อ่านบทความเรื่อง 9 bad programming habits we secretly love
ทำการสรุปพฤติกรรมแย่ ๆ ที่ developer ชอบทำ
ถึงแม้จะรู้ และ เข้าใจว่า มันไม่ดีนะ
แต่ก็รัก ชอบ ที่จะทำ
มาดูกันว่ามีอะไรที่น่าสนใจบ้าง ?
บางคนอาจจะบอกว่า
เราก็แค่เขียน code
จากนั้นก็ compile
ทำการ packaging
ทำการ deploy และ release ให้ลูกค้าใช้งาน
ระบบมันทำงานได้ดี ถูกต้อง
เพียงเท่านี้ลูกค้าก็ดีใจแล้วนะ
มันก็น่าจะเพียงพอนะ ว่าไหม ?
ฟัง ๆ ไปมันก็ดูมีเหตุมีผลที่ดีนะ
แต่เมื่อระบบมันโตขึ้นเรื่อย ๆ
จำนวนบรรทัดของ source code เพิ่มขึ้นอย่างมาก
ความซับซ้อน ซ่อนเงื่อนก็ยิ่งมาก
ดังนั้น การที่ Developer พัฒนาแบบ Not-hard and Fast
หรือพัฒนาแบบง่าย ๆ และ เร็ว ๆ
มันจึงเริ่มสร้างปัญหาออกมา
นั่นคือ การจะเพิ่ม แก้ไข feature ต่าง ๆ ในระบบ
เป็นเรื่องที่ยาก และ น่ากลัวขึ้นเรื่อย ๆ
แสดงดังรูป
ดังนั้น เราน่าจะหยุด
และกลับมาดูสิ่งที่เราสร้างมานั้น มันเป็นอย่างไร
เพื่อทำการปรับปรุงให้มันดีขึ้น สะอาดขึ้น เรียบง่ายขึ้นนะ
มาดูกันว่า สิ่งที่แย่ ๆ ที่ Developer ชอบทำกัน [ ผลที่ออกมามันทำงานได้ดีนะ ]
1. ใช้คำสั่ง goto !!
ผมคิดว่า
ปัจจุบันไม่น่ามีใครใช้นะครับ
น่าจะใช้ break, return กันหมดแล้วนะ
แต่ถ้าใครใช้เลิกเถอะครับ ได้โปรด !!
2. ไม่ชอบเขียนเอกสาร เพื่ออธิบาย code
มั่นใจว่า developer ส่วนใหญ่
ไม่ถูกกับการเขียนเอกสาร
โดย developer และ คนส่วนใหญ่
มักคิดว่า การเขียนเอกสารเพื่ออธิบาย code
มันคือ การเขียน comment หรือเอกสารอื่น ๆ ที่แยกออกไปจาก code
ซึ่ง มันคือ ความเข้าใจที่ผิด !!
การเขียน comment ใน code
มันคือสิ่งที่บอกว่า code ของคุณมันมีชื่อที่แย่
ไม่สามารถอธฺบายตัว code เองได้
ดังนั้น การแก้ไขควรแก้ให้ตรงจุด
นั่นก็คือ ตั้งชื่อให้มันสื่อถึงหน้าที่การทำงานสิ !!
ลองกลับไปดู code ที่เขียนสิว่า
มันอธิบายตัวมันเองได้ไหม ?
หรือแม้แต่ Developer ก็ยังไม่เข้าใจ !!
3. จำนวนบรรทัดของ code น้อย ๆ เข้าไว้
Developer บางคนเชื่อว่า
การเขียน code เพื่อแก้ไขปัญหาหนึ่ง ๆ
ยิ่งมีจำนวนบรรทัดน้อยเท่าไร มันยิ่งดี
แต่ขอให้เชื่อเถอะว่า
มันไม่ได้ดีเสมอไปนะครับ
ลองกลับไปดู code สิว่า
มันอ่านรู้เรื่องหรือไม่
มันทำความเข้าใจได้ง่ายหรือไม่
มันแก้ไขได้ง่ายหรือไม่
จำนวน code น้อย ๆ เป็นสิ่งที่ดี
แต่ควรอ่าน และ เข้าใจได้ง่ายด้วยเช่นกัน
เนื่องจาก code ที่เราเขียนขึ้นมานั้น
สร้างมาเพื่อให้คนอื่นอ่าน และ ใช้งานนะครับ
รวมทั้งเรื่องของการดูแลรักษาอีกด้วย
4. ชอบเขียน Yo-Yo code ?
เคยไหม ที่เขียน code เพื่อ
แปลงข้อมูลจากชนิดข้อความ (String) ไปเป็น ตัวเลข (Integer)
จากนั้นก็แปลงจาก ตัวเลข กับมาเป็น ข้อความ
และทำแบบนี้บ่อยมาก ๆ
ดังนั้น Developer ที่ดี
มักจะลดจำนวนของการแปลงข้อมูลให้เหลือน้อยที่สุด
แน่นอนว่า ส่งผลให้ code ทำงานได้เร็วขึ้น
แต่แปลกนะ ที่ Developer ชอบเขียน Yo-Yo code
เพราะว่า มันง่ายไงล่ะ
5. ชอบ break การทำงานออกจาก loop !!
เคยทำไหม ?
Developer ชอบทำการ break, return หรือ goto ออกจาก loop แบบหน้าตาเฉย
แน่นอนว่า มันคือ วิธีการที่ง่ายมาก ๆ
ใคร ๆ เขาก็ทำกันนะ !!
แต่หยุด และ กลับมาดู code ก่อนไหม ?
สาเหตุที่ต้องออกจาก loop คืออะไร ?
code มันซับซ้อนใช่ไหม ?
ดังนั้น เพื่อลดความซับซ้อน หรือ การออกจาก loop แบบนี้
ก็ทำการเปลี่ยนมาใช้ตัวแปรชนิด boolean (TRUE, FALSE)
เพื่อเป็นเงื่อนไขในการออกจาก loop น่าจะดีกว่า
แต่อย่าลืมว่า การตั้งชื่อของตัวแปร boolean นั้นต้องสื่อสารได้ชัดเจนด้วย
ว่าทำขึ้นมาสำหรับเงื่อนไขอะไร
6. ชอบตั้งชื่อตัวแปรสั้น และ ใช้ตัวย่อ
Developer ส่วนใหญ่ทำการตั้งชื่อได้แย่มาก ๆ
รวมไปถึงการใช้ชื่อตัวแปรสั้น ๆ และ ตัวย่อ
เช่น a, b, c, i, j, k, x, y, z เป็นต้น
ดังนั้น ลด ละ เลิก เถอะครับ
กลับมาตั้งชื่อดี ๆ กันนะ
Developer ลองหยุด และ กลับมาดูตัวเราเองก่อนสิว่า
เรามีพฤติกรรมแย่ ๆ เหล่านี้หรือไม่ ?
ถ้ามี แสดงว่า
เราน่าจะทำปรับปรุงได้แล้วนะ
เพียงแค่ 6 ข้อนี้ก็น่าจะทำให้เป็น Developer ที่ดีขึ้นได้แล้ว
