Λ-2D: สำรวจการวาดภาพในฐานะภาษาโปรแกรม

 (media.mit.edu)
1 คะแนน โดย GN⁺ 2024-11-10 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • λ-2D คือการทดลองภาษาแบบใช้ภาพวาดเป็นโค้ดโดยตรง มุ่งไปที่ทั้งการแสดงออกเชิงภาพที่ภาษาข้อความทำได้ยาก และรูปทรงเชิงสุนทรียะของตัวโปรแกรม
  • โครงหลักของภาษาคือ แลมบ์ดาแคลคูลัส โดยเริ่มจากแนวคิดที่ว่าโครงสร้างซึ่งใกล้เคียงกับการ “ประเมินค่า” มากกว่าลำดับการรันที่ตายตัว คล้ายกับวิธีที่เรามองภาพวาด
  • ใช้ สัญลักษณ์บนกริด และสายเชื่อมเพื่อแสดงการไหลของข้อมูล ให้ทั้งวาดด้วยมือได้ง่ายและให้เครื่องตีความได้
  • เนื่องจากแลมบ์ดาแคลคูลัสล้วน ๆ ใช้งานได้ไม่สะดวก จึงมีการเพิ่ม syntactic sugar และองค์ประกอบโต้ตอบ เช่น ตัวเลข ตัวดำเนินการทางคณิตศาสตร์ เฟรม และสไลเดอร์
  • การติดตั้งใช้งานปัจจุบันจะแปลงโปรแกรม λ-2D ให้เป็น JavaScript expression เดียวแล้วรัน โดยยังมีข้อจำกัดที่หน้าตาคล้ายแผงวงจร และยังเหลือความท้าทายด้านการเรียนรู้กับการสแกน

การทดลองภาษาที่เขียนโค้ดด้วยภาพวาด

  • λ-2D เป็นการทดลอง ภาษาโปรแกรมที่ไม่อิงภาษาเขียน ซึ่งเริ่มจากคำถามว่า “เราจะเขียนโค้ดผ่านภาพวาดได้หรือไม่”
  • ภาษาที่ไม่ใช่ข้อความมีอยู่แล้วหลายแนว
  • เป้าหมายการออกแบบสรุปได้ 3 ข้อ
    • ใช้ประโยชน์จากข้อเท็จจริงที่ว่าโปรแกรม “ถูกวาดขึ้น” เพื่อใส่ความสามารถที่ภาษาข้อความทำได้ยาก
    • หลีกเลี่ยงทั้งกรณีที่มีคำสั่งน้อยเกินไปจนโปรแกรมง่าย ๆ ก็ยังเขียนยาก และกรณีที่มีคำสั่งมากเกินไปจนไม่มินิมอลและยากต่อการประมวลผลด้วยคอมพิวเตอร์วิทัศน์
    • ทำให้ตัวโปรแกรมเองมีความน่าดึงดูดทางสายตา จนกลายเป็น ภาพวาด ที่อยากใส่กรอบแขวนไว้ได้

แลมบ์ดาแคลคูลัสและการแสดงผลแบบอิงกริด

  • λ-2D เลือกใช้ แลมบ์ดาแคลคูลัส เป็นฐานของภาษา แทนแนวทางแบบ imperative หรือระดับต่ำ
  • แลมบ์ดาแคลคูลัสใกล้เคียงกับการ “ประเมินค่า” มากกว่า “การรัน” และสอดคล้องกับวิธีที่สายตาไล่ตามจุด เส้น รูปทรง และองค์ประกอบในภาพโดยไม่จำเป็นต้องมีลำดับตายตัว
  • โครงสร้างเริ่มต้นเป็น ระบบแบบอิงกริด
    • ผู้ใช้สามารถลากเส้นต่อเนื่องที่พาดผ่านหลายช่องกริดได้
    • แต่ละช่องกริดสุดท้ายจะถูกตีความเป็นหนึ่งในชุดสัญลักษณ์แบบจำกัด
    • เป็นจุดสมดุลที่ทั้งคนวาดได้ง่ายและคอมพิวเตอร์ parse ได้ง่าย

