วันแรกของต้น ปี 1956#

ปี 1956 ต้นเพิ่งได้งานเป็นโปรแกรมเมอร์ของสายการบินเล็กๆ แห่งหนึ่ง

หัวหน้ายื่นงานแรกให้

“เขียนโปรแกรมนับที่นั่งที่ถูกจองหน่อย พอเที่ยวบินเต็ม 20 ที่ ให้ไฟเตือนติด”

ต้นคิดในใจ ง่ายนี่หว่า

เดี๋ยวก็รู้ครับ 555+

คอมพิวเตอร์รู้แค่ “เปิด” กับ “ปิด”#

ก่อนเขียนอะไร ต้นต้องเข้าใจก่อนว่าเครื่องคิดยังไง

ข้างในคอมพิวเตอร์มีแต่วงจรไฟฟ้า แต่ละจุดมีได้แค่สองสถานะ คือไฟผ่านกับไฟไม่ผ่าน

เราเลยเขียนแทนด้วยเลข 1 กับ 0

ระบบตัวเลขที่ใช้แค่ 0 กับ 1 เรียกว่า binary (เลขฐานสอง)

ลองนึกถึงสวิตช์ไฟในบ้าน 6 ตัวเรียงกัน แต่ละตัวมีค่าประจำตัว จากขวาไปซ้ายคือ 1, 2, 4, 8, 16, 32

อยากได้เลข 27 ก็เปิดสวิตช์ตัว 16, 8, 2 และ 1

16 + 8 + 2 + 1 = 27

เขียนเป็น binary ได้ 011011

ตัวเลข ตัวอักษร คำสั่งทุกคำ เครื่องเห็นเป็นแค่สวิตช์เปิดปิดแบบนี้หมด

ในตอนที่ 1 ผมเรียกมันว่า machine language คือภาษาที่เครื่องเข้าใจตรงๆ

ฟังดูง่าย แต่ทั้งโปรแกรมเป็นแบบนี้ เป็นพันเป็นหมื่นตัว

ตาลายครับ

ยุคนั้นเขียนโปรแกรมลงอะไร?#

ลงบัตรกระดาษเจาะรูครับ หนึ่งบัตรเก็บได้ประมาณหนึ่งบรรทัด ทั้งโปรแกรมเลยเป็นปึกบัตรที่ต้องถือไปส่งเครื่อง

แล้วต้นจะส่งเลข 0 กับ 1 เข้าเครื่องยังไง

คำตอบหลักๆ ของยุคนั้นคือ punch card (บัตรเจาะรู)

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

บัตรมาตรฐานของ IBM มี 80 ช่อง แต่ละช่องมี 12 แถว ส่วนมากหนึ่งบัตรก็เก็บได้หนึ่งบรรทัด

ต้นนั่งหน้าเครื่องเจาะบัตร พิมพ์ทีละบรรทัด ได้บัตรทีละใบ

โปรแกรมของเขาเลยไม่ใช่ไฟล์ในเครื่อง

แต่เป็นปึกบัตรที่ต้องถือไปถือมา

และมีกฎที่โหดมากข้อหนึ่ง คือ เจาะแล้วลบไม่ได้

พิมพ์ผิดตัวเดียว ต้องทิ้งบัตรใบนั้น แล้วเจาะใหม่ทั้งใบ

ถังขยะข้างโต๊ะต้นเลยเต็มเร็วมาก

ทำไมคนยุคนั้นต้องรอผลเป็นวัน?#

เพราะคอมพิวเตอร์แพงมาก ทั้งองค์กรมีเครื่องเดียว งานของทุกคนต้องต่อคิวให้ operator ป้อนเข้าเครื่องเป็นชุด บางที่เลยรอเป็นชั่วโมง บางที่รอข้ามวัน

ส่วนที่ทรมานที่สุดไม่ใช่การเจาะบัตร

แต่เป็นการรอ

