mess
คิดว่า developer หลาย ๆ คนน่าจะรู้จักกับ 5ส หรือ 5S

5S was developed in Japan and was identified
as one of the techniques that enabled Just in Time manufacturing

ซึ่งประกอบไปด้วย

  1. Seiri หรือ Sort/Clearing/Classify หรือ สะสาง
  2. Seiton หรือ Systematic Arrangement/Streamline/Simplify/Configure หรือ สะดวก
  3. Seiso หรือ Shine/Cleanliness/Clean and check หรือ สะอาด
  4. Seiketsu หรือ Standardize/Conformity หรือ สร้างมาตรฐาน
  5. Shitsuke หรือ Sustain the discipline/Custom and practice หรือ สร้างนิสัย

เมื่อนำ 5ส มาประยุกต์ใช้ในการพัฒนา จะเป็นอย่างไรนะ ?

หรือบางที่อาจจะเรียกว่า 5C คือ

  1. Clearing
  2. Configure
  3. Clean and Check
  4. Conformity and finally
  5. Custom and practice

เริ่มต้นด้วยสะสาง

คือการแยกส่วนที่จำเป็นออกจากส่วนที่ไม่จำเป็น
จากนั้นลบของที่ไม่จำเป็นทิ้งไปซะ
โดยมีขั้นตอนดังนี้

  • การสำรวจตรวจดู
  • การแยกแยะ
  • การลบหรือขจัดทิ้งไป

ถ้ามองมาในการพัฒนา software มีอะไรบ้าง ?

  • การลบ code ที่ไม่ถูกใช้งานออกไป
  • การลบ library ที่ไม่ถูกใช้งานออกไป
  • การลบ software ที่ไม่ถูกใช้งานออกไป

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

การจัดเรียงความสำคัญของงานก็ใช่
ไม่ใช่ว่างานทุกอย่างมีความสำคัญเท่ากันหมด
หรือว่ามีแต่งานเร่งด่วน และ ด่วนมาก !!

เมื่อพบว่าระบบงานมีข้อผิดพลาดหรือ bug
ก็อย่าปล่อยไว้ให้เป็นดินพอกหางหมู
ดังนั้นให้ทำการแก้ไขทันทีก่อนที่จะไปพัฒนาส่วนอื่น ๆ

สุดท้ายอะไรไม่ได้ใช้ก็อย่าเพิ่งทำหรือนำมาเผื่อไว้นะ

ต่อมาคือ สะดวก

เป็นการจัดวางจัดเรียงสิ่งต่าง ๆ ในที่ทำงานให้เป็นระบบ
เพื่อให้สะดวกและปลอดภัยต่อการหยิบจับหรือนำไปใช้งาน
โดยมีขั้นตอนดังนี้

  • กำหนดก่อนว่าสิ่งที่จำเป็นต่อการทำงานมีอะไรบ้าง
  • ทำการแบ่งเป็นกลุ่มหรือหมวดหมู่
  • ทำการจัดเก็บให้เป็นระบบระเบียบ
  • สิ่งใดใช้งานบ่อย ๆ ก็ย้ายให้อยู่ใกล้ ๆ มือ

ถ้ามองมาในการพัฒนา software มีอะไรบ้าง ?
ถ้าทำการเขียน script ต่าง ๆ บ่อย ๆ เช่น
การ compile, build, test, run และ deploy
ก็ให้ทำการสร้างไฟล์ build script ไว้ซะ

สำหรับ developer ก็ควรศึกษาหรือฝึกใช้งาน shortcut ต่าง ๆ
ของ Text editor และ IDE ที่ใช้งานไว้ด้วย
เพื่อทำให้การเขียน code ไหลลื่นมากยิ่งขึ้น
ดังนั้นการทำงานเข้าใจเรื่องของเครื่องมือที่ใช้งานมันสำคัญมาก ๆ นะ

สำหรับ code ที่เขียนขึ้นมา
ก็ควรจัดกลุ่มของ code ออกเป็น module
แต่ละ class ควรทำงานเรื่องเดียวกัน
ชื่อ method/function ก็ควรสื่สารได้ชัดเจน
แน่นอนว่า code ใน method/function ก็ควรสอดคล้องกัน

ถ้าต้องการลดความผิดพลาดและเสียเวลาไปโดยเปล่าประโยชน์
ก็ให้ทำการ review code และคุยกับคนอื่น ๆ ในทีมซะ
ไม่เช่นกันสิ่งที่กำลังพัฒนาอาจจะออกทะเลไปแล้วก็ได้
ซึ่งมันเสียเวลามาก ๆ

ให้ทำการสร้าง workflow หรือขั้นตอนการทำงานที่เรียบง่ายขึ้นมา
หรือมันคือ KISS (Keep It Simple Stupid)
เช่นขั้นตอนการ deploy ระบบงาน
ลองคิดดูสิว่า ถ้ายอมเสียเวลามาสร้างระบบ one-click deploy
มันจะมีประโยชน์มากเพียงใด

