เปลี่ยนแนวคิด จากสร้างอย่างไร มาเป็น สร้างอะไร ดีกว่านะ !!

ในการเขียนโปรแกรมนั้น ปกติเราจะเริ่มด้วย

• การสร้างไฟล์
• สร้าง class
• สร้าง method
• สร้าง object จาก class
• ไม่มี unit test

ดังนั้น code ที่ได้ออกมาส่วนใหญ่มันจะทดสอบยากมากๆ
ทั้งจำนวนบรรทัดของแต่ละ class, method มันเยอะมาก
ทั้งมีการ share state ของการทำงานผ่าน field บางตัว
ทั้งมีการผูกมัดของ code เยอะมาก
และอื่นๆ อีกมากมาย

ทำให้คนที่คิดว่า จะกลับมาแก้ไขให้ code มันดีขึ้น
เลิกความคิดนั้นไปกันเลยทีเดียว

แต่ก็มีแนวทางอื่นๆ ที่ดีสำหรับการเขียน code ที่ดีนะ
เช่น การแยกส่วนการทำงานต่างๆ ออกจากกันด้วย abstraction layer
มันเข้าใจยากเหมือนกันนะ
ดังนั้นลองทำตามแนวคิดนี้ไหม คือ “What -> How -> When”

แล้ว What -> How -> When มันคืออะไร ?

โดยปกติก่อนที่คุณจะทำการเพิ่มหรือแก้ไข code ใดๆ
ให้คุณถามตัวเองก่อนสิว่า

• class ชื่ออะไรดีนะ ?
• class นั้นจะทำงานอะไรดีนะ ?
• มี method อะไรบ้าง ?
• แต่ละ method ควรเป็น private หรือ public ?

ในจังหวะนี้คือ What นะครับ คือ คุณกำลังจะทำอะไร

อย่าเริ่มด้วย How อย่างเด็ดขาด !!!
เช่น class นี้ หรือ method นี้ ต้องทำอย่างไร เขียน code อย่างไรเพื่อให้มันทำงานได้

อย่าเริ่มต้นด้วย When อย่างเด็ดขาด !!!
เช่น เมื่อไรที่ class หรือ method นี้ต้องทำงานบ้าง

ดังนั้น แนะนำให้เริ่มคิดจาก What เสมอนะครับ
เพื่อให้ได้ชื่อที่ดี เหมาะสม ตรงกับความต้องการ
เพื่อให้ได้กลุ่มของ method
เพื่อให้ได้กลุ่มของ field หรือ property

ต่อจากนั้น ถามตัวเองต่อไปว่า ขอบเขตของแต่ละ class คือออะไรบ้าง
เพื่อทำให้ส่วนข้อมูลที่ share กันระหว่าง class ให้มีน้อยที่สุด
เพื่อทำให้ code มันผูกมัดกันน้อยที่สุด
มาถึงตรงนี้ คุณสามารถทำการสร้าง stub ของ class และ method ได้เลยนะ
เพื่อทำการทดสอบ class หรือ method ตามที่คุณต้องการ

เมื่อมาถึงจุดนี้ คุณก็พร้อมที่จะ How ล่ะ
นั่นคือการลงมือ implement code จริงๆ ตามที่ได้กำหนดไว้ใน What
และลงมือทำการทดสอบสิ่งที่คุณสร้างขึ้นมา
มันฟังดูยาก และ เยอะ แต่ให้ลองเชื่อและลงมือทำดูสิ
จะพบว่า มันง่ายมากๆ สำหรับการเขียน code

แต่ถ้าไม่เชื่อ คุณก็ลองคิด What และ How ไปพร้อมๆ กันสิ !!
สิ่งที่คุณจะได้ออกมาคือ code ที่มันสับสน ยุ่งเหยิง
และคุณเชื่อไหมว่า code ที่คุณสร้างขึ้นมามันเสร็จจริงๆ

ถ้าคุณเริ่มคิดด้วย When ก่อนล่ะ
สิ่งที่คิดก็คือ

• เมื่อไรจะทำการสร้าง object ?
• เมื่อไรจะทำการเรียกใช้ class และ method นี้ล่ะ ?

มันจะเกิด code ที่พันกันไปหมด นะสิ …
แล้วจะได้ code ที่ซับซ้อยขึ้นมา

มาถึงตรงนี้ก็ยังไม่เห็นภาพอะไรเลย ขอตัวอย่างหน่อย ?

ตัวอย่างเช่น
ให้ทำการเขียน code เพื่ออธิบายกิจกรรมของใครบางคนตั้งแต่ตื่นจนกระทั่งเข้านอน

แน่นอนว่าทุกๆ คนจะเริ่มคิดในลักษณะนี้ทันที

• เมื่อตื่นขึ้นมาก็ต้องล้างหน้า
• จากนั้นแปรงฟัน
• ต่อด้วยอาบน้ำ
• สวมใส่เสื้อผ้า
• …
• ไปกินอาหารค่ำ
• ดู TV
• เข้านอน

ลองหยุดเขียน code กันก่อนไหม ?

แล้ว code ที่ได้ก็มักออกมาในรูปแบบนี้ !!

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

code ที่เห็นนั้นคือ รูปแบบ procedural
ซึ่งมีการทำการตามลำดับ เป็นขั้นเป็นตอนชัดเจน
แต่เมื่อเราทำการ implement เสร็จ
code ชุดนี้มันจะน่ากลัวมากๆ
ลองจินตนาการดูเอากันเองนะครับ

ผมเชื่อว่าทุกๆ คนไม่อยากจะเขียน code แบบนี้
แต่มันง่ายมากๆ นะ ที่สำคัญมันหยุดไม่ได้ด้วยนะสิ
ผมก็ทำอยู่เป็นประจำเช่นกัน !!!

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

ดังนั้น อย่าเริ่มคิดด้วย When และ How โดยเด็ดขาด
ให้เริ่มที่ What เสมอนะครับ

เริ่ม What ง่ายๆ ด้วยการเริ่มจาก unit testing ครับ

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