ยุคนั้นคอมพิวเตอร์แพงมาก ตัวใหญ่เท่าห้อง ทั้งองค์กรมีเครื่องเดียวใช้ร่วมกัน

ต้นไม่ได้นั่งหน้าเครื่องเอง

เขาต้องเอาปึกบัตรไปยื่นให้เจ้าหน้าที่คุมเครื่อง ที่เรียกว่า operator (คนคุมเครื่อง)

operator จะรวบงานของหลายๆ คนไว้ แล้วป้อนเข้าเครื่องต่อกันเป็นชุด วิธีนี้เรียกว่า batch processing (ส่งงานเป็นชุดแล้วรอผล)

ผลที่ได้กลับมาคือกระดาษที่พิมพ์ออกมา

บางที่รอเป็นชั่วโมง บางทีก็ต้องรอข้ามวัน

ในเรื่องของเรา ต้นยื่นบัตรตอนเย็น ได้ผลพรุ่งนี้เช้า

เช้าวันต่อมา ไฟไม่ติด#

เช้าวันรุ่งขึ้น ต้นรีบไปรับกระดาษผลลัพธ์

ที่นั่งเต็ม 20 ที่แล้ว

แต่ไฟไม่ติด

กระดาษไม่ได้บอกเลยว่าผิดตรงไหน

ต้นต้องหยิบบัตรขึ้นมาส่องทีละใบ แปลรูกลับเป็นตัวเลขเอง

จนไปเจอบัตรใบที่ 4

เขาเจาะไว้ว่าให้เทียบกับ 21 แทนที่จะเป็น 20

ผิดตัวเลขตัวเดียว

แก้แค่บัตรใบเดียว แต่ต้องรอผลรอบใหม่อีกทั้งคืน

bug คือจุดผิดพลาดในโปรแกรม ส่วนการไล่หาแล้วแก้ เรียกว่า debug

มีเรื่องเล่าดังเรื่องหนึ่ง ปี 1947 ทีมที่ดูแลคอมพิวเตอร์ Harvard Mark II เจอแมลงเม่าติดอยู่ในชิ้นส่วนของเครื่อง เขาแปะมันลงในสมุดบันทึกแล้วเขียนว่า “first actual case of bug being found” (เจอ bug ตัวจริงเป็นครั้งแรก)

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

บัตรตกพื้น หายนะของแท้#

คืนที่สอง ต้นถือปึกบัตรใหม่เดินไปห้องเครื่อง

สะดุด

บัตรร่วงกระจายเต็มพื้น

นี่แย่กว่าบั๊กอีก

เพราะเครื่องอ่านบัตรตามลำดับในปึก บัตรสลับกัน คำสั่งก็สลับกัน โปรแกรมพังแบบไม่รู้เรื่องเลย

คนยุคนั้นเลยมีทริกกันไว้สองแบบ

1. ขีดเส้นทแยง: เรียงบัตรให้ตรงแล้ว เอาปากกาขีดเส้นทแยงพาดสันบัตรทั้งปึก ถ้าวันไหนบัตรสลับ เส้นจะเบี้ยวให้เห็นทันที
2. เลขลำดับบนบัตร: ภาษา FORTRAN ที่ IBM ออกมาในปี 1957 เผื่อช่อง 73 ถึง 80 ไว้ใส่เลขลำดับบัตร ถ้าบัตรตก ก็เอาเข้าเครื่องเรียงบัตร ให้เครื่องเรียงกลับให้

ผมว่าเส้นทแยงนี่ฉลาดมาก

ไม่ต้องใช้เทคโนโลยีอะไรเลย ปากกาด้ามเดียวจบ

ต้นเรียงบัตรกลับ ขีดเส้นทแยงไว้ ส่งอีกคืน

เช้าวันที่สาม ไฟติดตอนที่นั่งที่ 20 พอดี

งานที่แก้ตัวเลขแค่ตัวเดียว กินเวลาไปหลายวัน

