Golden Board:用 512 KiB 二进制消息在无共同语言下教授国际象棋
A 512 KiB binary message teaching chess without a shared language
Artem Legotin 发布 Golden Board 项目,用 4,194,304 位(512 KiB)的二进制消息向无共同语言、文化或棋类知识的未知接收者教授国际象棋。消息前 64 行含 32 幅 64×64 图形构成与棋类无关的引导层,用于教会读取后续内容,下方载荷包含可视化课程、带反馈练习和完整对局。作者用 LLM 模拟未知接收者测试解码与理解,代码和文档已在 GitHub 开源。
译文尚不完整,完整内容请切换到原文。
或者说,为什么要以及如何教外星人下国际象棋。
引言
Golden Board 是一条二进制信息,旨在向一个没有共同语言、文化或国际象棋先验知识的未知接收者教授国际象棋。它首先教授读取其自身内容所需的格式。
完整项目代码和文档可在 GitHub 上获取。
本指南遵循这一过程:从比特中恢复数字,用它们重建图片和交互,然后了解这些图片如何描述国际象棋。一局完整的对局连接了各个层次,从其物理比特到最终显示的局面。
欢迎随时反馈。
在我们深入之前,我想先说明关于这个项目的几点。
它看起来是什么样的?
简而言之,Golden Board 是一个由 4,194,304 个比特组成的序列,即 512 KiB 个一和零。
这个数字暗示将它们排列成一个 2,048 × 2,048 的正方形。
里面有什么?
前 64 行包含 32 幅图,每幅图有 64 × 64 个单元格。
它们共同构成引导部分:它教授如何读取信息的其余部分。它与国际象棋无关,可用于解码其他结构化信息。
下方的有效载荷包含可视化国际象棋课程、带反馈的练习、完整对局,以及查找、检查和显示它们所需的信息。
这个想法从何而来?
我从面向未知智能的信息中汲取了灵感,例如 旅行者金唱片、 Lincos 等。
但 Golden Board 不是分享科学知识或艺术作品,而是教授国际象棋。
为什么是国际象棋?
有两个原因。
首先,一小套规则开启了一个充满可能性、思想和美的巨大世界。
其次,一局游戏可以分享的不仅仅是知识:它提供了对人类心智的一瞥。
我是如何测试它的?
我使用 LLM 作为未知接收者的替代品进行了试验,用原始比特、解码后的内容以及不同程度的辅助来测试解码和理解。
正确恢复字节和理解课程是两项独立的测试。这些模型已经会下国际象棋,因此仅凭正确的国际象棋答案无法证明是这条信息教会了它们。这些试验帮助识别了歧义并改进了设计;它们并不能证明未知智能会理解它。阅读试验记录。
我是如何选择对局的?
没有任何一套 64 局对局是完整的。
我根据其国际象棋内容来选择对局:精彩的进攻、出人意料的弃子、巧妙的防守、安静的战略和优美的残局。PGN 选集包含 64 局对局,而二进制信息省略了姓名、日期和赛事。
这一切是为了什么?
分享你所热爱的事物有一种特别的快乐。
我们能和一个对我们一无所知的文明分享什么?他们可能已经了解我们的科学,或者缺乏理解我们艺术的背景,但国际象棋可以从零开始教授,展现几个世纪以来人类的想象力、错误和才华。
最有可能的是,永远不会有人收到这条信息。但即使只有很小的可能性,有人可能会发现一个带有像
Bf5 这样走法的局面,这也让整件事值得一试。
你能在此基础上继续构建吗?
可以。与象棋无关的引导程序、二进制格式和 Python 工具提供了一个起点, 可用于在没有共同语言或文化的情况下教授其他科目。开发者可以改编该系统; 研究者可以利用这些试验来探究哪些方法有效、哪些失败以及原因。源代码和文档。
如何阅读本指南
在源图中,每个单元格表示一个位:黑色代表 1,白色
代表 0。解码后的图片是根据存储的数据重建的,
而不是从源方块中裁剪出来的。
此处添加了颜色、细灰色参考线和标签,以便更轻松地阅读图片。 它们不属于原始信息。
预期接收者无需视觉辅助,即可利用边界框、固定序列长度和其他先前学到的模式推断出这些排列。
下方的框架提供了一个示例;其内容将在后面解释。 蓝色区域覆盖一行数据及其下方的小标记。 橙色区域标出其左侧的小数字。 绿色区域覆盖一个完整的带框列表。灰色参考线使各个位的位置更易于计数。
将鼠标悬停在彩色短语上,可仅保留与其匹配的高亮。将鼠标悬停在图片上,可隐藏所有视觉辅助。
阅读数字和图片
接收者从一段干净的位序列或一个采样方块开始,并假定其能够计数、识别模式并编写简单程序。 从信号或物理对象中获取这些单元格是另一个独立的问题。
第一项任务是从这些位中恢复图片和交互。接收者随后可以利用这些显示内容来学习象棋。 引导程序通过示例确立阅读规则;接收者提供一个遵循这些规则的程序。信息中携带的是供该程序解释的数据, 而不是可执行代码。
引导程序是下方视图顶部的窄条。 其下方的有效载荷区域包括末尾的未使用空间。
标题显示顺序和相关分组
在查看每幅图的内部之前,先利用其标题在条带中定位它。每个框架都重复
相同的角标。其顶行将填充单元格的计数与一个二进制数字配对,以给出其全局编号,
1–32。下方两行的第二对计数则统计相关组内的步骤。
该局部计数对每个组重新开始;独立框架则将该行留空。
比较这四个标题。框架 6 总体排第六,在其相关组中排第二。框架 3 独立存在:
下方的角部裁剪图 展示了同一接收模式在四个旋转方向下的样子:
如图所示
四分之一转
半转
四分之三转
重复出现的角点提示了一个可以尝试的方向。递增的计数、尺寸和校验和检验它是否保持一致。仅凭角点并不能证明方向,也不能证明哪个接收状态应代表 1。
第 1 帧,共 32 帧:通过计数读取数字
二进制数将位模式与数量联系起来。第一帧通过将数字与可计数的单元格配对来建立这种联系。
左侧条纹包含 0、1、2、3、4、7、8 和 15 个填充单元格。与每条条纹相对,上方四位数字给出相同的数量:空条纹对应 0000,两个填充单元格对应 0010。下方八位数字用前导零重复这些数量。
第 2 帧,共 32 帧:识别每个位的位置
填充的位根据其位置贡献不同的量。将其向左移动一位会使该贡献翻倍。这一帧将每个单一位模式与其位置编号配对。
左列从 00000001 开始,并在每一行将其单个填充位置向左移动一位,最后以 10000000 结束。右列从最右边的位开始,将这些位置从 1 计数到 8。每个水平配对属于一起。
每个字段都有一个黑色边框,其数据行周围有白色内嵌。即使大多数位置为空,边框也固定了完整宽度。因此,八位模式保持在一列中,而它们的四位位置编号保持在另一列中。
第 3 帧,共 32 帧:读取图片的尺寸和补集
图片既包括其填充位置,也包括其空位置。当位被反转时,其尺寸保持矩形不变。
左侧图片有三行五列。在其第一行中,第一个位置为空,第二个位置为填充。
右侧图片保留同样的十五个位置,但交换了填充和空。左侧图片下方的两个数字是 3 和 5:先是行数,然后是列数。两个数字都终止于图片的右边缘。它们计数的是图片位置,而不是用于绘制块的源单元格。
第 4 帧,共 32 帧:建立行顺序
如果没有共享的读取顺序,相同的值序列可能产生不同的图片。编号排列使顺序明确。
上方排列的第一行是 1, 2, 3,第二行是 4, 5, 6。下方序列重复 1 到 6。在继续下一行之前,从左到右完成每一行:这就是行主序。
第 5 帧,共 32 帧:将八位分组为一个字节
一个字节是按固定顺序排列的八个比特组成的一组。这个画面把一个紧凑的组与它的八个单独比特位置连接起来,从而确立了后续长度和校验所使用的单位。
上方的紧凑图案是
00110101。它下方的箭头
指向八个独立的方框,
其中包含相同顺序的相同比特。读取每个方框中的单个中心
单元格:第一个是空的,
而第三个是填充的。
该行下方的两个数字
是 00000001 和 00001000:一行,八个比特位置。上方的紧凑
组是一个字节;展开的行显示它的八个比特。它们共同确立了
一个字节 = 八个比特。下半部分对
00001011 重复了这一对应关系。
第 6 帧,共 32 帧:组合高字节和低字节
一个跨越多个字节的数字需要字节顺序。交换其高字节和低字节 可能会改变其值,即使每个字节仍然包含相同的比特。
每一行都在左侧重复一个
十六位数字,作为其
中间的八个比特和
右侧的最后八个比特。每个都有自己的
边界,因此完全为零的高字节或低字节仍然作为一个字段可见。在第五行,
0001001000110100 拆分为 00010010 和 00110100:十进制
18 和 52。
第一个字节计数 256 的组;第二个字节计数剩余的单位。该行表示 18×256 + 52 = 4,660。
下一行反转字节并表示 52×256 + 18 = 13,330。这
是高字节在前的顺序。记号 u16 表示一个两字节非负整数;
u32 表示一个四字节的。
第 7 帧,共 32 帧:读取尺寸和已用有效载荷长度
接收方需要定位有效载荷,并知道要读取剩余方阵的多少。 这四个测量值将引导部分、已用数据和未用保留区分开。
从上到下,这些字段给出
方阵边长,2,048;
第一个有效载荷行,64,
从 0 开始计数;
字节宽度,8 比特;以及
已用有效载荷长度,506,509 字节。
前三个字段各有十六个比特;最后一个有三十二个。它们的右边缘对齐,
因此更宽的最后一个字段向左延伸得更远。
从第 64 行开始,从左到右读取每一行,然后继续下一行。
每八个单元格组成一个字节,其最高值比特在前。准确恢复
所声明的字节数。
第 32 帧 显示了已用长度与剩余容量之间的关系。
检查恢复的字节
接收方在信任恢复出的课程和游戏之前,需要的不只是看似合理的数字。错误的方向、位解释或字节分组仍然可能产生数值。Golden Board 包含校验,让接收方在使用其内容之前能够拒绝不一致的读取结果。
内容被组织为文档:图片定义、数值数据以及显示或交互指令的集合。每个文档的字节位于一个带校验的块中,称为节。其头部标识该文档并给出其字节长度。该长度既定位末尾的校验值,也定位下一节的开头。
一节还存储一个校验和,即根据其标识字段和内容计算出的值。创建消息的程序根据原始字节计算该值。接收方对恢复出的字节重复该计算,并将结果与存储的校验值进行比较。不匹配则拒绝该读取结果。匹配支持这些字节的一致性;它并不能修复它们,也不能证明其含义已被理解。
从实际载荷中取出第 2 节。其前六个字节构成一个头部:
文档的编号,称为其 ID,以及
文档的字节长度。
随后是文档本身,
然后是存储的校验和。
计算覆盖头部和每一个文档字节,并在存储的校验值之前停止。
第 2 节 · 93,027 字节
头部 · 6 字节
ID:0 2 → 2
长度:0 1 107 89 → 93,017
文档 2
前八个字节:214 57 0 64 0 151 1 68
……然后是另外 93,009 个字节
计算输入:头部 + 完整文档 = 93,023 字节
存储的校验和 · 4 字节
182 147 233 40
不在计算的输入范围内
根据全部 93,023 个输入字节计算得出:182 147 233 40。
存储的四个字节与之匹配。
Golden Board 使用 CRC-32C 进行此计算。接下来的图示先用一个输入字节讲解它,然后将同样的方法应用于完整的一节。直接目标是从相同的位复现发送方的校验值。
第 8 帧,共 32 帧:定义 XOR 与相等
校验和需要一种组合位的方法和一种检验一致性的方法。本帧使用所有可能的输入对来定义这两种运算。
左侧输入列列出
00、01、10 和 11。它们的
结果为 0、
1、1、0:当输入不同时,XOR 产生 1。
右侧输入列重复这些
输入对;它们的结果为
1、0、0、1:当它们一致时,相等运算产生 1。
第 9 帧,共 32 帧:右移并保留移出的位
右移将每一位向右移动一个位置。此图将移位后的行与从右边缘移出的位分开显示;校验和计算会同时使用这两个结果。
在上方示例中,输入字段以 00110101 结尾。其下方的移位字段以 00011010 结尾。最左侧移入一个零,而单独的输出位框中包含从输入右边缘移出的 1。
其他示例以不同的输入模式重复此布局。在最下方的示例中,输入以 0 结尾,且输出位框的中心为空。即使结果为 0,其边框仍保留结果的位置。
第 10 帧,共 32 帧:确定校验和的固定模式
发送方和接收方需要相同的常量才能得到相同的校验和。以下计算使用此处展示的模式。
顶部字段包含三十二个 1。中间字段包含另一个三十二位模式。底部字段重复整个中间模式,并在前面添加一个 1。各字段右对齐,使添加的位在左侧可见。
下方字段是 CRC-32C 多项式的两种形式,即标识此 CRC 的固定模式。底部形式包含其前导位。保留中间模式,以便与 第 12 帧中各状态之间的变化进行比较。
| 含义 | 位 |
|---|---|
| 三十二个 1 |
11111111 11111111 11111111 11111111
|
| 正向多项式 |
00011110 11011100 01101111 01000001
|
| 带前导项的多项式 |
1 00011110 11011100 01101111 01000001
|
第 11 帧,共 32 帧:启动校验和并对一个字节进行 XOR
校验和保持一个不断变化的 32 位工作模式,称为其状态。将输入字节与该模式组合,可使该字节影响最终的校验值。此帧展示起始状态、第一个字节以及组合它们的结果。
一个共享外框将两个输入分组:上方的全 1 状态和下方的输入字节。该状态有四个八位带。输入为 00110101,即在 第 5 帧中展开的模式,对齐在最右侧带的下方。
对那八个对齐位置应用 第 8 帧的 XOR 规则,得到 11001010。其他三个状态带没有输入位需要改变,保持全 1。向下箭头从分组的输入指向此四带结果。该结果启动接下来展示的八个位轮次。
第 12 帧,共 32 帧:跟随全部八个位轮次
接收方必须能够从当前状态计算出下一个校验和状态。此帧提供完整的演算序列,以便对照每一次转换检查该规则。
右侧的数字标注了工作模式,从状态 0 到状态 9。第一行是起始模式;第二行是来自帧 11 的字节异或结果。其最后一位是 0。将该行右移,恰好得到状态 2。
状态 2 的最右位是 1。将整个模式右移。下方对比中的顶部青色行就是计算出的移位结果。引导程序还提供了下一个结果,即状态 3,显示在中间的玫瑰色行中。对比二者可揭示本轮所做的额外变化。
对齐这两行中对应的位置。在青色列中,位不同:必须翻转移位结果才能得到所提供的结 果。在每个不同的位置放 1,在每个相同的位置放 0。这就是在帧 8 中学到的异或比较。其底行是固定的反馈模式:一张标明哪些位置需要翻转的映射图。
我们利用帧所提供的结 果来识别该模式。要正向计算本轮,先移位状态 2,然后将移位结果与反馈模式进行异或。这些翻转产生状态 3。输出的 1 选择此反馈步骤,因此该位在离开右边缘后仍继续影响校验和。
剩余六轮使用相同规则。移位前检查最右位:输出的 0 只需移位;输出的 1 还需要固定的异或模式。字节异或步骤之后有八轮,结束于状态 9。表格转录了每个所提供的状态,并命名了产生该状态的操作。
| 模式 | 位 |
|---|---|
状态 2 的计算移位 | 00111111 11111111 11111111 11110010 |
状态 3,由帧提供 | 10111101 00001001 11000100 10001010 |
| 反馈模式:不同的位置 | 10000010 11110110 00111011 01111000 |
| 含义 | 位 | 产生此行的操作 |
|---|---|---|
状态 0:起始模式 |
11111111 11111111 11111111 11111111
|
全 1 起始状态 |
状态 1:字节异或后 |
11111111 11111111 11111111 11001010
|
对输入字节进行异或 |
状态 2:第 1 轮后 |
01111111 11111111 11111111 11100101
|
右移 |
状态 3:第 2 轮后 |
10111101 00001001 11000100 10001010
|
右移,然后异或固定模式 |
状态 4:第 3 轮后 |
01011110 10000100 11100010 01000101
|
右移 |
状态 5:第 4 轮后 |
10101101 10110100 01001010 01011010
|
右移,然后异或固定模式 |
状态 6:第 5 轮后 |
01010110 11011010 00100101 00101101
|
右移 |
状态 7:第 6 轮后 |
10101001 10011011 00101001 11101110
|
右移,然后异或固定模式 |
状态 8:第 7 轮后 |
01010100 11001101 10010100 11110111
|
右移 |
状态 9:第 8 轮后 |
10101000 10010000 11110001 00000011
|
右移,然后异或固定模式 |
由帧 12 的转换所揭示的固定异或模式,是帧 10 的中间模式按位逆序读取的结果。这将右移计算与那里所示的多项式联系起来。它改变了对该常量的解释;字节本身保持由帧 6 确立的高字节优先顺序。
第 13 帧,共 32 帧:完成并存储校验和
最后一个运行状态通过一次最终的 XOR 变成存储的校验和。接收方必须将 该最终值与计算过程中使用的中间状态区分开来。
这重复了 Frame 11 的分组输入布局。将
八轮之后的状态 与
其上方的全一状态 进行 XOR。箭头指向
结果,其四个条带读作
87 | 111 | 14 | 252。
第二个箭头指向
四个分别限界的字节。每个字节都
直接位于结果对应条带的下方,具有相同的八个位。从左到右读取
保持高字节在前的顺序。这是对单个输入字节 00110101 的校验;
下一帧将比较计算出的校验与存储的校验。
第 14 帧,共 32 帧:比较计算出的校验与存储的校验
通过将计算出的值与存储的值进行比较,校验和成为完整性检查。这三个 案例展示了同一个相等性测试先成功、再失败、然后再次成功。
在顶部案例中,输入字段 包含
00110101,读作 53。
上一行的计算校验 与
其下方的存储校验 一致。
右侧的单比特相等字段
因此包含 1,使用与 Frame 8 相同的方框比特约定。
中间案例将输入改为 00110100,但保留了针对先前
模式的校验。校验不同,因此相等字段包含 0。底部案例使用
00001011 及其自身的校验,并返回 1。这些是对字节模式的校验,
而不是对用于打印其十进制读数的字符的校验。
查找节和文档
接收方现在可以读取数字并重现校验和。下一个任务是找到每个 节的边界并恢复其中的文档。节是带校验的存储包装; 文档是要显示和使用的对象的集合。
这些对象存储为 记录。每条记录都有一个种类、一个称为 ID 的数字名称,以及其自身的内容。例如,一条记录可以定义一个小图片,另一条 可以通过 ID 引用该图片。将定义保存在一处可以让许多显示复用 它。ID 在消息创建期间分配并存储在数据中;接收方读取它们, 而不是从形状推断它们。它们的范围是一个文档。
清单 列出了必须恢复的文档以及每个文档可以在哪些记录中 打开。这些起始记录就是它的 条目。它们指向一个图片序列或一个 交互。条目是记录的 ID,而不是其字节地址。
为了教授这些关系,引导程序包含一个完整的、大小为
326 字节的小型示例文档。它的简单图片和响应在国际象棋出现之前就演练了该格式。
接下来的图示描述了这个示例,它被携带在条带内部。条带下方的完整五文档
载荷使用相同的规则。
第 15 帧(共 32 帧):划分一个完整的分区
这一帧将一个分区划分为字节范围。它的头部声明后面跟随多少正文数据,因此 接收方可以找到校验和下一个分区。
每一行有三列:起始地址、字节长度,以及该范围之后的第一个地址。
ID 行读作 0, 2, 2;
正文长度字段行读作
2, 4, 6。这两个字段构成六字节头部。
正文行读作 6、326、332,随后是
校验行:332, 4, 336。
因此该分区为 336 字节:六个头部字节、326 个正文字节和四个校验字节。这些三元组
描述的是布局;它们不是存储在头部中的额外字段。正文长度值只计算
正文。ID 为分区命名;其含义由下面的清单示例确立。
| 含义 | 位 | 十进制 |
|---|---|---|
| ID 范围 |
00000000 00000000 | 00000000 00000010 | 00000000 00000010
|
0 | 2 | 2 |
| 正文长度字段范围 |
00000000 00000010 | 00000000 00000100 | 00000000 00000110
|
2 | 4 | 6 |
| 正文范围 |
00000000 00000110 | 00000001 01000110 | 00000001 01001100
|
6 | 326 | 332 |
| 存储校验范围 |
00000001 01001100 | 00000000 00000100 | 00000001 01010000
|
332 | 4 | 336 |
第 16 帧(共 32 帧):将载荷地址映射到方格单元
字节地址必须能回溯到方格中的位置。这一帧将每个地址连接到物理 行和列。
每个框的顶行给出
距载荷起始处的字节偏移和
该字节内的位索引。正下方
是方格行和
方格列。这些是用于读取存储位的地址,因此它们从零开始;
位 0 是一个字节的第一个、最左边的位。第 2 帧中的标签
则从右往左计数二进制位,从一开始。
每个物理行容纳 2,048 ÷ 8 = 256 个字节。因此第一组 256 个字节填满
行 64:字节 0 从列 0 开始,字节 1 从列
8 开始,字节 255 结束于列 2,047。字节
256 从列 0 开始下一行 65。这些边界情况出现在
第三、第四和第五个框中。
要定位另一个字节,数出完整的 256 组,以确定从行 64 向下移动多少行。
在剩余的组内,每字节移动八列,然后加上其位索引。这就是为什么
分区边界不必与物理行边界重合。
第 17 帧(共 32 帧):保留矩形和空行
尺寸保留图片的完整矩形,包括白色位置和完全空白的行。
对于左上角矩阵,其上方的第一个数字是
00000010:两行的高度。下一个数字是 00001000:
八列的宽度。其他方框使用相同的顺序,得到三行五列、一行
七列,以及两行八列。
右下角矩阵的第二行完全为空。它的八个位置仍然属于 这幅图。无论是空行还是空白列,都不能通过裁剪到可见的黑色形状来移除。
第 18 帧,共 32 帧:为对象命名并统计其引用
可以给一个对象赋予数字名称,然后通过重复该名称来引用它。这一帧将 名称、引用计数和引用列表分开,每个目标都在使用之前引入。
每一行有三部分:左侧是八位名称,中间是八位引用计数,右侧是 一个带框的列表。名称并不指定对象的大小或其物理地址。
顶行以 00000110 开头,
读作 6。该模式命名第一个对象。其计数为 00000000,因此
引用列表为空。第二行给出另一个名称,
00000111 或 7,同样没有引用。
第三行以 00001000 开头,
读作 8。其计数 00000001 表示后面有一个引用:
00000110,重复了第一行的名称。
底行以
00001001 开头,读作 9。其计数 00000010 表示后面有两个引用:
00000111 和
00001000。这些引用到达第二个和第三个对象。再沿着第三个对象自身的引用,就到达了
第一个对象。计数和列表长度同步递增:零、零、一、二。
第 19 帧,共 32 帧:检查缩略图的实际区段
这一帧给出缩略图区段的实际字段及其校验和所覆盖的确切范围。它将 存储的校验值放在该范围之后,位于其自身计算之外。
左侧的三个四位数字
给出其旁边各带的字节数:0010、0100、0100
分别表示两字节、四字节和四字节。数据下方的小标记标识每个字节的起始位置。
这些黑色数字和标记属于原始绘图。它们描述如何读取其
各带;它们不会给区段增加字节。
前两个数据带给出
区段 ID 1 和主体长度 326。
第三个带包含四个
存储的校验和字节,255 64 93 120。
上方有界范围读作
0 | 332 | 332:从字节零开始,检查 332 个字节,在地址
332 之前停止。箭头下方的结果
重复了存储校验值的各位。下方有界范围是
332 | 4 | 336,将这四个校验字节定位在覆盖范围之后。
| 含义 | 位数 | 十进制 |
|---|---|---|
| 节 ID | 00000000 00000001 |
1 |
| 正文字节长度 |
00000000 00000000 00000001 01000110
|
326 |
| 存储的校验和字节 |
11111111 01000000 01011101 01111000
|
255 64 93 120 |
| 覆盖范围 |
00000000 00000000 | 00000001 01001100 | 00000001 01001100
|
0 | 332 | 332 |
| 存储校验范围 |
00000001 01001100 | 00000000 00000100 | 00000001 01010000
|
332 | 4 | 336 |
在一串字节上连续计算校验和
覆盖范围包含六个头部字节和 326 个正文字节。从全 1
状态开始,将第一个字节异或进其低八位,并执行八轮。将下一个字节
异或进结果状态,再执行八轮。对每个覆盖字节依次继续,
然后最后再应用一次全 1 异或。对每个节重新开始此过程。若为每个字节
分别计算一个独立的最终校验和,就会丢失连接该序列的运行状态。
帧 29 提供了这个示例节的所有字节。
第 20 帧,共 32 帧:读取完整的清单节
清单列出了完整消息所需的文档节。这里它 包含一个文档:示例微型文档。
六字节头部声明节 ID
0 和正文长度 18。
接下来的十八个字节是清单正文,
其后是它的四个校验和字节,
113 28 238 100。它们合计占用 28 个字节:三个完整的八字节行加上
第四行的一半,从局部行 31 开始。
第一行包含头部和正文的开头。换行是呈现边界,
不是节分隔符。ID 0 标识清单;正 ID 标识文档。
这个小清单只列出引导程序内的示例文档。
第 21 帧,共 32 帧:读取清单计数和条目引用
清单标识要恢复的文档以及可以开始读取它的记录。
本帧将 帧 20 中的清单正文展开为各个字段。
左侧的四位字节计数
使用 帧 19 中的约定。例如,第一条带旁的 0010 表示
其值占用两个字节。该条带中的值是 1:一个文档。
前三个数据带给出
文档计数 1、文档节 ID 1 和文档长度 326。
下一个条带包含
255 64 93 120,即该文档节的预期校验和字节。它们与
帧 19 中的校验一致。
条目计数是 2。
它给出方框列出的
条目 ID 512 和 257的长度。每个条目 ID 占用两个字节,
正如其各自的左侧计数所确认的那样。这些 ID 命名的是记录,而不是字节地址;
接下来的帧将定义这些记录。
| 含义 | 位数 | 十进制 | 字节 |
|---|---|---|---|
| 文档计数 | 00000000 00000001 |
1 |
2 |
| 文档节 ID | 00000000 00000001 |
1 |
2 |
| 文档字节长度 |
00000000 00000000 00000001 01000110
|
326 |
4 |
| 预期文档节校验和字节 |
11111111 01000000 01011101 01111000
|
255 64 93 120 |
4 |
| 条目计数 | 00000000 00000010 |
2 |
2 |
| 第一个条目 ID | 00000010 00000000 |
512 |
2 |
| 第二个条目 ID | 00000001 00000001 |
257 |
2 |
读取五种记录类型
找到文档的字节还不能告诉接收方如何绘制其中的图片或执行其中的练习。它的记录将这项工作分为五种,全部使用相同的命名记录格式。
字形存储一个小型矩形位图。显示帧将字形 ID 放入更大的网格中,因此同一位图可以在多个单元格中重复使用。帧单元格选择整个字形;它既不同于源消息单元格,也不同于字形内的单个像素。“32 的第 N 帧”仍然表示引导绘制;带编号的显示帧记录属于文档。
轨迹从帧开始,将存储的更改应用于带索引的单元格。这使得消息可以显示变化的图表或回放游戏,而无需分别存储每一张完整图片。页面将显示与选项、接受的响应、反馈目标和链接组合在一起。表格将数字与轨迹一起存储;课程会讲解这些数字的含义。
示例文档有 15 条记录:三个字形、四个显示帧、一条轨迹、一张表格和六个页面。其头部将页面 512 和轨迹 257 命名为条目。每条记录以其种类、ID 和内容长度开头;记录自身的内容也称为其载荷。该长度不包括记录七字节的头部。在解析引用之前请先读取所有记录:目标可能出现在文档的后面。
播放器是接收方用于解释这些记录并执行其显示和交互操作的程序。帧确定每个单元格中应放置哪个位图。本指南显示大小相同的图块,图块内是放大的字形;图块大小和间距是呈现方式的选择。编码的尺寸以帧单元格和字形像素计数。
第 22 帧,共 32 帧:读取文档头部和矩形字形
文档提供起始记录和可复用位图。本帧首先定义其头部,然后定义两条字形记录。
顶部五个数据带包含标记字节 214, 57、条目数 2、记录数 15,以及条目 ID 512 和 257。左侧的小标尺以字节计数。每个数据带下方的标记标识字节起始位置。两者都是描述数据带的原始黑色标记;都不向序列化文档贡献字节。表格的 Bytes 列转录了左侧的宽度。
中间组和空矩形定义字形 0;底部组和带图案的矩形定义字形 1。每条记录以种类 1、两字节 ID 和四字节载荷长度开头。其三个载荷字节给出两行、三列和一个打包位图。
Glyph 0 的位图字节为 00000000,读作 0。Glyph
1 具有 11010100,读作 212。其前六位构成
110 / 101;两个零填充位补足该字节。两个矩形均保留全部三
列,包括白色像素。
| 含义 | 位 | 十进制 | 字节 |
|---|---|---|---|
| 文档标记字节 |
11010110 | 00111001
|
214 | 57 |
2 |
| 条目数 | 00000000 00000010 |
2 |
2 |
| 记录数 | 00000000 00001111 |
15 |
2 |
| 第一条目 ID | 00000010 00000000 |
512 |
2 |
| 第二条目 ID | 00000001 00000001 |
257 |
2 |
| 记录类型 | 00000001 |
1 |
1 |
| 记录 ID | 00000000 00000000 |
0 |
2 |
| 载荷字节长度 |
00000000 00000000 00000000 00000011
|
3 |
4 |
| 字形行数 | 00000010 |
2 |
1 |
| 字形列数 | 00000011 |
3 |
1 |
| 打包字形掩码 | 00000000 |
0 |
1 |
| 记录类型 | 00000001 |
1 |
1 |
| 记录 ID | 00000000 00000001 |
1 |
2 |
| 载荷字节长度 |
00000000 00000000 00000000 00000011
|
3 |
4 |
| 字形行数 | 00000010 |
2 |
1 |
| 字形列数 | 00000011 |
3 |
1 |
| 打包字形掩码 | 11010100 |
212 |
1 |
四位宽度标尺 0010 计为两个字节。数据
11010110 00111001 是文档标记字节,读作 214 和 57。数据下方的标记
标识每个字节的起始位置。
22,局部行 6–7,列 0–31。标尺:列 3–6;数据:13–28;字节起始标记
位于 13 和 21 下方。
文档以这十个字节开头,以十进制显示并按字段分组。双字节整数 采用高字节在前存储。
214 57 0 2 0 15 2 0 1 1
带映射按此顺序标识各字段。每个条目 ID 占两个字节:2 0 为
512,1 1 为 257。
类型 1:可复用位图
Glyph 记录 1 占用微型字节 20–29:
1 0 1 0 0 0 3 2 3 212。其七字节头部给出类型、ID 和
载荷长度。其三个载荷字节给出两行、三列和掩码 212,即
11010100。前六位构成 110 / 101;两个零填充位补足
该字节。
Glyph 0 是独立记录,掩码全为零。两个字形均保留完整的
两行三列尺寸。它们的 ID 是名称,显示帧用其选择这些形状。因此,包含 1 的帧单元格
会选择 glyph 1;它不会把整个单元格变成
单个填充块。
010 和 1 以相同像素比例显示。完整矩形属于每个
字形。
第 23 帧,共 32 帧:用字形 ID 构建帧
显示帧通过在索引位置放置可复用字形来构建更大的图像。它还可以 为位置分配名称,后续练习允许接收者选择这些名称。
记录头部标识类型
2、ID 256 和载荷长度 18。
两个维度字段指定两行和
三列。六个字形 ID 为
0,1,1 / 1,0,1,按每行读取。查找这些 ID 可得到
左下方的图像。
左侧标尺给出每个数据带的字节
宽度。
字形 ID 可容纳于一个字节,因此这六个帧单元格占用六个字节。记录头部仍 使用双字节 ID。引用的宽度取决于承载它的字段。
在这些单元格之后,一个 2 的计数引入了两个选择定义。每个定义
包含一个区域 ID,后跟一个单元格索引。
第一个定义是
10 | 0:区域 10 选择单元格 0,即左上角位置。
第二个定义是
20 | 5:区域 20 选择单元格 5,即右下角位置。
匹配的高亮将每一对连接到其图片位置和索引框。
| 含义 | 位数 | 十进制 | 字节 |
|---|---|---|---|
| 记录类型 | 00000010 |
2 |
1 |
| 记录 ID | 00000001 00000000 |
256 |
2 |
| 负载字节长度 |
00000000 00000000 00000000 00010010
|
18 |
4 |
| 帧行数 | 00000010 |
2 |
1 |
| 帧列数 | 00000011 |
3 |
1 |
| 按行顺序排列的字形 ID |
00000000 | 00000001 | 00000001 | 00000001 | 00000000 | 00000001
|
0 | 1 | 1 | 1 | 0 | 1 |
6 |
| 区域数量 | 00000000 00000010 |
2 |
2 |
区域 1:ID、单元格索引 |
00000000 00001010 | 00000000 00000000
|
10 | 0 |
4 |
区域 2:ID、单元格索引 |
00000000 00010100 | 00000000 00000101
|
20 | 5 |
4 |
生成的图片及其六个单元格的索引:
256第 24 帧,共 32 帧:应用有序的部分更新
一条轨迹通过有序的部分更新改变初始帧。单元格会保留其先前的字形,直到 某个更新指定了该单元格。
前缀数据带标识类型
3、轨迹 257、负载长度 19、初始帧 256、
一个附加表 400 和两个补丁步骤。
左侧的标尺以字节计数。
上方图片是所引用的初始
帧。
中间图片中的第一个补丁组和已更改单元格
包含三个字段:赋值计数 1、单元格索引 0、字形 ID
1。将该赋值应用于初始图片:其左上角单元格现在显示字形
1,而其他五个单元格保留其值。
底部图片中的第二个补丁组和已更改单元格
也有一个赋值:单元格 5 接收字形 0。将其应用于中间
状态,而不是初始帧的全新副本。结果是 1,1,1 / 1,0,0。因此两个补丁
产生三张图片,并且第一个补丁的更改在第二个补丁之后仍然保留。
每个赋值都会替换单元格的字形 ID。赋值 0 会选择空白字形;
将某个单元格排除在补丁之外会保留其当前值。这些更改会影响此轨迹的
显示状态,因此可复用的初始帧记录仍可作为起点使用。
| 含义 | 位数 | 十进制 | 字节 |
|---|---|---|---|
| 记录类型 | 00000011 |
3 |
1 |
| 记录 ID | 00000001 00000001 |
257 |
2 |
| 负载字节长度 |
00000000 00000000 00000000 00010011
|
19 |
4 |
| 初始帧 ID | 00000001 00000000 |
256 |
2 |
| 附加表数量 | 00000001 |
1 |
1 |
| 附加表 ID | 00000001 10010000 |
400 |
2 |
| 补丁步骤数量 |
00000000 00000000 00000000 00000010
|
2 |
4 |
补丁 1:赋值计数 |
00000000 00000001 |
1 |
2 |
补丁 1:单元格索引 |
00000000 00000000 |
0 |
2 |
补丁 1:字形 ID |
00000001 |
1 |
1 |
补丁 2:赋值计数 |
00000000 00000001 |
1 |
2 |
补丁 2:单元格索引 |
00000000 00000101 |
5 |
2 |
补丁 2:字形 ID |
00000000 |
0 |
1 |
第 25 帧,共 32 帧:定义练习页面
此帧定义了一个练习页面,将图片、响应及其结果连接起来。仅靠显示 无法说明接收者应选择什么,也无法说明提交后会发生什么。
前三个条带标识类型 4
页面 512 及其 26 字节的有效载荷。
接下来的一对选择帧 256:显示标志
0 标识所显示的帧。页面的类型与其显示标志
是独立的字段。
响应字段请求一组
选定的区域 ID,并提供 10 和 20。
接受字段声明一个长度为 1 的已接受
集合:[10]。底部字段指定成功
页面 514、失败页面 515、演示页面 516 以及一个指向 516 的显式链接。
条带旁标尺以字节计数;列表
计数与列表内容保持为独立字段。
| 含义 | 位数 | 十进制 | 字节 |
|---|---|---|---|
| 记录类型 | 00000100 |
4 |
1 |
| 记录 ID | 00000010 00000000 |
512 |
2 |
| 有效载荷字节长度 |
00000000 00000000 00000000 00011010
|
26 |
4 |
| 显示类型 | 00000000 |
0 |
1 |
| 显示 ID | 00000001 00000000 |
256 |
2 |
| 响应形态 | 00000010 |
2 |
1 |
| 选项数量 | 00000000 00000010 |
2 |
2 |
| 选项区域 ID |
00000000 00001010 | 00000000 00010100
|
10 | 20 |
4 |
| 已接受响应数量 | 00000000 00000001 |
1 |
2 |
已接受响应 1:长度 |
00000000 00000001 |
1 |
2 |
已接受响应 1:区域 ID |
00000000 00001010 |
10 |
2 |
| 成功页面 ID | 00000010 00000010 |
514 |
2 |
| 失败页面 ID | 00000010 00000011 |
515 |
2 |
| 被动页面 ID | 00000010 00000100 |
516 |
2 |
| 链接数量 | 00000000 00000001 |
1 |
2 |
| 链接页面 ID | 00000010 00000100 |
516 |
2 |
页面 512 使用 帧 23 中讲授的区域映射:区域 10
标识单元格 0,区域 20 标识单元格 5。
选择记录的是区域 ID;它不会替换该单元格中显示的图形。
页面 512 将其响应视为一组互不相同的 ID,因此它们的选择顺序
不影响接受结果。再次选择某个区域会将其从集合中移除。完整的
提交集合必须与存储的已接受响应匹配:同时选择 10 和
20 会失败,即使其中包含已接受的选项 10。
页面也可以显示轨迹:显示标志 1 选择该形式,而
0 选择固定帧。下方完整图中的演示页面
使用轨迹。响应形态与此显示选择无关。形态 1
保留一个选择,在选择另一个时替换它;形态 2 保留一个集合;
形态 3 追加一个有序序列,保留重复项。序列的长度受
该页面上所暴露选项数量的限制。
形态 0 是被动页面:它有显示和链接,但没有可提交的响应。
其成功、失败和被动页面字段包含保留值 65,535,
表示无引用。该值从不命名任何记录。相比之下,图形 0
是真实记录,可以被绘制。
32 帧中的第 26 帧:展示两个具体的反馈结果
此帧将每个提交的选项与其打开的反馈页面和图片连接起来。 它首先定义失败图片所使用的对比图形。
上方条带和小矩形
定义图形 2:两行、三列、位图字节 00101000。
其前六位构成 001 / 010;最后两位是填充。白色的第一
列仍是图形的一部分。
上方色带旁的四位数字表示其字节宽度:1, 2, 4, 1, 1, 1。宽度和值不同:载荷长度字段旁的0100表示值3以四个字节写入。左下角较长的图案是提交的区域 ID,不是宽度标签。
提交的 ID 10 指向页面 514 和帧 259,填充字形 1。提交的 ID 20 指向页面 515 和帧 260,填充字形 2。每个反馈框给出页面类型和 ID,然后是显示标志和帧 ID,最后是生成的图像。
| 含义 | 位数 | 十进制 | 字节 |
|---|---|---|---|
| 记录类型 | 00000001 |
1 |
1 |
| 记录 ID | 00000000 00000010 |
2 |
2 |
| 载荷字节长度 |
00000000 00000000 00000000 00000011
|
3 |
4 |
| 字形行数 | 00000010 |
2 |
1 |
| 字形列数 | 00000011 |
3 |
1 |
| 打包字形掩码 | 00101000 |
40 |
1 |
第 27 帧,共 32 帧:选择、重置并提交响应
选择区域会编辑待定答案;提交会对其进行评估。以下三种情况展示了这一区别。
顶部情况使用操作 1 和参数 10 来选择区域 10。下方一行显示页面 512 保持活动状态。中间情况使用操作 3 和参数 0 清除待定选择;页面再次保持 512。
底部情况及其反馈图像使用操作 2 和参数 0 提交该现已为空的集合。它不是已接受的集合 [10],因此结果是页面 515,在每个单元格中显示字形 2。这些是操作示例,不是额外的序列化数据包。
提交会记录待定答案,将其与页面的已接受响应进行比较,并打开存储的成功或失败页面,且选择为空。什么都不做不会提交答案;提交空选择会提交长度为零的答案。后续课程在空答案正确时会用到这一区别。
| 含义 | 位数 | 十进制 |
|---|---|---|
| 操作码、操作数 |
00000000 00000001 | 00000000 00001010
|
1 | 10 |
| 操作前页面、操作后页面 |
00000010 00000000 | 00000010 00000000
|
512 | 512 |
| 操作码、操作数 |
00000000 00000011 | 00000000 00000000
|
3 | 0 |
| 操作前页面、操作后页面 |
00000010 00000000 | 00000010 00000000
|
512 | 512 |
| 操作码、操作数 |
00000000 00000010 | 00000000 00000000
|
2 | 0 |
| 操作前页面、操作后页面 |
00000010 00000000 | 00000010 00000011
|
512 | 515 |
第 28 帧,共 32 帧:跟随反馈和被动路由
存储的页面引用决定接下来打开什么。它们的数字顺序并不定义页面序列。
第一对将提交的区域 20 映射到失败页面 515。第二对和上方图像将区域 10 映射到成功页面 514。第三对和下方图像具有不同的作用:演示页面 516 链接到最终图像页面 518。
| 含义 | 位数 | 十进制 |
|---|---|---|
响应 20 → 失败页面 515 |
00000000 00010100 | 00000010 00000011
|
20 | 515 |
响应 10 → 成功页面 514 |
00000000 00001010 | 00000010 00000010
|
10 | 514 |
演示页面 516 → 最终页面 518 |
00000010 00000100 | 00000010 00000110
|
516 | 518 |
页面 516 播放轨迹 257,并且还链接到反馈页面 517。
完成它的两个补丁不会自动跟随这两个链接中的任何一个。页面 514、
515、517 和 518 都链接回问题 512。
跟随返回链接会以空选择开始一次新的尝试。重置只会清除问题页面上 待提交的答案;它无法从反馈页面抹去已提交的答案。 这些显式链接还让学习者无需先正确作答即可打开演示。
| 从 | 操作 | 到 / 显示 |
|---|---|---|
512 |
提交 [10] |
514 / 帧 259,全部字形 1 |
512 |
提交 []、[20] 或 [10, 20] |
515 / 帧 260,全部字形 2 |
512 |
打开演示 | 516 / 轨迹 257 |
516 |
打开反馈 | 517 / 帧 259 |
516 |
打开最终图片 | 518 / 帧 258 |
514, 515, 517, 518 |
返回链接 | 512 / 问题 |
第 29 帧,共 32 帧:阅读完整的微型模型部分
This frame supplies the complete miniature document inside its checked section. It lets the recipient test the earlier boundaries and record examples together.
The first six bytes are header bytes
0 1 | 0 0 1 70: ID 1 and body length 326. The
326-byte body begins with
214 57 | 0 2 | 0 15 | 2 0 | 1 1 and contains all fifteen records. The
last four bytes are
255 64 93 120. The total is 6+326+4 = 336 bytes, filling exactly forty-two eight-byte rows
starting at local row 12.
The final row contains four body bytes and four check bytes. There is no partial data row. The reader can verify this section’s check now; parsing every record also requires the table format shown next. This worked section belongs to the strip, not to the five-document payload below it.
Frame 30 of 32: Read a numeric table
Table values are unsigned numbers. A value here does not select a glyph, as a frame cell does.
The first three bands specify kind 5, ID
400 and payload length 17. The
dimension fields give two rows and
three columns. The last two bands contain
0,1,2 and 3,4,5, each value stored as a u16. Thus each value band occupies six
bytes.
The four-bit widths on the left
count the bytes in each band. The two value bands each have width 0110,
or six bytes: three values with two bytes each. Their small under-row marks locate
those byte boundaries.
| Meaning | Bits | Decimal | Bytes |
|---|---|---|---|
| Record kind | 00000101 |
5 |
1 |
| Record ID | 00000001 10010000 |
400 |
2 |
| Payload byte length |
00000000 00000000 00000000 00010001
|
17 |
4 |
| Table rows |
00000000 00000000 00000000 00000010
|
2 |
4 |
| Table columns | 00000011 |
3 |
1 |
Table values 0–2 |
00000000 00000000 | 00000000 00000001 | 00000000 00000010
|
0 | 1 | 2 |
6 |
Table values 3–5 |
00000000 00000011 | 00000000 00000100 | 00000000 00000101
|
3 | 4 | 5 |
6 |
Trace 257 refers to this table as attached data. The record reader recovers its values without assigning
them a subject-specific meaning. Later tables use the same format for move words, scores and field
widths; the displayed lessons teach those meanings.
A trace’s references make its attached tables available to the reader. Its stored patches give the display changes explicitly; the player does not calculate those changes from the table values.
Using the bootstrap to read the payload
The final two bootstrap frames show how sections form a stream and where the full message’s used data ends. Together with the earlier examples, the strip defines the byte order, checksum, section and inventory layouts, document header, and five record types needed to read the payload.
Frame 31 of 32: Locate consecutive sections and their boundary
This frame places sections consecutively and distinguishes the final byte from the address after it. The recipient needs both to stop at the correct boundary.
The upper rows have four columns: section ID, start, exclusive end and length. The
inventory row is 0,0,28,28;
the document row is
1,28,364,336. The second section begins exactly where the first ends. These rows describe
placement, not extra header fields.
The 0,1,2 line is a counting
sequence; this example contains only sections 0 and 1. The bottom pair
contrasts last included byte 363 with
exclusive end 364. In general, the next
section starts after six header bytes, the declared body length and four check bytes.
| Meaning | Bits | Decimal |
|---|---|---|
| Inventory: ID, start, end, length |
00000000 00000000 | 00000000 00000000 | 00000000 00011100 | 00000000 00011100
|
0 | 0 | 28 | 28 |
| Document: ID, start, end, length |
00000000 00000001 | 00000000 00011100 | 00000001 01101100 | 00000001 01010000
|
1 | 28 | 364 | 336 |
Counting sequence 0, 1, 2 |
00000000 00000000 | 00000000 00000001 | 00000000 00000010
|
0 | 1 | 2 |
Frame 32 of 32: Find the used end and verify zero reserve
This frame separates the full payload’s used bytes from its zero-filled reserve. The recipient must stop parsing at the used end and check what remains.
The four bounded fields give
start offset 0, used length 506,509, capacity 507,904, and reserve length 1,395. The small tallies at the right number
these rows.
The lower example contains two separately
bounded fields: thirty-two zero bits above, and the eight-bit numeral 00100000 below, read
as 32. The first field is data; the second states its width. Their separate boundaries keep
the numeral’s filled bit out of the zero data.
Recovering and validating the payload
The five document bodies total 506,181 bytes. Add 268 inventory-body bytes and
60 bytes of section headers and checks to obtain 506,509 used bytes. The
remaining 1,395 bytes must be zero rather than another document.
The reader starts at row 64 and uses Frame 16’s mapping to recover the declared number of bytes. For each
section, it reads the header, checks that the body fits within the remaining data, verifies the checksum,
and advances past header, body and check. Section IDs increase from 0, and each required document appears
once.
Section 0 is the full message’s inventory. Its body begins with the two-byte document count
5. Each document entry specifies an ID, body length, section checksum, entry count and ordered entry IDs.
The inventory contains these numeric declarations, not lesson titles or a curriculum order.
A complete reading must match the inventory to the received sections and document headers. It must also validate record lengths, kinds, references and cell indices. Missing objects and invalid references cause rejection; the reader does not guess replacements. Successfully displaying one fragment is not enough to accept the whole message.
The supplied Python decoder implements these rules directly. It tests rotations, reflections and swapped bit states, compares the bootstrap with its defined drawings, and requires one completely valid reading. This is a check of a known format. Discovering that format from the drawings is the recipient’s separate task.
| Document / section ID | Section stream offset | Body bytes | Contents, labelled for this guide |
|---|---|---|---|
1 |
278 |
13,245 |
Basic visual vocabulary |
2 |
13,533 |
93,017 |
The 64-game anthology |
3 |
106,560 |
35,296 |
Board, pieces and elementary rules |
4 |
141,866 |
195,452 |
Practical rules, state and move packing |
5 |
337,328 |
169,171 |
Relationships, tactics and strategic examples |
64. Storage order is not a requirement to read
document 2 before learning from documents 3 and 4.
The miniature belongs to the bootstrap strip. It demonstrates the format used by the inventory and five complete documents in the byte stream below it. After recovering and validating that full set, the recipient can open a declared entry.
The player can now look up the entry’s records and display them. No chess knowledge is needed to reconstruct the picture in the next example.
From payload bits to a displayed picture
Follow document 2, which stores the complete games, and its first declared entry,
trace 324. We will reconstruct its initial picture using the bootstrap’s rules,
then use the course to interpret that picture as chess.
Find the document and read its declared entry
After all six sections have been recovered and checked, the inventory identifies document
2 with a body of 93,017 bytes. Its section starts at payload byte
13,533. The six-byte header reads 0 2 | 0 1 107 89: document ID,
then body length, high byte first. The body begins six bytes later, at payload byte
13,539. Document offset 0 means this point.
The first eight body bytes come from source row 116, columns
1,816–1,879. They are one continuous row of 64 cells
in the message; the illustration regroups them into eight rows, one byte per row.
The first two bytes identify the document format.
The next two declare 64 entries;
the following two declare 151 records.
The last pair shown is the first entry ID.
| Field | Bits | Reading |
|---|---|---|
| Document marker | 11010110 00111001 | 214 57 |
| Entry count | 00000000 01000000 | 64 |
| Record count | 00000000 10010111 | 151 |
| First entry ID | 00000001 01000100 | 1×256 + 68 = 324 |
Entry 324 is a stored name, not the location of the next byte.
The remaining 63 entry IDs follow it. All 64 entries occupy
128 bytes after the six-byte header, so the records begin at document byte
6 + 64×2 = 134.
Read the records, then follow their names
At each record, read its one-byte kind, two-byte ID and four-byte content length.
Consume exactly that many content bytes, then continue with the next record.
For example, record 0 starts at byte 134 and declares three
content bytes. Its seven-byte header and three-byte contents end at byte
144, where the next record starts. Reading all 151 records
builds a lookup from each ID to its stored contents.
| Record | Document offset | Actual header bytes |
|---|---|---|
Glyph 32 | 199 | 1 | 0 32 | 0 0 0 6 |
Frame 256 | 355 | 2 | 1 0 | 0 0 0 76 |
Trace 324 | 15,028 | 3 | 1 68 | 0 0 2 88 |
Looking up the declared entry 324 finds a trace, kind 3.
Its first two content bytes are 00000001 00000000, or
1×256 + 0 = 256: its initial display-frame ID.
Looking up 256 finds the frame record above. This follows a reference
back to an earlier record; it does not jump to byte 256.
The rest of the trace contains its attached tables and ordered updates. Its initial
display uses this frame before applying any update.
-
Declared entry
324names the record below ↓ -
Trace record
324First content bytes:00000001 00000000name its initial frame ↓ -
Frame record
256Found at document byte355
Read the frame as a grid of glyph references
Frame 256 begins its contents with 00001001 00001000:
nine rows and eight columns. The next 9×8 = 72 bytes give one glyph ID
for each frame cell, across each row and then down. Here are those actual bytes,
shown as decimal IDs. The row and column labels are added for reading.
After the grid, two zero bytes give a selectable-region count of 0.
The frame’s contents therefore occupy 2 + 72 + 2 = 76 bytes, matching its header.
| Row | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|---|
0 | 41 | 39 | 40 | 42 | 43 | 40 | 39 | 41 |
1 | 38 | 38 | 38 | 38 | 38 | 38 | 38 | 38 |
2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
5 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
6 | 32 | 32 | 32 | 32 | 32 | 32 | 32 | 32 |
7 | 35 | 33 | 34 | 36 | 37 | 34 | 33 | 35 |
8 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Cell 48 is row 6, column 0, because
6×8 + 0 = 48. Its byte is 00100000, or ID 32.
The frame record starts at byte 355. After its seven-byte header and two
dimension bytes, the grid begins at 355 + 7 + 2 = 364.
Cell 48 is therefore at document byte 364 + 48 = 412,
or payload byte 13,539 + 412 = 13,951. The mapping from
Frame 16 places it at source row 118, columns
1,016–1,023. The byte names a glyph; its eight source bits
do not themselves draw that glyph.
Look up the bitmap and put it in the cell
Record 32 is a glyph, kind 1. Its six content bytes are
5 5 | 1 8 64 0: row count, column count, then the packed bitmap.
The dimensions require 5×5 = 25 picture bits. The four bitmap bytes
carry those first 25 bits, followed by
seven zero padding bits that complete the last byte.
Take five picture bits at a time to fill each bitmap row from left to right, then continue
on the next row. The padding completes the stored bytes and is excluded from the picture.
The recipient now draws that bitmap in
frame cell 48. Each of the other
cells is drawn by looking up its own glyph ID in this same document. A repeated ID
reuses the same bitmap. Record 0 has contents 2 2 | 0:
a two-by-two bitmap of zero bits. It supplies the blank tiles wherever the frame names
glyph 0. The result is the complete initial picture of entry 324:
32.Every glyph shape now comes from a stored bitmap, and every position from a stored frame cell. The recipient can draw this picture using the bootstrap’s rules alone. Learning what the shapes, arrangement and bottom row mean is the next task for the recovered course. Later, we will return to this same trace and apply its first stored update.
Learning chess from the payload
The picture just recovered is a display the recipient can draw before understanding chess.
Document 1 supplies the visual vocabulary; the chess course then explains the 8×8 board, two
sides, six piece types, starting positions and alternating turns. This guide uses the usual English names,
White and Black; White moves first. The recipient has no reason to associate any particular shape with a
chess piece, so the glyphs could be arbitrary. I chose patterns that resemble familiar chess pieces. Their roles still have to be taught
through setup, movement and repeated examples.
The study route begins with document 1’s representation lessons, then documents
3, 4 and 5: elementary rules, practical rules and history, then relationships and limited
strategic guidance. Document 2 supplies the complete-game anthology.
A worked example shows an input and its result. Contrasts make a distinction visible by showing a rejected result or changing a condition such as a blocker or a castling right. Practice asks the recipient to choose among stored alternatives, using the page mechanism from the bootstrap. A page can group several questions: the learner selects an answer for each and commits the combined set. The player checks that whole set against the page’s stored accepted responses.
A passive route shows the explanations and feedback without requiring a correct submission. Both routes use the same record operations. The chess calculations happen when the lessons are authored; the player later presents the resulting pictures, choices and feedback.
A glyph ID remains a local name. Its role as a pawn, knight or other piece comes from the examples. The same glyph can appear on the board, identify a selected piece in a question, and appear at its destination after a move.
Identifying the question and its answer
A question must identify its subject as well as show a board. This knight lesson uses a 29×10
display frame containing an 8×8 board and a separate 8×8 answer grid, or mask, below it. A footer between
them names the side, selected piece, square and question type.
Here the footer selects the
first-side knight at board row 7, column 1, or b1 in the added chess coordinates. The question asks for legal destinations. The knight can move to
a3 and c3. Its jump also reaches d2 geometrically, but a friendly pawn
occupies that square.
| Source footer field | Actual value / glyph | Meaning in this lesson |
|---|---|---|
| Side / selected piece | 3 / 33 |
First side / knight |
| Row / column | 19 / 13 |
Digit glyphs for 7 / 1 |
| Question mode | 9 |
Legal destinations |
| Positive mark | 6 |
Carried answer is affirmed |
Document 3, trace 3068, step 33. Within this 29×10 display frame, the board occupies rows
1–8 and columns 1–8; the mask occupies rows 11–18 and columns
1–8; the footer is row 9. Coordinates start at 0. The mask’s plus-shaped glyph 5
marks indices 40 and 42 within the 8×8 mask, corresponding to a3 and c3. This illustration shows the stored answer.
An ordinary capture removes the opposing piece at the destination and puts the moving piece there. A friendly piece prevents a move to that square. A legal move must also leave its own king safe. An attack on the king is check; check with no legal escape is checkmate. The king stays on the board when the game ends.
King safety depends on the resulting position. In one course example, a king on e1 tries to capture a bishop on d1 while an opposing rook stands on f1. Before the move, the king itself blocks the rook’s line to d1. Once the king leaves e1, that line opens, so the capture is illegal. The course shows the attempted move’s resulting occupancy and attack. Testing a king capture means moving the king, removing the captured piece, and checking its destination in that changed position.
Controlled squares and legal moves
Control follows a piece’s movement geometry in the displayed position. For a rook, bishop or queen, it extends along each permitted straight line to the first occupied square, including a friendly piece it defends. Pins do not remove controlled squares. Here the bishop on b5 points along a diagonal through the knight on c6 toward the knight’s king on e8. Moving the knight would expose the king. The knight still controls eight squares, but has no legal destination.
The control question follows the knight’s jump pattern. The legal-move question also checks whether moving would expose its king. The course distinguishes these questions with different mode glyphs. The board stays the same; the empty legal-move mask and eight-square control mask are answers to different questions. This knight cannot move along the diagonal that pins it. A pinned sliding piece or pawn can sometimes move along its pin line while continuing to shield its king, so a pin does not always mean that a piece has no legal move.
Control mask: document 3, trace 3124, step 1. Legal-move mask: trace 3119, step 8. Both show
the same board and selected knight.
Learning how moves are packed
A numeric table provides values, but their meaning must also be taught. Document 4 explains how a move’s
origin square, destination square and promotion choice form a packed number. These lessons are part of the
payload and become accessible through the reader established by the bootstrap.
One stored example uses origin 52,
destination 36 and
choice 0: e2→e4 without promotion. Squares are numbered across rows from a8=0 to h8=7, continuing
down to a1=56. Choice 0 means no promotion; 1, 2, 3 and 4 select queen, rook,
bishop and knight.
Both before-and-after boards already appear in the source display. The two crops below show the numeric part of that display before and after a trace step fills in the packed result. The board pictures do not move between these two states.
52, 36, 0; packed-word row blank26912| Row in these crops | What it represents |
|---|---|
| Top | Decimal origin 52, destination 36, choice 0 |
| Middle |
The respective 6, 6, 3 bits: 110100 / 100100 /
000
|
| Bottom |
The completed 16-bit word: 0 / 110100 / 100100 /
000
|
Document 4, page 1076→trace 1075. The crops show display-frame rows 9–11 and columns
0–18. A bit 0 uses glyph 2, the decimal digit 0 uses glyph 22, and
a blank cell uses glyph 0. These are three distinct records.
The completed word is 0110100100100000 = 26,912, calculated as 52×512 + 36×8 + 0. Its fields are one leading zero, six origin bits, six
destination bits and three choice bits. Other stored examples unpack a word into these fields and reject a
leading 1 or a choice outside 0–4.
The table [16,1,6,6,3] describes those widths: 16 bits total, with fields of
1, 6, 6 and 3 bits. The pictures teach which fields mean padding, origin, destination and
choice. The table alone provides widths, not that interpretation. We can now use the same rule to
understand a move in the anthology.
A well-formed move word is not necessarily a legal move. Packing checks field ranges; unpacking also rejects a nonzero leading bit. Neither operation checks the board, whose turn it is, or whether promotion is possible. Those questions require the chess rules and the position’s state.
Following one move from source to display
The first game in the anthology has 52 individual moves, or plies, beginning with d2→d4.
The byte-to-picture walkthrough above recovered this game’s initial frame. Following its first
move now connects the stored number’s meaning to the separately stored display update. The anthology stores the move in two
forms: a numeric move word and a display patch. The recipient must recover them separately and learn why they describe the same move.
1. Produce the move word and display patch
Game preparation starts with the anthology in PGN, a human-readable notation for recorded games.
The source importer checks each game’s main line by replaying it legally from the standard
starting position. It records every intermediate board, the side to move, and each move’s
origin, destination and explicit promotion choice. The first move here gives
[51,35,0]. Packing gives 51×512 + 35×8 = 26,392, stored as bytes
103 24.
The same replay supplies the board before and after the move. Comparing their display cells produces three
assignments: place pawn glyph 32 at cell 35,
clear cell 51 to glyph 0, and change footer cell 64 from side glyph 3 to side glyph 4. The move
word and patch come from this common replay. The reader does not calculate one from the other.
The message builder loads the checked game and presentation data, packs the move tables, and assembles the document. It verifies the retained inputs before using them. This construction uses the qualified presentation data rather than reimporting the PGN on every build.
The authoring code shares identical glyphs, frames and tables between games, then assigns trace IDs. In
document 2, trace 324 refers to initial frame 256, move table 257 and score table 258. Packing adds schema
table 388 as another reference. These IDs identify objects only within this document.
Record in document 2 |
Kind | What it supplies to trace 324 |
|---|---|---|
256 |
2: frame |
9×8 initial picture: 64 board cells +8 footer cells |
257 |
5: table |
52 rows ×1 column of packed move words |
258 |
5: table |
1×1 score table, value 1 |
388 |
5: table |
1×5 schema: 16, 1, 6, 6, 3 |
324 |
3: trace |
Initial 256, data[257,258,388],52 literal patches |
257 was a trace; document 2’s 257 is a table. Miniature 256 and document 2’s 256 are also
different frames. A name never identifies a record across document boundaries.
2. Store the document in a checked section
Document 2 contains 93,017 bytes. Its six-byte section header is
0 2 | 0 1 107 89: section ID 2 and body length 93,017. CRC-32C over that header
and body gives 182 147 233 40. Adding the four check bytes gives a 93,027-byte
section.
The section starts at stream byte 13,533, which maps to physical row 116, column 1,768. Its
body starts six bytes later, at stream byte 13,539. The boundary falls inside a physical row:
section storage follows the byte stream continuously, without row packets or row separators.
3. Recover and validate document 2
The recipient finds this boundary by reading the inventory section and document 1’s section
lengths. The inventory declares document ID 2, body length 93,017, expected check
182 147 233 40 and 64 entry IDs, starting with 324. These declarations must match the received
section and document header.
The document header starts 214 57 | 0 64 | 0 151: marker, 64 entries and 151 records. Its
first entry is 1 68, or 324. Reading each length-delimited record builds a map from IDs to
records. Resolving trace 324 then finds frame 256 and tables 257, 258 and 388. Schema 388 is
near the document’s end, so references must work even when the target record occurs later.
257 and trace 324: actual record bytes| Actual byte values, decimal | Interpretation |
|---|---|
5 | 1 1 | 0 0 0 109 |
Kind 5, ID 257, payload 109 bytes |
0 0 0 52 | 1 |
52 table rows, 1 column |
103 24 |
First u16 value: 26,392 |
3 | 1 68 | 0 0 2 88 |
Kind 3, ID 324, payload 600 bytes |
1 0 | 3 | 1 1 | 1 2 | 1 132 | 0 0 0 52 |
Initial 256; 3 references 257,258,388; 52 patches |
Spaces in these transcripts separate fields for reading; they are not stored delimiters. The table’s
payload length, 109 bytes, and its row count, 52, are different fields.
4. Locate and read the first move word
Table 257 starts at document byte 438. Its seven-byte record header is followed by a four-byte row count
and a one-byte column count. Its first value therefore begins at byte 450 and occupies bytes 450–451.
The document body starts at stream byte 13,539. Adding 450 locates the first value at stream
bytes 13,989–13,990. Frame 16’s mapping places its sixteen bits at physical row
118, columns 1,320–1,335. They read 0110011100011000: bytes 103 and
24, giving 103×256+24 = 26,392.
Read the sixteen positions from left to right: 0110011100011000. The table keeps those same
bits visible while showing their readings.
| Representation | Same carried value |
|---|---|
| Two bytes, decimal | 103 /24 |
One u16 |
103×256+24 =26,392 |
| Fields, binary | 0 |110011 |100011 |000 |
| Fields, decimal | padding 0 |origin 51 |target 35 |choice 0 |
5. Interpret the move fields
Apply schema 388 using the meanings taught in document 4: 0 | 110011 | 100011 | 000. The
fields give padding 0, origin 51, destination 35 and choice 0: d2→d4 without promotion. These
square numbers use row-major order on the 8×8 board; they are distinct from coordinates in the physical
message.
The table reader recovers the value 26,392. Interpreting it as a chess move requires
the course’s explanation of the fields. The native player does not use this word to calculate a legal
board update; it displays the separately stored patch.
6. Apply the stored patch
Trace 324’s first patch occupies document bytes 15,048–15,058:
0 3 | 0 35 32 | 0 51 0 | 0 64 4. The count is three, followed by assignments (cell 35, glyph
32), (cell 51, glyph 0) and (cell 64, glyph 4). Two change board cells; the third changes the
footer’s turn marker.
Both before and after the patch, glyph 32 refers to the same bitmap recovered earlier:
a 5×5 picture with mask bytes 1 8 64 0. The patch changes where it is drawn.
The glyph record itself stays unchanged.
Record 32 → a 5×5 bitmap
00000 / 00100 / 00100 / 00100 / 00000
The first 25 bits of bytes 1, 8, 64, 0, across each row and then down.
| Cell index | Before glyph ID | Assignment | Result |
|---|---|---|---|
35 (d4) |
0 |
32 |
Draw the pawn bitmap |
51 (d2) |
32 |
0 |
Draw the blank bitmap |
64 (footer, first cell) |
3 |
4 |
Second side to move |
The frame is 9×8; these pictures crop its first eight rows. Cell 64 is outside the board and is shown
separately in the complete replay below. Colored areas identify the assigned board cells.
The two stored representations agree: the move word specifies d2→d4, and the patch moves the pawn between those squares while changing the turn marker. During message creation, the program checks the reconstructed pictures against the board positions obtained from the original game’s moves. A recipient who has learned the meanings can compare them; the player itself only looks up glyphs and assigns cell values.
The move word, patch and bitmap thus meet in one displayed change. The bootstrap supplies the operations needed to recover and draw it; the course supplies its chess meaning. The special moves below use the same operations, with additional rules determining which changes are valid.
Why board positions need history
The first move changes two board cells and a footer. Other moves depend on more information or change additional squares. The course teaches these cases by showing a position, an attempted move and its result, then comparing what happens when a relevant condition changes.
In the examples below, the before-and-after boards occupy two regions of one stored display frame, at
display-frame columns 0–7 and 9–16. They are not separate frame records. The crops show only
the squares needed to explain each rule.
Castling moves two pieces
In this king-side castling example, the king and rook leave e1 and h1 and arrive on g1 and f1. Four board cells change. Castling requires the corresponding right to remain and every square between king and rook to be empty. The king must be safe on its starting square, its transit square after leaving the start, and its destination after both pieces move. The course compares accepted castling with attempts that fail these conditions.
A king or rook that moves and returns does not recover its lost right. For queen-side castling, the square next to the rook must also be empty, though the king never crosses it. An attack on that square or on the rook itself does not prevent castling; the safety test concerns the king’s route.
4, trace 798, step 0. The crops show e1–h1 in the before-and-after board regions.
The first side also loses its castling rights after this move.
En passant depends on the immediately preceding move
Immediately after the opposing pawn advances from d7 to d5, the pawn on e5 can capture on d6. That destination was empty. The captured pawn is removed from d5, so three squares change. The crop shows d6 and e6 above d5 and e5.
A matched example moves both sides’ knights away and back, restoring the same board occupancy. The opportunity for en passant has expired, so the same attempted capture is refused and the board remains unchanged. The pieces alone do not record when the opposing pawn advanced.
En passant must also leave the moving side’s king safe. Removing both pawns from their original squares can open an attacking line. The course includes an immediate capture refused for this reason, even though its timing and pawn geometry are otherwise correct.
4, trace 906. Step 0 shows the available capture; step 4 shows the same board after
the opportunity has expired.
Promotion needs a separate choice
Here the pawn leaves b7, captures the
rook on a8, and is replaced by the
selected promotion piece. Choice 1 produces a queen;
choice 4 produces a knight. Both moves have the same origin and destination, so the promotion choice needs
its own field. The course also shows rook and bishop promotion and rejects a missing promotion choice.
1: queen a8; b7 empty4: knight a8; b7 empty4, trace 929, steps 0 and 9. Each crop shows a8 and b8 above a7 and b7.
History is part of the state
A king can leave its starting square and return, restoring the board and side to move while losing
castling rights. Document 4, trace 1000 at step 3, compares two matching boards with
different histories: the first side has both castling rights in one case and neither in the other.
Repetition uses a precise meaning of “the same position”: the pieces occupy the same squares, the same side is to move, castling rights match, and any legal en-passant opportunity matches. An en-passant target counts only if an actual legal capture is available. A target that no pawn can use, or that would expose its own king, does not distinguish the position.
Count occurrences of the current position throughout the legal history, including the initial occurrence. They need not be consecutive. A separate counter records plies since the last pawn move or capture; either resets it to zero. That counter affects a draw claim, but is not part of the position compared for repetition.
The course carries legal histories and state displays for these distinctions. Reused history
segments have explicit links and complete starting pictures, so opening a segment does not
require the player to calculate its starting position. The anthology’s 72 display
cells serve a smaller purpose: its board and footer show play and result, without listing
all castling rights or an en-passant square.
When a game ends
A side with no legal move is checkmated if its king is in check, and stalemated otherwise. Checkmate is a loss; stalemate is a draw. Golden Board also recognizes three classes where neither side can give checkmate: king against king, king and bishop against king, and king and knight against king. Its rules machinery ends play after a legal move reaches one of these board endings, and refuses later moves or declarations.
A claim for threefold repetition becomes available once the current position has appeared
at least three times. A fifty-move claim needs at least 100 plies since the last
pawn move or capture. Neither condition ends play automatically: the side to move must
explicitly claim the eligible draw. A move that would reach a threshold does not make that
claim available in advance. The course shows eligible claims and the separate events that
accept or refuse them.
Either side can resign while play is active, awarding the other side the win. Draw agreement requires both sides’ explicit consent after each has made a move. These declarations have known causes. An anthology score only records the outcome: a win or draw on a nonterminal board does not identify resignation, agreement or a claim.
This is the project’s practical chess profile. It excludes automatic fivefold and
75-move adjudication, intended-next-move claim procedures, tournament procedures,
and a general solver for positions where checkmate is impossible. Material outside the
three recognized dead-position classes receives no general deadness verdict.
Tactics, mating and strategic guidance
The later course builds on control and legality to teach attacks, defenses, pins and forks. A fork here is one piece geometrically attacking at least two opposing pieces. That fact alone does not prove that either capture is legal or profitable. A passed pawn has no opposing pawn ahead on its own or an adjacent file; it still faces kings, other pieces and the timing of play.
Mating instruction includes king-and-queen and king-and-rook continuations, with contrasts that end in stalemate. A legal line ending in mate can still depend on the opponent choosing a losing reply. To support a forced win, the winning side may choose its continuations, but every legal defensive move and every eligible defensive draw claim must be covered. All resulting branches must end in the asserted win.
The message carries finite worked examples of this distinction. One starts with White’s king on f3 and queen on h4, and Black’s lone king on g1. White moves the queen to g3. Black’s only legal moves are king g1→f1 and king g1→h1. The stored continuations answer the first with queen g3→f2 and the second with queen g3→g2; both give checkmate. Covering only one reply would leave the forced-win claim incomplete. The player presents these stored displays and tables without searching for a mating line.
Strategic lessons use observable facts such as development, central control, open files
and mobility. Their rough material scale assigns 1 to a pawn, 3 to a
knight or bishop, 5 to a rook and 9 to a queen; the king has no exchange
value. These counts and comparisons provide guidance, not a verdict on the better position
or best move. A worked move-check routine first establishes whether play is active, whose
turn it is, whether the king is in check, and which draw claims are available. It then
examines legal choices and the shown move’s effects, including captures, check and game
endings. Comparisons remain limited to the continuations actually supplied.
Replaying a complete game
The 52-ply game has 53 display states: its initial frame and the result after each patch. To reconstruct a
state, copy the initial frame and apply all patches up to that point. Moving backward reconstructs an
earlier state in the same way; it does not require reversing chess moves.
The board and eight-cell footer appear separately below. Footer cell 0 identifies the side to
move. In the final patch, footer cell 1 changes to glyph 11, the second-side result mark.
Score table 258 contains 1, recording a second-side win. This stored result does not imply that the final
displayed board is checkmate.
1: all 53 display states and the footer
Use Next move to apply the next stored patch, Previous to reconstruct the preceding state, and Reset to
restore the start. The 53 states cover 0–52 plies.
Blue areas mark cleared cells;
ochre areas mark assigned pieces;
teal areas mark footer changes. The interpreted move word is listed
separately.
1 board · initial positionFirst side to move; result mark blank.
State 1 of 53 · before any move
Initial frame 256
Move-word details begin with the first stored update.
No patch applied. The source picture has 64 board cells and 8 footer cells.
The controls inspect stored moves and patches. This page does not calculate chess rules or generate legal moves.
The three checkpoints show selected states without interaction. Across 64 games, the artifact stores
6,890 plies and 6,954 initial-or-updated board states. The game records contain
no names, dates, opening labels or commentary.
The player displays castling, promotion and en passant by applying their stored cell changes. Interpreting move words or deciding whether a new move is legal requires the rules taught by the course. The picture player does neither.
Before you go
Getting from a square of bits to a game takes patience. Thank you for giving so much of your time and attention.
If something is unclear, seems wrong, or could be explained better, please let me know. Questions, corrections and other ideas are welcome, whether they concern the Golden Board itself or this guide.
You're also welcome to build on the source code. Try another subject, another way of teaching it, or a different experiment.
If you share or adapt the project, or use it in research, please credit and link the original work; the repository includes a BibTeX citation.
I'd love to see what you make from it.
来源:Hacker News · artemlegotin.com