dsh-plugin-term-dictionary 0.0.0-stage → 1.1.0

package/lib/core/lexicon.en.js

@@ -0,0 +1,872 @@
+"use strict";
+/**
+ * Built-in technical lexicon: English terms the plugin recognises without any
+ * network call. Keys are matched case-insensitively for single words and
+ * case-sensitively-normalised for multi-word phrases.
+ */
+module.exports = {
+  "algorithm": { zh: "算法", domain: "计算机", gloss: "一组有限、确定、可执行的步骤，用来把输入变换为输出。" },
+  "big-o notation": { zh: "渐进上界", domain: "数学", gloss: "描述算法耗时随输入规模增长的上界，忽略常数与低阶项。" },
+  "hash table": { zh: "哈希表", domain: "计算机", gloss: "用哈希函数把键映射到桶位、平均常数时间完成查找的数据结构。" },
+  "hash function": { zh: "哈希函数", domain: "计算机", gloss: "把任意长度输入压缩成定长摘要、且很难从摘要反推原文的函数。" },
+  "binary search": { zh: "二分查找", domain: "计算机", gloss: "在有序序列中每次比较中间元素并折半缩小范围来定位目标。" },
+  "depth-first search": { zh: "深度优先搜索", domain: "计算机", gloss: "沿着一条路径尽可能深入、走不通再回退的图或树遍历策略。" },
+  "breadth-first search": { zh: "广度优先搜索", domain: "计算机", gloss: "从起点逐层向外扩展、先访问近处节点的图或树遍历策略。" },
+  "amortized analysis": { zh: "摊还分析", domain: "计算机", gloss: "把偶发的高开销操作摊到一整串操作上，估计平均代价的方法。" },
+  "dynamic programming": { zh: "动态规划", domain: "计算机", gloss: "把问题拆成互相重叠的子问题并保存答案，避免重复计算。" },
+  "trie": { zh: "字典树", domain: "计算机", gloss: "按字符逐层共享前缀的树形结构，常用于字符串检索与补全。" },
+  "heap": { zh: "堆结构", domain: "计算机", gloss: "满足父子大小关系的完全二叉树，能在常数时间取到最值。" },
+  "binary heap": { zh: "二叉堆", domain: "计算机", gloss: "用数组表示的完全二叉树堆，是最常见的优先队列实现方式。" },
+  "bloom filter": { zh: "布隆过滤器", domain: "计算机", gloss: "用多个哈希位判断元素是否可能存在，空间极小但会假阳性。" },
+  "consistent hashing": { zh: "一致性哈希", domain: "系统", gloss: "把节点与键映射到同一个环上，使节点增减时仅少量键需迁移。" },
+  "quicksort": { zh: "快速排序", domain: "计算机", gloss: "选定基准把序列划分成两段再递归排序，平均速度很快。" },
+  "mergesort": { zh: "归并排序", domain: "计算机", gloss: "不断把序列对半拆分再合并有序子序列，复杂度稳定且排序稳定。" },
+  "heapsort": { zh: "堆排序", domain: "计算机", gloss: "借助堆结构反复取出最值来完成就地排序，最坏情况也有保障。" },
+  "topological sort": { zh: "拓扑排序", domain: "计算机", gloss: "为有向无环图排出线性次序，使所有依赖项都排在前面。" },
+  "dijkstra": { zh: "迪杰斯特拉算法", domain: "计算机", gloss: "在非负权图中从起点逐步向外扩展，求出到各点的最短路径。" },
+  "greedy algorithm": { zh: "贪心算法", domain: "计算机", gloss: "每一步都选当下最优方案，寄望局部最优能带来全局最优。" },
+  "divide and conquer": { zh: "分治法", domain: "计算机", gloss: "把大问题拆成同类小问题分别求解，再合并各子问题的答案。" },
+  "backtracking": { zh: "回溯法", domain: "计算机", gloss: "系统地尝试候选解，发现走不通就撤销选择并换一条分支。" },
+  "memoization": { zh: "记忆化", domain: "计算机", gloss: "把已经算过的函数结果缓存起来，遇到相同输入直接复用。" },
+  "sliding window": { zh: "滑动窗口", domain: "计算机", gloss: "维护一个可前后移动的区间，用它在线性时间内统计连续子段。" },
+  "two pointers": { zh: "双指针", domain: "计算机", gloss: "用两个下标从两端或同向推进，省去数组中的嵌套循环。" },
+  "union-find": { zh: "并查集", domain: "计算机", gloss: "维护元素所属集合、支持快速合并与查询连通性的数据结构。" },
+  "segment tree": { zh: "线段树", domain: "计算机", gloss: "把区间层层二分建成树，支持区间查询和区间修改。" },
+  "fenwick tree": { zh: "树状数组", domain: "计算机", gloss: "借助二进制低位技巧维护前缀和，支持单点更新与区间求和。" },
+  "skip list": { zh: "跳表", domain: "计算机", gloss: "在有序链表上叠加多级索引，用随机层数换取近似二分的查找。" },
+  "red-black tree": { zh: "红黑树", domain: "计算机", gloss: "用颜色约束维持近似平衡的二叉搜索树，插入删除开销可控。" },
+  "avl tree": { zh: "平衡二叉树", domain: "计算机", gloss: "严格要求左右子树高度差不超过一的二叉搜索树，查询很稳定。" },
+  "binary tree": { zh: "二叉树", domain: "计算机", gloss: "每个节点最多有两个子节点的树形结构，是最基础的层级结构。" },
+  "binary search tree": { zh: "二叉搜索树", domain: "计算机", gloss: "左子树键都更小、右子树键都更大的二叉树，支持有序查找。" },
+  "linked list": { zh: "链表", domain: "计算机", gloss: "由节点通过指针串联成的线性结构，插入删除无需搬移元素。" },
+  "queue": { zh: "队列", domain: "计算机", gloss: "只允许一端入队、另一端出队的线性结构，遵循先进先出。" },
+  "deque": { zh: "双端队列", domain: "计算机", gloss: "两端都能插入和删除的队列，同时具备栈与队列的能力。" },
+  "priority queue": { zh: "优先队列", domain: "计算机", gloss: "每次取出当前优先级最高元素的队列，通常用堆来实现。" },
+  "circular buffer": { zh: "环形缓冲区", domain: "计算机", gloss: "首尾相接的定长缓冲，读写指针循环移动以复用同一块内存。" },
+  "adjacency list": { zh: "邻接表", domain: "计算机", gloss: "为每个顶点记录相邻顶点，稀疏图里比矩阵节省大量空间。" },
+  "adjacency matrix": { zh: "邻接矩阵", domain: "计算机", gloss: "用二维数组表示任意两点之间是否存在边，查询快但占空间。" },
+  "hash collision": { zh: "哈希冲突", domain: "计算机", gloss: "不同的键被哈希函数映射到同一位置，需要额外策略来化解。" },
+  "load factor": { zh: "装载因子", domain: "计算机", gloss: "哈希表中元素数量与桶数量的比值，过高会明显拖慢查询。" },
+  "open addressing": { zh: "开放寻址", domain: "计算机", gloss: "发生冲突时在表内继续探测下一个空位，而不是外挂链表。" },
+  "separate chaining": { zh: "链地址法", domain: "计算机", gloss: "把哈希到同一桶的元素串成链表，以此化解哈希冲突。" },
+  "cuckoo hashing": { zh: "布谷鸟哈希", domain: "计算机", gloss: "给每个键准备两个候选位置，冲突时把旧元素踢到它的备选位。" },
+  "radix sort": { zh: "基数排序", domain: "计算机", gloss: "按数字的每一位依次分配与收集，不比较关键字即可完成排序。" },
+  "counting sort": { zh: "计数排序", domain: "计算机", gloss: "统计每个取值出现的次数再按序还原，适合范围很小的整数。" },
+  "bucket sort": { zh: "桶排序", domain: "计算机", gloss: "把元素按区间分进若干桶，各桶内部排好序后再依次拼接。" },
+  "suffix array": { zh: "后缀数组", domain: "计算机", gloss: "把字符串全部后缀按字典序排好后记录起始位置的下标数组。" },
+  "suffix tree": { zh: "后缀树", domain: "计算机", gloss: "把字符串所有后缀压入一棵压缩树，用于快速子串与重复串查询。" },
+  "kmp algorithm": { zh: "字符串匹配算法", domain: "计算机", gloss: "利用模式串自身的部分匹配信息跳过无用比较的字符串查找算法。" },
+  "levenshtein distance": { zh: "编辑距离", domain: "计算机", gloss: "把两个字符串互相改写所需的最少插入、删除与替换次数。" },
+  "edit distance": { zh: "编辑距离", domain: "计算机", gloss: "衡量两个序列差异程度的代价，允许替换、插入和删除操作。" },
+  "longest common subsequence": { zh: "最长公共子序列", domain: "计算机", gloss: "两个序列在不改变相对顺序的前提下能共同拥有的最长子序列。" },
+  "knapsack problem": { zh: "背包问题", domain: "数学", gloss: "在容量限制下挑选物品使总价值最大，是经典的组合优化问题。" },
+  "traveling salesman": { zh: "旅行商问题", domain: "数学", gloss: "寻找访问每个城市一次并回到起点的最短路线，属难解问题。" },
+  "np-hard": { zh: "难解判定问题", domain: "数学", gloss: "难度不低于NP中任何问题的判定问题，目前没有已知多项式解法。" },
+  "np-complete": { zh: "完全难解问题", domain: "数学", gloss: "既属于NP又是NP难的问题，其中一个被快速求解则全部可解。" },
+  "p versus np": { zh: "计算复杂性难题", domain: "数学", gloss: "追问容易验证的问题是否也都容易求解，是理论计算机的未解难题。" },
+  "randomized algorithm": { zh: "随机算法", domain: "计算机", gloss: "执行中借助随机选择来获得期望性能或可控正确概率的算法。" },
+  "monte carlo method": { zh: "蒙特卡洛方法", domain: "数学", gloss: "通过大量随机抽样来估算难以精确求解的数量或概率。" },
+  "approximation algorithm": { zh: "近似算法", domain: "计算机", gloss: "在可接受时间内给出接近最优的解，并附带可证明的误差界。" },
+  "linear programming": { zh: "线性规划", domain: "数学", gloss: "在若干线性约束下求线性目标函数的最大值或最小值。" },
+  "loop invariant": { zh: "循环不变式", domain: "计算机", gloss: "在循环每次迭代前后都成立的性质，用来论证算法正确性。" },
+  "time complexity": { zh: "时间复杂度", domain: "计算机", gloss: "衡量算法运行耗时随输入规模增长的量级，而不是具体秒数。" },
+  "space complexity": { zh: "空间复杂度", domain: "计算机", gloss: "衡量算法额外占用的存储空间随输入规模增长的量级。" },
+  "master theorem": { zh: "主定理", domain: "数学", gloss: "由递归式的形式直接给出分治算法复杂度的通用判断结论。" },
+  "recurrence relation": { zh: "递推关系", domain: "数学", gloss: "用较小规模的结果来表达当前规模取值，常用于分析复杂度。" },
+  "tail recursion": { zh: "尾递归", domain: "软件工程", gloss: "递归调用位于函数最后一步，编译器可把它优化成普通循环。" },
+  "convex hull": { zh: "凸包", domain: "数学", gloss: "包含给定点集的最小凸多边形，常用于计算几何与路径规划。" },
+  "simulated annealing": { zh: "模拟退火", domain: "人工智能", gloss: "模仿金属冷却过程，以一定概率接受更差解来跳出局部最优。" },
+  "genetic algorithm": { zh: "遗传算法", domain: "人工智能", gloss: "模拟自然选择，通过交叉变异与淘汰逐代改进候选解。" },
+  "hill climbing": { zh: "爬山法", domain: "人工智能", gloss: "每次只朝能让目标变好的邻近方向移动的局部搜索方法。" },
+  "expectation maximization": { zh: "期望最大化", domain: "人工智能", gloss: "交替估计隐变量与模型参数，逐步抬高含隐变量模型似然的方法。" },
+  "branch and bound": { zh: "分支定界", domain: "计算机", gloss: "把解空间不断分支，并用界剪掉不可能更优的分支来加速搜索。" },
+  "shortest path": { zh: "最短路径", domain: "计算机", gloss: "在带权图中寻找两点之间总代价最小的走法，是经典图论问题。" },
+  "minimum spanning tree": { zh: "最小生成树", domain: "计算机", gloss: "用总权重最小的边把所有顶点连通的子图，常见于网络布线。" },
+  "dynamic array": { zh: "动态数组", domain: "计算机", gloss: "容量可自动翻倍扩容的连续数组，兼顾随机访问与追加写入。" },
+  "monotonic stack": { zh: "单调栈", domain: "计算机", gloss: "栈内元素保持单调有序，用来快速求出每个元素左右最近的更大值。" },
+  "tree traversal": { zh: "树遍历", domain: "计算机", gloss: "按固定顺序访问树中每个节点，分为前序、中序和后序等方式。" },
+  "matrix multiplication": { zh: "矩阵乘法", domain: "数学", gloss: "按行与列对应元素相乘再求和得到新矩阵的线性代数运算。" },
+  "sorting algorithm": { zh: "排序算法", domain: "计算机", gloss: "把一组元素按指定顺序重新排列的算法统称，关注稳定性与复杂度。" },
+  "search algorithm": { zh: "搜索算法", domain: "计算机", gloss: "在解空间或数据结构中定位目标元素或路径的方法统称。" },
+  "closure": { zh: "闭包", domain: "软件工程", gloss: "函数连同它定义时所在作用域中的变量一起被保存下来的组合。" },
+  "monad": { zh: "单子", domain: "软件工程", gloss: "把带副作用的计算串成流水线的一种抽象，常见于函数式语言。" },
+  "functor": { zh: "函子", domain: "软件工程", gloss: "可以被映射操作的结构，允许在不破坏外壳的前提下变换内部值。" },
+  "higher-order function": { zh: "高阶函数", domain: "软件工程", gloss: "接受函数作为参数、或者把函数作为结果返回的函数。" },
+  "first-class function": { zh: "一等函数", domain: "软件工程", gloss: "函数可以像普通值一样被赋值、传递和返回的语言特性。" },
+  "pure function": { zh: "纯函数", domain: "软件工程", gloss: "相同输入必定得到相同输出、且不修改外部状态的函数。" },
+  "side effect": { zh: "副作用", domain: "软件工程", gloss: "函数除返回值之外对外部世界造成的影响，例如改全局变量或写文件。" },
+  "referential transparency": { zh: "引用透明", domain: "软件工程", gloss: "表达式可以被它的计算结果直接替换而不改变程序行为的性质。" },
+  "lazy evaluation": { zh: "惰性求值", domain: "软件工程", gloss: "表达式直到真正需要结果时才计算，可以避免无用工作与死循环。" },
+  "eager evaluation": { zh: "及早求值", domain: "软件工程", gloss: "参数在函数调用前就先算好，是最常见的求值策略。" },
+  "garbage collection": { zh: "垃圾回收", domain: "软件工程", gloss: "运行环境自动找出不再被引用的对象并释放其内存的机制。" },
+  "reference counting": { zh: "引用计数", domain: "软件工程", gloss: "为每个对象记录被引用次数，归零即回收，但难处理循环引用。" },
+  "mark and sweep": { zh: "标记清除", domain: "软件工程", gloss: "从根对象出发标记所有可达对象，再统一清扫未标记的垃圾。" },
+  "generational gc": { zh: "分代回收", domain: "软件工程", gloss: "按对象存活时间分代，优先回收年轻代以降低整体回收开销。" },
+  "write barrier": { zh: "写屏障", domain: "软件工程", gloss: "在修改引用时插入的一小段代码，用来维持垃圾回收器需要的记录。" },
+  "tail call": { zh: "尾调用", domain: "软件工程", gloss: "函数最后一步调用另一个函数，可复用当前栈帧而不再压栈。" },
+  "reflection": { zh: "反射", domain: "软件工程", gloss: "程序在运行时检查并操作自身类型、字段与方法的能力。" },
+  "metaprogramming": { zh: "元编程", domain: "软件工程", gloss: "编写能生成或修改其他程序、类型的程序，把代码当作数据来操作。" },
+  "macro expansion": { zh: "宏展开", domain: "软件工程", gloss: "编译期把宏调用替换成它生成的代码片段的过程。" },
+  "hygienic macro": { zh: "卫生宏", domain: "软件工程", gloss: "展开时不会意外捕获或遮蔽调用处同名变量的宏机制。" },
+  "type inference": { zh: "类型推断", domain: "软件工程", gloss: "编译器根据上下文自动推导出表达式类型，无需处处手写标注。" },
+  "hindley-milner": { zh: "全推断类型系统", domain: "软件工程", gloss: "一种支持完整类型推断的多态类型系统，是许多函数式语言的基础。" },
+  "polymorphism": { zh: "多态", domain: "软件工程", gloss: "同一份代码可以作用于多种类型，是抽象与复用的重要手段。" },
+  "parametric polymorphism": { zh: "参数化多态", domain: "软件工程", gloss: "用类型参数写出对任意类型都成立的泛型代码。" },
+  "ad-hoc polymorphism": { zh: "特设多态", domain: "软件工程", gloss: "同一名字针对不同类型有不同实现，例如函数重载与运算符重载。" },
+  "subtype polymorphism": { zh: "子类型多态", domain: "软件工程", gloss: "通过继承或接口，让子类型对象在父类型位置被统一使用。" },
+  "variance": { zh: "型变", domain: "软件工程", gloss: "描述泛型类型参数在子类型关系下如何随之变化的规则。" },
+  "covariance": { zh: "协变", domain: "软件工程", gloss: "子类型关系在容器或返回值方向上保持一致，如猫的容器也是动物的容器。" },
+  "contravariance": { zh: "逆变", domain: "软件工程", gloss: "子类型关系在参数方向上发生反转，接收更宽类型的函数可替代更窄的。" },
+  "invariance": { zh: "不变", domain: "软件工程", gloss: "泛型参数之间不存在子类型继承关系，必须精确匹配类型。" },
+  "monomorphization": { zh: "单态化", domain: "软件工程", gloss: "编译期为每个具体类型分别生成一份泛型代码，以换取运行速度。" },
+  "type erasure": { zh: "类型擦除", domain: "软件工程", gloss: "编译后丢弃泛型参数信息，运行时无法再获知具体类型实参。" },
+  "boxed type": { zh: "装箱类型", domain: "软件工程", gloss: "把基本值包装成堆上对象，以便参与泛型或空值语义。" },
+  "interning": { zh: "驻留", domain: "软件工程", gloss: "把相同内容的值只保留一份共享实例，比较与存储都更省。" },
+  "string interning": { zh: "字符串驻留", domain: "软件工程", gloss: "相同字面量字符串共用同一份内存，使相等判断可以极快完成。" },
+  "thunk": { zh: "形实转换", domain: "软件工程", gloss: "为延迟计算而包装出的一段代码，调用时才真正求出结果。" },
+  "trampoline": { zh: "蹦床", domain: "软件工程", gloss: "用循环反复调用返回下一个函数的技巧，避免递归把调用栈撑爆。" },
+  "continuation": { zh: "续延", domain: "软件工程", gloss: "把程序剩余要做的事情表示成一个可调用的函数对象。" },
+  "continuation-passing style": { zh: "续延传递风格", domain: "软件工程", gloss: "把后续逻辑显式作为参数传给函数的写法，便于实现控制流变换。" },
+  "coroutine": { zh: "协程", domain: "软件工程", gloss: "可以主动挂起并在稍后从原处恢复执行的轻量并发单元。" },
+  "green thread": { zh: "绿色线程", domain: "软件工程", gloss: "由运行时而非操作系统调度的用户态线程，创建开销很小。" },
+  "fiber": { zh: "纤程", domain: "软件工程", gloss: "由程序自行调度的协作式执行单元，切换成本低于系统线程。" },
+  "async await": { zh: "异步等待", domain: "软件工程", gloss: "用近似同步的写法表达异步操作，等待期间让出执行权。" },
+  "event loop": { zh: "事件循环", domain: "软件工程", gloss: "不断取出并派发待处理事件或回调的单线程调度循环。" },
+  "callback": { zh: "回调", domain: "软件工程", gloss: "传给别处、在特定时机被反过来调用的函数。" },
+  "promise": { zh: "承诺对象", domain: "软件工程", gloss: "代表某个异步操作最终结果的对象，可链式接续成功与失败处理。" },
+  "generator": { zh: "生成器", domain: "软件工程", gloss: "能一次产出一个值并在两次产出之间挂起的函数或对象。" },
+  "iterator": { zh: "迭代器", domain: "软件工程", gloss: "按约定逐个暴露元素、直到结束的统一遍历接口。" },
+  "iterable": { zh: "可迭代对象", domain: "软件工程", gloss: "实现了迭代协议、能被循环逐个取值的对象。" },
+  "pattern matching": { zh: "模式匹配", domain: "软件工程", gloss: "按数据的结构与取值分支拆解并绑定变量，让分支逻辑更直观。" },
+  "algebraic data type": { zh: "代数数据类型", domain: "软件工程", gloss: "由若干构造子组合而成的类型，用来精确表达可选的多种形状。" },
+  "sum type": { zh: "和类型", domain: "软件工程", gloss: "取值只能是若干情形之一，也叫标签联合类型。" },
+  "product type": { zh: "积类型", domain: "软件工程", gloss: "同时包含多个字段的复合类型，取值是各字段取值的组合。" },
+  "tagged union": { zh: "标签联合", domain: "软件工程", gloss: "用一个标签字段标明当前有效分支的联合类型。" },
+  "option type": { zh: "可选类型", domain: "软件工程", gloss: "显式表示有值或无值两种状态的类型，用来替代空指针。" },
+  "immutability": { zh: "不可变性", domain: "软件工程", gloss: "对象创建后状态不再改变，从而天然免于并发修改与意外篡改。" },
+  "persistent data structure": { zh: "持久化数据结构", domain: "软件工程", gloss: "修改时保留旧版本、新旧版本可同时访问的数据结构。" },
+  "structural sharing": { zh: "结构共享", domain: "软件工程", gloss: "新旧版本共用未改动的部分内存，使复制版本的开销很小。" },
+  "copy on write": { zh: "写时复制", domain: "软件工程", gloss: "共享数据直到有人要修改时才真正复制一份，读多写少时很省。" },
+  "ownership": { zh: "所有权", domain: "软件工程", gloss: "由编译器追踪每块内存归属、超出作用域即释放的规则。" },
+  "borrow checker": { zh: "借用检查器", domain: "软件工程", gloss: "编译期验证引用不会悬垂也不会与可变借用冲突的分析器。" },
+  "lifetime": { zh: "生命周期", domain: "软件工程", gloss: "标注引用有效范围的约束，用于保证引用始终指向存活的数据。" },
+  "move semantics": { zh: "移动语义", domain: "软件工程", gloss: "把资源所有权从一个对象转交给另一个，而不是深拷贝。" },
+  "zero-cost abstraction": { zh: "零开销抽象", domain: "软件工程", gloss: "高层写法编译后不额外付费，抽象不带来运行时代价。" },
+  "duck typing": { zh: "鸭子类型", domain: "软件工程", gloss: "只看对象是否具备所需方法，而不关心它的声明类型。" },
+  "structural typing": { zh: "结构化类型", domain: "软件工程", gloss: "类型是否相容由成员结构决定，而不是由名字或继承关系决定。" },
+  "nominal typing": { zh: "名义类型", domain: "软件工程", gloss: "类型相容由显式声明或继承关系决定，结构相同也未必兼容。" },
+  "trait": { zh: "特质", domain: "软件工程", gloss: "定义一组可被多种类型实现的行为契约，用于横向复用代码。" },
+  "generic programming": { zh: "泛型编程", domain: "软件工程", gloss: "用类型参数编写与具体类型无关、可复用的算法与容器。" },
+  "template metaprogramming": { zh: "模板元编程", domain: "软件工程", gloss: "借模板实例化在编译期完成计算与代码生成的技巧。" },
+  "jit compilation": { zh: "即时编译", domain: "软件工程", gloss: "运行时把热点字节码编译成机器码，兼顾启动速度与执行效率。" },
+  "ahead-of-time compilation": { zh: "提前编译", domain: "软件工程", gloss: "在运行之前就把源码整体编译成目标机器码的方式。" },
+  "bytecode": { zh: "字节码", domain: "软件工程", gloss: "介于源码与机器码之间的中间指令，由虚拟机解释或编译执行。" },
+  "interpreter": { zh: "解释器", domain: "软件工程", gloss: "逐条读取并直接执行程序指令、不预先生成机器码的程序。" },
+  "compiler": { zh: "编译器", domain: "软件工程", gloss: "把一种语言的源码翻译成另一种语言或机器码的程序。" },
+  "transpiler": { zh: "转译器", domain: "软件工程", gloss: "在相近抽象层次的语言之间做源码到源码翻译的工具。" },
+  "linker": { zh: "链接器", domain: "软件工程", gloss: "把多个目标文件与库合并、解析符号引用后生成可执行文件。" },
+  "static linking": { zh: "静态链接", domain: "软件工程", gloss: "编译期把库代码直接复制进可执行文件，运行时不再依赖外部库。" },
+  "dynamic linking": { zh: "动态链接", domain: "软件工程", gloss: "运行时才加载共享库并解析符号，多个程序可共用同一份库。" },
+  "symbol table": { zh: "符号表", domain: "软件工程", gloss: "记录标识符名称与其类型、地址等属性的编译期数据结构。" },
+  "abstract syntax tree": { zh: "抽象语法树", domain: "软件工程", gloss: "用树形节点表示程序语法结构的中间形式，供分析与代码生成使用。" },
+  "parser": { zh: "语法分析器", domain: "软件工程", gloss: "按语法规则把词法单元序列组织成语法树的程序模块。" },
+  "lexer": { zh: "词法分析器", domain: "软件工程", gloss: "把源字符流切分成标识符、数字、运算符等词法单元的程序模块。" },
+  "grammar": { zh: "文法", domain: "软件工程", gloss: "描述一门语言合法句子结构的规则集合，供解析器使用。" },
+  "backus-naur form": { zh: "巴科斯范式", domain: "软件工程", gloss: "用产生式规则描述编程语言语法的标准记法。" },
+  "exception": { zh: "异常", domain: "软件工程", gloss: "打断正常流程、沿调用栈向上传播直到被捕获的错误信号。" },
+  "stack unwinding": { zh: "栈展开", domain: "软件工程", gloss: "异常抛出后逐层退出栈帧并执行清理逻辑的过程。" },
+  "destructor": { zh: "析构函数", domain: "软件工程", gloss: "对象销毁时自动调用、用来释放其占用资源的特殊方法。" },
+  "finalizer": { zh: "终结器", domain: "软件工程", gloss: "对象被回收前由运行时调用的清理钩子，执行时机并不确定。" },
+  "raii": { zh: "资源获取即初始化", domain: "软件工程", gloss: "把资源生命周期绑定到对象作用域，离开作用域自动释放。" },
+  "smart pointer": { zh: "智能指针", domain: "软件工程", gloss: "封装裸指针并自动管理所指向对象生命周期的包装类型。" },
+  "weak reference": { zh: "弱引用", domain: "软件工程", gloss: "不阻止对象被回收的引用，用于打破循环依赖或做缓存。" },
+  "memory leak": { zh: "内存泄漏", domain: "软件工程", gloss: "不再使用的内存仍被引用而无法回收，长期运行会耗尽内存。" },
+  "stack overflow": { zh: "栈溢出", domain: "软件工程", gloss: "调用层级过深耗尽线程栈空间，通常由无限递归引起。" },
+  "buffer overflow": { zh: "缓冲区溢出", domain: "安全", gloss: "写入超出缓冲区边界的数据，可能覆盖相邻内存并被利用来攻击。" },
+  "undefined behavior": { zh: "未定义行为", domain: "软件工程", gloss: "语言标准未规定结果的操作，编译器可以做任意优化假设。" },
+  "prototype chain": { zh: "原型链", domain: "软件工程", gloss: "对象沿着一串原型逐级向上查找属性或方法的继承机制。" },
+  "virtual machine": { zh: "虚拟机", domain: "软件工程", gloss: "用软件模拟出的计算机环境，在其上运行特定指令集或操作系统。" },
+  "virtual dispatch": { zh: "虚方法分发", domain: "软件工程", gloss: "运行时根据对象真实类型决定调用哪个重写方法的机制。" },
+  "vtable": { zh: "虚函数表", domain: "软件工程", gloss: "每个多态类型存放方法地址的表，供运行时查找正确实现。" },
+  "mixin": { zh: "混入", domain: "软件工程", gloss: "把一组可复用方法注入到类中、而不作为父类的组合手段。" },
+  "decorator": { zh: "装饰器", domain: "软件工程", gloss: "在不改动原代码的前提下为函数或类附加额外行为的语法设施。" },
+  "annotation": { zh: "注解", domain: "软件工程", gloss: "附加在代码元素上的元数据，供编译器或框架在运行期读取。" },
+  "aspect-oriented programming": { zh: "面向切面编程", domain: "软件工程", gloss: "把日志、事务等横切关注点从业务代码中抽取出来统一织入。" },
+  "multiple inheritance": { zh: "多重继承", domain: "软件工程", gloss: "一个类同时继承多个父类，会带来菱形冲突等复杂问题。" },
+  "dependency injection": { zh: "依赖注入", domain: "软件工程", gloss: "由外部把对象所需的依赖传进来，而不是让对象自己创建，便于替换与测试。" },
+  "inversion of control": { zh: "控制反转", domain: "软件工程", gloss: "把创建与调度的控制权交给框架，业务代码只负责被动响应。" },
+  "idempotent": { zh: "幂等", domain: "软件工程", gloss: "同一操作执行一次与执行多次对系统状态的影响完全相同。" },
+  "eventual consistency": { zh: "最终一致性", domain: "系统", gloss: "停止写入后副本经过一段时间会收敛到相同状态，但中途可能读到旧值。" },
+  "circuit breaker": { zh: "熔断器", domain: "运维", gloss: "下游错误率超阈值时快速失败并暂停调用，避免故障被放大。" },
+  "backpressure": { zh: "背压", domain: "运维", gloss: "当下游处理不过来时向上游反馈减速，防止队列无限堆积。" },
+  "sharding": { zh: "分片", domain: "系统", gloss: "按某个键把数据切分到多个节点，用水平扩展突破单机上限。" },
+  "replication lag": { zh: "复制延迟", domain: "系统", gloss: "从库追不上主库写入进度的时间差，会造成读到过期数据。" },
+  "two-phase commit": { zh: "两阶段提交", domain: "系统", gloss: "先让所有参与者表决、再统一提交或回滚的分布式事务协议。" },
+  "three-phase commit": { zh: "三阶段提交", domain: "系统", gloss: "在两阶段提交中插入预提交阶段，减少参与者长期阻塞的风险。" },
+  "saga pattern": { zh: "长事务补偿模式", domain: "软件工程", gloss: "把长事务拆成一串本地事务，失败时逐步执行补偿动作来回退。" },
+  "cqrs": { zh: "命令查询职责分离", domain: "软件工程", gloss: "把写入命令与读取查询分成两条模型路径，各自优化扩展。" },
+  "event sourcing": { zh: "事件溯源", domain: "软件工程", gloss: "不保存最终状态而保存全部事件，靠重放事件重建当前状态。" },
+  "hexagonal architecture": { zh: "六边形架构", domain: "软件工程", gloss: "把业务核心与外部接口隔离，通过端口和适配器连接外部世界。" },
+  "bounded context": { zh: "限界上下文", domain: "软件工程", gloss: "同一术语含义明确且一致的业务边界，边界外可另作定义。" },
+  "ubiquitous language": { zh: "通用语言", domain: "软件工程", gloss: "业务专家与开发者在同一上下文中共同使用、含义统一的一套词汇。" },
+  "domain-driven design": { zh: "领域驱动设计", domain: "软件工程", gloss: "以业务领域模型为核心来组织复杂软件结构的方法论。" },
+  "aggregate root": { zh: "聚合根", domain: "软件工程", gloss: "一组相关对象中对外唯一入口，负责维护整体一致性边界。" },
+  "value object": { zh: "值对象", domain: "软件工程", gloss: "没有独立标识、仅由属性取值决定相等性的不可变对象。" },
+  "repository pattern": { zh: "仓储模式", domain: "软件工程", gloss: "用类似集合的接口屏蔽底层存储细节，让领域层专注业务规则。" },
+  "unit of work": { zh: "工作单元", domain: "软件工程", gloss: "把一批改动收集起来、在结束时统一提交或回滚的事务边界对象。" },
+  "factory pattern": { zh: "工厂模式", domain: "软件工程", gloss: "把对象创建过程封装到专门的方法或类中，调用方无需了解细节。" },
+  "singleton pattern": { zh: "单例模式", domain: "软件工程", gloss: "保证一个类只有一个实例并提供全局访问点的创建型模式。" },
+  "observer pattern": { zh: "观察者模式", domain: "软件工程", gloss: "被观察者状态变化时自动通知一组订阅者，实现一对多解耦。" },
+  "strategy pattern": { zh: "策略模式", domain: "软件工程", gloss: "把可互换的算法各自封装，运行时可替换而不改动调用方。" },
+  "adapter pattern": { zh: "适配器模式", domain: "软件工程", gloss: "把不兼容的接口转换成调用方期望的形状，使两者能协作。" },
+  "decorator pattern": { zh: "装饰器模式", domain: "软件工程", gloss: "在运行时给对象动态叠加职责，比继承更灵活地扩展功能。" },
+  "facade pattern": { zh: "外观模式", domain: "软件工程", gloss: "为一组复杂子系统提供一个简化入口，降低调用方的心智负担。" },
+  "proxy pattern": { zh: "代理模式", domain: "软件工程", gloss: "用一个替身对象控制对真实对象的访问，可附加缓存、鉴权等逻辑。" },
+  "mvc": { zh: "模型视图控制器", domain: "软件工程", gloss: "把数据模型、界面展示与输入处理分成三部分的经典架构模式。" },
+  "mvvm": { zh: "模型视图视图模型", domain: "软件工程", gloss: "在界面与数据之间加一层可绑定视图模型，双向同步界面状态。" },
+  "solid principles": { zh: "面向对象五原则", domain: "软件工程", gloss: "五条面向对象设计准则的合称，目标是让代码易扩展、易维护。" },
+  "single responsibility": { zh: "单一职责", domain: "软件工程", gloss: "一个模块只应有一个引起它变化的原因，只承担一类职责。" },
+  "open-closed principle": { zh: "开闭原则", domain: "软件工程", gloss: "软件实体应对扩展开放、对修改关闭，新增功能尽量不改旧代码。" },
+  "liskov substitution": { zh: "里氏替换", domain: "软件工程", gloss: "子类型对象必须能替换父类型而不破坏程序的既有正确性。" },
+  "interface segregation": { zh: "接口隔离", domain: "软件工程", gloss: "把臃肿接口拆成多个小而专的接口，避免使用者被迫依赖无用方法。" },
+  "dependency inversion": { zh: "依赖倒置", domain: "软件工程", gloss: "高层与低层都依赖抽象，抽象不依赖实现细节。" },
+  "dry principle": { zh: "避免重复原则", domain: "软件工程", gloss: "每一处知识在系统中都应有唯一且权威的表达，避免重复。" },
+  "yagni": { zh: "按需实现原则", domain: "软件工程", gloss: "你不会需要它：只实现当下确实需要的功能，别为想象的需求买单。" },
+  "separation of concerns": { zh: "关注点分离", domain: "软件工程", gloss: "把不同职责的问题切分开，各自独立演化、互不干扰。" },
+  "cohesion": { zh: "内聚", domain: "软件工程", gloss: "模块内部各元素围绕同一目标协作的紧密程度，越高越好。" },
+  "coupling": { zh: "耦合", domain: "软件工程", gloss: "模块之间相互依赖的程度，越低越容易独立修改与替换。" },
+  "code review": { zh: "代码评审", domain: "软件工程", gloss: "由同伴在合入前检查代码，以发现缺陷并统一风格与设计。" },
+  "pair programming": { zh: "结对编程", domain: "软件工程", gloss: "两人共用一台机器，一人写代码一人实时审查与思考。" },
+  "test-driven development": { zh: "测试驱动开发", domain: "软件工程", gloss: "先写失败的测试，再写实现让测试通过，最后重构的循环。" },
+  "behavior-driven development": { zh: "行为驱动开发", domain: "软件工程", gloss: "用贴近业务语言的场景描述来驱动开发与验收测试。" },
+  "unit test": { zh: "单元测试", domain: "软件工程", gloss: "针对单个函数或类、隔离外部依赖的快速自动化测试。" },
+  "integration test": { zh: "集成测试", domain: "软件工程", gloss: "验证多个模块或真实外部依赖协同工作时是否正确。" },
+  "end-to-end test": { zh: "端到端测试", domain: "软件工程", gloss: "从用户入口到最终结果完整走通全链路的自动化验证。" },
+  "regression test": { zh: "回归测试", domain: "软件工程", gloss: "确认新改动没有破坏原有功能的测试，通常反复执行。" },
+  "smoke test": { zh: "冒烟测试", domain: "软件工程", gloss: "只覆盖最关键路径的快速检查，确认版本基本可用。" },
+  "load test": { zh: "负载测试", domain: "软件工程", gloss: "在预期压力下测量吞吐与响应时间，验证容量是否达标。" },
+  "stress test": { zh: "压力测试", domain: "软件工程", gloss: "持续加大压力直到系统崩溃，找出极限与最先失效的环节。" },
+  "mutation testing": { zh: "变异测试", domain: "软件工程", gloss: "故意改动代码看测试能否发现，用来衡量测试本身的有效性。" },
+  "code coverage": { zh: "代码覆盖率", domain: "软件工程", gloss: "被测试执行到的代码比例，是参考指标而非质量保证。" },
+  "flaky test": { zh: "不稳定测试", domain: "软件工程", gloss: "同一代码多次运行结果时好时坏的测试，会侵蚀对测试的信任。" },
+  "mock": { zh: "模拟对象", domain: "软件工程", gloss: "在测试中替代真实依赖、可预设返回值并断言调用的假对象。" },
+  "stub": { zh: "桩对象", domain: "软件工程", gloss: "为测试提供固定返回值的简化替身，通常不校验调用行为。" },
+  "fixture": { zh: "测试夹具", domain: "软件工程", gloss: "测试运行前准备好的固定数据或环境，保证用例可重复。" },
+  "continuous integration": { zh: "持续集成", domain: "软件工程", gloss: "开发者频繁合并代码，每次合入都自动构建并跑测试。" },
+  "continuous delivery": { zh: "持续交付", domain: "软件工程", gloss: "保持代码随时可发布，但由人工决定何时真正上线。" },
+  "continuous deployment": { zh: "持续部署", domain: "软件工程", gloss: "通过全部自动化检查后自动发布到生产环境，无需人工干预。" },
+  "trunk-based development": { zh: "主干开发", domain: "软件工程", gloss: "所有人向同一条主干频繁提交小改动，避免长期分支分叉。" },
+  "feature flag": { zh: "功能开关", domain: "软件工程", gloss: "用配置开关控制新功能是否对用户可见，无需重新部署。" },
+  "semantic versioning": { zh: "语义化版本", domain: "软件工程", gloss: "用主版本、次版本、修订号表达兼容性变化的版本编号约定。" },
+  "deprecation": { zh: "弃用", domain: "软件工程", gloss: "标记某个接口或功能即将移除，提醒使用者尽快迁移。" },
+  "backwards compatibility": { zh: "向后兼容", domain: "软件工程", gloss: "新版本仍能正确读取或调用旧版本产生的数据与接口。" },
+  "contract testing": { zh: "契约测试", domain: "软件工程", gloss: "独立验证服务双方对接口请求响应的约定是否一致。" },
+  "schema registry": { zh: "模式注册表", domain: "数据", gloss: "集中存放并校验消息结构版本的仓库，保证上下游兼容。" },
+  "message queue": { zh: "消息队列", domain: "系统", gloss: "在生产者与消费者之间缓存消息、实现异步与削峰填谷的中间件。" },
+  "publish subscribe": { zh: "发布订阅", domain: "系统", gloss: "发布者把消息投到主题，多个订阅者各自收到副本的解耦模式。" },
+  "dead letter queue": { zh: "死信队列", domain: "系统", gloss: "存放多次重试仍失败消息的队列，供人工排查而不阻塞正常流程。" },
+  "retry storm": { zh: "重试风暴", domain: "运维", gloss: "故障时大量客户端同时重试，把本已吃紧的服务彻底压垮。" },
+  "fail fast": { zh: "快速失败", domain: "软件工程", gloss: "发现问题立即报错退出，避免带着错误状态继续运行。" },
+  "graceful degradation": { zh: "优雅降级", domain: "运维", gloss: "部分能力不可用时关闭次要功能，保证核心链路继续服务。" },
+  "graceful shutdown": { zh: "优雅停机", domain: "运维", gloss: "停止服务前先拒绝新请求并处理完在途请求再退出。" },
+  "health check": { zh: "健康检查", domain: "运维", gloss: "由外部定期探测服务是否正常，异常时触发下线或重启。" },
+  "readiness probe": { zh: "就绪探针", domain: "运维", gloss: "判断实例是否已准备好接收流量，未就绪就不导入负载。" },
+  "liveness probe": { zh: "存活探针", domain: "运维", gloss: "判断进程是否卡死，失败时由平台重启该实例。" },
+  "twelve-factor app": { zh: "十二要素应用", domain: "软件工程", gloss: "十二条构建可移植云原生服务的实践准则的合称。" },
+  "strangler fig": { zh: "绞杀者模式", domain: "软件工程", gloss: "在旧系统外围逐步替换功能，直到旧实现被完全取代。" },
+  "anti-corruption layer": { zh: "防腐层", domain: "软件工程", gloss: "在新旧模型之间做转换的隔离层，防止外来概念污染核心领域。" },
+  "domain event": { zh: "领域事件", domain: "软件工程", gloss: "描述业务上已发生且值得关注的事情，用于触发后续处理。" },
+  "compensating transaction": { zh: "补偿事务", domain: "系统", gloss: "为撤销已完成的步骤而执行的逆向业务操作，用于柔性事务。" },
+  "transactional outbox": { zh: "事务性发件箱", domain: "系统", gloss: "把待发消息与业务数据写在同一事务，再由后台可靠投递。" },
+  "orchestration": { zh: "编排", domain: "软件工程", gloss: "由一个中心协调者按流程依次驱动各参与者完成整体业务。" },
+  "choreography": { zh: "协同编排", domain: "软件工程", gloss: "各服务只听事件自行反应、没有中心指挥的去中心化协作方式。" },
+  "bulkhead": { zh: "舱壁隔离", domain: "运维", gloss: "按资源池隔离不同调用，使一处故障不会耗尽全部线程或连接。" },
+  "technical debt": { zh: "技术债务", domain: "软件工程", gloss: "为求短期速度而做的妥协，将来要付出额外成本来偿还。" },
+  "refactoring": { zh: "重构", domain: "软件工程", gloss: "在不改变外部行为的前提下调整代码结构，使其更易理解与修改。" },
+  "code smell": { zh: "代码坏味道", domain: "软件工程", gloss: "结构上暗示存在更深设计问题的征兆，提示应当重构。" },
+  "clean architecture": { zh: "整洁架构", domain: "软件工程", gloss: "让依赖只由外向内指向业务核心的分层组织方式。" },
+  "layered architecture": { zh: "分层架构", domain: "软件工程", gloss: "把系统按职责分成若干层，上层可调用下层、反之不行。" },
+  "microservice": { zh: "微服务", domain: "软件工程", gloss: "按业务能力拆成独立部署、各自拥有数据的小型服务。" },
+  "modular monolith": { zh: "模块化单体", domain: "软件工程", gloss: "仍是一个部署单元，但内部按模块严格划清边界的架构。" },
+  "monolith": { zh: "单体应用", domain: "软件工程", gloss: "所有功能打包在同一个部署单元中运行的传统架构形态。" },
+  "service-oriented architecture": { zh: "面向服务架构", domain: "软件工程", gloss: "把能力封装成可复用服务、通过标准协议互相调用的架构风格。" },
+  "api gateway": { zh: "接口网关", domain: "系统", gloss: "所有外部请求的统一入口，负责路由、鉴权、限流与协议转换。" },
+  "domain model": { zh: "领域模型", domain: "软件工程", gloss: "用对象与关系刻画业务概念和规则的软件表示。" },
+  "lint": { zh: "静态检查", domain: "软件工程", gloss: "不运行代码就扫描潜在错误与风格问题并给出提示。" },
+  "dependency hell": { zh: "依赖地狱", domain: "软件工程", gloss: "多个库互相要求不兼容的版本，导致无法同时满足而装不上。" },
+  "vendor lock-in": { zh: "供应商锁定", domain: "产品", gloss: "深度依赖某家厂商的专有接口，迁移成本高到难以更换。" },
+  "quorum": { zh: "法定人数", domain: "系统", gloss: "分布式决策所需的最少同意节点数，通常为多数派，以避免脑裂。" },
+  "leader election": { zh: "领导者选举", domain: "系统", gloss: "集群自动选出唯一主节点来协调写入，并在故障后重新选主。" },
+  "split brain": { zh: "脑裂", domain: "系统", gloss: "网络分区后两侧各自认为自己是主，导致数据被并行修改。" },
+  "vector clock": { zh: "向量时钟", domain: "系统", gloss: "用每个节点的计数向量刻画事件先后，可判定并发或因果关系。" },
+  "lamport timestamp": { zh: "兰波特时间戳", domain: "系统", gloss: "给分布式事件编号以确定全序的逻辑时钟，但不反映真实时间。" },
+  "hybrid logical clock": { zh: "混合逻辑时钟", domain: "系统", gloss: "结合物理时钟与逻辑计数，兼顾时间接近真实与因果一致。" },
+  "gossip protocol": { zh: "流言协议", domain: "系统", gloss: "节点随机两两交换信息，像谣言一样把状态扩散到整个集群。" },
+  "cap theorem": { zh: "分布式取舍定理", domain: "系统", gloss: "一致性、可用性与分区容忍三者最多同时满足两个的分布式结论。" },
+  "pacelc": { zh: "延迟一致权衡", domain: "系统", gloss: "在CAP之外补充：无分区时也要在延迟与一致性之间做取舍。" },
+  "service mesh": { zh: "服务网格", domain: "运维", gloss: "把服务间通信的流量治理能力下沉到独立数据面的基础设施层。" },
+  "sidecar": { zh: "边车", domain: "运维", gloss: "与主容器同生共死、替它处理代理或日志等辅助工作的伴生容器。" },
+  "blue-green deployment": { zh: "蓝绿部署", domain: "运维", gloss: "同时运行两套环境，验证好新版本后一次性把流量切过去。" },
+  "canary release": { zh: "金丝雀发布", domain: "运维", gloss: "先让极少量用户使用新版本，观察指标正常再逐步扩大范围。" },
+  "canary": { zh: "金丝雀", domain: "运维", gloss: "在正式全量之前先行试跑的那一小批实例或用户。" },
+  "rolling update": { zh: "滚动更新", domain: "运维", gloss: "分批替换实例、每批确认健康后再继续，实现不停机发布。" },
+  "rate limiting": { zh: "限流", domain: "运维", gloss: "限制单位时间内允许的请求数量，保护后端不被突发流量击穿。" },
+  "load shedding": { zh: "过载丢弃", domain: "运维", gloss: "系统过载时主动丢弃部分请求，以保住整体服务质量。" },
+  "cold start": { zh: "冷启动", domain: "运维", gloss: "实例首次被调用时需要初始化，导致这次请求明显变慢。" },
+  "autoscaling": { zh: "自动扩缩容", domain: "运维", gloss: "依据负载指标自动增减实例数量，兼顾成本与承载能力。" },
+  "horizontal scaling": { zh: "水平扩展", domain: "系统", gloss: "通过增加机器数量来提升整体处理能力。" },
+  "vertical scaling": { zh: "垂直扩展", domain: "系统", gloss: "通过升级单机配置来提升处理能力，受硬件上限约束。" },
+  "capacity planning": { zh: "容量规划", domain: "运维", gloss: "根据业务增长预估所需资源并提前准备，避免临时扩容不及。" },
+  "observability": { zh: "可观测性", domain: "运维", gloss: "仅凭系统对外输出的指标、日志与链路就能推断内部状态的能力。" },
+  "tracing": { zh: "链路追踪", domain: "运维", gloss: "为一次请求沿途打上标识，串起跨服务调用以定位耗时与故障。" },
+  "distributed tracing": { zh: "分布式链路追踪", domain: "运维", gloss: "跨多个进程与服务还原单次请求完整路径的追踪技术。" },
+  "span": { zh: "跨度", domain: "运维", gloss: "链路追踪中的一个操作单元，记录起止时间与父子关系。" },
+  "telemetry": { zh: "遥测数据", domain: "运维", gloss: "系统自动上报的指标、日志和链路等运行数据的总称。" },
+  "metric": { zh: "指标", domain: "运维", gloss: "按时间采集的数值型观测数据，如请求量、延迟与错误率。" },
+  "alert fatigue": { zh: "告警疲劳", domain: "运维", gloss: "告警过多过滥使值班人员逐渐麻木，反而漏掉真正重要的告警。" },
+  "runbook": { zh: "运维手册", domain: "运维", gloss: "针对特定故障写好的标准处置步骤，值班时照做即可。" },
+  "postmortem": { zh: "故障复盘", domain: "运维", gloss: "事故后梳理时间线、根因与改进项，重点是机制而非追责。" },
+  "blameless postmortem": { zh: "无责复盘", domain: "运维", gloss: "假设人是善意的，只分析系统与流程缺陷而不追究个人责任。" },
+  "incident": { zh: "生产事故", domain: "运维", gloss: "已经影响线上服务可用性或数据正确性的突发问题。" },
+  "on-call": { zh: "值班待命", domain: "运维", gloss: "由轮值工程师随时响应告警并处置线上问题的制度。" },
+  "toil": { zh: "重复性运维劳动", domain: "运维", gloss: "可自动化、重复、无长期价值的体力型运维工作。" },
+  "sla": { zh: "服务水平协议", domain: "运维", gloss: "服务等级协议（Service Level Agreement），与客户约定的可用性与响应承诺。" },
+  "slo": { zh: "服务水平目标", domain: "运维", gloss: "服务等级目标（Service Level Objective），团队内部设定的可量化质量目标。" },
+  "sli": { zh: "服务水平指标", domain: "运维", gloss: "服务等级指标（Service Level Indicator），用来衡量目标达成情况的实测值。" },
+  "error budget": { zh: "错误预算", domain: "运维", gloss: "允许的不可用额度，用完就应停止发布并优先修复稳定性。" },
+  "profiling": { zh: "性能剖析", domain: "运维", gloss: "采样统计程序各部分的耗时与内存占用，找出真正的瓶颈。" },
+  "flame graph": { zh: "火焰图", domain: "运维", gloss: "把调用栈耗时按宽度堆叠展示的图形，能一眼看出热点函数。" },
+  "chaos engineering": { zh: "混沌工程", domain: "运维", gloss: "主动在生产或类生产环境注入故障，验证系统的容错能力。" },
+  "fault injection": { zh: "故障注入", domain: "运维", gloss: "人为制造延迟、错误或宕机，观察系统是否按预期降级恢复。" },
+  "distributed lock": { zh: "分布式锁", domain: "系统", gloss: "跨进程互斥访问共享资源的机制，通常依赖共识或租约实现。" },
+  "lease": { zh: "租约", domain: "系统", gloss: "带有效期的授权，到期未续约即自动失效，避免持有者失联后死锁。" },
+  "fencing token": { zh: "隔离令牌", domain: "系统", gloss: "随租约递增的编号，存储端据此拒绝过期持有者的旧写入。" },
+  "raft": { zh: "易解共识算法", domain: "系统", gloss: "通过选主与日志复制达成一致的共识算法，以易理解著称。" },
+  "paxos": { zh: "经典共识算法", domain: "系统", gloss: "经典的分布式共识算法，在多数派同意后才确定某个取值。" },
+  "partition tolerance": { zh: "分区容忍", domain: "系统", gloss: "网络被割裂成互不通话的多块时系统仍能继续运行的能力。" },
+  "network partition": { zh: "网络分区", domain: "系统", gloss: "由于网络故障，集群被切成几组彼此无法通信的节点。" },
+  "replication": { zh: "副本复制", domain: "系统", gloss: "把同一份数据保存到多个节点，以提高可用性与读取吞吐。" },
+  "leaderless replication": { zh: "无主复制", domain: "系统", gloss: "任何节点都可接受读写、靠法定人数与修复来收敛的复制方式。" },
+  "read-your-writes": { zh: "写后读一致", domain: "系统", gloss: "同一个人写入后立刻读取，保证能看到自己刚写的内容。" },
+  "monotonic read": { zh: "单调读", domain: "系统", gloss: "一旦读到某个版本，后续读取不会再看到更旧的版本。" },
+  "strong consistency": { zh: "强一致性", domain: "系统", gloss: "任何时刻任何节点读到的都是最新已提交的数据。" },
+  "linearizability": { zh: "线性一致性", domain: "系统", gloss: "所有操作看起来按某个全局顺序瞬时生效，且与真实时间相容。" },
+  "serializability": { zh: "可串行化", domain: "数据", gloss: "并发事务的执行结果等价于它们按某个先后顺序串行执行。" },
+  "snapshot isolation": { zh: "快照隔离", domain: "数据", gloss: "事务读取开始时的一致快照，写冲突则在提交时检测并回滚。" },
+  "anti-entropy": { zh: "反熵修复", domain: "系统", gloss: "后台比对副本差异并补齐缺失数据，使集群最终趋于一致。" },
+  "merkle tree": { zh: "默克尔树", domain: "系统", gloss: "逐层哈希构成的树，可高效比对两份大数据集是否一致。" },
+  "crdt": { zh: "无冲突复制类型", domain: "系统", gloss: "可并发修改并自动合并、无需协调即可收敛的数据类型。" },
+  "write amplification": { zh: "写放大", domain: "数据", gloss: "一次逻辑写入在底层引发的实际写入量远大于一的现象。" },
+  "compaction": { zh: "压缩合并", domain: "数据", gloss: "把多个小文件或有重叠的段合并整理，减少碎片并回收空间。" },
+  "tombstone": { zh: "墓碑标记", domain: "数据", gloss: "用一条特殊记录表示某键已被删除，等待后续合并时真正清理。" },
+  "heartbeat": { zh: "心跳", domain: "系统", gloss: "节点周期性发出的存活信号，超时未收到即判定其失联。" },
+  "failure detector": { zh: "故障检测器", domain: "系统", gloss: "依据心跳与超时判断其他节点是否已经失效的组件。" },
+  "byzantine fault": { zh: "拜占庭故障", domain: "系统", gloss: "节点不仅失效还可能返回错误或恶意结果的最棘手故障类型。" },
+  "byzantine generals": { zh: "拜占庭将军问题", domain: "系统", gloss: "在存在叛徒且消息可能失真时，如何让各方达成一致的思想实验。" },
+  "two generals problem": { zh: "两将军问题", domain: "系统", gloss: "在不可靠信道上无法百分百确认对方是否收到确认的经典难题。" },
+  "at-least-once delivery": { zh: "至少一次投递", domain: "系统", gloss: "保证消息不丢但可能重复，消费端需自行做幂等处理。" },
+  "at-most-once delivery": { zh: "至多一次投递", domain: "系统", gloss: "消息至多被处理一次，允许丢失但不会重复。" },
+  "exactly-once semantics": { zh: "精确一次语义", domain: "系统", gloss: "消息恰好被处理一次，需要去重或事务机制配合才能实现。" },
+  "message ordering": { zh: "消息顺序", domain: "系统", gloss: "保证消息按发送或分区内的既定次序被消费的约束。" },
+  "queue depth": { zh: "队列深度", domain: "系统", gloss: "队列中尚未被消费的消息数量，是判断积压程度的核心指标。" },
+  "throughput": { zh: "吞吐量", domain: "系统", gloss: "单位时间内系统能够处理完成的请求或数据量。" },
+  "latency": { zh: "延迟", domain: "系统", gloss: "从发出请求到收到响应所经历的时间，通常关注分位值。" },
+  "tail latency": { zh: "尾延迟", domain: "系统", gloss: "最慢那一小部分请求的耗时，往往决定用户实际体感。" },
+  "p99 latency": { zh: "长尾延迟分位", domain: "系统", gloss: "把请求按耗时排序后第99百分位对应的值，反映长尾表现。" },
+  "jitter": { zh: "抖动", domain: "网络", gloss: "延迟的波动程度，抖动大时实时音视频体验明显变差。" },
+  "packet loss": { zh: "丢包", domain: "网络", gloss: "数据包在传输途中被丢弃，会触发重传并拖慢整体速度。" },
+  "mtu": { zh: "最大传输单元", domain: "网络", gloss: "最大传输单元（Maximum Transmission Unit），单个数据帧能承载的最大字节数。" },
+  "nat": { zh: "网络地址转换", domain: "网络", gloss: "网络地址转换（Network Address Translation），让多台内网主机共用公网地址。" },
+  "subnet": { zh: "子网", domain: "网络", gloss: "从大网段中按掩码切出的更小地址范围，便于隔离与管理。" },
+  "cidr": { zh: "无类别域间路由", domain: "网络", gloss: "无类别域间路由（Classless Inter-Domain Routing），用斜杠后缀表示网段大小的地址记法。" },
+  "bgp": { zh: "边界网关协议", domain: "网络", gloss: "边界网关协议（Border Gateway Protocol），互联网各自治域之间交换路由信息的协议。" },
+  "anycast": { zh: "任播", domain: "网络", gloss: "同一地址在多处宣告，用户被路由到最近的一个节点。" },
+  "multicast": { zh: "组播", domain: "网络", gloss: "一份数据同时发送给加入某组播组的多台主机，节省带宽。" },
+  "load balancer": { zh: "负载均衡器", domain: "网络", gloss: "把请求按策略分发到多个后端实例，并剔除不健康的节点。" },
+  "reverse proxy": { zh: "反向代理", domain: "网络", gloss: "代表服务器接收外部请求并转发，隐藏后端拓扑并可缓存。" },
+  "forward proxy": { zh: "正向代理", domain: "网络", gloss: "代表客户端向外发起请求，常用于访问控制与匿名上网。" },
+  "ingress": { zh: "入口流量", domain: "运维", gloss: "从集群外部进入内部服务的网络流量及其对应的接入规则。" },
+  "egress": { zh: "出口流量", domain: "运维", gloss: "从内部服务主动发往外部网络的流量，通常需要单独管控。" },
+  "http2": { zh: "二版超文本协议", domain: "网络", gloss: "支持多路复用与头部压缩的HTTP协议第二版，单连接可并发多请求。" },
+  "http3": { zh: "三版超文本协议", domain: "网络", gloss: "基于QUIC的HTTP新版本，用UDP减少队头阻塞并加快连接建立。" },
+  "quic": { zh: "快速传输协议", domain: "网络", gloss: "在UDP之上实现可靠传输与加密的协议，建连快且支持连接迁移。" },
+  "websocket": { zh: "全双工通信协议", domain: "网络", gloss: "在单个TCP连接上提供全双工通信的协议，适合实时推送。" },
+  "kubernetes": { zh: "容器编排平台", domain: "运维", gloss: "容器编排平台，负责调度、扩缩容、自愈与服务发现。" },
+  "container": { zh: "容器", domain: "运维", gloss: "借助内核隔离把进程与依赖打包在一起的轻量运行单元。" },
+  "helm": { zh: "容器包管理器", domain: "运维", gloss: "把Kubernetes资源清单模板化并成套安装升级的包管理工具。" },
+  "terraform": { zh: "声明式资源编排", domain: "运维", gloss: "用声明式配置文件描述并管理云资源的编排工具。" },
+  "infrastructure as code": { zh: "基础设施即代码", domain: "运维", gloss: "用可版本化的配置文件而非手工操作来定义和变更基础设施。" },
+  "immutable infrastructure": { zh: "不可变基础设施", domain: "运维", gloss: "实例一旦部署不再原地修改，变更靠替换成新镜像来完成。" },
+  "serverless": { zh: "无服务器", domain: "运维", gloss: "由平台按需分配运行资源，使用者只写函数并按调用量付费。" },
+  "function as a service": { zh: "函数即服务", domain: "运维", gloss: "把单个函数作为部署单元、由事件触发并按用量计费的云服务形态。" },
+  "edge computing": { zh: "边缘计算", domain: "系统", gloss: "把计算与缓存放在离用户更近的节点，以降低延迟与回源压力。" },
+  "availability zone": { zh: "可用区", domain: "运维", gloss: "同一地域内电力与网络相互独立的机房集群，用于交叉容灾。" },
+  "region": { zh: "地域", domain: "运维", gloss: "云厂商划分的独立地理区域，区域内多个可用区通过低延迟网络互联。" },
+  "disaster recovery": { zh: "灾难恢复", domain: "运维", gloss: "在机房或地域整体失效后恢复业务的能力、流程与预案。" },
+  "rto": { zh: "恢复时间目标", domain: "运维", gloss: "恢复时间目标（Recovery Time Objective），灾难后业务可容忍的中断时长。" },
+  "rpo": { zh: "恢复点目标", domain: "运维", gloss: "恢复点目标（Recovery Point Objective），灾难中可容忍丢失的数据时间跨度。" },
+  "backup": { zh: "备份", domain: "运维", gloss: "把数据另行复制保存，用于误删或灾难后恢复到某个时间点。" },
+  "snapshot": { zh: "快照", domain: "运维", gloss: "某一时刻数据或存储卷的只读映像，可用于快速回滚。" },
+  "secrets management": { zh: "密钥管理", domain: "安全", gloss: "集中存放、按权限分发并轮换口令与密钥，避免硬编码在代码里。" },
+  "config map": { zh: "配置字典", domain: "运维", gloss: "把配置与镜像解耦、可独立更新的键值配置载体。" },
+  "vpc": { zh: "虚拟私有云", domain: "网络", gloss: "虚拟私有云（Virtual Private Cloud），在公有云里划出的逻辑隔离网络。" },
+  "dns": { zh: "域名系统", domain: "网络", gloss: "域名系统（Domain Name System），把人类可读的域名解析成IP地址。" },
+  "cdn": { zh: "内容分发网络", domain: "网络", gloss: "内容分发网络（Content Delivery Network），把静态资源缓存到离用户最近的节点。" },
+  "qps": { zh: "每秒查询数", domain: "运维", gloss: "每秒查询数（Queries Per Second），衡量服务请求处理速率的常用指标。" },
+  "ttl": { zh: "生存时间", domain: "网络", gloss: "生存时间（Time To Live），数据或缓存条目在过期失效前可存活的时间。" },
+  "lru": { zh: "最近最少使用", domain: "计算机", gloss: "最近最少使用（Least Recently Used），优先淘汰最久未被访问数据的缓存策略。" },
+  "lfu": { zh: "最不经常使用", domain: "计算机", gloss: "最不经常使用（Least Frequently Used），优先淘汰访问次数最少数据的缓存策略。" },
+  "mvcc": { zh: "多版本并发控制", domain: "数据", gloss: "多版本并发控制（Multi-Version Concurrency Control），让读写互不阻塞地看到各自版本。" },
+  "nonce": { zh: "一次性随机数", domain: "安全", gloss: "只使用一次的随机值，用来防止重放并保证同一条消息只被处理一次。" },
+  "salt": { zh: "盐值", domain: "安全", gloss: "哈希口令时额外混入的随机串，使相同口令得到不同摘要、抵御彩虹表。" },
+  "key derivation": { zh: "密钥派生", domain: "安全", gloss: "由口令或主密钥经过刻意缓慢的运算派生出实际使用的密钥。" },
+  "zero-knowledge proof": { zh: "零知识证明", domain: "安全", gloss: "证明者能在不泄露具体内容的前提下让对方相信自己知道某个秘密。" },
+  "homomorphic encryption": { zh: "同态加密", domain: "安全", gloss: "可以直接在密文上做运算、解密后结果与明文运算一致的加密方式。" },
+  "certificate pinning": { zh: "证书锁定", domain: "安全", gloss: "客户端只信任预先内置的特定证书或公钥，防止被伪造证书中间人攻击。" },
+  "csrf": { zh: "跨站请求伪造", domain: "安全", gloss: "跨站请求伪造（Cross-Site Request Forgery），诱骗已登录用户浏览器发出非本人意愿的请求。" },
+  "ssrf": { zh: "服务端请求伪造", domain: "安全", gloss: "服务端请求伪造（Server-Side Request Forgery），诱导服务器去访问攻击者指定的内网地址。" },
+  "xss": { zh: "跨站脚本", domain: "安全", gloss: "跨站脚本（Cross-Site Scripting），把恶意脚本注入页面并在他人浏览器中执行。" },
+  "sql injection": { zh: "数据库注入攻击", domain: "安全", gloss: "把恶意片段拼进查询语句，从而越权读取或篡改数据库内容。" },
+  "timing attack": { zh: "时序攻击", domain: "安全", gloss: "通过测量运算耗时差异来推断密钥或口令的旁路攻击手法。" },
+  "ddos": { zh: "分布式拒绝服务", domain: "安全", gloss: "分布式拒绝服务（Distributed Denial of Service），用海量流量耗尽目标资源使其无法服务。" },
+  "man-in-the-middle": { zh: "中间人攻击", domain: "安全", gloss: "攻击者插入通信双方之间，既能窃听也能篡改双方看到的内容。" },
+  "replay attack": { zh: "重放攻击", domain: "安全", gloss: "截获合法报文后原样再发一次，冒充合法请求重复生效。" },
+  "brute force": { zh: "暴力破解", domain: "安全", gloss: "穷举所有可能的密钥或口令组合，直到试出正确的那一个。" },
+  "rainbow table": { zh: "彩虹表", domain: "安全", gloss: "预先算好的口令哈希对照表，用于快速反查常见口令的明文。" },
+  "digital signature": { zh: "数字签名", domain: "安全", gloss: "用私钥对摘要签名、任何人都能用公钥验证来源与完整性的机制。" },
+  "public key cryptography": { zh: "公钥密码学", domain: "安全", gloss: "加密与解密使用不同密钥，公钥可公开、私钥必须保密。" },
+  "symmetric encryption": { zh: "对称加密", domain: "安全", gloss: "加密与解密共用同一把密钥，速度快但密钥分发是难点。" },
+  "asymmetric encryption": { zh: "非对称加密", domain: "安全", gloss: "使用公钥与私钥配对运算，解决密钥分发问题但速度较慢。" },
+  "aes": { zh: "高级加密标准", domain: "安全", gloss: "高级加密标准（Advanced Encryption Standard），广泛使用的分组对称加密算法。" },
+  "rsa": { zh: "公钥加密算法", domain: "安全", gloss: "基于大整数分解困难的非对称加密与签名算法，以三位发明者命名。" },
+  "elliptic curve": { zh: "椭圆曲线密码", domain: "安全", gloss: "基于椭圆曲线离散对数难题的密码体制，密钥更短而强度相当。" },
+  "diffie-hellman": { zh: "密钥协商算法", domain: "安全", gloss: "双方在公开信道上协商出共享密钥、而窃听者无法推算的协议。" },
+  "key exchange": { zh: "密钥交换", domain: "安全", gloss: "通信双方安全地协商出本次会话所用密钥的过程。" },
+  "perfect forward secrecy": { zh: "完美前向保密", domain: "安全", gloss: "每次会话使用独立临时密钥，长期私钥泄露也无法解密历史记录。" },
+  "certificate authority": { zh: "证书颁发机构", domain: "安全", gloss: "受信任的第三方，负责签发和吊销证明公钥归属的数字证书。" },
+  "x509": { zh: "公钥证书标准", domain: "安全", gloss: "规定公钥证书格式与校验规则的国际标准，HTTPS依赖它建立信任。" },
+  "ssl": { zh: "安全套接层", domain: "安全", gloss: "安全套接层（Secure Sockets Layer），TLS的前身，现已基本被取代。" },
+  "https": { zh: "安全超文本传输", domain: "安全", gloss: "在HTTP之下套用TLS加密，保证传输内容不被窃听或篡改。" },
+  "hsts": { zh: "严格传输安全", domain: "安全", gloss: "严格传输安全（HTTP Strict Transport Security），强制浏览器此后只用HTTPS访问本站。" },
+  "csp": { zh: "内容安全策略", domain: "安全", gloss: "内容安全策略（Content Security Policy），用白名单限制页面可加载与执行的资源。" },
+  "cors": { zh: "跨域资源共享", domain: "安全", gloss: "跨域资源共享（Cross-Origin Resource Sharing），由服务端声明允许哪些跨域请求。" },
+  "same-origin policy": { zh: "同源策略", domain: "安全", gloss: "浏览器只允许同协议同域名同端口的页面互相读取数据的隔离规则。" },
+  "openid connect": { zh: "身份认证协议", domain: "安全", gloss: "建立在OAuth之上的身份认证层，用标准令牌告诉应用你是谁。" },
+  "multi-factor authentication": { zh: "多因素认证", domain: "安全", gloss: "在口令之外再要求手机验证码或硬件密钥等第二种凭证。" },
+  "password hashing": { zh: "口令哈希", domain: "安全", gloss: "只保存口令的单向摘要、并在校验时重算比对，避免明文泄露。" },
+  "bcrypt": { zh: "慢速口令哈希", domain: "安全", gloss: "专为口令设计的慢哈希算法，可通过调高代价参数抵御暴力破解。" },
+  "argon2": { zh: "抗硬件口令哈希", domain: "安全", gloss: "口令哈希竞赛胜出算法，同时消耗内存与计算以抵抗专用硬件破解。" },
+  "side-channel attack": { zh: "旁路攻击", domain: "安全", gloss: "不破解算法本身，而是利用耗时、功耗或电磁泄露推断秘密信息。" },
+  "privilege escalation": { zh: "权限提升", domain: "安全", gloss: "攻击者从低权限账户获取更高权限，进而控制整个系统。" },
+  "rce": { zh: "远程代码执行", domain: "安全", gloss: "远程代码执行（Remote Code Execution），攻击者能让目标服务器运行任意代码。" },
+  "cve": { zh: "通用漏洞披露", domain: "安全", gloss: "通用漏洞披露（Common Vulnerabilities and Exposures），公开漏洞的唯一编号标识。" },
+  "zero-day": { zh: "零日漏洞", domain: "安全", gloss: "厂商尚未发布补丁就已被利用的漏洞，防御方几乎没有准备时间。" },
+  "exploit": { zh: "漏洞利用", domain: "安全", gloss: "针对特定漏洞编写的攻击代码或手法，用来取得非预期的控制权。" },
+  "malware": { zh: "恶意软件", domain: "安全", gloss: "以窃取数据、加密勒索或远程控制为目的的软件统称。" },
+  "ransomware": { zh: "勒索软件", domain: "安全", gloss: "加密受害者文件并索要赎金才肯解密的恶意程序。" },
+  "phishing": { zh: "网络钓鱼", domain: "安全", gloss: "伪装成可信机构骗取账号口令或诱导转账的欺诈手段。" },
+  "social engineering": { zh: "社会工程", domain: "安全", gloss: "利用人的信任与疏忽而非技术漏洞来获取敏感信息。" },
+  "penetration testing": { zh: "渗透测试", domain: "安全", gloss: "在授权范围内模拟攻击者，主动发现系统可被入侵的路径。" },
+  "threat model": { zh: "威胁模型", domain: "安全", gloss: "系统梳理要防谁、防什么以及资产边界，作为安全设计的前提。" },
+  "attack surface": { zh: "攻击面", domain: "安全", gloss: "系统暴露给外界、可被攻击者尝试利用的全部入口之和。" },
+  "defense in depth": { zh: "纵深防御", domain: "安全", gloss: "叠加多层不同手段的防护，使单点失效也不至于全盘沦陷。" },
+  "least privilege": { zh: "最小权限", domain: "安全", gloss: "只授予完成当前任务所必需的权限，减少被滥用的范围。" },
+  "fuzz testing": { zh: "模糊测试", domain: "安全", gloss: "自动生成大量畸形输入喂给程序，以触发崩溃和潜在漏洞。" },
+  "supply chain attack": { zh: "供应链攻击", domain: "安全", gloss: "通过污染依赖库、构建工具或更新渠道来入侵下游用户。" },
+  "dependency confusion": { zh: "依赖混淆", domain: "安全", gloss: "利用内外网同名包，诱使构建系统拉取攻击者上传的高版本包。" },
+  "encryption at rest": { zh: "静态加密", domain: "安全", gloss: "对落盘存储的数据加密，磁盘或备份被盗时内容仍不可读。" },
+  "encryption in transit": { zh: "传输加密", domain: "安全", gloss: "对网络上流动的数据加密，防止中途被窃听或篡改。" },
+  "kms": { zh: "密钥管理服务", domain: "安全", gloss: "密钥管理服务（Key Management Service），集中生成、存储与轮换加密密钥。" },
+  "hsm": { zh: "硬件安全模块", domain: "安全", gloss: "硬件安全模块（Hardware Security Module），专门保管密钥且密钥不出设备的硬件。" },
+  "message authentication code": { zh: "消息认证码", domain: "安全", gloss: "用共享密钥为消息生成短标签，验证其来源与未被篡改。" },
+  "hmac": { zh: "哈希消息认证码", domain: "安全", gloss: "哈希消息认证码（Hash-based Message Authentication Code），用密钥与哈希共同校验消息完整性。" },
+  "initialization vector": { zh: "初始化向量", domain: "安全", gloss: "配合密钥使用的随机起点，使相同明文每次加密得到不同密文。" },
+  "cipher suite": { zh: "密码套件", domain: "安全", gloss: "一次TLS连接所约定的密钥交换、加密与校验算法组合。" },
+  "access token": { zh: "访问令牌", domain: "安全", gloss: "代表已授权身份、用于调用受保护接口的短期凭证。" },
+  "refresh token": { zh: "刷新令牌", domain: "安全", gloss: "用于在访问令牌过期后换取新令牌的长期凭证，需严格保管。" },
+  "session hijacking": { zh: "会话劫持", domain: "安全", gloss: "窃取或伪造会话凭证，冒充已登录用户继续操作。" },
+  "waf": { zh: "应用层防火墙", domain: "安全", gloss: "Web应用防火墙（Web Application Firewall），按规则拦截SQL注入、跨站脚本等应用层攻击。" },
+  "api": { zh: "应用程序接口", domain: "软件工程", gloss: "应用编程接口（Application Programming Interface），软件之间约定好的调用契约。" },
+  "sdk": { zh: "软件开发工具包", domain: "软件工程", gloss: "软件开发工具包（Software Development Kit），封装好接口与工具、便于接入某平台的一整套库。" },
+  "cli": { zh: "命令行界面", domain: "软件工程", gloss: "命令行界面（Command-Line Interface），通过敲命令而不是点界面来操作程序。" },
+  "orm": { zh: "对象关系映射", domain: "数据", gloss: "对象关系映射（Object-Relational Mapping），把数据库表与程序对象互相转换的框架。" },
+  "dsl": { zh: "领域特定语言", domain: "软件工程", gloss: "领域特定语言（Domain-Specific Language），为某一类问题专门设计的表达语言。" },
+  "oop": { zh: "面向对象编程", domain: "软件工程", gloss: "面向对象编程（Object-Oriented Programming），用对象封装数据与行为来组织程序。" },
+  "etl": { zh: "抽取转换加载", domain: "数据", gloss: "抽取转换加载（Extract-Transform-Load），把源系统数据经清洗转换后写入目标仓库。" },
+  "rpc": { zh: "远程过程调用", domain: "系统", gloss: "远程过程调用（Remote Procedure Call），像调用本地函数一样调用另一台机器上的服务。" },
+  "grpc": { zh: "远程调用框架", domain: "系统", gloss: "基于HTTP/2与Protocol Buffers的高性能远程调用框架，支持流式传输。" },
+  "rest": { zh: "表述性状态转移", domain: "软件工程", gloss: "表述性状态转移（Representational State Transfer），用资源与标准HTTP动词设计接口的风格。" },
+  "tls": { zh: "传输层安全", domain: "安全", gloss: "传输层安全（Transport Layer Security），为网络连接提供加密与身份校验的协议。" },
+  "jwt": { zh: "网络身份令牌", domain: "安全", gloss: "JSON网络令牌（JSON Web Token），把声明签名后放在字符串里传递身份信息。" },
+  "oauth": { zh: "开放授权", domain: "安全", gloss: "开放授权（Open Authorization），让第三方在不知晓口令的情况下获得受限访问权。" },
+  "ssr": { zh: "服务端渲染", domain: "软件工程", gloss: "服务端渲染（Server-Side Rendering），在服务器生成完整HTML再发给浏览器以加快首屏。" },
+  "csr": { zh: "客户端渲染", domain: "软件工程", gloss: "客户端渲染（Client-Side Rendering），先下发空壳页面再由浏览器执行脚本渲染内容。" },
+  "acid": { zh: "事务四特性", domain: "数据", gloss: "原子性、一致性、隔离性与持久性（Atomicity, Consistency, Isolation, Durability），关系数据库的事务保证。" },
+  "base": { zh: "基本可用软状态", domain: "数据", gloss: "基本可用、软状态、最终一致（Basically Available, Soft state, Eventually consistent），牺牲强一致换取可用性的思路。" },
+  "crud": { zh: "增删改查", domain: "数据", gloss: "创建、读取、更新、删除（Create, Read, Update, Delete），对数据最常见的四种基本操作。" },
+  "saas": { zh: "软件即服务", domain: "产品", gloss: "软件即服务（Software as a Service），厂商直接提供可用的在线软件，用户按订阅付费。" },
+  "paas": { zh: "平台即服务", domain: "产品", gloss: "平台即服务（Platform as a Service），厂商托管运行时与中间件，用户只部署应用。" },
+  "iaas": { zh: "基础设施即服务", domain: "产品", gloss: "基础设施即服务（Infrastructure as a Service），按需租用虚拟机、存储与网络等底层资源。" },
+  "attention mechanism": { zh: "注意力机制", domain: "人工智能", gloss: "让模型按相关度为输入的各个部分动态分配权重的计算方式。" },
+  "self-attention": { zh: "自注意力", domain: "人工智能", gloss: "序列中每个位置都与其余位置互相计算相关度并聚合信息。" },
+  "transformer": { zh: "变换器", domain: "人工智能", gloss: "完全基于注意力搭建的神经网络架构，是当今大语言模型的基础。" },
+  "embedding": { zh: "嵌入向量", domain: "人工智能", gloss: "把词语、图片等离散对象映射成稠密向量，使语义相近者距离更近。" },
+  "tokenization": { zh: "分词", domain: "人工智能", gloss: "把原始文本切分成模型能处理的最小单元序列的过程。" },
+  "token": { zh: "词元", domain: "人工智能", gloss: "模型处理文本的最小单位，可能是一个词、一个子词或一个字符。" },
+  "vocabulary": { zh: "词表", domain: "人工智能", gloss: "分词器与模型共同使用的全部词元及其编号的集合。" },
+  "byte pair encoding": { zh: "字节对编码", domain: "人工智能", gloss: "反复合并最高频相邻字节对的子词切分算法，能兼顾词表与未登录词。" },
+  "out-of-vocabulary": { zh: "未登录词", domain: "人工智能", gloss: "不在词表中、模型无法直接表示的词或字符。" },
+  "fine-tuning": { zh: "微调", domain: "人工智能", gloss: "在预训练模型基础上用领域数据继续训练，使其适配特定任务。" },
+  "lora": { zh: "低秩适配", domain: "人工智能", gloss: "低秩适配（Low-Rank Adaptation），只训练插入的小型低秩矩阵即可微调大模型。" },
+  "qlora": { zh: "量化低秩适配", domain: "人工智能", gloss: "把基座模型量化到低位宽再做LoRA微调，大幅降低显存需求。" },
+  "peft": { zh: "参数高效微调", domain: "人工智能", gloss: "参数高效微调（Parameter-Efficient Fine-Tuning），只更新极少量参数来适配下游任务。" },
+  "adapter": { zh: "适配器模块", domain: "人工智能", gloss: "插在预训练层之间的小型可训练模块，换任务时只替换它。" },
+  "quantization": { zh: "量化", domain: "人工智能", gloss: "把模型权重或激活从高精度压到低比特，以省显存并加速推理。" },
+  "distillation": { zh: "蒸馏", domain: "人工智能", gloss: "让小模型学习大模型的输出分布，以较小体量逼近其能力。" },
+  "knowledge distillation": { zh: "知识蒸馏", domain: "人工智能", gloss: "用教师模型的软标签指导学生模型训练，迁移其学到的隐含知识。" },
+  "pruning": { zh: "剪枝", domain: "人工智能", gloss: "删掉贡献很小的权重、通道或层，在精度损失可控下压缩模型。" },
+  "sparsity": { zh: "稀疏性", domain: "人工智能", gloss: "参数或激活中大量元素为零，可利用它跳过无用的计算。" },
+  "beam search": { zh: "束搜索", domain: "人工智能", gloss: "解码时同时保留若干条最优候选路径，逐步扩展以减少贪心短视。" },
+  "greedy decoding": { zh: "贪心解码", domain: "人工智能", gloss: "每一步都直接选概率最高的词元，速度快但容易错过更优整句。" },
+  "temperature": { zh: "温度参数", domain: "人工智能", gloss: "调节输出概率分布尖锐程度的参数，越大越发散、越小越确定。" },
+  "top-p sampling": { zh: "核采样", domain: "人工智能", gloss: "只在累计概率达到阈值的最小词元集合中随机抽取下一个词。" },
+  "top-k sampling": { zh: "限定候选采样", domain: "人工智能", gloss: "每一步只从概率最高的K个候选词中随机抽取一个。" },
+  "sampling": { zh: "随机采样", domain: "人工智能", gloss: "按概率分布随机选择下一个输出，使相同提示也能生成不同结果。" },
+  "logits": { zh: "逻辑值", domain: "人工智能", gloss: "softmax之前、模型对每个候选词元给出的原始打分。" },
+  "softmax": { zh: "归一化指数", domain: "人工智能", gloss: "把一组实数转成和为1的概率分布，放大较大值之间的差距。" },
+  "hallucination": { zh: "幻觉", domain: "人工智能", gloss: "模型自信地生成看似合理却与事实不符或凭空捏造的内容。" },
+  "context window": { zh: "上下文窗口", domain: "人工智能", gloss: "模型一次能读取并参与计算的词元数量上限。" },
+  "long context": { zh: "长上下文", domain: "人工智能", gloss: "把窗口扩展到数万乃至上百万词元，以便一次处理整本书或整个仓库。" },
+  "prompt injection": { zh: "提示注入", domain: "人工智能", gloss: "把恶意指令混进模型读取的内容中，劫持它原本的任务。" },
+  "prompt engineering": { zh: "提示工程", domain: "人工智能", gloss: "通过设计指令、示例与格式来稳定提升模型输出质量的方法。" },
+  "system prompt": { zh: "系统提示", domain: "人工智能", gloss: "在对话最前面设定角色、边界与风格的固定指令。" },
+  "prompt template": { zh: "提示模板", domain: "人工智能", gloss: "带占位符的提示骨架，填入变量后即可复用同一套指令。" },
+  "in-context learning": { zh: "上下文学习", domain: "人工智能", gloss: "不更新参数，仅靠提示中给出的示例让模型学会新任务。" },
+  "few-shot learning": { zh: "少样本学习", domain: "人工智能", gloss: "只提供少量示例就完成新任务的学习或提示方式。" },
+  "zero-shot learning": { zh: "零样本学习", domain: "人工智能", gloss: "不给任何示例，仅凭任务描述直接让模型作答。" },
+  "chain of thought": { zh: "思维链", domain: "人工智能", gloss: "让模型先写出中间推理步骤再给结论，可显著提升复杂题正确率。" },
+  "tree of thought": { zh: "思维树", domain: "人工智能", gloss: "把推理展开成多分支并搜索评估，而不是只走一条线性链条。" },
+  "self-consistency": { zh: "自洽投票", domain: "人工智能", gloss: "多次采样不同推理路径，取出现次数最多的答案作为最终结果。" },
+  "scratchpad": { zh: "草稿区", domain: "人工智能", gloss: "留给模型先演算再回答的中间文本区域，不计入最终答案。" },
+  "retrieval-augmented generation": { zh: "检索增强生成", domain: "人工智能", gloss: "先检索相关资料再交给模型作答，以缓解幻觉并注入私有知识。" },
+  "rag": { zh: "检索增强生成", domain: "人工智能", gloss: "检索增强生成（Retrieval-Augmented Generation），把外部知识检索结果拼进提示再生成答案。" },
+  "reranking": { zh: "重排序", domain: "人工智能", gloss: "对初步召回的候选做更精细打分，把最相关的排到最前面。" },
+  "chunking": { zh: "分块", domain: "人工智能", gloss: "把长文档切成大小合适的片段，便于向量化与精准检索。" },
+  "vector database": { zh: "向量数据库", domain: "人工智能", gloss: "专门存储与检索高维向量的数据库，支持近似最近邻搜索。" },
+  "approximate nearest neighbor": { zh: "近似最近邻", domain: "人工智能", gloss: "用索引以少量精度损失换取海量向量中的快速检索。" },
+  "hnsw": { zh: "分层可导航小世界", domain: "人工智能", gloss: "分层可导航小世界（Hierarchical Navigable Small World），常用的高维向量近邻索引结构。" },
+  "inverted index": { zh: "倒排索引", domain: "数据", gloss: "记录每个词出现在哪些文档中，是全文检索的核心结构。" },
+  "bm25": { zh: "经典检索打分", domain: "人工智能", gloss: "综合词频、逆文档频率与长度归一化的经典检索相关性打分函数。" },
+  "semantic search": { zh: "语义检索", domain: "人工智能", gloss: "按向量表示的语义相似度查找内容，而不依赖字面关键词匹配。" },
+  "dense retrieval": { zh: "稠密检索", domain: "人工智能", gloss: "用连续向量表示查询与文档，通过向量内积或距离召回。" },
+  "sparse retrieval": { zh: "稀疏检索", domain: "人工智能", gloss: "基于词项权重的传统检索方式，可解释性强且对精确词匹配敏感。" },
+  "hybrid search": { zh: "混合检索", domain: "人工智能", gloss: "同时使用关键词检索与向量检索，再融合两路结果取长补短。" },
+  "knowledge graph": { zh: "知识图谱", domain: "人工智能", gloss: "用实体与关系构成的有向图来组织结构化知识。" },
+  "ontology": { zh: "本体", domain: "人工智能", gloss: "对某一领域中概念、属性及其相互关系的形式化定义。" },
+  "mixture of experts": { zh: "混合专家", domain: "人工智能", gloss: "模型内含多组专家网络，每次只激活少数几个以降低计算量。" },
+  "kv cache": { zh: "键值缓存", domain: "人工智能", gloss: "缓存已算过的注意力键值，避免生成每个新词时重复计算历史。" },
+  "paged attention": { zh: "分页注意力", domain: "人工智能", gloss: "像操作系统分页那样管理键值缓存，减少显存碎片并提高并发。" },
+  "flash attention": { zh: "分块高效注意力", domain: "人工智能", gloss: "通过分块与重计算减少显存读写，显著加速注意力计算的实现。" },
+  "speculative decoding": { zh: "投机解码", domain: "人工智能", gloss: "先用小模型草拟多个词，再由大模型一次并行校验，从而加速生成。" },
+  "prefix caching": { zh: "前缀缓存", domain: "人工智能", gloss: "把相同提示前缀的中间结果缓存复用，降低重复请求的算力开销。" },
+  "positional encoding": { zh: "位置编码", domain: "人工智能", gloss: "把词序信息注入模型，使注意力机制能够区分先后位置。" },
+  "rotary embedding": { zh: "旋转位置编码", domain: "人工智能", gloss: "用旋转矩阵编码相对位置，外推到更长上下文时表现更稳。" },
+  "rlhf": { zh: "人类反馈强化学习", domain: "人工智能", gloss: "人类反馈强化学习（Reinforcement Learning from Human Feedback），用人工偏好训练奖励模型再优化生成策略。" },
+  "rlaif": { zh: "机器反馈强化学习", domain: "人工智能", gloss: "AI反馈强化学习（Reinforcement Learning from AI Feedback），用模型代替人来提供偏好信号。" },
+  "dpo": { zh: "直接偏好优化", domain: "人工智能", gloss: "直接偏好优化（Direct Preference Optimization），跳过奖励模型直接用偏好数据优化策略。" },
+  "ppo": { zh: "近端策略优化", domain: "人工智能", gloss: "近端策略优化（Proximal Policy Optimization），限制每次策略更新幅度的强化学习算法。" },
+  "reward model": { zh: "奖励模型", domain: "人工智能", gloss: "学习人类偏好、为模型输出打分的模型，用于指导策略优化。" },
+  "reward hacking": { zh: "奖励欺骗", domain: "人工智能", gloss: "模型钻奖励函数的空子拿到高分，却没有真正完成目标。" },
+  "instruction tuning": { zh: "指令微调", domain: "人工智能", gloss: "用大量指令与回答数据训练，使模型更愿意按要求完成任务。" },
+  "supervised fine-tuning": { zh: "有监督微调", domain: "人工智能", gloss: "用人工标注的优质问答对继续训练预训练模型。" },
+  "alignment": { zh: "对齐", domain: "人工智能", gloss: "让模型的行为与人类意图和价值观保持一致的技术方向。" },
+  "constitutional ai": { zh: "原则约束对齐", domain: "人工智能", gloss: "给模型一套明文原则，让它据此自我批评与修正输出。" },
+  "guardrails": { zh: "护栏", domain: "人工智能", gloss: "在模型输入输出两侧加设的过滤与约束，阻止有害或越界内容。" },
+  "red teaming": { zh: "红队测试", domain: "人工智能", gloss: "主动扮演攻击者去诱导模型越界，以发现安全与合规缺口。" },
+  "jailbreak": { zh: "越狱提示", domain: "人工智能", gloss: "用特殊话术绕过模型的安全限制，使其输出本应拒绝的内容。" },
+  "agent": { zh: "智能体", domain: "人工智能", gloss: "能自主规划、调用工具并根据结果迭代直到完成目标的模型程序。" },
+  "tool use": { zh: "工具调用", domain: "人工智能", gloss: "模型按需调用搜索、计算或代码执行等外部能力来完成任务。" },
+  "function calling": { zh: "函数调用", domain: "人工智能", gloss: "模型输出结构化参数，由宿主程序代为执行对应函数的机制。" },
+  "multi-agent": { zh: "多智能体", domain: "人工智能", gloss: "多个智能体分工协作或相互评审，共同完成复杂任务。" },
+  "self-reflection": { zh: "自我反思", domain: "人工智能", gloss: "智能体检查自己的中间结果与错误并据此修正下一步行动。" },
+  "react prompting": { zh: "推理行动循环", domain: "人工智能", gloss: "让模型交替进行推理与行动，边想边调用工具以推进任务。" },
+  "model context protocol": { zh: "模型上下文协议", domain: "人工智能", gloss: "模型上下文协议（Model Context Protocol），把工具与数据源以标准接口接入模型的开放协议。" },
+  "seed": { zh: "随机种子", domain: "人工智能", gloss: "固定随机数生成的起点，使实验在相同条件下可复现。" },
+  "determinism": { zh: "确定性", domain: "人工智能", gloss: "相同输入与参数下总是得到相同输出，是复现实验结果的前提。" },
+  "needle in a haystack": { zh: "大海捞针测试", domain: "人工智能", gloss: "在超长文本中埋入一条信息，检验模型能否准确找出来。" },
+  "catastrophic forgetting": { zh: "灾难性遗忘", domain: "人工智能", gloss: "学习新任务后原有能力明显退化，是持续学习的主要难点。" },
+  "continual learning": { zh: "持续学习", domain: "人工智能", gloss: "模型在不断到来的新数据上持续更新而不遗忘旧知识。" },
+  "federated learning": { zh: "联邦学习", domain: "人工智能", gloss: "数据留在本地，各端只上传模型更新以保护隐私的协同训练方式。" },
+  "gradient accumulation": { zh: "梯度累积", domain: "人工智能", gloss: "把多个小批次的梯度累加起来再更新一次，模拟更大批次。" },
+  "mixed precision": { zh: "混合精度", domain: "人工智能", gloss: "训练时低位宽与高精度混用，在几乎不掉精度下省显存提速。" },
+  "bfloat16": { zh: "半精度浮点格式", domain: "人工智能", gloss: "保留与单精度相同指数范围的16位浮点格式，训练时不易溢出。" },
+  "model parallelism": { zh: "模型并行", domain: "人工智能", gloss: "把单个模型的不同层或张量切到多张卡上协同计算。" },
+  "data parallelism": { zh: "数据并行", domain: "人工智能", gloss: "每张卡持有完整模型、各跑一部分数据再同步梯度。" },
+  "tensor parallelism": { zh: "张量并行", domain: "人工智能", gloss: "把单个矩阵运算切开分到多张卡上，适合单层就很大的模型。" },
+  "pipeline parallelism": { zh: "流水线并行", domain: "人工智能", gloss: "按层把模型分段放在不同卡上，微批次依次流过形成流水。" },
+  "gradient descent": { zh: "梯度下降", domain: "人工智能", gloss: "沿着损失函数下降最快的方向逐步调整参数以求得最小值。" },
+  "stochastic gradient descent": { zh: "随机梯度下降", domain: "人工智能", gloss: "每次只用一小批样本估计梯度来更新参数，速度快但路径有噪声。" },
+  "backpropagation": { zh: "反向传播", domain: "人工智能", gloss: "按链式法则从输出层往回逐层计算梯度，用于更新网络参数。" },
+  "overfitting": { zh: "过拟合", domain: "人工智能", gloss: "模型把训练数据的噪声也记住了，在新数据上表现明显变差。" },
+  "underfitting": { zh: "欠拟合", domain: "人工智能", gloss: "模型过于简单，连训练数据中的基本规律都没能学到位。" },
+  "regularization": { zh: "正则化", domain: "人工智能", gloss: "在损失中加惩罚项限制模型复杂度，以缓解过拟合。" },
+  "dropout": { zh: "随机失活", domain: "人工智能", gloss: "训练时随机屏蔽一部分神经元，迫使网络学到更稳健的特征。" },
+  "batch normalization": { zh: "批归一化", domain: "人工智能", gloss: "按小批量统计把每层输入标准化，使训练更快更稳定。" },
+  "layer normalization": { zh: "层归一化", domain: "人工智能", gloss: "在单个样本的特征维度上做归一化，适合变长序列与Transformer。" },
+  "cross-entropy": { zh: "交叉熵", domain: "人工智能", gloss: "衡量预测分布与真实分布差异的损失，分类任务中最常用。" },
+  "perplexity": { zh: "困惑度", domain: "人工智能", gloss: "语言模型对文本感到意外的程度，数值越低表示预测越准。" },
+  "loss function": { zh: "损失函数", domain: "人工智能", gloss: "把预测与正确答案的差距量化成数值，训练就是把它降到最小。" },
+  "learning rate": { zh: "学习率", domain: "人工智能", gloss: "每次参数更新的步长，过大易震荡、过小则收敛缓慢。" },
+  "learning rate schedule": { zh: "学习率调度", domain: "人工智能", gloss: "按训练进度动态调整学习率的策略，通常先升后降。" },
+  "warmup": { zh: "预热", domain: "人工智能", gloss: "训练初期把学习率从很小逐步升上去，避免早期训练不稳定。" },
+  "epoch": { zh: "训练轮次", domain: "人工智能", gloss: "把整个训练集完整过一遍称为一个轮次。" },
+  "batch size": { zh: "批大小", domain: "人工智能", gloss: "一次前向与反向计算所处理的样本数量，影响显存与稳定性。" },
+  "mini-batch": { zh: "小批量", domain: "人工智能", gloss: "从训练集中随机抽出的一小部分样本，用于一次参数更新。" },
+  "convergence": { zh: "收敛", domain: "人工智能", gloss: "训练指标不再明显改善、参数趋于稳定的状态。" },
+  "vanishing gradient": { zh: "梯度消失", domain: "人工智能", gloss: "深层网络回传的梯度越来越小，导致浅层参数几乎学不动。" },
+  "exploding gradient": { zh: "梯度爆炸", domain: "人工智能", gloss: "梯度在反向传播中急剧放大，使参数更新发散甚至变成无穷。" },
+  "activation function": { zh: "激活函数", domain: "人工智能", gloss: "给神经元输出加非线性变换，使网络能拟合复杂函数。" },
+  "relu": { zh: "修正线性单元", domain: "人工智能", gloss: "修正线性单元（Rectified Linear Unit），负数取零、正数原样输出的激活函数。" },
+  "sigmoid": { zh: "压缩型激活函数", domain: "人工智能", gloss: "把任意实数压缩到零到一之间的S形函数，常用作概率输出。" },
+  "feedforward network": { zh: "前馈网络", domain: "人工智能", gloss: "信息只从输入单向流向输出的神经网络，层间没有回环。" },
+  "multilayer perceptron": { zh: "多层感知机", domain: "人工智能", gloss: "由若干全连接层堆叠而成的最基础深度神经网络结构。" },
+  "convolutional neural network": { zh: "卷积神经网络", domain: "人工智能", gloss: "用滑动卷积核提取局部特征，擅长处理图像与网格状数据。" },
+  "recurrent neural network": { zh: "循环神经网络", domain: "人工智能", gloss: "带隐藏状态、可处理变长序列的网络，但长依赖容易遗忘。" },
+  "lstm": { zh: "长短期记忆网络", domain: "人工智能", gloss: "长短期记忆网络（Long Short-Term Memory），用门控机制缓解梯度消失的循环网络。" },
+  "gru": { zh: "门控循环单元", domain: "人工智能", gloss: "门控循环单元（Gated Recurrent Unit），结构比LSTM更简化的循环网络变体。" },
+  "autoencoder": { zh: "自编码器", domain: "人工智能", gloss: "把输入压缩成低维表示再重建的网络，常用于降维与去噪。" },
+  "variational autoencoder": { zh: "变分自编码器", domain: "人工智能", gloss: "在隐空间引入概率分布的自编码器，可采样生成新样本。" },
+  "generative adversarial network": { zh: "生成对抗网络", domain: "人工智能", gloss: "生成器与判别器互相博弈，最终生成以假乱真的样本。" },
+  "diffusion model": { zh: "扩散模型", domain: "人工智能", gloss: "先给数据加噪再学习逐步去噪，从而按提示生成图像或音频。" },
+  "latent space": { zh: "隐空间", domain: "人工智能", gloss: "模型内部压缩后的抽象表示空间，相似概念在其中距离更近。" },
+  "manifold": { zh: "流形", domain: "数学", gloss: "高维空间中局部近似平坦的低维结构，真实数据往往分布在它上面。" },
+  "representation learning": { zh: "表示学习", domain: "人工智能", gloss: "让模型自动学出有用的特征表示，替代人工设计特征。" },
+  "self-supervised learning": { zh: "自监督学习", domain: "人工智能", gloss: "从数据自身构造监督信号进行训练，无需人工标注。" },
+  "supervised learning": { zh: "监督学习", domain: "人工智能", gloss: "用带标签的样本训练模型，使其能预测新样本的标签。" },
+  "unsupervised learning": { zh: "无监督学习", domain: "人工智能", gloss: "在没有标签的数据中发现聚类、密度或低维结构。" },
+  "semi-supervised learning": { zh: "半监督学习", domain: "人工智能", gloss: "少量标注数据配合大量无标注数据共同训练模型。" },
+  "active learning": { zh: "主动学习", domain: "人工智能", gloss: "让模型挑出最有价值的样本请人标注，以最少标注换最好效果。" },
+  "reinforcement learning": { zh: "强化学习", domain: "人工智能", gloss: "智能体通过与环境交互并获得奖励，逐步学会最优决策策略。" },
+  "policy gradient": { zh: "策略梯度", domain: "人工智能", gloss: "直接对策略参数求梯度，使高回报动作的出现概率变大。" },
+  "q-learning": { zh: "状态动作值学习", domain: "人工智能", gloss: "通过迭代更新状态动作价值来学习最优策略的无模型算法。" },
+  "exploration exploitation": { zh: "探索与利用", domain: "人工智能", gloss: "在尝试新选项获取信息与坚持已知最优之间做权衡。" },
+  "markov decision process": { zh: "马尔可夫决策过程", domain: "人工智能", gloss: "用状态、动作、转移概率与奖励刻画序贯决策的数学框架。" },
+  "monte carlo tree search": { zh: "蒙特卡洛树搜索", domain: "人工智能", gloss: "用随机模拟为博弈树各分支估值并逐步聚焦有希望的方向。" },
+  "transfer learning": { zh: "迁移学习", domain: "人工智能", gloss: "把在一个任务上学到的知识迁移到数据更少的新任务上。" },
+  "graph neural network": { zh: "图神经网络", domain: "人工智能", gloss: "在图的节点与边上传递并聚合信息来做表示学习的网络。" },
+  "feature engineering": { zh: "特征工程", domain: "人工智能", gloss: "从原始数据中构造对预测真正有用的特征变量。" },
+  "feature selection": { zh: "特征选择", domain: "人工智能", gloss: "从众多候选特征中挑出最有信息量的一组，降低噪声与维度。" },
+  "dimensionality reduction": { zh: "降维", domain: "人工智能", gloss: "在尽量保留信息的前提下把高维数据映射到低维空间。" },
+  "pca": { zh: "主成分分析", domain: "数学", gloss: "主成分分析（Principal Component Analysis），用方差最大的若干正交方向重新表示数据。" },
+  "t-sne": { zh: "邻域保持降维", domain: "人工智能", gloss: "把高维点映射到二维以便可视化，重视保留局部邻域结构。" },
+  "clustering": { zh: "聚类", domain: "人工智能", gloss: "把相似样本自动归成若干组，组内相近而组间差异明显。" },
+  "k-means": { zh: "均值聚类算法", domain: "人工智能", gloss: "反复把样本分配给最近的族中心并更新中心的划分算法。" },
+  "dbscan": { zh: "密度聚类算法", domain: "人工智能", gloss: "基于密度连通性聚类，能发现任意形状的簇并识别噪声点。" },
+  "classification": { zh: "分类", domain: "人工智能", gloss: "预测样本属于哪个离散类别的监督学习任务。" },
+  "regression": { zh: "回归", domain: "人工智能", gloss: "预测连续数值的监督学习任务，例如价格或销量。" },
+  "logistic regression": { zh: "逻辑回归", domain: "人工智能", gloss: "用Sigmoid把线性组合压成概率的经典二分类模型。" },
+  "decision tree": { zh: "决策树", domain: "人工智能", gloss: "按特征条件逐层分裂样本、形如树状规则的预测模型。" },
+  "random forest": { zh: "随机森林", domain: "人工智能", gloss: "训练许多棵随机化的决策树并投票，降低单棵树的方差。" },
+  "gradient boosting": { zh: "梯度提升", domain: "人工智能", gloss: "逐轮训练新树去拟合当前残差，串行叠加成强模型。" },
+  "xgboost": { zh: "高效梯度提升", domain: "人工智能", gloss: "对梯度提升做工程与正则优化的高效实现，表格数据上表现强势。" },
+  "support vector machine": { zh: "支持向量机", domain: "人工智能", gloss: "寻找间隔最大的分界超平面，并可借核函数处理非线性。" },
+  "naive bayes": { zh: "朴素贝叶斯", domain: "人工智能", gloss: "假设各特征相互独立、用贝叶斯公式做分类的简单模型。" },
+  "knn": { zh: "近邻投票算法", domain: "人工智能", gloss: "K近邻算法（K-Nearest Neighbors），按最相近的K个样本投票决定类别。" },
+  "ensemble learning": { zh: "集成学习", domain: "人工智能", gloss: "组合多个弱模型来获得更稳、更准的预测结果。" },
+  "bagging": { zh: "装袋法", domain: "人工智能", gloss: "对样本有放回抽样训练多个模型并平均，主要降低方差。" },
+  "boosting": { zh: "提升法", domain: "人工智能", gloss: "串行训练模型、每轮专注纠正前面错误，主要降低偏差。" },
+  "bias variance tradeoff": { zh: "偏差方差权衡", domain: "人工智能", gloss: "模型复杂度升高会降低偏差却抬高方差，需要在两者间取平衡。" },
+  "confusion matrix": { zh: "混淆矩阵", domain: "人工智能", gloss: "按真实类别与预测类别交叉统计样本数的表格，用于分析错误类型。" },
+  "precision recall": { zh: "精确率与召回率", domain: "人工智能", gloss: "前者衡量预测为正的有多准，后者衡量真正的正例被找出多少。" },
+  "f1 score": { zh: "综合平衡分数", domain: "人工智能", gloss: "精确率与召回率的调和平均，综合反映分类器的平衡表现。" },
+  "roc curve": { zh: "检出权衡曲线", domain: "人工智能", gloss: "随判定阈值变化绘制真正率与假正率关系的曲线，用于比较模型。" },
+  "auc": { zh: "曲线下面积", domain: "人工智能", gloss: "曲线下面积（Area Under the Curve），ROC曲线下的面积，越大表示排序能力越强。" },
+  "class imbalance": { zh: "类别不平衡", domain: "人工智能", gloss: "某一类样本远多于其他类，导致模型偏向多数类。" },
+  "data augmentation": { zh: "数据增强", domain: "人工智能", gloss: "通过旋转、裁剪或改写等方式扩充训练样本，提升泛化能力。" },
+  "data annotation": { zh: "数据标注", domain: "人工智能", gloss: "由人工为样本打上标签或结构化信息，为训练提供监督信号。" },
+  "ground truth": { zh: "标准答案", domain: "人工智能", gloss: "被认为是正确无误的参考标注，用于评估模型表现。" },
+  "label noise": { zh: "标签噪声", domain: "人工智能", gloss: "训练数据中标注错误或含混的样本，会拖累模型效果。" },
+  "bayesian inference": { zh: "贝叶斯推断", domain: "数学", gloss: "用先验分布与观测数据推出参数后验分布的方法。" },
+  "variational inference": { zh: "变分推断", domain: "数学", gloss: "用一个简单分布去逼近难以计算的后验分布，把推断变成优化。" },
+  "multimodal": { zh: "多模态", domain: "人工智能", gloss: "模型能同时理解文本、图像、音频等多种类型的信息。" },
+  "vision transformer": { zh: "视觉变换器", domain: "人工智能", gloss: "把图像切成小块当作词元、用Transformer处理的视觉模型。" },
+  "clip": { zh: "图文对齐模型", domain: "人工智能", gloss: "对比语言图像预训练（Contrastive Language-Image Pre-training），让图文在同一向量空间对齐。" },
+  "speech recognition": { zh: "语音识别", domain: "人工智能", gloss: "把语音信号自动转写成文字的技术。" },
+  "text to speech": { zh: "语音合成", domain: "人工智能", gloss: "把文字转换成自然流畅的语音输出。" },
+  "ocr": { zh: "光学字符识别", domain: "人工智能", gloss: "光学字符识别（Optical Character Recognition），从图片中识别出文字内容。" },
+  "named entity recognition": { zh: "命名实体识别", domain: "人工智能", gloss: "从文本中找出人名、机构、地点等专有实体的任务。" },
+  "part of speech tagging": { zh: "词性标注", domain: "人工智能", gloss: "为句子中每个词标出名词、动词等语法类别的任务。" },
+  "sentiment analysis": { zh: "情感分析", domain: "人工智能", gloss: "判断文本表达的情绪倾向是正面、负面还是中性。" },
+  "machine translation": { zh: "机器翻译", domain: "人工智能", gloss: "用模型自动把一种自然语言翻译成另一种。" },
+  "summarization": { zh: "自动摘要", domain: "人工智能", gloss: "把长文本压缩成保留要点的短文本，分抽取式与生成式。" },
+  "question answering": { zh: "问答系统", domain: "人工智能", gloss: "根据给定资料或知识回答用户自然语言提问的任务。" },
+  "information retrieval": { zh: "信息检索", domain: "数据", gloss: "从大规模文档集合中找出与查询最相关内容的学科与技术。" },
+  "recommender system": { zh: "推荐系统", domain: "人工智能", gloss: "根据历史行为与相似用户偏好，为每个人挑选可能感兴趣的内容。" },
+  "collaborative filtering": { zh: "协同过滤", domain: "人工智能", gloss: "利用用户与物品之间的历史交互矩阵来预测未知偏好。" },
+  "click-through rate": { zh: "点击率", domain: "产品", gloss: "曝光中被点击的比例，是推荐与广告排序的核心目标之一。" },
+  "model drift": { zh: "模型漂移", domain: "人工智能", gloss: "线上数据分布随时间变化，使原有模型效果逐渐衰减。" },
+  "feature store": { zh: "特征平台", domain: "人工智能", gloss: "集中管理离线与在线特征、保证训练和推理口径一致的系统。" },
+  "mlops": { zh: "机器学习运维", domain: "人工智能", gloss: "机器学习运维（Machine Learning Operations），把训练、部署与监控模型工程化的一整套实践。" },
+  "hyperparameter": { zh: "超参数", domain: "人工智能", gloss: "由人设定、不由训练过程学出的参数，例如层数与学习率。" },
+  "hyperparameter tuning": { zh: "超参数调优", domain: "人工智能", gloss: "通过搜索不同超参数组合来找到验证集上最好的配置。" },
+  "grid search": { zh: "网格搜索", domain: "人工智能", gloss: "在预设的参数网格上逐一穷举评估，简单但代价高。" },
+  "early stopping": { zh: "早停", domain: "人工智能", gloss: "验证集指标不再改善时就停止训练，防止过拟合与浪费算力。" },
+  "cross validation": { zh: "交叉验证", domain: "人工智能", gloss: "把数据轮流切成训练与验证多份，取平均来更稳健地评估模型。" },
+  "train test split": { zh: "训练测试划分", domain: "人工智能", gloss: "把数据分成训练与测试两部分，用后者检验真实泛化能力。" },
+  "data leakage": { zh: "数据泄漏", domain: "人工智能", gloss: "训练时不小心用到了未来信息或测试数据，使评估结果虚高。" },
+  "ab testing": { zh: "分组对照实验", domain: "产品", gloss: "把用户随机分成两组分别体验不同方案，用数据判断孰优。" },
+  "online inference": { zh: "在线推理", domain: "人工智能", gloss: "请求到来时实时计算并返回预测结果，对延迟要求高。" },
+  "batch inference": { zh: "批量推理", domain: "人工智能", gloss: "离线一次性对大批数据算好预测结果并落库备用。" },
+  "gpu": { zh: "图形处理器", domain: "人工智能", gloss: "图形处理器（Graphics Processing Unit），凭借大量并行核心成为深度学习的主力算力。" },
+  "tpu": { zh: "张量处理器", domain: "人工智能", gloss: "张量处理器（Tensor Processing Unit），为矩阵运算定制的专用加速芯片。" },
+  "cuda": { zh: "并行计算平台", domain: "人工智能", gloss: "英伟达提供的并行计算平台与编程接口，用于在GPU上运行通用计算。" },
+  "tensor": { zh: "张量", domain: "人工智能", gloss: "标量、向量与矩阵向更高维度的推广，是深度学习框架的基本数据单位。" },
+  "lsm tree": { zh: "日志结构合并树", domain: "数据", gloss: "写入先落内存表再顺序刷盘，靠后台合并维持有序，写入吞吐很高。" },
+  "b-tree": { zh: "多路平衡查找树", domain: "数据", gloss: "每个节点存放多个键、树高很低的平衡查找树，适合磁盘与数据库索引。" },
+  "b plus tree": { zh: "叶链多路查找树", domain: "数据", gloss: "只在叶子节点存数据、叶子间用链表串联的B树变体，范围扫描高效。" },
+  "write-ahead log": { zh: "预写日志", domain: "数据", gloss: "先把改动顺序写入日志再更新数据文件，崩溃后可据此恢复。" },
+  "materialized view": { zh: "物化视图", domain: "数据", gloss: "把查询结果实际存储下来，读取很快但需要按策略刷新。" },
+  "columnar storage": { zh: "列式存储", domain: "数据", gloss: "按列而非按行存放数据，分析场景下只需读取相关列且压缩率更高。" },
+  "oltp": { zh: "联机事务处理", domain: "数据", gloss: "联机事务处理（Online Transaction Processing），面向高并发短事务的日常业务负载。" },
+  "olap": { zh: "联机分析处理", domain: "数据", gloss: "联机分析处理（Online Analytical Processing），面向大范围聚合与多维分析的负载。" },
+  "htap": { zh: "混合事务分析处理", domain: "数据", gloss: "混合事务分析处理（Hybrid Transactional/Analytical Processing），在同一系统中兼顾事务与分析。" },
+  "star schema": { zh: "星型模型", domain: "数据", gloss: "一个中心事实表周围环绕多个维度表的数仓建模结构，查询直观。" },
+  "snowflake schema": { zh: "雪花模型", domain: "数据", gloss: "维度表进一步规范化拆分的星型模型变体，省空间但连接更多。" },
+  "slowly changing dimension": { zh: "缓慢变化维度", domain: "数据", gloss: "描述客户、产品等维度属性随时间变化时如何在数仓中保留历史。" },
+  "cardinality": { zh: "基数", domain: "数据", gloss: "某列不同取值的个数，基数高低直接影响索引与执行计划的选择。" },
+  "normalization": { zh: "规范化", domain: "数据", gloss: "通过拆表消除冗余与更新异常，使每份数据只存一次。" },
+  "denormalization": { zh: "反规范化", domain: "数据", gloss: "有意引入冗余以减少连接、提升读取性能的建模取舍。" },
+  "primary key": { zh: "主键", domain: "数据", gloss: "唯一标识表中每一行、且不允许为空的一列或若干列。" },
+  "foreign key": { zh: "外键", domain: "数据", gloss: "指向另一张表主键的列，用来约束引用关系的完整性。" },
+  "composite index": { zh: "复合索引", domain: "数据", gloss: "由多个列按顺序共同构成的索引，遵循最左前缀匹配。" },
+  "covering index": { zh: "覆盖索引", domain: "数据", gloss: "索引中已包含查询所需的全部列，无需再回表读取数据行。" },
+  "clustered index": { zh: "聚簇索引", domain: "数据", gloss: "决定数据行物理排列顺序的索引，一张表通常只有一个。" },
+  "full table scan": { zh: "全表扫描", domain: "数据", gloss: "逐行读取整张表来筛选数据，数据量大时往往是性能瓶颈。" },
+  "query planner": { zh: "查询规划器", domain: "数据", gloss: "根据统计信息为查询挑选连接顺序与访问路径的数据库组件。" },
+  "query optimization": { zh: "查询优化", domain: "数据", gloss: "改写查询或调整执行方式，使其在相同结果下耗时更少。" },
+  "execution plan": { zh: "执行计划", domain: "数据", gloss: "数据库为一条查询选定的算子顺序与访问方式，可用来诊断慢查询。" },
+  "vacuum": { zh: "空间回收", domain: "数据", gloss: "清理已删除或过期版本占用的空间，并更新统计信息。" },
+  "transaction isolation": { zh: "事务隔离级别", domain: "数据", gloss: "规定并发事务之间可见性的强弱，权衡一致性与并发度。" },
+  "dirty read": { zh: "脏读", domain: "数据", gloss: "读到了别的事务尚未提交、随后可能被回滚的数据。" },
+  "phantom read": { zh: "幻读", domain: "数据", gloss: "同一事务内两次范围查询之间，别的事务插入的新行凭空出现。" },
+  "non-repeatable read": { zh: "不可重复读", domain: "数据", gloss: "同一事务内两次读取同一行结果不同，因为期间被别人改过。" },
+  "deadlock": { zh: "死锁", domain: "数据", gloss: "多个事务互相持有并等待对方资源，谁也推进不下去。" },
+  "optimistic locking": { zh: "乐观锁", domain: "数据", gloss: "平时不加锁，提交时用版本号比对，冲突才回滚重试。" },
+  "pessimistic locking": { zh: "悲观锁", domain: "数据", gloss: "在读或改之前先加锁，假定冲突一定会发生。" },
+  "write skew": { zh: "写偏斜", domain: "数据", gloss: "两个事务各读一部分数据、各自写入不冲突的行，合起来却破坏约束。" },
+  "lost update": { zh: "更新丢失", domain: "数据", gloss: "并发写入时后提交者覆盖了先提交者的改动，导致一次更新白做。" },
+  "savepoint": { zh: "保存点", domain: "数据", gloss: "事务内可回滚到的中间标记，不必把整个事务全部撤销。" },
+  "rollback": { zh: "回滚", domain: "数据", gloss: "撤销事务已做的改动，使数据恢复到事务开始前的状态。" },
+  "checkpoint": { zh: "检查点", domain: "数据", gloss: "把内存中的改动刷到持久存储并记录位置，缩短崩溃恢复时间。" },
+  "redo log": { zh: "重做日志", domain: "数据", gloss: "记录已提交的改动，崩溃后据此重放以恢复数据。" },
+  "undo log": { zh: "撤销日志", domain: "数据", gloss: "记录改动前的旧值，用于回滚事务与实现多版本读取。" },
+  "change data capture": { zh: "变更数据捕获", domain: "数据", gloss: "订阅数据库日志流，把每一行变更实时同步到下游系统。" },
+  "elt": { zh: "抽取加载转换", domain: "数据", gloss: "抽取加载转换（Extract-Load-Transform），先把原始数据装入仓库再借助其算力转换。" },
+  "data warehouse": { zh: "数据仓库", domain: "数据", gloss: "面向分析、集成多个业务源并保留历史的结构化数据存储。" },
+  "data lake": { zh: "数据湖", domain: "数据", gloss: "以原始格式集中存放海量结构与非结构化数据的存储池。" },
+  "data lakehouse": { zh: "湖仓一体", domain: "数据", gloss: "在数据湖的低成本存储上叠加表格式与事务能力，兼具仓库特性。" },
+  "data mart": { zh: "数据集市", domain: "数据", gloss: "面向某个部门或主题的小型数据仓库，从仓库中裁剪而来。" },
+  "data mesh": { zh: "数据网格", domain: "数据", gloss: "把数据作为产品交给各业务域自治管理、以去中心方式治理的组织范式。" },
+  "partitioning": { zh: "分区", domain: "数据", gloss: "按某个规则把大表切分成多个更易管理的物理片段。" },
+  "hot spot": { zh: "热点", domain: "数据", gloss: "访问或写入严重集中在少数分片上，使个别节点成为瓶颈。" },
+  "tiered storage": { zh: "分层存储", domain: "数据", gloss: "按访问频率把数据放在不同成本的介质上，兼顾性能与开销。" },
+  "object storage": { zh: "对象存储", domain: "系统", gloss: "以对象为单位、通过HTTP接口访问的海量可扩展存储，适合非结构化数据。" },
+  "block storage": { zh: "块存储", domain: "系统", gloss: "以固定大小块形式提供、可挂载成磁盘的存储服务。" },
+  "erasure coding": { zh: "纠删码", domain: "数据", gloss: "把数据切片并计算校验块，用较少冗余容忍多块同时失效。" },
+  "raid": { zh: "磁盘阵列", domain: "系统", gloss: "独立磁盘冗余阵列（Redundant Array of Independent Disks），用多块磁盘组合提升性能或可靠性。" },
+  "replication factor": { zh: "副本数", domain: "数据", gloss: "每份数据保存的副本数量，决定容错能力与存储成本。" },
+  "distributed transaction": { zh: "分布式事务", domain: "系统", gloss: "跨多个服务或数据库、需要整体成功或整体失败的事务。" },
+  "olap cube": { zh: "多维数据集", domain: "数据", gloss: "按多个维度预先聚合的数据结构，支持快速切片与钻取。" },
+  "rollup": { zh: "上卷", domain: "数据", gloss: "沿维度层级把细粒度数据汇总成更粗粒度的结果。" },
+  "drill down": { zh: "钻取", domain: "数据", gloss: "从汇总结果逐层深入到更细粒度数据查看细节。" },
+  "dimension table": { zh: "维度表", domain: "数据", gloss: "存放分析角度描述性属性的表，如时间、地区与产品类别。" },
+  "fact table": { zh: "事实表", domain: "数据", gloss: "存放可度量业务事件与各维度外键的表，是数仓的核心。" },
+  "surrogate key": { zh: "代理键", domain: "数据", gloss: "系统生成的、与业务无关的唯一编号，用作维度表的稳定主键。" },
+  "upsert": { zh: "插入或更新", domain: "数据", gloss: "记录已存在就更新、不存在就插入的合并写入操作。" },
+  "bulk load": { zh: "批量导入", domain: "数据", gloss: "绕过逐条写入、以批处理方式高速灌入大量数据。" },
+  "histogram": { zh: "直方图", domain: "数据", gloss: "统计各取值区间的数据分布，供优化器估算选择率。" },
+  "selectivity": { zh: "选择率", domain: "数据", gloss: "条件过滤后剩下的数据比例，越低越适合走索引。" },
+  "data lineage": { zh: "数据血缘", domain: "数据", gloss: "追踪一份数据从哪些源头经过哪些加工流转而来。" },
+  "data catalog": { zh: "数据目录", domain: "数据", gloss: "集中登记数据集、字段含义与负责人，便于发现与治理。" },
+  "metadata": { zh: "元数据", domain: "数据", gloss: "描述数据本身的数据，例如结构、来源、权限与更新时间。" },
+  "schema evolution": { zh: "模式演进", domain: "数据", gloss: "在不中断上下游的前提下为数据表增删字段或调整类型。" },
+  "parquet": { zh: "列式分析文件", domain: "数据", gloss: "面向分析的列式文件格式，按列压缩并支持谓词下推。" },
+  "protobuf": { zh: "协议缓冲区", domain: "系统", gloss: "协议缓冲区（Protocol Buffers），用模式定义描述结构化消息的高效二进制序列化格式。" },
+  "avro": { zh: "自带模式序列化", domain: "数据", gloss: "把模式与数据一起存放、支持模式演进的序列化格式。" },
+  "messagepack": { zh: "紧凑二进制序列化", domain: "系统", gloss: "比JSON更紧凑的二进制序列化格式，体积小且解析快。" },
+  "json schema": { zh: "结构化校验规则", domain: "数据", gloss: "用JSON描述的校验规则，规定文档允许的字段与类型。" },
+  "storage engine": { zh: "存储引擎", domain: "数据", gloss: "数据库内部负责数据组织、索引与读写事务的底层模块。" },
+  "buffer pool": { zh: "缓冲池", domain: "数据", gloss: "数据库在内存中缓存数据页的区域，命中率决定读写性能。" },
+  "fsync": { zh: "同步落盘", domain: "系统", gloss: "强制把操作系统缓存中的写入真正刷到持久介质再返回。" },
+  "durability": { zh: "持久性", domain: "数据", gloss: "事务一旦提交，即使随后断电数据也不会丢失的保证。" },
+  "read replica": { zh: "只读副本", domain: "系统", gloss: "专门承担读流量的从库，用来分担主库压力。" },
+  "sharding key": { zh: "分片键", domain: "数据", gloss: "决定一条数据被路由到哪个分片的字段，选择不当会造成热点。" },
+  "range partition": { zh: "范围分区", domain: "数据", gloss: "按键的取值区间划分数据，便于按范围扫描与归档。" },
+  "hash partition": { zh: "哈希分区", domain: "数据", gloss: "按键的哈希值取模分散数据，使各分区负载更均匀。" },
+  "cold data": { zh: "冷数据", domain: "数据", gloss: "访问频率很低、可以放到廉价介质上长期保存的数据。" },
+  "eigenvalue": { zh: "特征值", domain: "数学", gloss: "矩阵作用于某向量时只把它伸缩的倍数，方向保持不变。" },
+  "eigenvector": { zh: "特征向量", domain: "数学", gloss: "被矩阵变换后方向不变、只被缩放的那个非零向量。" },
+  "markov chain": { zh: "马尔可夫链", domain: "数学", gloss: "下一步状态只依赖当前状态、与更早历史无关的随机过程。" },
+  "bayes theorem": { zh: "贝叶斯定理", domain: "数学", gloss: "根据新证据把先验概率更新为后验概率的基本公式。" },
+  "entropy": { zh: "信息熵值", domain: "数学", gloss: "衡量随机变量不确定性的量，分布越均匀取值越大。" },
+  "information theory": { zh: "信息论", domain: "数学", gloss: "研究信息的量化、压缩与可靠传输的数学分支。" },
+  "kl divergence": { zh: "分布差异度量", domain: "数学", gloss: "衡量两个概率分布差异的非对称指标，也叫相对熵。" },
+  "mutual information": { zh: "互信息", domain: "数学", gloss: "知道一个变量后能减少对方多少不确定性，用来度量相关性。" },
+  "conditional probability": { zh: "条件概率", domain: "数学", gloss: "在已知某事件发生的前提下另一事件发生的概率。" },
+  "prior probability": { zh: "先验概率", domain: "数学", gloss: "在看到新数据之前，根据既有认知给出的概率判断。" },
+  "posterior probability": { zh: "后验概率", domain: "数学", gloss: "结合观测数据更新之后得到的概率分布。" },
+  "maximum likelihood": { zh: "最大似然估计", domain: "数学", gloss: "选择让已观测数据出现概率最大的那组参数。" },
+  "maximum a posteriori": { zh: "最大后验估计", domain: "数学", gloss: "在最大似然基础上再乘先验，取后验概率最大的参数。" },
+  "central limit theorem": { zh: "中心极限定理", domain: "数学", gloss: "大量独立随机变量之和近似服从正态分布，与原始分布无关。" },
+  "law of large numbers": { zh: "大数定律", domain: "数学", gloss: "样本量越大，样本均值越接近真实期望值。" },
+  "normal distribution": { zh: "正态分布", domain: "数学", gloss: "钟形对称、由均值与标准差决定的连续概率分布。" },
+  "poisson distribution": { zh: "泊松分布", domain: "数学", gloss: "描述单位时间内随机事件发生次数的离散分布。" },
+  "expected value": { zh: "期望值", domain: "数学", gloss: "随机变量按各自概率加权后的平均取值，描述长期重复试验的平均结果。" },
+  "statistical variance": { zh: "方差", domain: "数学", gloss: "各取值与均值之差的平方的平均，衡量数据分散程度。" },
+  "covariance matrix": { zh: "协方差矩阵", domain: "数学", gloss: "记录各维度两两之间协方差的矩阵，刻画变量的联合变化。" },
+  "correlation coefficient": { zh: "相关系数", domain: "数学", gloss: "取值在负一到一之间、衡量两变量线性相关强弱的数值。" },
+  "p-value": { zh: "显著性概率值", domain: "数学", gloss: "假设原假设成立时观察到当前或更极端结果的概率。" },
+  "hypothesis testing": { zh: "假设检验", domain: "数学", gloss: "用样本数据判断某个关于总体的假设是否应被拒绝。" },
+  "confidence interval": { zh: "置信区间", domain: "数学", gloss: "以一定置信水平包含真实参数的取值范围。" },
+  "statistical significance": { zh: "统计显著性", domain: "数学", gloss: "观测到的差异不太可能仅由随机波动造成的判断。" },
+  "simpson paradox": { zh: "辛普森悖论", domain: "数学", gloss: "分组比较时占优的一方，合并数据后反而落后的统计现象。" },
+  "survivorship bias": { zh: "幸存者偏差", domain: "产品", gloss: "只看到成功留下来的样本，因而得出片面甚至相反的结论。" },
+  "selection bias": { zh: "选择偏差", domain: "数据", gloss: "样本选取方式不随机，使结论无法代表整体。" },
+  "confounding variable": { zh: "混杂变量", domain: "数据", gloss: "同时影响自变量与结果、从而制造虚假关联的第三因素。" },
+  "causal inference": { zh: "因果推断", domain: "数据", gloss: "在观测数据中区分相关与因果，估计干预的真实效果。" },
+  "queueing theory": { zh: "排队论", domain: "数学", gloss: "研究到达、排队与服务过程，用于估算延迟与所需容量。" },
+  "littles law": { zh: "利特尔法则", domain: "运维", gloss: "系统中的平均请求数等于到达速率乘以平均停留时间。" },
+  "graph theory": { zh: "图论", domain: "数学", gloss: "研究顶点与边构成的结构及其路径、连通与着色性质的学科。" },
+  "set theory": { zh: "集合论", domain: "数学", gloss: "研究元素与集合、映射及基数等基础概念的分支。" },
+  "linear algebra": { zh: "线性代数", domain: "数学", gloss: "研究向量、矩阵与线性变换的数学分支，是机器学习的基础。" },
+  "singular value decomposition": { zh: "奇异值分解", domain: "数学", gloss: "把任意矩阵分解为旋转、缩放与旋转三个部分的通用方法。" },
+  "determinant": { zh: "行列式", domain: "数学", gloss: "由方阵元素算出的标量，反映线性变换对体积的缩放倍数。" },
+  "positive definite": { zh: "正定", domain: "数学", gloss: "对任意非零向量其二次型都为正的对称矩阵性质。" },
+  "convex optimization": { zh: "凸优化", domain: "数学", gloss: "目标与约束均为凸的问题，局部最优即全局最优，易求解。" },
+  "lagrangian": { zh: "拉格朗日函数", domain: "数学", gloss: "把约束条件乘上乘子并入目标函数，从而求解带约束优化。" },
+  "duality": { zh: "对偶", domain: "数学", gloss: "把原问题转化为另一形式的问题，其最优值可给出原问题界。" },
+  "hessian": { zh: "海森矩阵", domain: "数学", gloss: "多元函数二阶偏导组成的方阵，描述曲率与凹凸性。" },
+  "jacobian": { zh: "雅可比矩阵", domain: "数学", gloss: "向量函数一阶偏导构成的矩阵，是多元导数的推广。" },
+  "taylor series": { zh: "泰勒级数", domain: "数学", gloss: "用函数在某点的各阶导数多项式逼近该函数的方法。" },
+  "fourier transform": { zh: "傅里叶变换", domain: "数学", gloss: "把信号从时间域分解成不同频率成分的变换。" },
+  "laplace transform": { zh: "拉普拉斯变换", domain: "数学", gloss: "把微分方程转成代数方程求解、再变回时域的积分变换。" },
+  "convolution": { zh: "卷积", domain: "数学", gloss: "把两个函数按翻转平移后相乘求和的运算，用于滤波与特征提取。" },
+  "partial derivative": { zh: "偏导数", domain: "数学", gloss: "多元函数对某一个变量求导、其余变量视为常数的导数。" },
+  "chain rule": { zh: "链式法则", domain: "数学", gloss: "复合函数求导时逐层相乘的规则，是反向传播的数学基础。" },
+  "combinatorics": { zh: "组合数学", domain: "数学", gloss: "研究计数、排列与组合结构的离散数学分支。" },
+  "permutation": { zh: "排列", domain: "数学", gloss: "从若干元素中有序选取一部分的方式，顺序不同视为不同结果。" },
+  "combination": { zh: "组合", domain: "数学", gloss: "从若干元素中选取一部分、不考虑顺序的取法。" },
+  "pigeonhole principle": { zh: "鸽巢原理", domain: "数学", gloss: "物品比抽屉多时，至少有一个抽屉里放了不止一件物品。" },
+  "mathematical induction": { zh: "数学归纳法", domain: "数学", gloss: "证明基础情形成立、并证明由前一项可推出后一项来覆盖全体。" },
+  "proof by contradiction": { zh: "反证法", domain: "数学", gloss: "先假设命题不成立，推出矛盾从而证明原命题为真。" },
+  "halting problem": { zh: "停机问题", domain: "数学", gloss: "不存在通用程序能判断任意程序是否会在有限步内结束。" },
+  "turing machine": { zh: "图灵机", domain: "数学", gloss: "用纸带与读写头刻画可计算性的抽象计算模型。" },
+  "automata theory": { zh: "自动机理论", domain: "数学", gloss: "研究有限状态机等形式模型及其可识别语言的能力与极限。" },
+  "lambda calculus": { zh: "λ演算", domain: "数学", gloss: "只用函数定义与应用于表达计算的极简形式系统。" },
+  "computability": { zh: "可计算性", domain: "数学", gloss: "研究哪些问题能被算法解决、哪些原则上无法解决的领域。" },
+  "decidability": { zh: "可判定性", domain: "数学", gloss: "是否存在算法能在有限时间内对某类问题给出是或否的答案。" },
+  "kolmogorov complexity": { zh: "最短程序长度", domain: "数学", gloss: "生成某串数据所需的最短程序的长度，用来刻画其随机性。" },
+  "modular arithmetic": { zh: "模运算", domain: "数学", gloss: "只保留除以模数后余数的运算，是哈希与密码学的常用工具。" },
+  "number theory": { zh: "数论", domain: "数学", gloss: "研究整数性质与整除、同余规律的数学分支。" },
+  "simplex method": { zh: "单纯形法", domain: "数学", gloss: "沿可行域顶点逐步移动、求解线性规划最优解的经典算法。" },
+};