แล้วระบบใหญ่ๆ ยุคนั้นทำได้ยังไง#

ฟังแบบนี้แล้วอาจสงสัยว่า ยุคที่แก้บั๊กทีละวัน จะสร้างระบบใหญ่ๆ ได้ยังไง

เรื่องของต้นเป็นเรื่องสมมติ แต่มาดูเรื่องจริงกันบ้าง

ในตอนที่ 1 ผมเล่าถึง SABRE ระบบจองตั๋วเครื่องบินของ American Airlines ที่ทำร่วมกับ IBM

เรื่องนี้มีที่มาที่ผมชอบมาก

ปี 1953 ประธานของ American Airlines ชื่อ C.R. Smith นั่งเครื่องบินข้างพนักงานขายของ IBM ชื่อ R. Blair Smith นามสกุลเดียวกันพอดี คุยกันไปคุยกันมา จนได้ไอเดียว่าน่าจะใช้คอมพิวเตอร์จัดการการจองตั๋ว

แต่จากวันที่คุยกันบนเครื่องบิน ไปถึงวันที่ใช้งานได้จริงนานมาก

ตั้งแต่คุยกันครั้งแรกจนใช้ได้เต็มระบบ ห่างกัน 11 ปี

IBM เล่าว่าพอใช้งานได้แล้ว เวลาจองตั๋วหนึ่งครั้งลดจากเฉลี่ย 90 นาที เหลือไม่กี่วินาที

คุ้มมาก แต่ก็สร้างยากมากเหมือนกัน

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

สิ่งที่ผมได้จากยุคนี้#

ลองทำเอง

ตามต้นมาทั้งเรื่อง ผมรู้สึกเลยว่า การรอผลคือศัตรูตัวจริง

เขียนผิดไม่ใช่เรื่องใหญ่ ทุกคนเขียนผิด

แต่พอรู้ว่าผิดช้า ความผิดเล็กๆ ก็กลายเป็นความเสียหายใหญ่

เก็บศัพท์

จดบันทึก

ยุคนี้สอนผมว่า สิ่งที่ทำให้งานแพง คือระยะเวลาตั้งแต่ลงมือทำ จนถึงตอนที่รู้ว่าผิด

ยิ่งรอบนี้ยาว ยิ่งเจ็บ

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

คำถามที่พบบ่อย#

binary คืออะไร?

ระบบตัวเลขที่ใช้แค่ 0 กับ 1 เช่น 27 เขียนเป็น binary ได้ 011011 คอมพิวเตอร์ใช้ระบบนี้เพราะวงจรมีแค่สองสถานะ คือไฟผ่านกับไฟไม่ผ่าน

บัตรเจาะรูของ IBM มีกี่ช่อง?

บัตรมาตรฐานของ IBM มี 80 ช่อง แต่ละช่องมี 12 แถว

คำว่า bug มาจากแมลงในคอมพิวเตอร์ปี 1947 จริงไหม?

ไม่ใช่ครับ ปี 1947 ทีม Harvard Mark II เจอแมลงเม่าในเครื่องจริง แต่วิศวกรใช้คำว่า bug เรียกจุดบกพร่องมาตั้งแต่ก่อนมีคอมพิวเตอร์แล้ว

SABRE ใช้งานได้จริงปีไหน?

ทดลองใช้ปี 1960 บน IBM 7090 สองเครื่อง และใช้งานเต็มระบบปี 1964

Next → ตอนที่ 3: ยุคทีมใหญ่กับ Waterfall ตอนหน้าเป็นยุคที่เครื่องมือยังมีจำกัด คนเริ่มมีภาษาที่อ่านออกเหมือนภาษาคนมากขึ้น ไม่ต้องเจาะ 0 กับ 1 เองแล้ว แต่ปัญหาใหม่ก็ตามมา ผมจะลองดูว่ามันง่ายขึ้นจริง หรือแค่ยากในแบบใหม่ 555+