สัญลักษณ์ฟังก์ชันและการไหลของข้อมูลผ่านสายเชื่อม

  • คำสั่งพื้นฐานของแลมบ์ดาแคลคูลัสมีเพียง 2 อย่าง
    • การใช้ฟังก์ชัน
    • การนิยามฟังก์ชัน
  • λ-2D แทนการใช้ฟังก์ชันด้วย สัญลักษณ์รูปถ้วย และแทนการนิยามฟังก์ชันด้วยอักษรกรีก λ
  • เช่นเดียวกับแลมบ์ดาแคลคูลัสพื้นฐาน ฟังก์ชันจะรับอาร์กิวเมนต์ได้ครั้งละหนึ่งตัวและสร้างเอาต์พุตหนึ่งค่าเสมอ
  • หากต้องจัดการหลายอาร์กิวเมนต์ จะใช้วิธี currying โดยเชื่อมหลายฟังก์ชันเข้าด้วยกัน
  • สายเชื่อมระหว่างสัญลักษณ์ทำหน้าที่เป็นทางผ่านของข้อมูล
  • แม้ภาษาขั้นนี้จะครบถ้วนเชิงทฤษฎีถึงระดับทัวริง แต่การใช้งานจริงยุ่งยากมาก จึงมีการเพิ่มสัญลักษณ์เสริมอย่างตัวเลขและตัวดำเนินการทางคณิตศาสตร์
    • สัญลักษณ์เพิ่มเติมเหล่านี้เป็นเพียง syntactic sugar
    • หากต้องการ ก็ยังใช้เฉพาะโครงสร้างแลมบ์ดาแคลคูลัสล้วน ๆ อย่าง Church numeral ได้

เฟรม ข้อมูลภาพวาด และสไลเดอร์

  • λ-2D พยายามต่อยอดประสบการณ์แบบ Scratch ที่วาดสไปรต์แล้วนำมาใช้ได้ทันทีในเอดิเตอร์เดียวกัน ให้เป็นธรรมชาติมากขึ้น
  • เฟรม คือการล้อมพื้นที่บางส่วนของแคนวาสด้วยสายเชื่อม และวางสัญลักษณ์บอกการแสดงผลไว้ที่มุมซ้ายบน
    • รอยขีดเขียนภายในพื้นที่นั้นสามารถใช้เป็นข้อมูลได้
    • สามารถสเก็ตช์รูปร่างของฟังก์ชันคณิตศาสตร์โดยตรงเพื่อนำไปใช้กับงานอย่างแอนิเมชันได้
    • จัดการกับรูปร่างในฐานะข้อมูลได้เลย โดยไม่ต้องมีขั้นตอนแยกสำหรับหาสมการ
  • ยังมี สไลเดอร์ ที่ลากได้ขณะรัน
    • ใช้ควบคุมโปรแกรมแบบพารามิเตอร์
    • ในอนาคตอาจมีองค์ประกอบ GUI อื่นเพิ่มเติม

เอดิเตอร์และสัญลักษณ์ขนาด 5×5

  • แนวคิดแรกเริ่มมาจากโปรแกรมตัวอย่างที่วาดด้วยมือลงบนสมุดจุด
  • เนื่องจากส่วนคอมพิวเตอร์วิทัศน์สำหรับสแกนโปรแกรมบนกระดาษยังไม่พร้อม จึงเริ่มจากการสร้าง เอดิเตอร์อย่างง่าย สำหรับวาดโปรแกรมแบบดิจิทัลก่อน
  • แต่ละสัญลักษณ์ถูกสร้างเป็นพิกเซลขนาด 5×5 เพื่อให้ปั๊มลงบนแคนวาสแบบกริดได้ง่าย
  • ผู้ใช้ยังสามารถวาดแบบ freehand ได้เหมือนใช้เครื่องมือดินสอ
  • เอดิเตอร์ที่เริ่มมาในฐานะเครื่องมือชั่วคราว ค่อย ๆ พัฒนาให้ใกล้เคียงเอดิเตอร์ที่มีฟังก์ชันครบมากขึ้น

