ข้าม​ไป​ยัง​เนื้อหา

Whole Team Activity

การ​พัฒนา​ซอฟต์แวร์​คือ​กีฬา​ประเภท​ทีม — เลี่ยง​ไซโล​และ​กำแพง​การ​สื่อสาร

การ​พัฒนา​ซอฟต์แวร์​เป็น กิจกรรม​ของ​ทั้ง​ทีม (Whole Team Activity) ไม่ใช่​งาน​ที่​แบ่ง​เป็น​ท่อน​แล้ว​โยน​ต่อ​กัน​ไป​ที​ละ​แผนก Extreme Programming (XP) เสนอ​แนวคิด Whole Team ที่​รวม​ตัวแทน​ฝ่าย​ธุรกิจ (on-site customer) ผู้​ทดสอบ (tester) และ​โปรแกรมเมอร์​ไว้​ใน​ทีม​เดียวกัน ทำงาน​ร่วม​กัน​ใน​อุดมคติ​คือ​อยู่​ใน​พื้นที่​เดียวกัน (co-located) เพื่อ​ให้การ​สื่อสาร​และ​การ​ถ่ายทอด​ความ​รู้​ใน​ทีม​สูงสุด

Kent Beck และ​ทีม XP ตั้ง​ข้อสังเกต​ว่า​ความ​รู้​ที่​จำเป็นต่อ​การ​สร้าง​ซอฟต์แวร์​ที่​ดี​นั้น กระจัดกระจาย​อยู่​ใน​ตัว​คน​หลาย​บทบาท — นัก​ออกแบบ​เข้าใจ​แนวทาง​เชิง​เทคนิค ลูกค้า​เข้าใจ​คุณค่า​ทาง​ธุรกิจ ผู้​ทดสอบ​มอง​เห็น​ปัญหา​ที่​จะ​เกิด​ขึ้น​ล่วงหน้า ถ้า​ความ​รู้​เหล่า​นี้​ไม่​ไหล​เวียน​ระหว่าง​กัน​อย่าง​ต่อ​เนื่อง ทีม​จะ​ต้อง​เดา ต้อง​รอ หรือ​ต้อง​แก้ไข​ย้อนหลัง ซึ่ง​ล้วน​เป็น​ความ​สูญเปล่า

แทนที่​จะ​ให้ “ลูกค้า” ภายนอก​โยน​รายการ​ข้อ​กำหนด​ให้​นัก​พัฒนา​ไป​เดา​ว่า​หมาย​ถึง​อะไร แล้ว​โยน​ผลลัพธ์ “ข้าม​กำแพง” (throw it over the wall) ไป​ให้​ทีม​ทดสอบ​ต่อ จง​ให้​ทุก​คน​มี​ส่วนร่วม​ใน​กระบวนการ​อย่าง​ต่อ​เนื่อง​ตั้งแต่​ต้น​จน​จบ การ​พัฒนา​ซอฟต์แวร์​คือ​การ​แปลง​ความ​รู้​ให้​เป็น​ซอฟต์แวร์​ที่​ทำงาน​ได้ และ feedback loop ที่​ยาว เป็น​บ่อเกิด​มหาศาล​ของ​ความ​สูญเปล่า​และ bug การ​ลด feedback loop และ​หลีก​เลี่ยง​เงื่อนไข​ที่​ทำให้​งาน​ติดขัด (เช่น “ฉัน​แตะ code นั้น​ไม่​ได้ ต้อง​รอ Bob กลับ​จาก​พักร้อน​ก่อน”) จึง​เป็น​หัวใจ​สำคัญ

แนวคิด​นี้​สอดคล้อง​กับ​ค่า​นิยม​แรก​ของ Agile Manifesto ที่​ว่า “individuals and interactions over processes and tools” — เน้น​ปฏิสัมพันธ์​ระหว่าง​คน​มากกว่า​ขั้นตอน​และ​เครื่องมือ และ​ยัง​ใกล้​เคียง​กับ​แนวคิด cross-functional team ใน​ความหมายกว้าง คือ​กลุ่ม​คน​ที่​มี​ความ​เชี่ยวชาญ​ต่าง​สาขา​กัน​แต่​ทำงาน​ร่วม​กัน​เพื่อ​เป้าหมาย​เดียว โดย​ไม่​ต้อง​ส่ง​งาน​ข้าม​แผนก​ที่​แยก​กัน​บริหาร

“การ​พัฒนา​ซอฟต์แวร์​คือ​กีฬา​ประเภท​ทีม”