ต่อมาคือ สะอาด

เป็นการทำความสะอาดเครื่องไม้เครื่องมือและพื้นที่การทำงาน
รวมทั้งการดูแลบำรุงรักษาระบบด้วย
โดยมีขั้นตอนดังนี้

  • ระบุพื้นที่
  • หาและกำจัดต้นเหตุของความสกปรก
  • ทำความสะอาด

ถ้ามองมาในการพัฒนา software มีอะไรบ้าง ?
มันคือการทำความสะอาดโต๊ะทำงาน
บางคนอาจจะสร้างบ้านหรืออาณาจักรขึ้นมาบนโต๊ะตัวเองก็ได้ !!
รวมทั้งเครื่อง computer/notebook ที่ใช้งานด้วย
การจัดการ files และ folders ก็สำคัยมาก ๆ นะ
เนื่องจากบ่อยครั้งเรามักจะค้นหามันไม่เจอ
เรื่องของการจัดการกับ email ก็เช่นกัน

หรือการใช้งาน version control เช่น Git
ก็ให้ลองใช้คำสั่ง git status ดูบ้าง
ว่ามีอะไรที่ยังค้างอยู่บ้าง
ว่ามีอะไรที่ยังไม่ commit บ้าง
ว่ามีอะไรที่ต้อง push/pull บ้าง
หรือก่อนกลับก็ git clean -f บ้างนะ

หรือ code ที่เขียนขึ้นมานั้นมัน clean หรือยัง
ถ้ายังไม่รู้ห็ให้ไปอ่านเรื่อง Clean code เพิ่มเติมนะ

หรือ code ที่เขียนขึ้นมานั้น
ทำการนำไปรวมกับคนอื่น ๆ ในทีมหรือยัง
ดังนั้นเรื่องของ Continuous Integration จึงต้องถูกนำมาใช้งาน

หรือ environment ต่าง ๆ ในการพัฒนา
ทั้งเครื่องของ developer และ server
ยังคงทำงานได้ดี
มี software ตรงกัน

ต่อมาคือเรื่อง สร้างมาตรฐาน

เป็นรักษามาตรฐานความเป็นระบบระเบียบให้คงอยู่ตลอดไป เช่น
ไม่มีของที่ไม่จำเป็นอยู่อีกต่อไปแล้ว
ไม่มีความรก
ไม่มีความสกปรก
หลังจากที่สะสาง และ ทำความสะอาดไปแล้วนะ

ถ้ามองมาในการพัฒนา software มีอะไรบ้าง ?

  • การนำ framework/library มาใช้งาน
  • การนำ design pattern มาใช้งาน
  • การพูดคุยในภาษาที่ทุกคนเข้าในร่วมกัน
  • เอกสารต่าง ๆ ควรอยู่ในที่ที่ทุกคนรู้ และ เข้าใจตรงกัน เช่น Code branching, Wiki, Task, Bug เป็นต้น

เมื่อทุกอย่างมันทำงานได้อย่างดีแล้ว
เราก็สามารถเขียนเป็นกฏกติกาขึ้นมาได้
ไม่ใช่เขียนขึ้นก่อนทำนะครับ
บางที่จะเรียกว่า Standard process นั่นเอง

สุดท้ายคือ สร้างนิสัย

ทุกสิ่งทุกอย่างมันจะยั่งยืนได้นั้น
ไม่ใช่มาจากการบังคับหรือการทำตามกฏ
แต่มันต้องออกมาจากนิสัยของคนจริง ๆ
นั่นคือต้องออกมาจากจิตสำนึกที่ดี
นั่นคือต้องออกมาทัศนคติที่ดี

ถ้ามองมาในการพัฒนา software มีอะไรบ้าง ?

  • ก่อนเขียน code ต้องเขียนชุดการทดสอบก่อนเสมอ (Unit test และ TDD)
  • การทดสอบอย่างต่อเนื่องและรวดเร็ว เพื่อทำให้ได้ feedback กลับมาอย่างรวดเร็ว
  • การทำ code review อย่างต่อเนื่อง
  • การปรับปรุง code อย่างต่อเนื่อง
  • การเขียน Unit test สามารถดูค่า code coverage เพิ่มเติมได้อีกด้วย
  • มีการ training และแบ่งปันความรู้ภายในทีมและองค์กร

ยังไม่พอนะ ยังไม่สิ่งอื่น ๆ อีกเช่น Safety, Security และ Satisfaction อีก
แต่พอเท่านี้ก่อนดีกว่า

มีคำถามว่าระหว่าง 5ส หรือ 7ส ดี ?

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

ปล.
5ส ไม่น่าจะเป็นการจัดเก็บโต๊ะและเอกสารเข้าตู้เมื่อมีคนมาตรวจนะ
หรือต้องมีคนคอยเฝ้าต้นทางว่าผู้ตรวจจะมาหรือยัง
แบบนี้มันคือ การทำแบบผักชีโรยหน้า
ซึ่งมันไม่ยั่งยืนเลยนะ !!