โปรแกรมเมอร์คนหนึ่งได้สร้างเกม Snake ที่ใช้งานได้โดยใช้ตัวแปรจำนวนเต็มเพียง 4 ตัว แสดงให้เห็นถึงแนวทางที่รุนแรงในการเขียนโปรแกรมที่มีข้อจำกัดด้านหน่วยความจำ โครงการนี้เก็บสถานะของเกมทั้งหมด รวมถึงกระดานเกม ตำแหน่งของงู ทิศทาง และตำแหน่งของแอปเปิ้ล ภายในจำนวนเต็ม 4 ตัวที่รวมกันประมาณ 17 ไบต์ของหน่วยความจำ
การใช้งานนี้ใช้กริดเกมขนาด 4x4 ที่เก็บไว้ในจำนวนเต็ม 32 บิตตัวเดียว โดยแต่ละบิตแทนเซลล์หนึ่งเซลล์บนกระดาน ข้อมูลเกมเพิ่มเติม เช่น ตำแหน่งหัวงู ตำแหน่งหาง ความยาว ตำแหน่งแอปเปิ้ล และทิศทางการป้อนข้อมูลของผู้เล่น ถูกบรรจุลงในจำนวนเต็ม 32 บิตอีกตัวหนึ่งโดยใช้การดำเนินการแบิตไวส์ จำนวนเต็มตัวที่สามติดตามทิศทางการเคลื่อนไหวของงู ในขณะที่ตัวที่สี่ทำหน้าที่เป็นตัวนับลูป
การแบ่งโครงสร้างหน่วยความจำ:
uint32_t map- 16 บิตสำหรับตารางเกม 4x4 (4 ไบต์)uint32_t vars- เก็บตำแหน่งหัว (5 บิต), ตำแหน่งหาง (5 บิต), ความยาว (5 บิต), ตำแหน่งแอปเปิล (5 บิต), ทิศทาง (2 บิต) (4 ไบต์)uint32_t shape- เก็บทิศทางการเคลื่อนที่, 2 บิตต่อทิศทาง, สูงสุด 16 ทิศทาง (4 ไบต์)int8_t i- ตัวนับลูป (1 ไบต์)- รวม: 17 ไบต์สำหรับสถานะหลักของเกม
ชุมชนตั้งคำถามเกี่ยวกับการอ้างเรื่องความเป็นไปได้
ชุมชนโปรแกรมเมอร์ได้ตั้งข้อกังวลหลายประการเกี่ยวกับการอ้างที่ทะเยอทะยานของโครงการนี้ นักวิจารณ์ชี้ให้เห็นว่าแม้สถานะหลักของเกมจะพอดีกับจำนวนเต็มสี่ตัว แต่โปรแกรมที่สมบูรณ์ต้องการหน่วยความจำเพิ่มเติมสำหรับการทำงาน รวมถึงพื้นที่สแต็ก ตัวนับลูป และไลบรารี curses ที่ใช้สำหรับการป้อนข้อมูลจากแป้นพิมพ์และการแสดงผล
การอ้างจริง ๆ คือคุณสามารถเก็บสถานะเกมสำหรับกระดานเกมขนาด 8x4 ที่ค่อนข้างเล็กไว้ใน uint32_t สองตัว uint64_t หนึ่งตัว และ uint_8t หนึ่งตัว นั่นไม่ใช่สถานะโปรแกรมทั้งหมด
นักพัฒนาบางคนแนะนำว่าชื่อเรื่องขายเกินความเป็นจริง โดยสังเกตว่าด้วยข้อจำกัดเช่นนี้ แม้แต่เกมที่ง่ายกว่าก็เป็นไปได้ ผู้แสดงความคิดเห็นคนหนึ่งสังเกตอย่างตลกขบขันว่าการลดกระดานเกมให้เหลือเพียง 2x2 เซลล์จะทำให้เกมทั้งหมดพอดีกับจำนวนเต็มตัวเดียว
การใช้งานทางเทคนิคได้รับปฏิกิริยาที่หลากหลาย
โครงการนี้อาศัยการกำหนดแมโครที่ซับซ้อนอย่างมากเพื่อจัดการบิตแต่ละบิตภายในจำนวนเต็ม เมื่อแมโครเหล่านี้ขยายตัวระหว่างการคอมไพล์ พวกมันจะสร้างโค้ดที่อ่านไม่ออกเกือบทั้งหมดที่เต็มไปด้วยการดำเนินการแบิตไวส์และการเลื่อนบิต ผู้เขียนยอมรับว่าแนวทางนี้สร้างแมโครที่น่าเกลียดและเตือนว่าผลลัพธ์ควรมองเป็นการฝึกฝนการเขียนโปรแกรมมากกว่าแนวปฏิบัติการเขียนโค้ดที่ดี
การบีบอัดรูปร่างของงูทำให้สมาชิกชุมชนบางคนสนใจเป็นพิเศษ ซึ่งสังเกตว่าแพทเทิร์นบิตหลายแบบเป็นไปไม่ได้ทางกายภาพสำหรับเกมงู สิ่งนี้แนะนำว่าสถานะเกมอาจถูกบีบอัดได้มากกว่านี้ แม้ว่าจะต้องแลกกับความซับซ้อนเพิ่มเติม
ข้อจำกัดของเกม:
- ตาราง 4x4 = ทั้งหมด 16 ช่อง
- ความยาวสูงสุดของงูถูกจำกัดด้วยพื้นที่จัดเก็บทิศทางที่มีอยู่
- ใช้ไลบรารี curses สำหรับการรับข้อมูลและแสดงผล (การพึ่งพาภายนอก)
- ต้องใช้แมโครการจัดการแบบ bitwise สำหรับการจัดการสถานะ
การถอดถอนปรัชญาการเขียนโปรแกรมในวงกว้าง
โครงการนี้ได้จุดประกายการถอดถอนเกี่ยวกับคุณค่าของข้อจำกัดการเขียนโปรแกรมที่รุนแรง ในขณะที่นักพัฒนาบางคนชื่นชมมันในฐานะการฝึกฝนการเพิ่มประสิทธิภาพที่น่าสนใจ คนอื่น ๆ ตั้งคำถามว่าข้อจำกัดเช่นนี้มีจุดประสงค์ที่เป็นประโยชน์อะไรนอกจากความอยากรู้ทางวิชาการ การถอดถอนสะท้อนให้เห็นความตึงเครียดที่กว้างขึ้นในการเขียนโปรแกรมระหว่างโค้ดที่อ่านได้ ดูแลรักษาได้ และการสาธิตทางเทคนิคของการใช้ทรัพยากรน้อยที่สุด
ซอร์สโค้ดที่สมบูรณ์มีประมาณ 150 บรรทัดและมีให้ใน GitHub ทำให้โปรแกรมเมอร์คนอื่น ๆ สามารถตรวจสอบเทคนิคการจัดการแบิตไวส์ที่ใช้ได้ แม้จะมีความสำเร็จทางเทคนิค แต่ฉันทามติแนะนำว่าแนวทางนี้ใช้งานได้ดีกว่าในฐานะการฝึกฝนการเรียนรู้มากกว่าแม่แบบสำหรับการพัฒนาเกมในโลกจริง