— Steve Smith

การนำ Whole Team Activity ไป​ใช้​จริง​มี​องค์​ประกอบ​สำคัญ​หลาย​ด้าน:

  1. รวม​บทบาท​เข้า​ใน​ทีม​เดียว — ทีม XP ทั่วไป​ประกอบ​ด้วย​ลูกค้า​ประจำ​ที่ (on-site customer หรือ product manager/domain expert), โปรแกรมเมอร์ (แนะนำ 4-10 คน), ผู้​ทดสอบ (ราว 1 คน​ต่อ​โปรแกรมเมอร์ 4 คน) และ​โค้ช (coach) ที่​ช่วย​ให้​ทีม self-organize แทนที่​จะ​สั่ง​งาน​แบบ​บน​ลง​ล่าง
  2. จัด​พื้นที่​ทำงาน​ร่วม​กัน (co-location) — ทีม​นั่ง​ด้วย​กัน​ใน​พื้นที่​เปิด เพื่อ​ให้​คำถาม​ได้​คำ​ตอบ​ทันที​แทนที่​จะ​รอ​ผ่าน​อีเมล​หรือ ticket ข้าม​คิว
  3. ทำงาน​เต็ม​เวลา​กับ​ทีม​เดียว — หลีก​เลี่ยง​การ​แบ่ง​เวลา​คน​ให้​หลาย project พร้อม​กัน (fractional assignment) เพราะ​การ​สลับ​บริบท​บ่อย​ทำลาย throughput ของ​ทั้ง​ทีม
  4. ดึง​ผู้​ทดสอบ​และ​ผู้เชี่ยวชาญ domain เข้า​มา​ตั้งแต่​ต้น — ไม่ใช่​รอ​ให้ code เสร็จ​ก่อน​ค่อย​ส่ง​ให้ QA แต่​ให้​ผู้​ทดสอบ​ร่วม​เขียน acceptance criteria และ Behavior Driven Development scenario ตั้งแต่​ก่อน​เริ่ม​เขียน code
  5. ลด hand-off และ single point of failure — ใช้​แนว​ปฏิบัติ​อย่าง Collective Code Ownership และ Pair Programming เพื่อ​กระจาย​ความ​รู้​ใน code ให้​ทั่ว​ทีม ไม่​กระจุก​อยู่​ที่​คน​ใด​คน​หนึ่ง
  6. สื่อสาร​แบบ​สั้น​และ​ถี่ — daily stand-up, การ​พูด​คุย​แบบ​เผชิญหน้า (face-to-face) และ retrospective ที่​มี​ตัวแทน​ทุก​บทบาท​เข้า​ร่วม ช่วย​ตัด​วงจร feedback ให้​สั้น​ลง

แผนภาพ​ต่อ​ไป​นี้​เปรียบเทียบ model hand-off แบบ​ไซโล กับ model whole-team ที่​ทำงาน​คู่​ขนาน​ร่วม​กัน

flowchart LR
    subgraph Siloed
        A1[Business writes spec] --> A2[Dev guesses and builds]
        A2 --> A3[Throw over wall to QA]
        A3 --> A4[Bugs found late]
    end
    subgraph WholeTeam
        B1[Business Dev Tester plan together] --> B2[Build and test in parallel]
        B2 --> B3[Fast feedback fix early]
    end

สมมติ​ทีม​กำลัง​พัฒนา feature ตะกร้า​สินค้า​ใหม่ ใน model ไซโล นัก​วิเคราะห์​ธุรกิจ​เขียน spec ส่ง​อีเมล​ให้​ทีม​พัฒนา ทีม​พัฒนา​ตีความ​เอง เขียน code เสร็จ​แล้ว​ส่ง​ต่อ​ให้ QA ทดสอบ ผล​คือ​พบ​ว่า​ตีความ​กฎ​ส่วนลด​ผิด​ไป​ตั้งแต่​ต้น ต้อง​ทำ​ใหม่

ใน model Whole Team ทั้ง​สาม​บทบาท​นั่ง​ประชุม​สั้น ๆ ร่วม​กัน​ตั้งแต่​ก่อน​เริ่ม​เขียน code กำหนด acceptance criteria แบบ BDD ไว้​ล่วงหน้า และ​ผู้​ทดสอบ​เขียน automated test คู่​ขนาน​กับ​ที่​โปรแกรมเมอร์​เขียน code production ตัวอย่าง​เช่น​การ​นิยาม test case ร่วม​กัน​ใน​สไตล์ Gherkin ที่​ทุก​ฝ่าย​อ่าน​เข้าใจ​ตรง​กัน:

// Acceptance test ที่เขียนร่วมกับผู้เชี่ยวชาญ domain ตั้งแต่ก่อนเริ่ม implement
// ไม่ใช่เขียนทีหลังโดย QA คนเดียวหลัง code เสร็จ
public class ShoppingCartDiscountTests
{
[Fact]
public void Applies_10_percent_discount_when_cart_exceeds_1000_baht()
{
// Arrange: สถานการณ์ที่ตกลงร่วมกันระหว่าง business, dev, tester
var cart = new ShoppingCart();
cart.AddItem(new LineItem("SKU-001", quantity: 3, unitPrice: 400m));
// Act
var total = cart.CalculateTotal();
// Assert: เกณฑ์ยอมรับที่ทุกฝ่ายเห็นพ้องตั้งแต่วัน planning
Assert.Equal(1080m, total); // 1200 - 10%
}
}

การ​เขียน test ร่วม​กัน​แบบ​นี้​ทำให้​ความ​เข้าใจ​ผิด​ถูก​จับ​ได้​ตั้งแต่​ก่อน​เขียน code จริง ไม่ใช่​หลัง​จาก​ที่ QA เจอ bug ใน​รอบ​ทดสอบ​ท้าย​สุด ซึ่ง​คือ​แก่น​ของ​การ​ลด feedback loop ที่​แนวคิด​นี้​เน้น​ย้ำ

ประโยชน์

  • ลด feedback loop ให้​สั้น​ลง ปัญหา​ถูก​จับ​ได้​เร็ว​ก่อน​ที่​จะ​สะสม​เป็น​หนี้​ทาง​เทคนิค
  • ลด​ความ​สูญเปล่า​จาก​การ​ตีความ spec ผิด เพราะ​ทุก​ฝ่าย​เข้าใจ​ตรง​กัน​ตั้งแต่​ต้น
  • กระจาย​ความ​รู้​ใน​ทีม ลด​ความ​เสี่ยง​จาก “bus factor” หรือ​การ​ติดขัด​เพราะ​รอ​คน​ใด​คน​หนึ่ง
  • เพิ่ม​ความ​รู้สึก​เป็น​เจ้าของ​ร่วม (shared ownership) ทั้ง​ต่อ code และ​ต่อ​ผลลัพธ์​ทาง​ธุรกิจ

ข้อ​ควร​ระวัง

  • ต้องการ​ความ​มุ่งมั่น​สูง​จาก​ทุก​ฝ่าย โดย​เฉพาะ​การ​จัดสรร​เวลา​ของ business representative ให้​ประจำ​อยู่​กับ​ทีม​ได้​จริง ไม่ใช่​แค่​ทฤษฎี
  • การ co-location เต็ม​รูปแบบ​อาจ​ทำได้​ยาก​ใน​ทีม distributed หรือ remote-first จำเป็น​ต้องหา​เครื่องมือ​และ​จังหวะ​สื่อสาร​ทดแทน เช่น video call ประจำ, shared documentation ที่​ปรับปรุง​สด​เสมอ
  • หาก​องค์กร​มี​โครงสร้าง​แผนก​ที่​แยก​กัน​บริหาร​งบ​และ KPI คนละ​ชุด (เช่น dev กับ QA อยู่​คนละ​ฝ่าย) การ​รวม​ทีม​จริง​อาจ​ขัด​กับ incentive ของ​องค์กร ต้อง​แก้​ที่​โครงสร้าง​องค์กร​ด้วย ไม่ใช่​แค่​กระบวนการ​ทำงาน — ซึ่ง​สัมพันธ์​กับ Conway’s Law ที่​ว่า​โครงสร้าง​ซอฟต์แวร์​มัก​สะท้อน​โครงสร้าง​การ​สื่อสาร​ของ​องค์กร
  • ทีม​ที่​ใหญ่​เกิน​ไป​จะ​สื่อสาร​กัน​ไม่​ทั่วถึง​แม้​จะ​อยู่​ห้อง​เดียวกัน ควร​รักษา​ขนาด​ทีม​ให้​เล็ก​พอที่​จะ​พูด​คุย​กัน​ได้​จริง (โดย​ทั่วไป​แนะนำ​ราว 4-10 โปรแกรมเมอร์​บวก​บทบาท​สนับสนุน)