ปัญหาเรื่องเอาต์พุตในภาษาฟังก์ชันล้วน

  • λ-2D เป็นภาษาฟังก์ชันล้วนและไม่มีสถานะ จึงยากที่จะทำคำสั่ง print แบบทั่วไป
  • การแสดงผลคือการเปลี่ยนสถานะ และถ้าคาดหวังให้แสดงผลตามลำดับที่แน่นอน ก็ต้องสมมติลำดับการประเมิน expression ด้วย
  • วิธีแก้คือการนิยาม “เอาต์พุต” ใหม่ในแบบฟังก์ชัน
    • ส่งแคนวาสว่างเปล่าเข้าไปให้ฟังก์ชัน
    • รับแคนวาสใหม่กลับมา โดยพิกเซลถูกเปลี่ยนจนดูเป็นข้อความหรือรอยวาดตามต้องการ
  • ภาษานี้จึงถูกออกแบบโดยมี แคนวาสและพิกเซล เป็นศูนย์กลาง แทนที่จะยึดกับสตริงและตัวอักษร

การแปลงเป็น JavaScript และการแสดงภาพการรัน

  • parser พื้นฐานจะแปลงโปรแกรม λ-2D ทั้งหมดให้เป็น JavaScript expression ที่เทียบเท่ากัน
  • JavaScript ที่ได้เป็น expression ขนาดมหึมาเพียงตัวเดียวที่เต็มไปด้วยวงเล็บ แม้จะไม่มีประสิทธิภาพแต่ก็ใช้งานได้
  • ปัจจุบัน parser ทำหน้าที่แค่ส่งออก JavaScript และให้ JavaScript engine ของเบราว์เซอร์เป็นผู้รัน จึงยากที่จะทำภาพการทำงานจริงระหว่างรัน
  • อย่างไรก็ตาม กระบวนการ parse นั้นทำเป็นภาพได้ง่าย และอาจดูคล้ายเส้นทางที่ tree-walk interpreter ไล่ผ่านขณะรันโปรแกรม
  • หากใส่เสียงประจำสัญลักษณ์ลงในแอนิเมชันการ parse ก็อาจ “ฟัง” การรันโปรแกรมได้เหมือนเพลง
    • ผลลัพธ์จะใกล้กับเสียงเกมคอมพิวเตอร์ประหลาด ๆ ยุค 8 บิตมากกว่า
    • ดูได้ใน เดโมออนไลน์ ที่ Menu > Program > Animated Run

ข้อจำกัดที่ยังเหลือและขั้นถัดไป

  • เดิมที λ-2D เริ่มจากการเป็นส่วนหนึ่งของงานวิจัยที่ใหญ่กว่า ซึ่งมุ่งให้ผู้ใช้วาดโปรแกรมด้วยปากกาและกระดาษ แล้วรับฟีดแบ็กเชิงโต้ตอบผ่าน augmented reality
  • เมื่อโครงการค่อย ๆ น่าสนใจขึ้น มันจึงกลายมาเป็นโปรเจกต์เดี่ยว
  • เป้าหมายตั้งต้นยังไม่บรรลุครบทั้งหมด
    • โปรแกรมยังมีแนวโน้มดูคล้ายแผนผังวงจรมากกว่าจะเป็นภาพวาด
    • ยังยากจะมั่นใจว่าคนทั่วไปจะเรียนรู้ได้ง่ายหรือไม่
    • ระบบคอมพิวเตอร์วิทัศน์อาจยังสแกนได้ยากโดยไม่มีข้อผิดพลาด
  • หลังจากขัดเกลา λ-2D ให้ดีขึ้นแล้ว ก็มีแผนจะออกแบบภาษาโปรแกรมอื่น ๆ ที่สามารถรวมเข้ากับระบบซึ่งจัดการภาพวาดในฐานะการคำนวณได้
  • λ-2D เวอร์ชันเบตาสามารถลองใช้ได้ ออนไลน์ และซอร์สโค้ดของ parser กับ editor จะเปิดเผยบน GitHub เร็ว ๆ นี้

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2024-11-10
ความคิดเห็นใน Hacker News

  • ถ้าชอบอะไรแบบนี้ งาน วิศวกรโปรเจกต์ระบบอัตโนมัติ ก็น่าจะสนุก หรืออย่างน้อยก็คุ้นเคยได้
    Function Block Diagram (FBD) ค่อนข้างคล้ายกัน คือมีฟังก์ชันบล็อกเชื่อมต่อกันด้วยเส้น และลำดับการทำงานถูกกำหนดตามลำดับของบล็อก ตัวบล็อกเองอาจเป็นเหมือนฟังก์ชัน built-in ของเอนจิน หรือเป็นบล็อกประกอบก็ได้ ไดอะแกรมจะถูกรันหนึ่งครั้งต่อรอบการควบคุม และโดยปกติถ้าไม่มี jump block แต่ละบล็อกจะถูกรันพอดีหนึ่งครั้งในทุกรอบการควบคุม ไม่ว่าอินพุตจะเปลี่ยนหรือไม่ก็ตาม
    ลอจิกควบคุมตั้งแต่โรงเบียร์ไปจนถึงโรงงานปิโตรเคมีถูกทำด้วยวิธีนี้ ผมทำงานด้าน UI ของระบบควบคุมที่ใช้ FBD เลยเจอสิ่งเหล่านี้ทุกวัน

    • หมายถึงอะไรอย่าง PLC หรืออะไรทำนองนั้นหรือเปล่า?

  • คล้ายกับ BitGrid[1] แต่ไม่เหมือนกัน ลองนึกภาพ FPGA ที่ถูกทำให้ง่ายแบบสุดขั้ว โดยมีบิตเคลื่อนขบวนแบบขนานไปบนกริด
    ไอเดียนี้อาจมีประโยชน์มหาศาล หรืออาจไม่มีก็ได้—อาจเป็นเพตาฟลอปส์สำหรับมวลชน—ท้ายที่สุดขึ้นอยู่กับว่า DFF หนึ่งตัวใน ASIC ใช้พลังงานเท่าไร ตัวเลขที่ตามหามานานคือพลังงานคงที่และพลังงานในการโหลดหนึ่งบิต
    โมเดลการเขียนโปรแกรมก็เป็นปัญหา ไม่มีใครอยากวางลอจิกลงบนกริดโดยตรง ทุกคนพยายามจะสร้าง abstraction ให้เร็วที่สุด ผมไม่มีสมาธิพอจะทำส่วนนั้นให้สำเร็จ
    ระหว่างสำรวจเรื่องนี้ ผมไปเจอ Von Neumann cellular automaton[2] และ Nobili cellular automata[3] ซึ่งแม้จะสนใจไอเดียคล้าย ๆ กันมาหลายสิบปี แต่นี่เป็นครั้งแรกที่เห็น พื้นที่นี้ของวิทยาการคอมพิวเตอร์ค้นพบได้ยากจนน่าหงุดหงิด
    ทั้งสองอย่างมีรากฐานไร้สาระเหมือนกัน คือชุดของ FSA กำหนดพื้นที่เซลล์ขนาดอนันต์ และ FSA ทุกตัวมีฟังก์ชันเปลี่ยนสถานะหรือชุดกฎเหมือนกันหมด แค่ “การทำให้ง่าย” แบบนั้นอย่างเดียวก็ทำให้รู้สึกว่ามันถูกผลักไปอยู่ในโลกของ code golf แล้ว
    [1] https://github.com/mikewarot/Bitgrid
    [2] https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton
    [3] https://en.wikipedia.org/wiki/Nobili_cellular_automata
    ถ้ามีใครอยากสานต่อไอเดีย BitGrid ก็จะขอบคุณมาก

  • ตรงที่บอกว่า “ในเชิงเทคนิค ณ จุดนี้ภาษานี้เป็น Turing-complete แล้ว แต่ใช้งานเจ็บปวดสุด ๆ จนละเมิดกฎการออกแบบข้อที่ 2 ของผม” นั้น Lambda Diagrams[1] ของผมหยุดอยู่ที่ขั้นที่ 1
    ด้านล่างของหน้านั้นมีลิงก์ไปยังสัญกรณ์ lambda calculus แบบกราฟิกอื่น ๆ ทั้งหมดที่ผมรู้จัก และเพิ่งเพิ่มอันนี้เข้าไปด้วย
    [1] https://tromp.github.io/cl/diagrams.html

    • สิ่งที่น่าสนใจบนไซต์นี้คือ Y combinator ที่วาดเป็น Lambda Diagram: https://tromp.github.io/img/cl/Y.logo.gif
    • แต่ฟีเจอร์แปลภาษาในตัวของ Firefox ถามว่าจะให้แปลหน้านั้นจาก ภาษากรีก ไหม
      ตอนนี้อ้างได้แล้วว่าเป็นภาษาที่ทำให้เบราว์เซอร์พูดว่า “สำหรับฉันมันเป็นภาษากรีกไปหมด!” ถือเป็นความสำเร็จที่เจ๋งทีเดียว
    • อ่านก็ยากสุด ๆ ด้วย ฟอนต์พิกเซลกับลายเส้นให้กลิ่นอายย้อนยุคก็จริง แต่ถ้าต้องหรี่ตาเพื่ออ่านตัวอักษรหรือแยกรูปร่างของเส้น มันก็ไม่ถูกหลักสรีรศาสตร์
      พวกของแบบนั้นเราทิ้งไว้ข้างหลังตั้งแต่ยุค 90 ที่จอความละเอียดสูงเริ่มมาแล้ว
    • ในสายตาผมมันดูเหมือน อักษรลิ่มสุเมเรียน เลย เท่มาก
    • ดูเหมือนจะตกหล่น Alligator Eggs ไป
      https://worrydream.com/AlligatorEggs/

  • ของพวกนี้เคยทำกันใน LabVIEW ด้วย และเห็นได้ว่ามันไปต่อได้ยากแค่ไหน โปรแกรมสร้างเสียง/ดนตรีก็ทำกันมาแล้ว และ Max [max] น่าจะเป็นต้นตำรับ
    มันสร้างอะไรบางอย่างได้ แต่ไม่นานก็รก ถ้าถามว่าดูดีไหม ผมว่าไม่
    [max] https://en.wikipedia.org/wiki/Max_(software)

    • ผมมองว่า พาราไดม์เส้น/โหนดแบบภาพ ของ Max/MSP และ Pure Data ค่อนข้างสมเหตุสมผล เพราะมันต่อยอดจากอินเทอร์เฟซแบบ “เสียบกล่องหนึ่งเข้ากับอีกกล่อง” ของฮาร์ดแวร์ดนตรีอิเล็กทรอนิกส์ และยังสามารถสะท้อนการจัดวางวงจรอิเล็กทรอนิกส์ได้ด้วย
      การไหลของสัญญาณที่ซับซ้อนติดตามได้ง่ายกว่ามากเมื่อเป็นการจัดวางแบบภาพ โดยเฉพาะไดอะแกรมที่แสดงค่าตัวเลขแบบเรียลไทม์เป็นแอนิเมชัน แทนที่จะเป็นบล็อกข้อความนิ่ง ๆ
      Max/MSP รุ่นหลัง ๆ ยังมี mc ที่ให้การเชื่อมต่อหลายแชนเนล จึงไม่ต้องสร้างเส้น/โหนดแยกสำหรับสัญญาณที่เหมือนกันหลายชุด และ ~gen กับ JavaScript ก็ทำให้มีโหนดโปรแกรมมิงแบบข้อความได้ด้วย
    • Simulink ก็ควรอยู่ในรายการนี้ด้วยไม่ใช่หรือ?
      “ภาษาโปรแกรมมิงแบบบล็อก” แบบนี้ดูมีศักยภาพ เพราะทำ abstraction ด้วยการทำให้เป็น black box แล้วสร้างกล่องซ้อนในกล่องอีกที เลยสงสัยว่าเป็นเพราะ implementation แย่ ใช้งานไม่เป็น หรือพาราไดม์นี้เองที่ไปไม่รอดกันแน่
      สิ่งที่ต้องคำนึงคือของพวกนี้มักถูกใช้โดยคนที่ไม่รู้เรื่องการเขียนโปรแกรมและ abstraction ถ้าเป็นคนที่เขียนโปรแกรมเก่ง อาจทำให้ไม่รกได้ แต่ถ้าอย่างนั้นก็เขียนโค้ดไปเลยก็ได้ เลยก้ำกึ่ง
      เห็นด้วยว่า LabVIEW แย่มาก ไม่ใช่แค่ปัญหานี้เท่านั้น อัปเดตก็ทำทุกอย่างพัง ไลเซนส์ก็อีก เป็นตัวปัญหาล้วน ๆ
    • มันแค่เป็นวิธีคิดที่ต่างออกไป แต่ก็สามารถเขียน โค้ด LabVIEW ที่สะอาดและอ่านง่ายได้
      เคยมีชุมชนเล็ก ๆ ของนักพัฒนา LabVIEW มืออาชีพ และโดยรวมพวกเขาเขียนโค้ดที่อ่านง่ายและดีมาก แม้จะแตกต่างจากวิธีที่คนส่วนใหญ่คุ้นเคย แต่ก็ดี
      เพียงแต่ผมออกจากโลกนั้นมาเมื่อไม่กี่ปีก่อน เพราะมีสัญญาณชัดเจนว่าไม่ว่าจะทำอะไรได้ LabVIEW ก็จะตายในที่สุด

  • หลังจากได้ยินเรื่อง Petri net ครั้งแรกเมื่อประมาณ 10 ปีก่อน ผมก็สนใจข้อกำหนดเชิงรูปแบบแบบกราฟิกมาโดยตลอด
    ผมรู้สึกเสมอว่าถ้ามีการนำเสนอแบบกราฟิกแทนสัญกรณ์และภาษาคณิตศาสตร์ที่น่ากลัว วิศวกรน่าจะใช้ประโยชน์จากเทคนิคเชิงรูปแบบได้ดีขึ้น แต่น่าเสียดายที่ทุกครั้งที่ผมเอา Petri net ไปให้วิศวกรคนอื่นดู พวกเขาก็แทบจะหมดความสนใจทันที
    ก่อนจะเลิกเรียนปริญญาเอกที่ University of York ผมเคยทำงานกับสิ่งที่เรียกว่า RoboChart และ RoboSim[1] ซึ่งผมคิดว่าในทางปฏิบัติอาจเข้าถึงง่ายกว่าด้วยซ้ำ เพียงแต่มันผูกติดกับ semantics ด้านหุ่นยนต์ค่อนข้างมาก ในโปรเจกต์ส่วนตัว ผมพยายามปรับและขยาย RoboSim ให้เหมาะและมีประโยชน์กับโลกของเครือข่ายและเซิร์ฟเวอร์มากขึ้น
    [1] https://robostar.cs.york.ac.uk/robotool/

  • ชอบอันนี้มาก โดยเฉพาะที่มันเขียนด้วย JavaScript
    พวกสายบริสุทธิ์นิยมคงพลิกตัวบนเตียงหรือในหลุมศพกันเป็นแถว แต่อย่างน้อยขั้นต่อไปด้าน visualization และ audio ก็น่าจะง่ายขึ้นอย่างชัดเจน ภาพสวยสุด ๆ และขั้นถัดไปก็ดูเหมือนจะเป็นการแปลงโครงสร้างระดับบนของโปรแกรมเดิม ๆ ให้อยู่ในรูปแบบนี้ให้ได้ น่าจะมีพวกเนิร์ดไม่น้อยที่ยอมจ่ายเงินเพื่อเอาอัลกอริทึม Dijkstra หรืออัลกอริทึม backpropagation ของโครงข่ายประสาทเทียมไปแขวนผนัง
    ส่วนที่น่าสนุกคือมีการบอกว่าภาษานี้เป็น pure functional มาก และไม่มี state เลย จึง implement คำสั่ง print ไม่ได้ เพราะ output คือการเปลี่ยน state และการคาดหวังให้ output ออกมาตามลำดับใดลำดับหนึ่งก็เท่ากับสมมติว่า expression ต่าง ๆ ถูก evaluate ตามลำดับบางอย่าง
    นี่ก็แค่หมายความว่า “ไม่ใช่ imperative” ไม่ใช่เหรอ? แต่ก็ยังสงสัยว่าจะ encode state กันอย่างไร อาจแนะนำตัวแปร เช่น ไอคอน+สี แล้วจัดแนวประโยคแต่ละอันตามแกนเดียวหรือทั้งสองแกนก็ได้

  • “ขอบเขตของ ภาษาโปรแกรมมิงแบบไม่ใช้ภาษา ไม่ใช่สิ่งที่ไม่เคยถูกสำรวจ”
    แค่ประโยคที่สองก็เริ่มด้วยการปฏิเสธสามชั้นแบบดุดันแล้ว

    • แล้ว Scratch ก็มีอยู่ไม่ใช่เหรอ?

  • นึกถึง Wireworld จากปี 1987 แน่นอนว่ามีบทความ Wikipedia ด้วย [1]
    เคยเห็นตัวนับ 8 บิตที่ implement ด้วย Wireworld ซึ่งค่อนข้างสุดยอด แต่ของนี้ดูจะกระชับกว่าหน่อย
    [1]: https://en.wikipedia.org/wiki/Wireworld

    • ผมชอบวิธีที่ Zachtronics ทำใน KOHCTPYKTOP มากกว่าอย่างบอกไม่ถูก
      แต่ตอนนี้เล่นยากแล้ว เพราะหน้าเว็บ[1] กับเวอร์ชัน Steam พึ่งพา Flash และต้องไปยุ่งกับ Flash reimplementation ของ third-party
      ถึงอย่างนั้น ผมก็คิดว่าการ implement การทำงานของ semiconductor ทำได้ดีกว่า Wireworld มาก
      [1] https://www.zachtronics.com/kohctpyktop-engineer-of-the-peop...

  • ลิงก์ตรงไปยังเดโมออนไลน์: https://l-2d.glitch.me/

    • เอาสาระสำคัญไปฝังไว้ลึกเกินไปแล้ว

  • นี่คือสภาพแวดล้อม/ภาษาโปรแกรมมิงที่เป็นภาพมาก ๆ แบบอื่น ๆ ที่ผมเจอ ซึ่งต่างจาก visual programming แบบอื่นที่เชื่อมโหนดด้วยเส้น
    อาจจัดหมวดหมู่ได้อีกแบบ แต่ผมไม่รู้ว่าจะเรียกว่าอะไร
    Piet https://www.dangermouse.net/esoteric/piet.html
    Turnstyle https://jaspervdj.be/turnstyle/ https://github.com/jaspervdj/turnstyle
    Markovjunior https://github.com/mxgmn/MarkovJunior
    Cellpond https://cellpond.cool/ https://github.com/TodePond/CellPond https://www.youtube.com/watch?v=xvlsJ3FqNYU
    Imagegram https://zaratustra.itch.io/imagegram
    Color Code http://colorcode.bananabanana.me/ https://www.youtube.com/watch?v=5M5hy9xsqKc Color Code 2 http://colorcode2.bananabanana.me/ https://www.youtube.com/watch?v=tTvvX4sjZWw Splaty Code http://splatycode.bananabanana.me/ https://www.youtube.com/watch?v=gd_e85lAKOs (สร้างโดย Muril Polese https://github.com/murilopolese/ http://gallery.bananabanana.me/)
    Alchemy Online https://maxbittker.github.io/alchemy-online/ https://github.com/MaxBittker/alchemy-online