PlumePHP

记录前后端开发、系统设计与工程实践的技术博客。深入探讨 PHP、Go、数据库与基础设施等领域。

阅读最新 全部文章

精选

探索

按主题浏览

Game 791 Prd 329 Server 280 GameDev 271 Rust 206 Client 160 Lua 135 Indie 119

最新

最新技术文章

归档

浏览发布历史

2026 475 篇文章

June 58

  1. OAuth2.0与JWT安全实战：认证授权的正确打开方式
  2. 写孢子三部曲：从创作手记回到小说正文
  3. 写孢子三部曲：技术人、父亲和小说作者之间的自己
  4. 写孢子三部曲：把长期写作当成一个项目来管理
  5. 写孢子三部曲：不要把对立面写成简单坏人
  6. 写孢子三部曲：危机之外也要有生活纹理
  7. Envoy代理深度配置：构建高性能API网关
  8. 写孢子三部曲：为什么这个故事拖了17年我还想写完
  9. 写孢子三部曲：我后来才学会怎样重写
  10. 写孢子三部曲：读者想看什么和我想写什么
  11. 写孢子三部曲：科幻感和小说感之间的拉扯
  12. 写孢子三部曲：世界观不是越大越好
  13. 写孢子三部曲：如何面对一个故事的收束
  14. 写孢子三部曲：现实生活如何挤压小说时间
  15. 分布式共识算法：Raft与Paxos的原理与实践
  16. Serverless与边缘计算：构建低延迟、高弹性的分布式系统
  17. 写孢子三部曲：人物关系比人物设定更难
  18. 游戏性能预算管理：移动端、PC 和主机项目怎么把帧率做稳
  19. 个人游戏技术选型案例：跨平台存档路径为什么不能随手放在游戏目录
  20. 个人游戏技术选型案例：Steam Deck 适配为什么先改 UI 和功耗
  21. 写孢子三部曲：时间线和因果关系的反复整理
  22. 游戏服务器数据隐私与保留策略
  23. 个人游戏技术选型案例：崩溃日志为什么选择玩家可控的诊断包
  24. 写孢子三部曲：那些没有留下来的废稿
  25. 游戏限时道具与临时资产服务端设计
  26. UGC 游戏生态设计：编辑器、审核、激励和内容长尾怎么做
  27. 写孢子三部曲：从设定笔记到小说世界
  28. 孢子三部曲人物手记：为什么小孩叫乐汀
  29. 孢子三部曲人物手记：为什么女主角叫秋冷糖
  30. 17年之后，我从孢子三部曲里得到什么
  31. 写《孢子起源》：回到源头反而最难
  32. 个人游戏技术选型案例：UI 架构为什么从面板脚本改成事件驱动
  33. 写《孢子崛起》：续集不是把危机写得更大
  34. 写《孢子危机》：第一部最难的是承认自己还不会写
  35. 我写孢子三部曲的17年：一个故事如何开始
  36. 孢子三部曲创作手记：17年写作回望目录
  37. 个人游戏技术选型案例：资源加载为什么从直接引用改成分组加载
  38. 游戏地图实例生命周期管理
  39. 游戏回归测试自动化：版本越做越大时，QA 怎么守住质量
  40. 游戏服务器实验与 A/B 测试设计
  41. 游戏玩家分层和 CRM：怎么把运营动作从群发变成精准触达
  42. 游戏 DLC 制作管线：从商业定位到内容交付的完整拆解
  43. 游戏实时语音信令服务设计
  44. 个人游戏技术选型案例：竞速游戏回放为什么只记录输入而不是录视频
  45. 游戏好友关系与社交图谱服务设计
  46. 个人游戏技术选型案例：程序生成为什么选择种子房间而不是纯随机地图
  47. 游戏本地化和配音管线：从文本锁定到多语言上线的全流程
  48. 跨平台游戏账号绑定的服务端设计
  49. 游戏经济系统反通胀：赛季重置、资源回收和长期留存的平衡
  50. 个人游戏技术选型案例：物理解谜为什么没有直接依赖完整物理引擎
  51. 游戏 LiveOps 事故响应：活动翻车、经济异常和服务器波动怎么处理
  52. 世界 Boss 玩法的服务端设计
  53. 游戏服务器幂等 API 设计模式
  54. 跨平台存档和账号同步：PC、手机、主机一起做时怎么避坑
  55. 个人游戏技术选型案例：敌人 AI 为什么选择有限状态机而不是行为树
  56. 个人游戏技术选型案例：本地化管线为什么要先处理字体和文本长度
  57. 游戏软启动实操：全球上线前，怎么用小市场把风险跑出来
  58. 在线游戏服务器蓝绿发布实战

May 85

  1. 游戏跨媒介改编：动画、漫画、小说和影视化前要想清楚什么
  2. 在线游戏服务器容灾演练实战
  3. 游戏客户端设备兼容矩阵：不要等玩家替你覆盖机型
  4. 个人游戏开发者失败案例：宣传片好看但游戏卖点被误读
  5. 个人游戏技术选型案例：埋点分析为什么选择轻量本地优先方案
  6. Godot 客户端自动化测试：从脚本单测到可重复的场景冒烟
  7. 游戏续作和产品线策略：什么时候做续作，什么时候做新IP
  8. 中度在线游戏服务器参考架构
  9. 个人游戏免费序章策略：Prologue 不是免费试玩的另一个名字
  10. 游戏数据看板治理：指标口径、权限、告警和复盘怎么统一
  11. 游戏客户端画质分级系统：低配不是一个开关，而是一套策略
  12. Godot 战斗动画状态机：AnimationTree、命中窗口和表现事件
  13. 个人游戏开发者成功案例：先做本地玩家社区的小众游戏
  14. 多租户架构设计：数据隔离、资源管理与安全策略
  15. 在线游戏服务器云成本优化
  16. 游戏项目复盘和KPI看板：上线后到底该看哪些指标
  17. 游戏服务器架构评审清单
  18. 游戏平台客服协同：商店差评、退款工单和封禁申诉怎么联动
  19. 个人游戏开发者失败案例：把社区反馈管成了压力源
  20. 游戏服务器敏感词与文本审核设计
  21. Godot 工具脚本工作流：用 EditorPlugin 把重复劳动留在编辑器里
  22. 游戏客户端请求队列与幂等：玩家连点不是异常，是日常
  23. 个人游戏技术选型案例：Mod 支持为什么先从 JSON 关卡开始
  24. 跨服活动的游戏服务器架构设计
  25. 游戏UGC治理干货：玩家创作开放后，审核、推荐和版权怎么管
  26. API版本管理策略：从URL版本化到语义化版本的最佳实践
  27. 游戏用户研究实验室：招募玩家、观察行为和转化需求的方法
  28. 个人游戏愿望单转化：发售前最后两周，不是只等系统通知
  29. Godot 网络客户端：把 WebSocket、状态同步和重连边界拆清楚
  30. 个人游戏开发者成功案例：一个机制撑起的益智小品
  31. 游戏服务器 Leader 选举与服务所有权
  32. 游戏客户端时间与倒计时一致性：活动差一秒，也可能是事故
  33. 游戏美术风格规范：Style Bible怎么写才真的有用
  34. 多游戏共用服务器平台架构设计
  35. 游戏品牌资产系统：Logo、角色、世界观和视觉识别怎么长期沉淀
  36. 游戏观战模式的服务端设计
  37. 个人游戏开发者失败案例：存档系统最后才做的代价
  38. Godot 移动端导出与性能：从编辑器流畅到真机稳定
  39. 事件驱动架构与领域事件：构建松耦合的响应式系统
  40. 游戏客户端角色换装系统：外观自由背后是资源、骨骼和性能账
  41. 游戏广告变现设计：激励视频、插屏和广告频控怎么做
  42. 游戏内活动商业化：限时礼包、通行证和兑换商店怎么不伤口碑
  43. 个人游戏技术选型案例：发布流程为什么从手动打包改成半自动管线
  44. 游戏服务器读写模型分离架构
  45. Godot 存档系统：Resource、JSON 和版本迁移怎么选
  46. 游戏客户端 DLC 与模块化下载：不是所有内容都该塞进首包
  47. 个人游戏开发者成功案例：从 Mod 走向独立游戏
  48. 游戏客服运营体系：从工单到补偿，怎么把玩家问题处理清楚
  49. 游戏客服工具的服务端支撑设计
  50. 个人游戏海外发行：不要一开始就把全世界当成目标市场
  51. 游戏服务器集群拓扑架构设计
  52. 游戏 Demo 和试玩节策略：怎么用有限内容换取愿望单和反馈
  53. Godot UI 开发：Control、Container 和主题系统的响应式组织
  54. 游戏客户端运行时权限与隐私：弹窗点同意之前，体验已经开始
  55. CORS与CSRF防护实战：Web安全的常见陷阱与最佳实践
  56. 个人游戏开发者失败案例：先画世界再找玩法的 RPG
  57. 在线游戏 Feature Flag 系统设计
  58. 游戏匹配和天梯系统：公平、速度和留存怎么平衡
  59. 个人游戏技术选型案例：音频系统为什么没有一开始就接 FMOD
  60. 游戏服务器事件驱动架构设计模式
  61. 个人游戏开发者成功案例：90 分钟恐怖短篇带来的稳定回报
  62. 游戏客户端 UI 焦点导航：手柄菜单不能靠鼠标思维设计
  63. Godot 输入系统实践：InputMap、手柄和移动端触控如何统一
  64. 游戏新手引导设计：怎么教玩家而不把玩家劝退
  65. 个人游戏线下展会推广：摊位前的三分钟，比宣传册重要得多
  66. 数据库分片与分区：水平扩展大规模数据存储
  67. 游戏对局回放与审计日志设计
  68. 在线游戏服务器分层架构设计
  69. 游戏退款和拒付运营：平台退款、支付争议和账号风控怎么处理
  70. 个人游戏开发者失败案例：开放世界梦想把项目拖垮
  71. Godot 客户端资源加载：PackedScene、预加载和异步切场景的取舍
  72. 游戏客户端自动化冒烟测试：每天跑一遍核心路径，比上线前祈祷可靠
  73. 游戏服务器每日重置与时间窗口设计
  74. 游戏性能优化生产指南：帧率、内存、包体和加载怎么管
  75. 游戏创作者计划怎么做：招募、素材、激励和内容转化的运营体系
  76. 个人游戏技术选型案例：输入系统为什么不能只按键盘写死
  77. 游戏服务器状态归属架构设计
  78. Godot 游戏客户端场景架构：把 Node 树从原型拉到可维护项目
  79. 个人游戏开发者成功案例：靠 Demo 节把短篇解谜游戏卖出去
  80. 个人游戏众筹推广：上线前两个月，页面其实已经开始决定成败
  81. 游戏客户端资源依赖图：为什么删一张贴图会炸三个界面
  82. 游戏赛季通行证的服务端设计
  83. 游戏本地化LQA流程：翻译完成后为什么还不能直接上线
  84. 游戏服务器领域驱动的服务边界设计
  85. 游戏发行合同怎么谈：分成、买断、里程碑和控制权的关键条款

April 72

  1. 游戏音乐和音频授权：BGM、语音、音效与直播版权怎么避坑
  2. 在线游戏服务器事故复盘怎么做
  3. 游戏定价和折扣策略：买断、DLC、捆绑包和促销怎么定
  4. 游戏客户端内置控制台与命令系统：调试能力要可控也要可追踪
  5. Godot 客户端可访问性选项：字幕、色彩、震动和输入替代
  6. 个人游戏长尾推广：卖完首周之后，怎样让游戏继续被发现
  7. 游戏服务器线上配置变更风控
  8. 个人游戏开发者失败案例：众筹成功后的预算崩盘
  9. 竞技游戏平衡委员会怎么运作：数据、玩家反馈和版本节奏
  10. 游戏主播发行打法：怎么让直播和短视频真正带来转化
  11. Godot 多人大厅实践：ENet、房间状态和客户端准备流程
  12. 游戏客户端云存档冲突处理：别让玩家自己猜哪份进度是真的
  13. 个人游戏开发者失败案例：最后才想起本地化的冒险游戏
  14. 游戏上线后路线图治理：承诺、优先级和玩家期待怎么管
  15. 游戏服务器限流与滥用保护设计
  16. Godot Camera2D 系统：跟随、边界、震屏和镜头叙事
  17. 游戏法务合规清单：上线前哪些文件和规则必须准备
  18. 游戏客户端平台 SDK 集成：登录、成就和支付都不是复制示例代码
  19. 个人游戏开发者失败案例：经济系统失控的放置游戏
  20. 个人移动游戏发行：上架应用商店前，先想清楚首日留存
  21. 游戏服务器存档数据迁移策略
  22. 个人游戏开发者失败案例：没有编辑器的叙事游戏
  23. Godot C# 与 GDScript 边界：性能、工具和团队协作怎么取舍
  24. 游戏客户端跨平台按键提示：别让手柄玩家看到键盘文案
  25. 游戏团队组织和招聘：不同阶段到底该招什么人
  26. 游戏外包供应商管理：从试单、验收到长期协作的实战方法
  27. 游戏交易与拍卖行服务端设计
  28. 缓存策略与设计模式：从本地缓存到分布式缓存的完整指南
  29. 游戏客户端背包界面性能：几百个道具不该让 UI 掉帧
  30. AI游戏资产管线：怎么用AI提效，同时不把版权和质量搞炸
  31. 个人游戏开发者失败案例：手感差一点的平台跳跃游戏
  32. Godot 本地化实践：TranslationServer、字体回退和对话文本排版
  33. 游戏隐私优先的数据分析：少收集、能解释、可合规的埋点方法
  34. 个人游戏中文社区推广：不要只发链接，要先成为一个具体的人
  35. Godot 2D 精灵导入流水线：Aseprite、SpriteFrames 和版本一致性
  36. 游戏客户端剧情演出流水线：别让 Cutscene 成为特殊代码集合
  37. 游戏无障碍设计干货：不是加字幕那么简单
  38. 游戏公会系统的服务端设计
  39. 个人游戏开发者失败案例：没有玩家池的卡牌对战游戏
  40. 游戏 Discord 社区运营：频道结构、版主管理和全球玩家互动
  41. Service Mesh实战：Istio与Envoy构建微服务流量治理体系
  42. 服务发现与健康检查：构建自适应的微服务架构
  43. 长线游戏留存设计：玩家为什么第二天、第七天、第三十天还会回来
  44. 个人游戏开发者失败案例：恐怖游戏 Demo 爆火后的崩盘
  45. 游戏客户端 Overdraw 优化：UI 和特效不该把屏幕刷成一层雾
  46. 游戏服务器支付回调与发货安全
  47. Godot 音频总线实践：音乐、音效、语音和运行时混音
  48. 数据库连接池优化：从原理到生产实践
  49. 游戏内容节奏日历：周活动、赛季、大版本和节日档期怎么排
  50. 个人游戏媒体包：别等编辑来猜你游戏有什么新闻点
  51. Godot 2D 光照与 Shader：氛围、可读性和移动端预算
  52. 数据仓库与湖仓一体架构：从OLAP到实时分析的演进
  53. 个人游戏开发者失败案例：被付费墙毁掉的手机益智游戏
  54. 游戏商店页转化干货：截图、标签、愿望单和首屏怎么做
  55. 游戏客户端配置表校验：别让一格表格毁掉整场活动
  56. 游戏服务器跨区域延迟与路由设计
  57. 游戏玩家信任怎么建立：公告、补偿、改动说明和长期沟通
  58. 游戏服务器缓存一致性与失效策略
  59. 游戏制作预算和排期：项目为什么总是超时超钱
  60. 个人游戏开发者失败案例：困在数值平衡里的 Roguelike
  61. 游戏客户端确定性模拟实践：不是所有同步都要逐帧追平
  62. Godot TileMap 与导航：2D 地图编辑、运行时阻挡和寻路更新
  63. API网关限流与熔断实战：保护后端服务的最后一道防线
  64. 2026 SaaS 行业报告：数据隐私与合规的新挑战
  65. 个人游戏发行定价：价格不是胆量测试，而是玩家预期管理
  66. 游戏制作人的风险台账：需求、进度、质量和成本怎么提前管
  67. 游戏客户端实体生命周期管理：怪物消失以后，引用还在不在
  68. 游戏服务器异步任务队列设计
  69. 游戏IP授权实操：从拿授权到上线，哪些坑必须提前避开
  70. Godot 信号事件流：从随手 connect 到可追踪的客户端事件边界
  71. 个人游戏开发者失败案例：承诺太多的治愈系农场游戏
  72. 游戏首发战情室怎么搭：上线前 72 小时到首周运营的实操清单

March 96

  1. 游戏客户端调试菜单设计：给研发和测试一把可靠的手电筒
  2. Godot 编辑器数据与运行时存档：关卡元数据如何安全进入客户端
  3. 游戏服务器线上可观测性实战手册
  4. 个人游戏技术方案案例：2D 游戏卡顿时，为什么先改资源管线而不是换渲染方案
  5. 个人游戏发布后一个月：真正的发行工作才刚刚开始
  6. 个人游戏开发者失败案例：把发行押在一个大主播身上
  7. Kite 关闭案例：AI 编程助手为什么早起飞却没飞远
  8. 游戏外包验收标准：怎么避免交付时才发现不能用
  9. 个人游戏开发者成功案例：为主播友好而设计的物理搞笑游戏
  10. 独立游戏成就与奖杯设计：Steam 成就、PSN 奖杯与成就系统最佳实践
  11. 游戏客户端补丁差分与 CDN 策略：更新包小，不代表更新体验好
  12. Godot 分辨率与 Stretch 策略：像素风、高清 UI 和多比例屏幕
  13. 游戏服务器 TCP WebSocket 与 QUIC 选择
  14. 个人游戏开发者成功案例：用 Demo 反馈循环打磨动作手感
  15. Powa Technologies 失败案例：宏大支付愿景为什么没有落地
  16. 游戏社区危机处理：差评、节奏和事故公告怎么应对
  17. 个人游戏开发者成功案例：一款温和移动小游戏如何靠订阅之外活下来
  18. 独立游戏存档系统设计：自动存档、云存档与存档数据结构完全指南
  19. 游戏经济系统的流水服务设计
  20. Godot 崩溃与诊断日志：导出包里也要知道发生了什么
  21. 游戏客户端内存泄漏排查：越玩越卡通常不是错觉
  22. 个人游戏开发者失败案例：没有考虑读档行为的策略游戏
  23. 个人游戏技术方案案例：剧情和关卡数据为什么没有直接写进代码
  24. BlueJeans 受挫案例：视频会议早入场，为什么没赢到最后
  25. 游戏埋点方案干货：上线后想看懂玩家，前期必须埋什么
  26. 个人游戏发行谈判：找发行商之前，先写清楚自己要什么
  27. Mod 支持与社区内容：延长游戏生命周期的 Mod 系统设计实战
  28. 个人游戏开发者成功案例：从失败 RPG 里拆出一款畅销小游戏
  29. 在线游戏服务端 NPC AI 调度
  30. Godot 桌面与 Steam 发布：导出、成就、云存档和覆盖层边界
  31. 游戏客户端断线重连与会话恢复：别让玩家卡在半个世界里
  32. 个人游戏开发者成功案例：程序和美术两人合作做完第一款游戏
  33. Evernote 受挫案例：最早装进用户大脑的笔记应用为什么掉队
  34. 个人游戏开发者成功案例：没有全球爆红，却在本地市场卖得很好
  35. 游戏支付与风控：充值到账、退款、盗刷和对账怎么管
  36. Game Jam 实战：如何用 Game Jam 提升技能、积累作品与建立人脉
  37. Godot 背包拖拽 UI：Control 拖放、堆叠拆分和事务确认
  38. 消息队列高级特性：死信队列、延迟消息与重试机制
  39. 领域驱动设计实战：从战略建模到战术落地的完整指南
  40. 个人游戏开发者失败案例：移动端测试不足毁掉首发
  41. Miro 案例：把白板做成远程团队的共同空间
  42. 在线游戏分区分服与分片设计
  43. 个人游戏技术方案案例：排行榜要不要自建后端
  44. 游戏平台审核干货：上线前哪些问题最容易卡住
  45. 游戏客户端手柄震动与触觉反馈：别只在爆炸时震一下
  46. 个人游戏开发者成功案例：接受发行商后，那个慢热叙事游戏终于被看见
  47. 独立游戏法律保护指南：版权、商标、合同与知识产权保护实战
  48. Godot 粒子与 VFX 池化：GPUParticles、CPUParticles 和特效生命周期
  49. API文档自动化：OpenAPI规范与Swagger实战指南
  50. 游戏客户端开局准备流程：进战斗前那几秒决定后面顺不顺
  51. 个人游戏推广案例：给主播写邮件前，先把可播性做出来
  52. 在线游戏后端反作弊信号设计
  53. 游戏用户研究实操：不要只问玩家喜不喜欢
  54. 个人游戏开发者成功案例：聪明使用素材商店做出完整动作游戏
  55. Toast 案例：把餐厅收银机做成经营平台
  56. 个人游戏开发者成功案例：靠 Mod 社区活起来的沙盒建造游戏
  57. 独立游戏主机移植实战：Switch、PlayStation、Xbox 移植流程与认证要求
  58. Godot glTF 资源导入：从 Blender 到运行时 3D 资产的可控链路
  59. 个人游戏开发者失败案例：只靠机器翻译毁掉了海外口碑
  60. Box 案例：在云盘红海里守住企业内容管理
  61. 个人游戏技术方案案例：存档系统为什么要从第一周开始设计
  62. 游戏客户端红点系统设计：小红点背后是复杂状态图
  63. 游戏关卡生产管线：从灵感到可上线关卡的完整流程
  64. 游戏服务器消息协议版本管理
  65. 个人游戏开发者成功案例：失败游戏里拆出一个赚钱的关卡工具
  66. 独立游戏多人网络基础：同步、延迟补偿与多人游戏开发实战指南
  67. 2026 SaaS 行业报告：AI 原生开发平台的崛起
  68. Godot PCK 内容包：DLC、热修和资源版本的客户端边界
  69. 游戏服务器运维干货：稳定在线不是堆机器那么简单
  70. 游戏客户端特效预算与对象池：华丽不能靠堆数量
  71. 个人游戏发行经验：Demo 节展不是考试，而是一次带问题的路演
  72. 大型游戏世界里的 AOI 系统设计
  73. gRPC流式通信实战：双向流、服务端推送与实时数据处理
  74. Snowflake 案例：把数据仓库做成云时代平台
  75. 个人游戏开发者成功案例：用会员订阅支撑长期开发
  76. 个人游戏开发者成功案例：把儿童编程做成一款能卖的解谜游戏
  77. 独立游戏平衡与经济系统设计：数值平衡、进度曲线与资源循环实战指南
  78. Godot CharacterBody3D 控制器：手感、坡面、台阶和相机协同
  79. 游戏服务器会话与重连令牌设计
  80. 游戏版本发布管理：从提测到上线，如何减少事故
  81. 个人游戏开发者失败案例：AI NPC 让小镇游戏失去边界
  82. Workday 案例：用云端系统重做 HR 和财务核心
  83. 分布式锁实现方案：Redis、ZooKeeper与etcd的实战对比
  84. 游戏客户端回放与问题复现：能复现的 Bug 才有尊严
  85. 个人游戏技术方案案例：解谜游戏为什么从 Unity 改选 Godot
  86. 个人游戏开发者成功案例：一款 20 分钟恐怖游戏卖出了长尾
  87. 独立游戏程序化生成实战：Roguelike 关卡生成、算法与内容复用技巧
  88. Godot 物理层与碰撞矩阵：别让 Area、Body 和射线互相误伤
  89. 个人游戏推广笔记：Steam 页面不是海报，而是一次十秒面试
  90. 个人游戏开发者成功案例：反复打磨商店页后卖出去的解谜冒险
  91. 游戏服务器如何做权威移动校验
  92. ServiceNow 案例：从 IT 工单到企业工作流平台
  93. 游戏客户端玩法模块边界：别让角色、UI 和网络互相拉扯
  94. 游戏经济系统实操：资源、货币和付费点如何不把项目带崩
  95. 个人游戏开发者成功案例：一个 Demo 如何把愿望单慢慢推到 2 万
  96. 独立游戏版本控制与项目管理实战：Git 工作流、分支策略与工具链完全指南

February 82

  1. 游戏服务器如何做优雅停服
  2. 个人游戏开发者失败案例：首发之后才真正崩溃
  3. 游戏客户端运营配置安全：配置灵活，也要防止把线上点炸
  4. Godot 平台生命周期：后台、暂停、窗口失焦和恢复状态
  5. GraphQL Federation：构建统一的微服务API网关
  6. 独立游戏数据分析实战：玩家行为追踪、留存优化与 A/B 测试指南
  7. 游戏行业人才培养：为什么会玩游戏不等于会做游戏
  8. Docker 受挫案例：开发者心智第一，不等于商业模式第一
  9. 个人游戏开发者坚持案例：一年做三款短篇游戏的人
  10. Godot 配置表导入：CSV、JSON、Resource 和运行时校验
  11. 游戏客户端构建与发布流水线：稳定出包也是核心能力
  12. 个人游戏开发者成功案例：关卡编辑器让益智游戏活得更久
  13. RethinkDB 失败案例：好技术为什么没有变成好生意
  14. 道具背包服务如何处理并发修改
  15. 数据库分片实战：水平扩展的架构设计与实现
  16. 独立游戏 QA 测试与 Bug 修复工作流：从崩溃日志到稳定发售的实战指南
  17. 游戏反作弊和安全：公平体验背后的攻防战
  18. 游戏客户端反作弊边界：客户端能做什么，不能假装什么都能做
  19. 个人游戏开发者失败案例：平台选择错了，游戏被渠道埋没
  20. 限流与熔断：构建高可用分布式系统的防护机制
  21. Godot 3D 世界空间 UI：交互射线、Viewport 纹理和焦点反馈
  22. 游戏服务器配置中心应该怎么落地
  23. Parse 关闭案例：开发者平台最怕失去长期承诺
  24. 独立游戏性能优化实战：帧率、内存与加载速度的系统调优指南
  25. 游戏中间件行业：为什么成熟团队不会什么都从零开始
  26. Godot 本地存档加密与完整性：防误改、防损坏和可恢复
  27. 个人游戏开发者成功案例：小范围付费 Alpha 帮他避开大坑
  28. 个人游戏开发者坚持案例：一边接外包，一边养自己的策略游戏
  29. 游戏客户端埋点事件设计：数据要能回答问题
  30. 战斗结算服务如何防止重复发奖
  31. 独立游戏发行商合作完全指南：合同条款、分成比例与避坑清单
  32. ScaleFactor 失败案例：自动化会计没有自动化到位
  33. GraphQL订阅与实时更新：构建响应式数据流架构
  34. 全球游戏市场差异：同一款游戏为什么在不同地区表现完全不同
  35. 游戏客户端辅助功能选项：不是小众需求，而是基本体验
  36. 个人游戏开发者失败案例：教程墙挡住了玩家
  37. Godot 游戏内调试控制台：命令、权限和运行时诊断
  38. Datadog 案例：从监控工具到云原生观察平台
  39. 活动服务器为什么要做开关和灰度
  40. 独立游戏众筹实战：Kickstarter 从策划到交付的完整流程指南
  41. 游戏商业化伦理：赚钱和伤害玩家之间的边界在哪里
  42. SaaS 行业观察：量子计算时代的网络安全挑战与应对
  43. 个人游戏开发者坚持案例：靠社区试玩慢慢打磨的农场游戏
  44. Godot Timer 与暂停系统：游戏时间、UI 时间和慢动作不要混在一起
  45. 游戏客户端本地化与 CJK 排版：翻译完不代表能上线
  46. 配置管理与特性开关：构建灵活可控的运行时配置系统
  47. 个人游戏开发者成功案例：浏览器小游戏也能成为稳定收入
  48. 副本服务器如何处理玩家中途掉线
  49. DocuSign 案例：电子签名的核心不是签字，而是信任
  50. 独立游戏手柄适配与无障碍设计完全指南：让每个玩家都能玩你的游戏
  51. 游戏叙事设计：故事为什么不能只写在剧情文本里
  52. 个人游戏开发者失败案例：外包美术没有管线，风格越做越乱
  53. 大地图游戏客户端场景流式加载：让世界大起来，也要稳起来
  54. Godot Gameplay 对象池：子弹、掉落物和浮字的复用边界
  55. Calendly 案例：一个预约链接如何做成 SaaS 生意
  56. 游戏音频行业：那些容易被忽略却决定沉浸感的声音
  57. 独立游戏关卡设计实战：空间引导、难度曲线与环境叙事完全指南
  58. 游戏邮件系统要注意哪些服务端细节
  59. 数据库事务隔离级别与并发控制：从理论到实践
  60. 个人游戏开发者坚持案例：把周末项目做成三年长跑
  61. Godot 任务图 Resource：条件、奖励和节点编辑的客户端做法
  62. 个人游戏开发者成功案例：靠开发日志慢慢养大的动作游戏
  63. 游戏客户端 Shader 变体管理：首帧卡顿往往藏在这里
  64. 云游戏行业：把游戏放到云端，难点不只是网速
  65. 排行榜服务为什么不能只用一张表
  66. 独立游戏叙事设计实战：分支对话、环境叙事与情感节奏设计指南
  67. Dropbox 案例：把文件同步做到让人忘记技术存在
  68. 个人游戏开发者失败案例：程序生成地图越做越空
  69. 移动游戏客户端发热与耗电优化：性能不是跑满就算赢
  70. Godot 技能 Ability 架构：用 Resource 描述规则，用 Node 表现效果
  71. 跨服聊天系统的服务端设计
  72. Atlassian 案例：不靠传统销售也能卖进企业
  73. 游戏数据分析：为什么策划越来越需要看懂数字
  74. 独立游戏音效与配乐设计指南：从音频基础到引擎集成的完整实战
  75. 个人游戏开发者坚持案例：靠每月小更新活下来的地牢游戏
  76. 游戏服务器如何设计可靠的心跳机制
  77. 动作游戏客户端镜头系统：玩家看得清才谈得上打得爽
  78. Salesforce 案例：把 CRM 从机房搬到浏览器
  79. Godot HTTP API 客户端：登录、鉴权、重试和错误码边界
  80. 游戏测试行业：玩家看到流畅体验之前，QA团队在做什么
  81. 个人游戏开发者成功案例：用抢先体验控制范围的生存建造游戏
  82. 独立游戏像素美术与视觉风格设计实战：从零打造统一画风

January 82

  1. 个人游戏开发者失败案例：定价和内容预期错位
  2. 游戏客户端崩溃日志与可观测性：线上问题要能找回现场
  3. Godot 客户端发布前体检：资源、平台、日志和玩家路径的最后检查
  4. 压测游戏服务器时不要只看在线人数
  5. 独立游戏发售后运营实战：DLC 策略、社区管理与长尾收入最大化
  6. 个人游戏开发者失败案例：下班后做了两年，最后被项目耗空
  7. InVision 受挫案例：领先的原型工具为什么没守住协作时代
  8. SaaS 行业观察：边缘计算与离线 AI 能力的崛起
  9. 个人游戏开发者成功案例：用垂直切片拿到发行支持
  10. 分布式ID生成方案：Snowflake算法、UUID与序列号生成器实战
  11. Godot 编辑器与运行时开关：调试功能、实验玩法和灰度配置
  12. 游戏服务器热更新的边界在哪里
  13. 游戏客户端热更新边界：哪些东西适合热，哪些不该热
  14. 独立游戏商业化：小团队如何在热爱之外算清账
  15. Zenefits 受挫案例：高速增长撞上合规红线
  16. 独立游戏 Early Access 完全指南：何时用、怎么上、如何成功转正
  17. 个人游戏开发者失败案例：Demo 做得太晚，问题已经改不动
  18. UGC和Mod经济：为什么玩家创作正在变成游戏公司的第二条生命线
  19. 游戏客户端音频系统实践：声音不是最后再补的装饰
  20. Atrium 失败案例：法律科技不是把律师换成软件那么简单
  21. Godot 资源唯一 ID：路径会变，配置引用不能跟着断
  22. 玩家数据落库要避免哪些坑
  23. Steam 推荐算法深度解析：曝光机制、发现队列与流量获取实战指南
  24. 个人游戏开发者失败案例：没人在线的多人竞技游戏
  25. 个人游戏开发者成功案例：从第一天准备多语言的叙事游戏
  26. 数据同步与CDC实战：基于Debezium构建实时数据管道
  27. 游戏服务器日志应该记录什么
  28. 游戏客户端动画状态机：别让角色看起来像在抢拍
  29. Godot 脚本状态机模式：角色、UI 和流程控制如何避免 if 地狱
  30. 电竞产业结构：一场比赛之外，谁在支撑整个生意
  31. Fast 失败案例：一键结账没有撑起一家公司
  32. 独立游戏多语言本地化实战：从文本系统搭建到 12 种语言覆盖指南
  33. 个人游戏开发者失败案例：功能投票把路线图变成拼盘
  34. Notion 案例：用灵活积木和社区模板打开知识管理市场
  35. 游戏本地化不只是翻译：出海项目为什么会在细节里输掉
  36. 游戏客户端本地存档与缓存：能离线不等于可以乱存
  37. 匹配服务不只是把玩家凑成一局
  38. Godot 对话打字机效果：逐字显示、跳过、语音和选项节奏
  39. 独立游戏营销日历：发售前 6 个月到发售后的完整宣发作战计划
  40. 个人游戏开发者成功案例：用外包收入养出的个人游戏
  41. 游戏美术外包行业：一张角色立绘背后的协作链条
  42. 个人游戏开发者失败案例：以为靠广告就能赚钱的休闲手游
  43. Godot 可交互对象系统：提示、条件、优先级和交互事务
  44. 游戏客户端输入系统设计：手感从按下那一刻开始
  45. Shopify 案例：把开店软件做成商家生态
  46. API网关架构设计与实现：路由、鉴权与流量治理
  47. 时序数据库实战：InfluxDB与TimescaleDB的架构设计与应用
  48. 状态同步游戏如何减少带宽压力
  49. 独立开发者 AI 工具链实战：用 AI 提效美术、代码、音乐与测试（2025-2026）
  50. 游戏引擎也是一门生意：Unity、Unreal、Godot背后的行业逻辑
  51. 个人游戏开发者失败案例：忽视素材授权让项目临近发布返工
  52. HubSpot 案例：从营销工具到中小企业增长平台
  53. Godot 2D 视差背景：Parallax2D、相机速度和循环层管理
  54. 游戏客户端网络同步：不要把所有问题都推给延迟
  55. SaaS 行业观察：AI Agent 间的协作与协商机制
  56. 帧同步服务器到底负责什么
  57. 独立游戏定价策略完全指南：从数据模型到折扣节奏的实战手册
  58. 直播和社区如何改变游戏行业：玩家不只是消费者
  59. 个人游戏开发者成功案例：先做好声音的节奏动作游戏
  60. 长线运营游戏的客户端 UI 架构：活动越多越要克制
  61. Godot 导入预设治理：纹理、音频、模型设置别靠手点
  62. 个人游戏开发者失败案例：Steam 裸发后无人问津的解谜游戏
  63. Figma 案例：把设计工具从文件时代带到协作时代
  64. 游戏买量入门：广告投放为什么越来越像一门精密生意
  65. 房间服崩溃后怎样恢复玩家状态
  66. 实时通信架构：WebSocket、SSE与长轮询的设计与实践
  67. 独立游戏预告片制作实战：单人开发者零预算做出专业级 Trailer
  68. 个人游戏开发者失败案例：反复换引擎让项目停在起点
  69. Godot Autoload 启动顺序：服务初始化、依赖和首屏耗时
  70. Zoom 案例：在拥挤市场里靠可靠体验突围
  71. 游戏客户端资源加载设计：别让 Loading 条替你背锅
  72. 手游长线运营：为什么一款游戏上线后才是真正开始
  73. 游戏网关服务如何扛住登录高峰
  74. Steam 商店页优化实战：封面、标签、截图与文案的转化率指南
  75. 个人游戏开发者失败案例：那个不断加功能的像素 RPG
  76. 个人游戏开发者成功案例：从 Game Jam 原型做成商业小品
  77. 游戏发行产业链：一款游戏从立项到卖出去，中间到底发生了什么
  78. Godot 项目目录约定：让 scenes、scripts、resources 不再互相缠绕
  79. 游戏客户端帧节奏优化：比平均帧率更重要的体验指标
  80. 实时游戏服务器为什么需要时间同步
  81. Slack 案例：从游戏公司副产品到团队协作基础设施
  82. 独立游戏核心循环与手感设计实战指南：让玩家"停不下来"的系统方法论
2025 790 篇文章

December 52

  1. Plumego Best Practices · 一个真实业务（用户中心）的完整示例
  2. 一个真实业务（用户中心）的完整 Plumego 示例
  3. SaaS 市场时机判断：太早、太晚和刚刚好的信号
  4. Plumego Roadmap
  5. Plumego Docs 信息架构（IA）总览
  6. Plumego Best Practices
  7. Plumego 入门：一个克制而清晰的 Go 服务框架
  8. 什么时候不该使用 Plumego
  9. Plumego vs 常见 Go 框架：设计取舍说明
  10. Plumego：一个回归 Go 本质的极简服务框架
  11. SaaS 创始人客服手册：把每次支持都变成产品和销售线索
  12. SaaS 收费和账单设置：从第一笔收入开始就别手忙脚乱
  13. 独立游戏商业化现实：买断、免费、DLC、广告与长期运营怎么选
  14. 独立游戏上线前检查清单：Steam 页面、Demo、愿望单与发布节奏
  15. 独立游戏开发的工程策略：一个人如何控制复杂度
  16. 独立游戏 MVP 设计：如何在 30 天内验证一款游戏是否值得继续做
  17. 独立开发者生存指南（十）：12 个月生存路线图——把混乱的尝试，变成可控的系统
  18. 独立开发者生存指南（九）：失败、暂停与转向——什么时候该坚持，什么时候该放弃
  19. 独立开发者生存指南（八）：时间、精力与心理——如何避免在长期不确定中崩溃
  20. 独立开发者生存指南（七）：推广与增长——为什么你不该追求“爆款”
  21. 独立开发者生存指南（六）：变现与定价——为什么“免费”往往是最贵的选择
  22. 独立开发者生存指南（五）：产品与体验——为什么“功能多”反而更难赚钱
  23. 独立开发者生存指南（四）：工程与技术策略——为什么“技术先进”往往是失败信号
  24. 独立开发者生存指南（三）：从想法到验证，如何在不 All in 的情况下启动项目
  25. 独立开发者生存指南（二）：方向选择才是真正的生死分叉点
  26. 独立开发者生存指南（一）：你以为你在创业，其实你在求生
  27. 独立开发者生存指南
  28. 独立游戏开发者如何选择第一款游戏：从兴趣到可完成项目
  29. SaaS 首次实施清单：让客户买完之后真的上线
  30. 一个完整的独立游戏开发者失败案例：三年、一个人、一款没能活下来的游戏
  31. 独立开发者失败案例：那些真正教会你活下来的错误
  32. 独立开发者的故事：那些没有写在成功案例里的真实人生
  33. 独立开发者生存指南（进阶扩展篇）
  34. 个人工具 / SaaS 的选题池与验证方法
  35. 从工程、产品到商业的一整套独立项目模板
  36. 面向开发者的低成本变现模型设计
  37. 独立开发者 12 个月生存路线图
  38. 个人独立开发者生存指南
  39. Go 学习路线图：从入门到专家
  40. SaaS 激活邮件设计：让新用户在第一周完成关键动作
  41. SaaS 销售演示脚本：早期 Demo 不要从功能列表开始
  42. SaaS 产品范围控制：如何拒绝看似合理但会拖垮团队的需求
  43. 为什么 Bun 这么快？深入解析 Zig + JavaScriptCore + Bundler 架构
  44. Node.js vs Bun vs Deno：三大 JavaScript Runtime 架构深度对比
  45. 选择 Node / Bun / Deno 的架构决策指南
  46. Node.js 性能调优指南
  47. Node.js 架构图解析：事件循环、线程池与 N-API
  48. Node.js 深度解析：运行时架构、事件循环、性能模型与未来路线
  49. Node.js 简介：历史、特性、发展与未来
  50. SaaS 小众需求调研：如何判断一个窄市场值不值得做
  51. SaaS 客户分层：早期不要用同一套方式服务所有客户
  52. SaaS 创始人操作系统：从混乱推进到每周可复盘

November 120

  1. 可观测性工程：结构化日志、Prometheus指标与OpenTelemetry链路追踪
  2. 后端安全架构：OAuth2.1、JWT认证与零信任网络实战指南
  3. SaaS 早期决策日志：为什么小团队也要记录关键取舍
  4. CI/CD与GitOps实践：从代码提交到生产部署的自动化流水线设计
  5. Kubernetes容器编排实战：从Pod到生产级部署的完整指南
  6. 消息队列与事件驱动架构：Kafka、RabbitMQ与事件溯源实战
  7. 数据库扩展与性能优化：索引策略、分库分表与读写分离完全指南
  8. 数字无极小程序问答设计
  9. 高可用架构与灾备设计：多活部署、故障转移与RTO/RPO实战
  10. 分布式系统一致性与可用性：CAP定理、共识算法与容错设计详解
  11. SaaS 早期销售管道：不用复杂 CRM，也要管住每个机会
  12. Next.js 完全指南 — 第 1 章：Next.js 的出现、背景与核心理念（Part 1）
  13. API设计实战：REST、gRPC与GraphQL的选型、规范与版本管理
  14. 微服务架构设计模式：API网关、服务发现与分布式通信实战指南
  15. 后端架构的长期主义：从边界设计到平台化治理的实践哲学
  16. 2025 后端架构实战指南：从单体演进到云原生可观测系统的全栈最佳实践
  17. Steam 发行商与外包交接：独立游戏上架资料如何避免失控
  18. Jamstack 独立开发盈利模式分析（AdSense / 订阅 / API SaaS）
  19. 基于 Jamstack 的 SaaS 设计架构与多租户模型
  20. 基于 Next.js 的 Jamstack / SSR / SPA 混合实践指南
  21. Jamstack vs SSR vs SPA：现代前端架构的系统对比
  22. Jamstack 架构详解：现代 Web 的高性能构建方式
  23. 第 7 章：Next.js 数据获取体系
  24. 第 6 章：Client Components 与浏览器端交互
  25. 第 5 章：React Server Components 深入解析
  26. 第 4 章：现代 Web 渲染模型全景
  27. 第 3 章：App Router 目录结构全解构
  28. 第 2 章：快速上手 — 创建你的第一个 Next.js 项目
  29. Next.js 完全指南：从入门到 SaaS 生产实战（2025 App Router）
  30. 第 1 章：Next.js 简介与核心理念
  31. Next.js 介绍
  32. 附录 C：Tailwind CSS 速查表（Cheat Sheet）
  33. 附录 B：Tailwind + shadcn/ui 最佳实践组件示例
  34. 附录 A：Tailwind 全类名一览表
  35. 第 12 章：Tailwind 与主流 UI 框架全面对比
  36. 第 11 章：Tailwind 与原子化 CSS 的未来趋势（StyleX / UnoCSS / WindiCSS 深度对比）
  37. 第 10 章：Tailwind 在企业级 Design System 的落地方案
  38. 第 9 章：Tailwind 与最佳实践 UI 组件体系
  39. 第 8 章：Tailwind 生态系统深度解析
  40. 第 7 章：Tailwind 插件系统（Plugin API 深度解析）
  41. 第 6 章：Tailwind 的高级工程化体系（企业级）
  42. 第 5 章：Tailwind 在现代前端框架中的实践（React / Vue / Next.js / Nuxt / Svelte / Solid）
  43. Tailwind CSS 详解
  44. SaaS 落地页信息测试：还没写完产品，也能验证客户是否看懂
  45. Birdor 商业计划书第七章：Birdor 的必要性与市场空白
  46. Birdor 商业计划书第六章：全球开发者工具竞品矩阵
  47. Birdor 商业计划书第五章：开发者生产力市场的可持续增长分析
  48. Birdor 商业计划书第四章：AI 工具与自动化工具的新机会窗口
  49. Birdor 商业计划书第三章：MicroSaaS 与工具平台化趋势
  50. Birdor 商业计划书第二章：全球在线工具站行业现状
  51. Birdor 商业计划书第一章：AI 时代的开发者生态变革
  52. Birdor 商业计划书：AI 时代全球开发者工具平台目录
  53. Cloudflare 详细介绍
  54. Cloudflare Pages 介绍（2025 技术版）
  55. Vercel 与 Netlify、Render、Railway、Cloudflare Pages 对比：SaaS 场景下的部署选择
  56. 用 Vercel 部署一个 Next.js + Postgres 的 SaaS Demo
  57. vercel 介绍
  58. 独立游戏 Demo 制作指南：黄金结构、内容深度与节奏设计（2025 完整版）
  59. 独立游戏开发者避坑手册：50 个最常见失败陷阱与应对策略（2025）
  60. 独立游戏开发者：从 0 到上线的完整实战流程指南
  61. 独立游戏全球发行财务结构设计指南：多币种结算与税务优化
  62. 香港公司开户 + Steam 收款操作指南（实战版）
  63. 独立游戏海外发行合规与税务风险清单：W-8BEN、GDPR 与跨境收款
  64. Steam 还是 Epic：独立游戏 PC 发行平台选择指南
  65. 独立游戏单人开发完整路线图：9 个月从立项到发售的实战指南
  66. 独立游戏开发者指南：移动端与 Steam 平台深度对比与发展策略
  67. 独立游戏移动端 vs Steam 平台深度对比：开发者选平台终极指南
  68. Steam 游戏长期运营：折扣、更新、DLC 与长尾销售复盘
  69. Steam 独立游戏营销指南：愿望单、Demo、创作者与社群增长
  70. Steam 游戏发行实操指南：独立开发者从商店页到首发复盘
  71. 独立游戏适合上 Steam 吗：机会、成本与发行前判断
  72. 游戏商业核心指标详解
  73. 游戏制作人知识储备汇总
  74. 游戏服务端进阶知识储备汇总
  75. 游戏服务端高级进阶知识储备汇总
  76. 游戏服务端入门知识储备汇总
  77. SaaS 设计伙伴计划：如何找客户共创，但不变成免费外包
  78. Dell R650 vs HPE DL360 Gen11 企业级服务器深度评测
  79. 在线联机原型全集：第 28 章　副本脚本系统
  80. 在线联机原型全集：第 27 章　协作建造系统（Cooperative Building System）
  81. 在线联机原型全集：第 26 章　合作解谜系统（Cooperative Puzzle System）
  82. 在线联机原型全集：第 25 章　市场系统（Market System）
  83. 在线联机原型全集：第 24 章　动态赛事系统（Dynamic Tournament System）
  84. 在线联机原型全集：第 23 章　跨服战系统
  85. 在线联机原型全集：第 22 章　公会建设
  86. 在线联机原型全集：第 21 章　异步远征（Async Expedition）——延迟任务 / 幂等结算原型
  87. 在线联机原型全集：第 20 章　社交大厅（Platform Lobby｜Multi-Room Roaming & Unified Identity）
  88. 在线联机原型全集：第 19 章　战场吃鸡
  89. 在线联机原型全集：第 18 章　城市经营
  90. 在线联机原型全集：第 17 章　战棋对战
  91. 在线联机原型全集：第 16 章　简版 MOBA（Battle + AI Units｜Tick Sync, Reconnect & Recovery）
  92. 在线联机原型全集：第 15 章　微型赛车系统（Mini Racing System）
  93. 在线联机原型全集：第 14 章　房间逃脱（Room Escape — Synchronous Puzzle）
  94. 在线联机原型全集：第 13 章　小队生存系统
  95. 在线联机原型全集：第 12 章　Elo 与 Glicko-2 评分系统详解
  96. 在线联机原型全集：第 12 章　团队占点
  97. 在线联机原型全集：11.1 团队塔防设计
  98. 在线联机原型全集：第 11 章　团队塔防
  99. 在线联机原型全集：第 10 章　城格建造 mini-SLG（City SLG Mini）
  100. 在线联机原型全集：第 9 章　协作扫雷 / 限时合作解谜（Cooperative Minesweeper）
  101. 在线联机原型全集：第 8 章　战舰（Battleship） / UNO 简版
  102. 在线联机原型全集：第 7 章　贪吃蛇大作战（Snake Battle）
  103. 在线联机原型全集：第 6 章　Pong 对战（Realtime 60 FPS 原型）
  104. 在线联机原型全集：第 5 章　你画我猜（Pictionary / 白板协作）
  105. 在线联机原型全集：第 4 章　快速问答抢答（Trivia Buzzer）
  106. 在线联机原型全集：第 3 章　井字棋 / 四子棋（Tic-Tac-Toe / Connect Four）
  107. 在线联机原型全集：第 2 章　石头剪刀布（Rock–Paper–Scissors, RPS）
  108. 在线联机原型全集：第 1 章　聊天室（Echo Chatroom）
  109. 「在线联机原型全集」第七章：验证体系全景图
  110. 「在线联机原型全集」第六章：AI 自治文明与永续世界（#51–#60）
  111. 「在线联机原型全集」第五章：智能调节与自愈层（#41–#50）
  112. 「在线联机原型全集」第四章：开放世界与生态层（#31–#40）
  113. 「在线联机原型全集」第三章：异步与平台化层（#21–#30）
  114. 「在线联机原型全集」第二章：协作与实时竞技层（#11–#20）
  115. 「在线联机原型全集」第一章：通信与回合制基础层（#1–#10）
  116. 「在线联机原型全集」从聊天室到永续宇宙
  117. 「在线联机原型全集」产品汇总
  118. SaaS 客户发现访谈：早期电话到底该问什么
  119. ClickHouse 深入解析与实战
  120. clickhouse和tidb对比分析

October 129

  1. 大型 MMO+SLG 游戏网关与世界服通信架构设计
  2. 为什么让客户端决定战斗结果会摧毁整个游戏系统
  3. 分布式时间（Distributed Time）与多世界同步体系
  4. 状态即数据流（State-as-Stream）与游戏世界的持续计算模型
  5. AI 驱动的自适应状态同步与智能容灾架构
  6. 从无状态演进到 Serverless —— 游戏状态管理的未来架构趋势
  7. 《游戏服务端编程实践》思考02：从 Go 工程视角看有状态架构的实现与演化
  8. 《游戏服务端编程实践》思考01：为什么游戏服务器必须是有状态的？能否设计成无状态架构？
  9. SaaS 行业观察：AI 驱动的安全防护与威胁检测
  10. 《游戏服务端编程实践》3.3.3 消息路由与分发策略
  11. 《游戏服务端编程实践》3.3.2 封包拆包、粘包与断线重连
  12. 《游戏服务端编程实践》3.3.1 消息头与命令号设计
  13. 《游戏服务端编程实践》3.2.3 序列化性能与内存占用对比
  14. 《游戏服务端编程实践》3.2.2 JSON、MsgPack、Cap’n Proto
  15. 《游戏服务端编程实践》3.2.1 Protobuf 与 FlatBuffers
  16. 《游戏服务端编程实践》3.1.3 延迟与丢包问题分析
  17. 《游戏服务端编程实践》3.1.2 游戏中的连接保持与心跳机制
  18. 《游戏服务端编程实践》3.1.1 TCP / UDP / WebSocket 对比
  19. 《游戏服务端编程实践》2.3.4 Rust Tokio + Actix
  20. 《游戏服务端编程实践》2.3.3 Skynet（Lua）
  21. 《游戏服务端编程实践》2.3.2 Go net/http + goroutine
  22. 《游戏服务端编程实践》2.3.1 Netty（Java）
  23. 《游戏服务端编程实践》2.2.3 线程池与任务分发策略
  24. 《游戏服务端编程实践》2.2.2　Channel 通信与消息投递
  25. 《游戏服务端编程实践》2.2.1　Actor 模型详解（Akka / Erlang）
  26. 《游戏服务端编程实践》2.1.3 多线程与协程的差异
  27. 《游戏服务端编程实践》2.1.2 Reactor 模式与事件循环
  28. 《游戏服务端编程实践》2.1.1　阻塞与非阻塞 I/O
  29. 《游戏服务端编程实践》1.4.1 典型架构演进
  30. 《游戏服务端编程实践》1.4.0 游戏服务器的通信体系与协议设计
  31. 《游戏服务端编程实践》1.3.1 游戏服务器的生命周期
  32. 《游戏服务端编程实践》1.3.0 游戏服务器的核心模块与职责
  33. 《游戏服务端编程实践》1.2.5 服务器架构的比较与统一演化
  34. 《游戏服务端编程实践》1.2.4 FPS / MOBA 实时性特征与总体架构
  35. 《游戏服务端编程实践》1.2.3 SLG / 策略类游戏架构模式详解
  36. 《游戏服务端编程实践》1.2.2 MMO（大型多人在线游戏）架构模式详解
  37. 《游戏服务端编程实践》1.2.1 单机、局域网与在线游戏对比
  38. 《游戏服务端编程实践》1.1.2 客户端与服务端的职责划分
  39. 《游戏服务端编程实践》1.1.3 状态保持与逻辑权威
  40. 《游戏服务端编程实践》1.1.1 为什么需要服务器
  41. SaaS 备份和恢复：早期别等数据出事才补基本功
  42. 《游戏服务端编程实践》1.2 游戏类型与服务端架构
  43. 《游戏服务端编程实践》1.1 游戏服务器的定义与职责
  44. QuickJS 集成与实践指南
  45. 《游戏服务端编程实践》目录
  46. SaaS 模板产品化：把一次成功交付变成标准开局
  47. QuickJS 与 Lua 的深度对比与实战分析
  48. QuickJS介绍
  49. 「DeployLite」品牌视觉与叙事白皮书
  50. 「DeployLite」梦开始的地方
  51. 「DeployLite」技术实现详解（工程手册）（Engineering Implementation Handbook）
  52. 「DeployLite」系统架构白皮书（System Architecture Whitepaper）
  53. 「DeployLite」第十章：附录
  54. 「DeployLite」第九章：版本规划与迭代路线（Version Planning & Iteration Roadmap）
  55. 「DeployLite」第八章：验收标准与测试计划（Acceptance Criteria & QA Plan）
  56. 「DeployLite」第七章：技术实现与接口设计（Technical Implementation & API Specification）
  57. 「DeployLite」第六章：交互原型与用户体验设计（Interaction Design & UX Specification）
  58. 「DeployLite」第五章：非功能性需求与运维保障
  59. 「DeployLite」第四章：进阶功能与策略化能力（Advanced & Strategic Features）
  60. 「DeployLite」第三章：核心功能需求
  61. 「DeployLite」第二章：总体架构与系统设计（System Architecture & Design）
  62. 「DeployLite」第一章：产品概述与背景
  63. 「DeployLite」目录：轻量级打包与部署平台 PRD
  64. 「DeployLite」功能与特性清单
  65. 「DeployLite」技术白皮书
  66. 「DeployLite」商业计划书
  67. SaaS 小团队协作节奏：两三个人也需要明确谁在推进什么
  68. Python 发展史：众人的语言（第三卷）
  69. Python 发展史：众人的语言（第二卷）
  70. Python 发展史：众人的语言（第一卷）
  71. 游戏服务器战斗遥测采样架构设计
  72. Python 极简入门教程
  73. 「产品矩阵平台」未来演进方向
  74. 「产品矩阵平台」运维与成本优化
  75. 「产品矩阵平台」安全与合规体系
  76. 「产品矩阵平台」SaaS 商业化能力
  77. 「产品矩阵平台」DevOps 与可观测性
  78. 「产品矩阵平台」平台级 AI 支撑架构
  79. 「产品矩阵平台」高并发与可用性架构
  80. 「产品矩阵平台」数据与缓存架构
  81. 「产品矩阵平台」可扩展的服务框架
  82. 「产品矩阵平台」多租户与多应用设计
  83. 「产品矩阵平台」业务域服务体系
  84. 「产品矩阵平台」平台通用能力中心
  85. 「产品矩阵平台」核心技术架构层
  86. 「产品矩阵平台」总体架构蓝图
  87. 「产品矩阵平台」后端架构白皮书目录结构
  88. SaaS 试点范围控制：小范围成功，比大范围失控更有价值
  89. 「UptimeMonitor」商业计划书
  90. Go 代码审查指南：从检查清单到团队协作
  91. SaaS 原型可用性测试：写代码前先看客户会不会走通流程
  92. Steam 发售后版本治理：补丁、分支、公告和存档兼容的长期规则
  93. SaaS 等待名单验证：不要把邮箱数量误当成真实需求
  94. 「小游戏引擎」公司治理与股权架构白皮书
  95. 「小游戏引擎」公司结构设计
  96. 「小游戏引擎」 系统规划（完整版）
  97. 「小游戏引擎」 项目实施计划（Sprint）
  98. 「小游戏引擎」 商业计划 PPT 内容稿（Infrastructure）
  99. 「小游戏引擎」系统蓝图（PRD）
  100. 「小游戏引擎」 功能特性（Feature）
  101. 「小游戏引擎」 商业计划 PPT 内容稿
  102. 「小游戏引擎」的主要痛点（SWOT Analysis）
  103. 「小游戏引擎」市场分析（Marketing Analysis）
  104. 「小游戏引擎」商业计划书
  105. 个人开发者产品方向扩展清单（第十四版）
  106. 个人开发者产品方向扩展清单（第十三版）
  107. 个人开发者产品方向扩展清单（第十二版）
  108. 个人开发者产品方向扩展清单（第十一版）
  109. 个人开发者产品方向扩展清单（第十版）
  110. 个人开发者产品方向扩展清单（第九版）
  111. 个人开发者产品方向扩展清单（第八版）
  112. 个人开发者产品方向扩展清单（第七版）
  113. 个人开发者机会地图
  114. 个人开发者产品方向扩展清单（第六版）
  115. 个人开发者产品方向扩展清单（第五版）
  116. 个人开发者产品方向扩展清单（第四版）
  117. 个人开发者产品方向扩展清单（第三版）
  118. 个人开发者扩展产品方向清单（第二版）
  119. 个人开发者可行的产品方向扩展清单
  120. 个人开发者适合的产品方向推荐清单
  121. AI 时代 SaaS 创业赛道地图
  122. 「Webhooks」平台高优先级用户故事与测试用例
  123. 「Webhooks」核心页面设计
  124. 「Webhooks」功能需求文档
  125. 「Webhooks」产品需求文档（PRD）
  126. 「Webhooks」商业计划书
  127. 「Webhooks」商业可行性分析报告
  128. 「Webhooks」商业推广计划（GTM）
  129. 「Webhooks」创业机会地图

September 57

  1. 游戏服务器剧情分支状态架构设计
  2. SaaS 产品内提示：别把新手引导全部丢给客服和文档
  3. 小游戏平台 + Web 引擎 + 可视化编辑器项目预算表
  4. 小游戏平台 + Web 引擎 + 可视化编辑器项目任务单
  5. 小游戏平台 + Web 引擎 + 可视化编辑器项目路线图
  6. 小游戏平台 + Web 引擎 + 可视化编辑器飞书任务清单
  7. 小游戏平台 + Web 引擎 + 可视化编辑器功能清单
  8. 小游戏平台 + Web 引擎 + 可视化编辑器
  9. 「小游戏服务平台」商业模式与技术可行性
  10. 「小游戏服务平台」Web 游戏引擎 + 小游戏平台 路线图（Gantt 风格）
  11. 「小游戏服务平台」轻量级 Web 游戏引擎 & 编辑器 + 平台 功能路线图
  12. 「小游戏服务平台」轻量级 Web 游戏引擎 & 平台一体化架构
  13. 「小游戏服务平台」游戏编辑器
  14. 「小游戏服务平台」融资计划扩展版
  15. 「小游戏服务平台」融资计划
  16. 「小游戏服务平台」（扩展工程版）
  17. 「小游戏服务平台」错误码手册
  18. 「小游戏服务平台」错误码规范（落地实现版）
  19. 「小游戏服务平台」错误码规范
  20. 「小游戏服务平台」ADR
  21. 「小游戏服务平台」API
  22. 「小游戏服务平台」技术方案
  23. 「小游戏服务平台」PRD蓝皮书
  24. 「小游戏服务平台」功能设计
  25. 「小游戏服务平台」产品需求清单
  26. 「小游戏服务平台」商业计划书
  27. 「短网址服务」的商业前景展望
  28. 「短网址服务」的商业拓展计划
  29. 「短网址服务」的商业模式画布
  30. SaaS 早期法务边界：条款、隐私、数据责任先做到够用
  31. 「短网址服务」的商业模式
  32. 「短网址服务」的创新与独特功能扩展
  33. 「短网址服务」官网
  34. 「短网址服务」品牌故事
  35. 「短网址服务」短网址服务功能进阶路线图
  36. 「短网址服务」架构演进路线图
  37. 「短网址服务」运维监控指标清单
  38. 「短网址服务」架构部署图
  39. 「短网址服务」上线前检查清单
  40. 「短网址服务」安全测试清单
  41. 「短网址服务」性能测试点清单
  42. 「短网址服务」测试用例大纲
  43. 「短网址服务」低保真草图清单
  44. 「短网址服务」产品UI需求
  45. 「短网址服务」错误码规范
  46. 「短网址服务」功能设计
  47. 「短网址服务」产品需求
  48. 「短网址服务」商业计划书
  49. SaaS 创始人销售复盘：每周看哪些线索、话术和丢单原因
  50. SaaS 采购材料包：小团队也要帮客户完成内部审批
  51. SaaS 替换触发点：客户什么时候才愿意从旧工具换到你
  52. SaaS 价值指标选择：到底按席位、用量还是业务对象收费
  53. 2025 SaaS 行业报告：AI 驱动的客户成功与留存策略
  54. SaaS 用户角色设计：不要把所有人都做成管理员
  55. SaaS 功能开关：早期如何安全发布和灰度试点客户
  56. SaaS 早期异议处理：客户说贵、怕麻烦、不确定时怎么推进
  57. SaaS 第一个案例大纲：客户成功还没很大，也能写出可信材料

August 25

  1. Go 反模式：常见陷阱与最佳实践
  2. SaaS 转介绍闭环：让满意客户帮你带来下一批相似客户
  3. SaaS 创始人现金跑道：从第一天就知道还能试错几个月
  4. SaaS 取消挽回流程：客户要走时，别只弹一个折扣窗口
  5. Steam 评测期与 Embargo：独立游戏发售前媒体协作流程
  6. SaaS 行业观察：AI 伦理与偏见缓解的实践指南
  7. SaaS 路线图沟通：怎么告诉客户将来做什么，又不把自己锁死
  8. SaaS 行业观察：AI 驱动的动态定价与货币化策略
  9. SaaS 产品质量门槛：早期哪些问题不能靠客户容忍
  10. 游戏服务器边缘接入加速架构设计
  11. SaaS Demo 环境：不要拿真实客户数据和半成品页面做演示
  12. SaaS 实施启动会：第一次正式上线前要和客户对齐什么
  13. SaaS 流失访谈：客户取消时最该问什么
  14. Slg游戏的通用模块介绍
  15. SaaS 客户顾问组：早期如何让少数客户参与方向，但不绑架产品
  16. SLG游戏客户端消息分发与状态同步模块设计
  17. SLG游戏塔防战斗通信协议的详细设计
  18. SLG游戏产品架构
  19. SLG游戏产品模块浅析
  20. SLG游戏前端模块浅析
  21. SLG游戏后端模块浅析
  22. SLG游戏后端分层解析
  23. SLG游戏开发语言浅析
  24. SaaS 礼宾式 MVP：先人工服务客户，再决定哪些环节自动化
  25. SaaS 问题排序：从一堆客户抱怨里选出最值得做的切口

July 16

  1. SaaS 最小网站分析：官网上线后先看这几个转化信号
  2. SaaS PMF 早期信号：不要只用收入判断产品市场匹配
  3. Go 数据库迁移：goose、golang-migrate 与最佳实践
  4. SaaS 轻量 SLA：早期支持承诺要清楚，但别承诺做不到的赔付
  5. 游戏服务器数据修复工单架构设计
  6. SaaS 使用复盘：早期别只问客户满不满意，要看真实行为
  7. SaaS 反馈分拣：客户提需求后，先判断是问题、方案还是情绪
  8. SaaS 行业观察：AI 治理与合规的新时代
  9. SaaS Demo 后跟进：客户说不错之后，下一封邮件该写什么
  10. SaaS 试点协议：小团队也要把范围、结果和退出条件写清楚
  11. SaaS 无代码验证栈：还没开发系统前，先把业务闭环跑起来
  12. Steam 商店页数据实验：截图、短描述和标签如何小步迭代
  13. 数字无极小程序接口设计
  14. 数字无极小程序功能规划
  15. SaaS 冷启动名单：第一批潜在客户不要靠随机加好友
  16. SaaS ICP 排除清单：早期先明确哪些客户暂时不服务

June 47

  1. SaaS 方向转向标准：什么时候该坚持，什么时候该换切口
  2. SaaS 自助和人工边界：哪些事让客户自己做，哪些事你必须介入
  3. 游戏模块划分和语言选型
  4. SaaS 客户培训：第一次培训不要变成功能朗读
  5. SaaS 发布说明：小团队也要告诉客户产品变化了什么
  6. Go 与 Kubernetes：构建自定义 Operator
  7. SaaS 后台运营能力：早期哪些管理功能必须给自己留出来
  8. SaaS 扩展收入：从一个团队用到更多团队愿意买
  9. Steam 无障碍与控制器支持：上架前别忽略的体验承诺
  10. Lua性能优化实战指南
  11. Lua面向对象编程完全指南
  12. LuaJIT FFI外部函数接口详解
  13. Lua尾调用优化详解
  14. Lua环境机制与沙箱技术
  15. Lua字符串模式匹配详解
  16. Lua垃圾回收机制与优化实践
  17. Lua闭包和上值深入解析
  18. SaaS 对比页：如何客观说明你和旧方案、竞品的差异
  19. Lua协程深入解析
  20. Lua元表和元方法详解
  21. SaaS 样本数据收集：没有真实数据，MVP 很容易做偏
  22. SaaS 行业观察：AI 驱动的个性化用户体验革命
  23. 第 18 章：SEO 深度优化（Metadata API 与结构化数据）
  24. 第 19 章：测试体系（Vitest + RTL + Playwright）
  25. 第 20 章：错误处理与监控（Sentry 与可观测性）
  26. 第 21 章：Docker 部署与 CI/CD 流水线
  27. 第 22 章：多租户 SaaS 架构实战
  28. 第 10 章：数据库集成（Prisma + PostgreSQL）
  29. 第 11 章：认证体系（NextAuth.js v5 全解）
  30. 第 12 章：Middleware 中间件（路由守卫与请求拦截）
  31. 第 13 章：Tailwind CSS 深度集成
  32. 第 14 章：组件库选型与业务组件体系
  33. 第 15 章：状态管理（Zustand / Jotai / Redux Toolkit）
  34. 第 16 章：表单与验证（React Hook Form + Zod）
  35. 第 17 章：性能优化（Core Web Vitals 与 Bundle 瘦身）
  36. SaaS 开发前承诺：还没写完产品，如何拿到客户的明确下一步
  37. 第 9 章：Server Actions（后端函数调用）
  38. 第 8 章：Route Handlers（API 路由）
  39. SaaS 线索资格判断：第一次沟通后要不要继续投入
  40. 游戏服务器资源配额与背压架构设计
  41. Java EE/Jakarta EE 三大规范详解：CDI、JPA 与 Bean Validation
  42. JAX-RS规范介绍
  43. Jakarta RESTful Web Services介绍
  44. Fyne的UI定制
  45. Fyne跨平台的最佳实践
  46. Fyne和wails的详细对比
  47. SaaS 行业学习笔记：进入陌生垂直领域前，创始人要先学什么

May 15

  1. SaaS 创始人周报：一个人创业也要每周向自己汇报一次
  2. Steam 成人与敏感内容披露：上架前如何写清页面和玩家预期
  3. SaaS 客户内部反对者：别只服务支持你的人，也要理解谁会阻碍上线
  4. SaaS 沙盒试用：让客户安全试产品，而不是一上来接真实业务
  5. Go 与 WebAssembly：从浏览器到边缘计算
  6. SaaS 支持问题分类：别把所有客户消息都当成同一种客服
  7. 游戏服务器玩法插件运行时架构设计
  8. SaaS 行业观察：AI 驱动的客户成功与流失预测
  9. SaaS 试点成功看板：两周试点到底有没有进展，不能靠感觉
  10. SaaS 客户冠军：早期成交往往不是卖给公司，而是先帮一个人成功
  11. Awesome Java
  12. SaaS 信息屋：官网、冷邮件和 Demo 话术要讲同一个故事
  13. SaaS ROI 计算表：早期销售别只讲效率，要帮客户算清值不值
  14. SaaS 风险登记表：从第一天记录哪些假设可能让项目失败
  15. SaaS 创始人领域地图：从 0 做产品前，先把业务世界画清楚

April 15

  1. SaaS 早期运营手册：从第一个客户开始，就把重复动作写下来
  2. 游戏服务器多版本客户端兼容架构设计
  3. SaaS 服务层级：早期不同客户不能都用同一种服务方式
  4. SaaS 激活基准线：第一周用户到底做到哪一步才算看见价值
  5. SaaS 行业观察：上下文工程 - AI 产品的核心竞争力
  6. SaaS 定价访谈：不要只问愿不愿意付费，要问客户怎么做预算
  7. Steam 创意工坊上架准备：UGC 游戏的内容、审核与社区运营
  8. Go 与领域驱动设计：构建复杂业务系统
  9. SaaS 早期数据隐私：还没大客户，也要先说清数据怎么收、怎么用
  10. SaaS 证据库：早期每一条客户原话、样本和结果都要存起来
  11. SaaS Beta 小组：第一批测试用户要按批次管理，而不是谁来都给试
  12. SaaS 创始人日历：早期一周应该怎样分配客户、产品和销售时间
  13. SaaS 问题备忘录：每个产品想法都要先写成一页问题说明
  14. SaaS 创始人内容引擎：把销售问题写成获客资产
  15. SaaS 前 100 次客户对话：从 0 开始别急着卖，先建立问题数据库

March 16

  1. SaaS 30 天启动冲刺：从 0 开始的第一个月不要忙乱，要每天产出证据
  2. Steam DLC 与原声集上架：独立游戏扩展内容的发行检查表
  3. SaaS 公司和财务基础：从第一个试点开始，就要把钱、合同和责任说清楚
  4. SaaS 最小技术架构：从 0 开始先保证可交付、可改动、可追踪
  5. SaaS 早期销售漏斗：从第一次聊天到付费试点，每一步都要有下一步承诺
  6. 《spring boot入门》目录
  7. SaaS 第一批外呼名单：从 0 开始不要乱发私信，要建立可复盘的触达系统
  8. SaaS 着陆页承诺：第一版官网不是介绍公司，而是测试客户是否理解价值
  9. 游戏服务器合服控制面架构设计
  10. SaaS 人工交付实验：在写自动化之前，先用服务验证客户是否真要这个结果
  11. Go 与 AI：构建智能应用
  12. SaaS MVP 范围控制：第一版产品不是小而全，而是只证明一个关键闭环
  13. SaaS 行业观察：AI 原生定价模型的革命
  14. SaaS 工作流跟访：从 0 开始别只听客户说，要看他真实怎么做
  15. RoadRunner项目介绍
  16. SaaS 细分市场评分卡：从 0 开始不要先选赛道，要先选可进入的楔子

February 61

  1. SaaS 创始人学习系统：从 0 开始别只积累资料，要把市场认知变成决策
  2. SaaS 试点复盘会：从 0 开始每次试点结束，都要拿到下一步判断
  3. 游戏服务器机器人压测平台架构设计
  4. Grpc Gateway初探
  5. SaaS 早期信任包：没有品牌和案例时，如何让客户敢把第一次机会给你
  6. SaaS 手把手 onboarding：第一批客户不要只发账号，要陪他走完一次价值闭环
  7. 《Defold游戏开发入门》目录
  8. SaaS 样本数据协议：从第一个客户样本开始，就要把数据、权限和用途说清楚
  9. Go1.24发布说明
  10. Go 可观测性：OpenTelemetry 完全指南
  11. SaaS 早期合伙分工：从 0 开始先写角色契约，再谈股权和头衔
  12. SaaS 垂直切口：从一个窄流程切进真实行业
  13. Steam 测试分支与灰度发布：独立游戏补丁上线前的安全流程
  14. SaaS 第一份商业承诺：别先卖功能，先设计一个客户愿意回应的 offer
  15. 《Lua高级编程》7.5 案例分析：调用系统库、编写高性能扩展模块
  16. 《Lua高级编程》7.4 FFI在性能关键代码中的应用与优化策略
  17. 《Lua高级编程》7.3 FFI与Lua数据类型和内存布局的交互
  18. 《Lua高级编程》7.2 ffi.new、ffi.cast与ffi.metatype的高级用法
  19. 《Lua高级编程》7.1 使用 ffi.cdef 声明 C 函数、结构体与枚举
  20. 《Lua高级编程》6.3FFI基本语法
  21. 《Lua高级编程》6.2 安装与配置LuaJIT FFI环境
  22. 《Lua高级编程》6.1 FFI简介与LuaJIT中FFI模块的作用
  23. 《Lua高级编程》5.3 利用协程实现高并发模型
  24. 《Lua高级编程》5.2 性能调优策略与常见陷阱
  25. 《Lua高级编程》5.1 LuaJIT工作原理与JIT编译优势
  26. SaaS 购买触发地图：客户不是因为你上线了才买，而是因为某个事件发生了
  27. 《Lua高级编程》4.4 实战案例：构建一个简单的对象系统
  28. 《Python计算机图形学入门》目录
  29. 《Lua高级编程》4.3 继承、多态与封装的模拟
  30. 《Lua高级编程》4.2 类、对象与构造函数的设计模式
  31. 《Lua高级编程》4.1 Lua中实现面向对象的思路与技巧
  32. 《Lua高级编程》3.4 实战案例：利用元表实现自定义数据结构和操作符重载
  33. 《Lua高级编程》3.3 元表的继承、链式查找与动态绑定
  34. 《Lua高级编程》3.2 常用元方法详解
  35. 《Lua高级编程》3.1 元表基本概念及其在Lua中的作用
  36. 《Lua高级编程》2.3 错误处理、异常捕捉与调试技巧
  37. 《Lua高级编程》2.2 表、函数、闭包及局部变量的高级用法
  38. 《Lua高级编程》2.1 Lua核心语法、数据类型与运算符
  39. 《Lua高级编程》1.4 开发环境与工具（编辑器、调试器、版本管理等）
  40. 《Lua高级编程》1.3 Lua与LuaJIT概览
  41. 《Lua高级编程》1.2 本书目标、读者定位与章节安排
  42. 《Lua高级编程》1.1 Lua语言的发展历程与应用场景
  43. 《Lua高级编程》目录
  44. 《Lua游戏开发实战》后记
  45. 《Lua游戏开发实战》附录B：Lua在其他领域的应用
  46. 《Lua游戏开发实战》附录B：常见问题解答
  47. 《Lua游戏开发实战》附录A：相关文档与学习资源
  48. 《Lua游戏开发实战》附录A：常用开发工具介绍
  49. 《Lua游戏开发实战》16.3 压力测试与监控工具
  50. 《Lua游戏开发实战》16.2 数据库查询与缓存优化
  51. 《Lua游戏开发实战》16.1 并发处理与服务拆分
  52. 《Lua游戏开发实战》15.2 动画与物理引擎优化
  53. 《Lua游戏开发实战》15.1 绘制性能与资源管理
  54. 《Lua游戏开发实战》14.3 性能测试与优化工具
  55. 《Lua游戏开发实战》14.2 热更新与动态加载
  56. 《Lua游戏开发实战》14.1 内存管理与垃圾回收
  57. 《Lua游戏开发实战》13.3 遇到的挑战与解决方案
  58. 《Lua游戏开发实战》13.2 项目设计与开发流程
  59. SaaS 表格审计法：从客户的 Excel 里找到真正值得产品化的工作
  60. 《Lua游戏开发实战》13.1 基于Defold和Skynet的多人游戏完整案例
  61. SaaS 创始人假设账本：从 0 开始先把你相信的事写下来

January 237

  1. SaaS 早期研究综合：从 0 开始做完访谈后，怎样把零散信息变成方向判断
  2. SaaS 从问题到工作流：客户说有痛点后，下一步要翻译成可执行流程
  3. 《Lua游戏开发实战》12.3 多人游戏实现与优化
  4. 《Lua游戏开发实战》12.2 数据同步与实时更新
  5. 《Lua游戏开发实战》12.1 登录与注册流程
  6. 《Lua游戏开发实战》11.3 安全性与加密处理
  7. 《Lua游戏开发实战》11.2 消息序列化与反序列化
  8. 《Lua游戏开发实战》11.1 通信协议设计
  9. 《Lua游戏开发实战》10.4 日志与监控
  10. 《Lua游戏开发实战》10.3 实时战斗系统
  11. 《Lua游戏开发实战》10.2 游戏逻辑服务
  12. 《Lua游戏开发实战》10.1 玩家账户系统
  13. 《Lua游戏开发实战》9.4 网络通信与协议设计
  14. 《Lua游戏开发实战》9.3 数据存储与数据库集成
  15. 《Lua游戏开发实战》9.2 定时器与异步任务
  16. 《Lua游戏开发实战》9.1 Actor模型的设计与实现
  17. 《Lua游戏开发实战》8.3 服务模型与通信机制
  18. 《Lua游戏开发实战》8.2 Skynet环境搭建与配置
  19. 《Lua游戏开发实战》8.1 Skynet简介与架构
  20. SaaS 单人创始人节奏：从 0 开始一个人也要同时推进客户、产品和现金
  21. 《Lua游戏开发实战》7.4 常见问题与解决方案
  22. 《Lua游戏开发实战》7.3 多平台发布流程
  23. 《Lua游戏开发实战》7.2 资源压缩与打包策略
  24. 《Lua游戏开发实战》7.1 性能优化技巧
  25. 《Lua游戏开发实战》6.4 网络通信的基础实现
  26. 《Lua游戏开发实战》6.3 音频系统与声音管理
  27. 《Lua游戏开发实战》6.2 动画与粒子效果的实现
  28. 《Lua游戏开发实战》6.1 场景管理与动态切换
  29. 《Lua游戏开发实战》5.3 输入处理与事件机制
  30. 《Lua游戏开发实战》5.2 游戏对象（Game Object）与组件（Component）的关系
  31. 《Lua游戏开发实战》5.1 脚本的基本使用
  32. 《Lua游戏开发实战》4.3 快速创建第一个Defold项目
  33. 《Lua游戏开发实战》4.2 开发环境配置与工具使用
  34. 《Lua游戏开发实战》4.1 Defold的特点与优势
  35. 《Lua游戏开发实战》3.4 引擎的生命周期与脚本执行顺序
  36. 《Lua游戏开发实战》3.3 消息传递与组件通信机制
  37. 《Lua游戏开发实战》3.2 项目结构与资源管理
  38. 《Lua游戏开发实战》3.1 Defold的核心组成
  39. 《Lua游戏开发实战》2.4 错误处理与调试
  40. 《Lua游戏开发实战》2.3 文件操作与输入输出
  41. 《Lua游戏开发实战》2.2 协程（Coroutines）
  42. 《Lua游戏开发实战》2.1 元表与元方法
  43. 《Lua游戏开发实战》1.4 函数与模块
  44. 《Lua游戏开发实战》1.3 流程控制
  45. 《Lua游戏开发实战》1.2 基本语法与数据类型
  46. 《Lua游戏开发实战》1.1 Lua的安装与环境配置
  47. 《Lua游戏开发实战》序言: 本书目标与读者对象
  48. 《Lua游戏开发实战》序言: Skynet框架简介
  49. 《Lua游戏开发实战》序言: Defold引擎简介
  50. 《Lua游戏开发实战》序言: Lua游戏开发的优势与趋势
  51. 《Lua游戏开发实战》目录
  52. 在Rust中进行原型设计的实践和优势
  53. 《Lua快速入门》附录:Lua相关社区与论坛
  54. 《Lua快速入门》附录:常见问题解答（FAQ）
  55. 《Lua快速入门》附录:Lua官方文档与资源推荐
  56. 《Lua快速入门》13.Lua测试与工具
  57. 《Lua快速入门》12.性能优化
  58. 《Lua快速入门》11.Lua和游戏开发
  59. 《Lua快速入门》10.Lua在嵌入式开发中的应用
  60. 《Lua快速入门》9.元编程
  61. 《Lua快速入门》8.协程
  62. 《Lua快速入门》7.错误处理与调试
  63. 《Lua快速入门》6.Lua的数据结构
  64. 《Lua快速入门》5.输入输出
  65. 《Lua快速入门》4.表（Table）
  66. 《Lua快速入门》3.函数与模块
  67. Steam Playtest 实操指南：把公开测试做成可复盘的发行漏斗
  68. SaaS 早期市场地图：从 0 开始先画清客户、角色、流程和预算关系
  69. 《Lua快速入门》2.Lua的基本语法
  70. 《Lua快速入门》1.简介
  71. 《Lua快速入门》目录
  72. 《Rust快速入门》16. 附录
  73. 《Rust快速入门》15. 项目实战
  74. 《Rust快速入门》14. 高级主题
  75. 《Rust快速入门》13. 宏与元编程
  76. 《Rust快速入门》12. 异步编程
  77. 《Rust快速入门》11. 并发编程
  78. 《Rust快速入门》10. 模块与包管理
  79. 《Rust快速入门》9. 泛型与特性
  80. 《Rust快速入门》8. 错误处理
  81. 《Rust快速入门》7. 集合类型
  82. 《Rust快速入门》6. 结构体与枚举
  83. 《Rust快速入门》5. 所有权与借用
  84. 《Rust快速入门》2. 控制流
  85. 《Rust快速入门》2. 基础语法
  86. 《Rust快速入门》2. 入门
  87. 《Rust快速入门》1. 简介
  88. 《Rust快速入门》目录
  89. 大语言模型应用开发框架Eino介绍
  90. SaaS 手工结果 Demo：产品还没做完，也可以先让客户看见未来结果
  91. 《深入Rust系统编程》C: Rust常见问题解答
  92. 《深入Rust系统编程》B: Rust代码风格指南
  93. 《深入Rust系统编程》A: Rust资源与社区
  94. 《深入Rust系统编程》12.3 Rust在操作系统中的应用
  95. 《深入Rust系统编程》12.2 区块链与分布式系统
  96. 《深入Rust系统编程》12.1 WebAssembly与边缘计算
  97. 《深入Rust系统编程》11.3 与数据库交互
  98. 《深入Rust系统编程》11.2 编写Python/Ruby扩展
  99. 《深入Rust系统编程》11.1 调用C/C++代码
  100. 《深入Rust系统编程》10.3 系统安全与加固
  101. 《深入Rust系统编程》10.2 日志系统与监控
  102. 《深入Rust系统编程》10.1 命令行工具开发
  103. 《深入Rust系统编程》9.4 性能优化与调试
  104. 《深入Rust系统编程》9.3 线程池与异步任务
  105. 《深入Rust系统编程》9.2 IO多路复用与epoll
  106. 《深入Rust系统编程》9.1 事件驱动架构
  107. 《深入Rust系统编程》8.3 裸金属编程
  108. 《深入Rust系统编程》8.2 设备驱动开发
  109. 《深入Rust系统编程》8.1 嵌入式系统开发
  110. 《深入Rust系统编程》7.4 网络安全与加密
  111. 《深入Rust系统编程》7.3 异步网络编程
  112. 《深入Rust系统编程》7.2 HTTP协议与Web框架
  113. 《深入Rust系统编程》7.1 TCP/UDP编程
  114. Go 1.25 前瞻：持续进化的 Go 生态
  115. 《深入Rust系统编程》6.5 定时器与时间管理
  116. 《深入Rust系统编程》6.4 内存映射与共享内存
  117. 《深入Rust系统编程》6.3 进程管理与信号处理
  118. 《深入Rust系统编程》6.2 文件I/O与目录操作
  119. 《深入Rust系统编程》6.1 系统调用与libc绑定
  120. 《深入Rust系统编程》5.5 异步编程与Future
  121. 《深入Rust系统编程》5.4 线程与同步原语
  122. 《深入Rust系统编程》5.3 并发编程模型
  123. 《深入Rust系统编程》5.2 智能指针与引用计数
  124. 《深入Rust系统编程》5.1 所有权与借用检查器
  125. 《深入Rust系统编程》4.5 网络编程基础
  126. 《深入Rust系统编程》4.4 文件系统与I/O
  127. 《深入Rust系统编程》4.3 内存管理
  128. 《深入Rust系统编程》4.2 进程与线程
  129. 游戏服务器玩家信誉体系架构设计
  130. 《深入Rust系统编程》4.1 操作系统概述
  131. 《深入Rust系统编程》3.3 测试与文档
  132. 《深入Rust系统编程》3.2 使用Cargo构建项目
  133. 《深入Rust系统编程》3.1 模块系统与包管理
  134. SaaS 一人销售实验室：还没有团队时，创始人怎样系统跑客户验证
  135. SaaS 行业观察：多智能体协作与工作流编排
  136. Go 语言学习路线图：从入门到精通
  137. 《深入Rust系统编程》2.6 错误处理
  138. 《深入Rust系统编程》2.5 泛型与trait
  139. 《深入Rust系统编程》2.4 结构体、枚举与模式匹配
  140. 《深入Rust系统编程》2.3 所有权与生命周期
  141. 《深入Rust系统编程》2.2 控制流与函数
  142. 《深入Rust系统编程》2.1 变量与数据类型
  143. 《深入Rust系统编程》1.3 Rust工具链与生态系统
  144. 《深入Rust系统编程》1.2 Rust的优势与应用场景
  145. 《深入Rust系统编程》1.1 Rust的历史与设计理念
  146. 《深入Rust系统编程》目录
  147. 《Rust编程实战》工具集推荐
  148. 《Rust编程实战》性能陷阱
  149. 《Rust编程实战》19.2 操作系统开发
  150. 《Rust编程实战》19.1 金融系统应用
  151. 《Rust编程实战》18.2 Nightly工具链
  152. 《Rust编程实战》18.1 最新更新解析
  153. 《Rust编程实战》17.2 版本管理
  154. 《Rust编程实战》17.1 API设计
  155. 《Rust编程实战》16.2 硬件交互优化
  156. 《Rust编程实战》16.1 嵌入式Rust应用
  157. SaaS 问题严重度阶梯：从 0 开始判断痛点，不要只听客户说痛
  158. Flatpak介绍
  159. 《Rust编程实战》15.2 数据流处理
  160. 《Rust编程实战》15.1 Clap命令行工具
  161. 《Rust编程实战》14.2 WebSocket实现
  162. 《Rust编程实战》14.1 Actix Web和Axum
  163. 《Rust编程实战》13.3 高吞吐消息队列
  164. 《Rust编程实战》13.2 高效序列化工具
  165. 《Rust编程实战》13.1 分布式通信框架
  166. 《Rust编程实战》12.2 Rayon数据并行
  167. 《Rust编程实战》12.1 Actor模式实现
  168. 《Rust编程实战》11.2 高可维护性设计
  169. 《Rust编程实战》11.1 多模块管理
  170. 《Rust编程实战》10.3 IO优化实践
  171. 《Rust编程实战》10.2 高性能网络服务
  172. 《Rust编程实战》10.1 自定义文件操作
  173. 《Rust编程实战》9.3 内存布局优化
  174. 《Rust编程实战》9.2 抽象设计技巧
  175. 《Rust编程实战》9.1 内联与性能
  176. 《Rust编程实战》8.3 性能基准测试
  177. 《Rust编程实战》8.2 内存对齐优化
  178. 《Rust编程实战》8.1 栈与堆管理
  179. SaaS 替代方案成本计算：客户现在怎么凑合，决定你未来怎么收费
  180. 《Rust编程实战》7.3 FFI接口开发
  181. 《Rust编程实战》7.2 安全使用Unsafe
  182. 《Rust编程实战》7.1 Unsafe场景分析
  183. 《Rust编程实战》6.4 tokio异步编程
  184. 《Rust编程实战》6.3 Async和Await机制
  185. 《Rust编程实战》6.2 同步原语应用
  186. 《Rust编程实战》6.1 线程安全原理
  187. 游戏服务端学习计划
  188. 游戏客户端从入门到进阶
  189. 《Rust编程实战》5.3 宏与优化
  190. 《Rust编程实战》5.2 过程宏开发
  191. 《Rust编程实战》5.1 声明式宏详解
  192. 《Rust编程实战》4.3 Trait设计实践
  193. 《Rust编程实战》4.2 泛型与Trait约束
  194. 《Rust编程实战》4.1 Trait对象与分发
  195. 《Rust编程实战》3.3 生命周期省略规则
  196. 《Rust编程实战》3.2 嵌套结构管理
  197. 《Rust编程实战》3.1 生命周期参数详解
  198. 机器学习的知识结构
  199. 《Rust编程实战》2.3 Copy与Move
  200. 《Rust编程实战》2.2 借用检查器
  201. 《Rust编程实战》2.1 所有权模型
  202. 《Rust编程实战》1.3 Rust的独特价值
  203. 《Rust编程实战》1.2 零成本抽象
  204. 《Rust编程实战》1.1 性能与安全并存
  205. 《Rust编程实战》序
  206. 《Rust编程实战》前言
  207. 《Rust编程实战》目录
  208. SaaS 客户任务故事库：从 0 开始不要收集需求，要收集客户要完成的任务
  209. SaaS 创始人个人约束盘点：从 0 开始先弄清你能打多久、适合打什么仗
  210. 《Rust编程入门》附录D：常见问题与解决方案（FAQ）
  211. 《Rust编程入门》附录C：Rust常用工具与资源
  212. 《Rust编程入门》附录B：Rust标准库概览
  213. 《Rust编程入门》附录A：Rust语言参考
  214. 《Rust编程入门》17.3 常见性能瓶颈与解决方案
  215. 《Rust编程入门》17.2 代码优化与剖析工具
  216. 《Rust编程入门》17.1 使用cargo bench进行性能测试
  217. 《Rust编程入门》16.3 编写集成测试
  218. 《Rust编程入门》16.2 编写与运行单元测试
  219. 《Rust编程入门》16.1 测试的重要性
  220. 《Rust编程入门》15.3 处理HTTP请求与响应
  221. 《Rust编程入门》15.2 使用框架（Rocket、Actix Web等）
  222. 《Rust编程入门》15.1 Rust在Web开发中的角色
  223. 《Rust编程入门》14.3 项目结构与模块化设计
  224. 《Rust编程入门》14.2 错误处理与用户反馈
  225. 《Rust编程入门》14.1 解析命令行参数
  226. 《Rust编程入门》13.3 性能优化技巧与零成本抽象
  227. 《Rust编程入门》13.2 堆与栈的分配
  228. 《Rust编程入门》13.1 Rust的内存管理机制
  229. 《Rust编程入门》12.3 线程安全与共享状态
  230. 《Rust编程入门》12.2 消息传递与mpsc
  231. 《Rust编程入门》12.1 线程与 std::thread 基础
  232. 《Rust编程入门》11.3 公有性与私有性
  233. 《Rust编程入门》11.2 包与 crate 的概念
  234. 《Rust编程入门》11.1 模块系统：组织与复用代码
  235. 《Rust编程入门》10.3 特性约束与特化
  236. 《Rust编程入门》10.2 特性（Traits）的定义与实现
  237. 《Rust编程入门》10.1 泛型编程
2024 255 篇文章

December 35

  1. 《Rust编程入门》9.3 错误传播与处理技巧
  2. 《Rust编程入门》9.2 Result和Option枚举
  3. 《Rust编程入门》9.1 Rust的错误类型
  4. 《Rust编程入门》8.3 闭包与高阶函数
  5. 《Rust编程入门》8.2 迭代器与迭代器适配器
  6. 《Rust编程入门》8.1 标准集合（Vec、HashMap、String等）
  7. 《Rust编程入门》7.3 模式匹配与结构体/枚举
  8. 《Rust编程入门》7.2 枚举类型及其应用
  9. 《Rust编程入门》7.1 定义与使用结构体
  10. 《Rust编程入门》6.3 生命周期的定义与用法
  11. 《Rust编程入门》6.2 借用与引用规则
  12. 《Rust编程入门》6.1 所有权的基本概念
  13. 《Rust编程入门》5.3 模式匹配（match、if和let）
  14. 《Rust编程入门》5.2 循环（loop、while和for）
  15. 《Rust编程入门》5.1 条件判断（if语句）
  16. 《Rust编程入门》4.4 常用Rust函数
  17. 《Rust编程入门》4.3 运算符与表达式
  18. 《Rust编程入门》4.2 数据类型与类型推断
  19. 《Rust编程入门》4.1 变量、常量与可变性
  20. 《Rust编程入门》3.3 了解Rust编译过程
  21. 《Rust编程入门》3.2 编译与运行Rust程序
  22. 游戏服务器服务治理架构设计
  23. 《Rust编程入门》3.1 编写第一个Rust程序
  24. 《Rust编程入门》2.3 使用Cargo：包管理与项目构建
  25. 《Rust编程入门》2.2 配置开发工具（文本编辑器与IDE）
  26. 《Rust编程入门》2.1 安装Rust和工具链
  27. 《Rust编程入门》1.3 Rust的适用场景
  28. 《Rust编程入门》1.2 Rust的主要特性
  29. 《Rust编程入门》1.1 Rust语言的诞生与历史
  30. Rust生成的二进制依赖问题
  31. K8s Memos对比
  32. Go 小项目发布前检查清单：从能跑到敢交付
  33. 游戏服务器运营控制台架构设计
  34. 游戏服务器多活读模型架构设计
  35. SaaS 套餐权益：权限、用量和功能边界要从早期就可解释

November 6

  1. Steam 正式发布前总验收：独立游戏上线前 7 天检查表
  2. Go 项目实战：从零构建完整的 Web 应用
  3. Conan工具介绍
  4. SaaS 案例营销：把一个客户成功变成可复制获客资产
  5. 游戏 LiveOps 活动运营架构设计
  6. Go 轻量分层入门：Handler、Service、Store 怎么刚刚好

October 26

  1. 游戏服务器限时玩法编排架构设计
  2. 第15章：设计 Google Drive
  3. 第14章：设计 YouTube
  4. 第13章：设计一个搜索自动完成系统
  5. 第12章：设计一个聊天系统
  6. 第11章：设计一个信息推送系统
  7. 第10章：设计一个通知系统
  8. 第09章：网络爬虫设计
  9. 第08章：短网址设计
  10. 第07章：在分布式系统中设计唯一 ID 生成器
  11. 第06章：key-value 存储设计
  12. 第05章：一致性hash设计
  13. 第04章：设计一个限流器
  14. 第03章：系统设计面试框架
  15. 第02章：粗略估算
  16. 第01章：从0到百万用户
  17. 系统设计面试：内幕指南（中文翻译）目录
  18. Project Loom虚拟介绍
  19. SaaS 行业观察：AI 驱动的产品开发革命
  20. 在线游戏服务器安全架构设计
  21. Akka Actor编程
  22. MessagePack格式介绍
  23. Java生态资源大全
  24. Awesome First PR Opportunities
  25. Tauri介绍
  26. Steam 区域发行实操：中文、日韩、欧美市场页面与运营差异

September 14

  1. Go 与区块链：从概念到实现
  2. Go HTTP 中间件入门：日志、恢复、鉴权和请求 ID 怎么串起来
  3. 游戏后台权限与审计架构设计
  4. Flatpak包详解
  5. Golang1.23版本功能说明
  6. 巴科斯范式
  7. 并发编程模式actor详解
  8. SaaS 行业观察：AI 时代的安全与数据保护新范式
  9. SaaS 渠道伙伴：早期合作不要只谈分成，要先谈交付能力
  10. 游戏服务器数据分析管道架构设计
  11. spring boot3进阶
  12. Spring Boot3入门例子
  13. Awesome JavaFX
  14. Spring Boot常用注解说明

August 49

  1. Learn Clojure by Examples
  2. asyncio库介绍
  3. Vuetify介绍
  4. Vue3和vue2的区别
  5. 机器学习的学习计划
  6. 游戏服务器离线推进架构设计
  7. electron深入
  8. Awesome Electron
  9. electron介绍
  10. Go GC 调优实战：从理论到实践
  11. SaaS 加 AI 功能：先找可验证工作流，不要先做聊天框
  12. PHP发展趋势
  13. php还有前景吗
  14. 虚幻引擎UnrealEngine介绍
  15. Rust的tikio库介绍
  16. Rust包crate
  17. Rust原生类型
  18. Rust的跨平台特性
  19. SaaS 行业观察：可组合 SaaS 架构的兴起与实践
  20. Go slices 和 maps 包入门：少写一点重复集合代码
  21. Rust语言的所有权系统
  22. Cargo.toml文件详细说明
  23. Rust语言在系统编程方面有哪些优势
  24. Rust和c++的区别
  25. Java17中的文本块特性在实际开发中有哪些具体的应用场景
  26. Springboot3介绍
  27. Steam 退款与差评复盘：用首月数据修正页面和产品
  28. 安装和配置Rust开发环境
  29. 游戏内容分发与资源版本架构设计
  30. Rust基础语法介绍
  31. 《Rust编程入门》前言
  32. 《Rust编程入门》序
  33. 《Rust编程入门》目录
  34. Rust语言应用场景
  35. WebAssembly介绍
  36. Clojure数据操作
  37. Clojure基础语法
  38. Erlang循环与迭代：递归、列表推导式与高阶函数详解
  39. Erlang模式匹配详解：从基础语法到高级错误处理
  40. Erlang基础语法教程：从模块定义到并发编程完全指南
  41. Erlang语言基础入门：并发、分布式与OTP框架详解
  42. Lua错误处理
  43. Lua模块和包介绍
  44. Lua和c语言的结合
  45. Lua的数组及迭代器特性的介绍
  46. 微信小程序开发框架优势
  47. Go语言优秀资源整理
  48. Defold引擎中使用Lua语言有哪些优势和局限性
  49. Defold可以使用python来开发吗

July 65

  1. 微信小程序项目框架结构推荐
  2. Rust基础知识入门
  3. Unity和Unreal哪个更适合入门
  4. 独立游戏创意推荐（第一期）
  5. H5游戏产业全景
  6. 游戏开发相关资源汇总
  7. Pitaya和Skynet框架对比
  8. Rust中的不可变引用
  9. 在Rust中，如何正确地使用不可变借用和可变借用
  10. Rust语言的内存安全特性是如何实现的
  11. skynet推荐教程
  12. skynet框架中如何实现玩家之间的通信和数据同步
  13. 如何使用skynet框架实现一个简单的多人在线游戏服务器
  14. skynet游戏服务器开发中的常见问题
  15. Pitaya框架在游戏开发中有哪些具体的技术优势
  16. 游戏服务器框架Pitaya介绍
  17. 常用开源游戏服务端框架详细比较
  18. 游戏服务器配置平台架构设计
  19. 游戏客户端开发学习计划
  20. 程序员职业发展规划：技术与成长的并行之路
  21. 一些rust学习资源
  22. Defold支持哪些类型的3D游戏开发
  23. Steam 多人在线游戏上架检查：服务器、匹配、版本和首发容量
  24. Clojure学习计划
  25. 适合新手入门的Golang开源项目推荐
  26. 使用pyproject来管理python项目
  27. 适合新手的开源项目（python篇）
  28. 用golang实现一个并发爬虫
  29. Python教程之倒计时猜数字
  30. Python教程之猜数字的游戏
  31. 程序员在编程时通常会用到哪些工具
  32. 在Defold中，如何实现复杂的游戏逻辑和状态管理
  33. Defold游戏引擎的学习计划
  34. Defold游戏引擎介绍
  35. Python函数datetime.strptime介绍
  36. Golang进阶教程
  37. Java快速入门教程
  38. 如何使用Go实现生产者-消费者模式
  39. Go语言中的并发模型简介
  40. Golang快速入门
  41. Golang学习路线参考
  42. Python入门教程推荐
  43. Python入门快速教程
  44. Python的GIL对于并发编程有哪些影响
  45. Lua在skynet中的应用
  46. Lua与Python相比，有哪些优势和不足
  47. 在Web应用开发中，Lua语言通常用于哪些场景，它的优势是什么
  48. Lua入门快速教程2
  49. Lua入门快速教程
  50. 除了游戏开发，Lua语言还有哪些其他领域的应用
  51. Lua语言在游戏开发中有哪些优势和局限性
  52. Lua在游戏开发中的具体应用
  53. Lua语言的热更新技术是如何实现的
  54. Lua语言在游戏开发中有哪些具体的应用场景
  55. Lua学习计划
  56. Go 与消息队列：Kafka 和 RabbitMQ 实战
  57. 在Rust中，如何避免借用冲突和悬垂指针的问题
  58. Rust语言中的所有权和借用规则具体是如何工作的
  59. Rust语言中有哪些常见的内存安全问题
  60. Clojure基础教程
  61. PlumePHP - 羽量级的单文件php开发框架
  62. Rust学习路线
  63. 游戏服务器延迟补偿裁决架构设计
  64. SaaS 行业观察：AI 销售副驾驶与收入智能的变革
  65. SaaS 迁移方案：让客户从旧系统切换，不是发个导入模板就够了

June 8

  1. SaaS 行业观察：垂直 AI Agent 的行业深耕与专业化浪潮
  2. 游戏社交系统服务器架构设计
  3. 游戏服务器赛季结算架构设计
  4. Go context 取消原因入门：让超时和主动取消更容易排查
  5. Steam 成就与云存档上线检查：别让小功能变成差评来源
  6. 游戏服务器可观测性架构设计
  7. SaaS 数据模型：从第一天就想清租户、权限和审计
  8. Go 1.24 新特性：持续进化的 Go

May 7

  1. Steam Deck 支持怎么做：独立游戏上架前的掌机体验检查
  2. 游戏服务器世界状态快照架构设计
  3. 游戏服务器跨服务事务架构设计
  4. SaaS 行业观察：MCP 协议与 AI 工具集成的标准化革命
  5. 游戏场景服务架构设计
  6. Go 模糊测试入门：让工具帮你发现边界输入
  7. Go 与微服务：服务发现与注册实战

April 8

  1. Steam 商店直播实操：独立游戏如何用直播承接新品节和首发流量
  2. Go 工作区入门：用 go work 同时开发多个本地模块
  3. 游戏经济系统架构与风险控制
  4. 游戏服务器跨平台权益服务架构设计
  5. SaaS 行业观察：AI 治理与负责任 AI 的实践框架
  6. Go 与 GraphQL：构建灵活的 API
  7. SaaS 事故沟通：小团队也要提前准备停机、错误和数据问题
  8. 游戏资产服务架构设计

March 8

  1. SaaS 集成策略：从第一个对接开始设计产品边界
  2. 游戏服务器规则脚本沙箱架构设计
  3. Steam Key、策展人与主播外联：独立游戏评测码发放实操
  4. 游戏房间服集群架构设计
  5. Go 1.23 回顾：迭代器与新标准库
  6. SaaS 行业观察：AI 模型成本通缩与商业模式革命
  7. Go ServeMux 路由入门：用标准库写更清楚的 HTTP 路由
  8. 开放世界游戏服务器流式加载架构

February 8

  1. 构建现代 CLI 工具：cobra 框架完全指南
  2. Steam 发售档期怎么选：独立游戏避开拥堵窗口的排期方法
  3. Go slog 入门：用结构化日志记录更清楚的服务行为
  4. 游戏服务器网关与路由层架构设计
  5. SaaS 行业观察：AI 原生产品的崛起与传统 SaaS 的转型困境
  6. 游戏服务器动态难度服务架构设计
  7. 游戏匹配系统服务器架构设计
  8. SaaS 产品埋点：早期先追关键动作，不要堆满事件

January 21

  1. 实时战斗游戏服务器架构设计
  2. Skynet 最佳实践与生产部署
  3. Skynet 完整游戏服务器实战
  4. Skynet 性能调优实战
  5. Skynet 调试技巧与问题排查
  6. 游戏服务器玩家画像分层架构设计
  7. Skynet 热更新机制详解
  8. Skynet WebSocket 支持与实现
  9. Skynet 数据库集成实践
  10. Skynet 集群通信详解
  11. Go 1.22 新特性：range over integers 和 math/rand/v2
  12. Skynet Lua API 参考手册
  13. 游戏服务器从模块化单体到服务化架构
  14. Go 泛型入门：从重复函数到类型参数的自然过渡
  15. Skynet 消息传递机制
  16. SaaS 创始人销售剧本：从随缘聊天到可复盘成交
  17. Skynet 服务模型详解
  18. SaaS 行业观察：AI Agent 的崛起与自主工作流革命
  19. Skynet 安装与环境搭建
  20. Steam 审核被退回怎么办：商店页与构建返工实操手册
  21. Skynet 简介与核心概念
2023 80 篇文章

December 5

  1. 2023 年 Go 语言年度回顾与展望
  2. 从 Demo 到正式发售的 Steam 更新漏斗：个人游戏如何不丢掉早期关注者
  3. 游戏服务器运营回滚控制架构设计
  4. SaaS 路线图取舍：需求很多时先做什么
  5. Steam 发售后更新与长尾运营：让独立游戏持续被发现

November 2

  1. 游戏服务器端到端可靠性架构设计
  2. 游戏服务器玩家设备信任架构设计

October 7

  1. SaaS 失败复盘：早期每个丢单和失败试点都要变成资产
  2. 游戏服务器消息扇出架构设计
  3. SaaS 行业观察：可持续 SaaS 与绿色数据中心战略
  4. Steam 本地化、标签与自然发现：让正确玩家更容易找到你的游戏
  5. 游戏服务器任务依赖图架构设计
  6. Go 安全编程：防范常见漏洞
  7. 游戏服务器区域合规架构设计

September 7

  1. Steam 商店链接与外部承接：个人游戏如何让官网、社媒和媒体包指向同一个动作
  2. SaaS 行业观察：新兴市场的机遇与本地化挑战
  3. 游戏服务器热区隔离架构设计
  4. 游戏服务器冷却令牌服务架构设计
  5. Steam 社区、评论与客服运营：独立游戏发售后的口碑管理
  6. SaaS 现金流和单元经济：别只算服务器成本
  7. Go 1.23 迭代器：range over func 的革命

August 6

  1. 游戏服务器 NPC 群体模拟架构设计
  2. SaaS 客户内部推广：买下来的工具，未必真的推得动
  3. 给主播看的 Steam 试玩构建：个人游戏如何准备可录制版本
  4. SaaS 行业观察：数据治理与隐私合规的新挑战
  5. 游戏服务器分片再均衡架构设计
  6. 游戏服务器体力服务架构设计

July 6

  1. Steam 首发日操作手册：从发布按钮到首周复盘
  2. 游戏服务器热加载架构边界设计
  3. Go 项目结构：构建可维护的大型项目
  4. SaaS 行业观察：安全合规从可选项到准入门槛
  5. 游戏组队与小队服务架构设计
  6. Steam 商店页 FAQ：个人游戏如何提前回答购买前疑虑

June 8

  1. 游戏服务器世界事件触发器架构设计
  2. SaaS 信任材料：小团队也要说清安全、权限和数据
  3. 游戏服务器后台 Worker 架构设计
  4. Steam 定价、地区价格与首发折扣：独立游戏的实际决策方法
  5. Go 1.21 泛型增强：cmp 包与内置 min/max
  6. SaaS 行业观察：客户顾问委员会的战略价值与运营实践
  7. 游戏奖励编排引擎架构设计
  8. Steam 商店文案本地化：不是翻译完就能拿到海外愿望单

May 7

  1. 游戏服务器服务发现与健康检查架构
  2. 游戏服务器竞技场段位晋升架构设计
  3. Steam Demo 与新品节准备：愿望单增长背后的试玩设计
  4. Go 测试进阶：从单元测试到基准测试
  5. SaaS 开放 API：早期别急着全开放，先定义高价值边界
  6. Steam Demo、Prologue 还是免费版：个人游戏上架前如何选公开入口
  7. SaaS 行业观察：多租户架构的演进与现代实践

April 8

  1. 游戏任务进度服务架构设计
  2. Steam 商店页首屏文案：个人游戏如何在 30 秒内讲清购买理由
  3. SaaS 交付边界：配置、定制和服务到底怎么分
  4. Go 1.21 集合操作三剑客：cmp、slices 与 maps 标准库实战
  5. 游戏服务器聊天频道治理架构设计
  6. SaaS 行业观察：产品驱动销售（PDS）的兴起与实践
  7. Steam 构建上传与 Depot 配置：从本地版本到可发布 Build
  8. 游戏服务器命令与查询 API 架构设计

March 8

  1. SaaS 合同和收款流程：早期别让成交卡在行政细节
  2. Steam 素材实操：Capsule、截图和预告片如何服务上架转化
  3. 游戏属性计算服务架构设计
  4. 游戏服务器持久化定时器架构设计
  5. SaaS 行业观察：客户健康评分系统的构建与应用
  6. 游戏服务器战斗实例分配 Broker 架构设计
  7. Steam 主题活动报名准备：个人游戏如何判断适不适合参加
  8. Go 1.21 slog：标准库的结构化日志

February 8

  1. HTTP 服务器模式：从入门到生产
  2. Steam 发现队列准备：个人游戏如何让一次曝光更容易转成愿望单
  3. 游戏在线状态目录服务架构设计
  4. 游戏服务器运行时配置差量分发架构设计
  5. SaaS 行业观察：收入运营（RevOps）的兴起与实践
  6. 游戏角色服务架构设计
  7. Steam 商店页审核与转化指南：从 Coming Soon 到正式发布
  8. SaaS 试点转正式：不要让客户一直停在试用状态

January 8

  1. 游戏服务器战斗命令管线架构设计
  2. SaaS 行业观察：AI 功能集成的战略与实践
  3. Steamworks 账号与上架资料准备：独立游戏上线前的第一张清单
  4. SaaS 客户健康度：早期不要等客户流失才发现问题
  5. Go 1.20 新特性：让错误处理更优雅
  6. 游戏服务器玩家镜像数据架构设计
  7. 在线游戏登录链路架构设计
  8. Steam 品类货架定位：个人游戏上架前如何做竞品地图
2022 70 篇文章

December 5

  1. 错误处理的高级技巧：从基础到企业级
  2. Go 小服务可观测性入门：日志、指标和健康检查先做到位
  3. 游戏服务器发布列车架构设计
  4. 游戏服务器规则评估引擎架构设计
  5. SaaS 第一位协作者：什么时候该找人，哪些事不能外包

November 1

  1. Steam 下载体积与补丁体验：个人游戏上架前要检查的不只是容量

October 6

  1. SaaS 小团队扩张：在混乱前建立基本系统
  2. 游戏服务器数据一致性架构设计
  3. SaaS 行业观察：服务等级目标与错误预算管理
  4. 游戏服务器社交动态流架构设计
  5. Steam 首发客服与崩溃反馈入口：个人开发者如何把问题收集完整
  6. Go 泛型切片工具入门：自己写 Filter、Map 和 Reduce

September 3

  1. 游戏服务器韧性架构模式
  2. SaaS 行业观察：客户顾问委员会与共创机制
  3. SaaS 帮助文档：早期文档不是附属品，而是可复制交付

August 7

  1. 游戏服务器市场价格索引架构设计
  2. SaaS 行业观察：可组合架构与模块化产品设计
  3. Steam 审核证据包怎么准备：让商店页和构建返工更少
  4. Go any 和 interface{} 入门：新名字背后的老概念
  5. 游戏服务器跨服务可观测性架构
  6. SaaS 早期指标：别只看注册数和收入
  7. Go 1.19：稳定中求进步

July 6

  1. Go atomic 入门：什么时候需要原子计数，什么时候该用锁
  2. 游戏服务器异步战斗模拟架构设计
  3. SaaS 行业观察：免费版与试用策略的精细化运营
  4. Steam 运行库与安装脚本检查：别让玩家卡在启动前
  5. Channel 模式：掌握 Go 并发编程的精髓
  6. SaaS 数据导入：第一批客户能否用起来，常常卡在旧数据

June 6

  1. 游戏玩法事件溯源架构设计
  2. Steam 标签小众发现审计：别让个人游戏掉进错误流量池
  3. 原子操作：无锁并发编程的艺术
  4. 游戏服务器区域分片目录架构设计
  5. SaaS 行业观察：经济下行周期的韧性策略
  6. Go 构建信息入门：在程序里查看版本、依赖和构建来源

May 7

  1. SaaS 客服和反馈闭环：把问题变成产品改进
  2. 游戏服务器成长状态机架构设计
  3. SaaS 行业观察：工作流自动化与业务流程优化
  4. Go TLS 和 HTTP 客户端安全入门：证书、超时和最小信任边界
  5. Steam 活动与公告工具怎么用：上架前把更新写成玩家看得懂的节点
  6. 逃逸分析：理解 Go 的内存分配策略
  7. 游戏配置版本化架构设计

April 7

  1. Go netip 入门：更清楚地处理 IP 地址和网段
  2. 游戏实例调度器架构设计
  3. Steam UTM 与流量报表实操：个人游戏推广别只看愿望单总数
  4. SaaS 试用设计：不要让免费试用变成无期限陪跑
  5. SaaS 行业观察：可持续发展与 ESG 的商业实践
  6. 游戏服务器掉落表服务架构设计
  7. Go 1.18 any 类型：告别 interface{} 的冗长

March 8

  1. 性能分析实战：pprof 从入门到精通
  2. Go 1.18 Fuzz 测试：发现隐藏 Bug 的利器
  3. 游戏服务器领地战控制面架构设计
  4. SaaS 行业观察：客户数据平台的兴起与统一客户视图
  5. SaaS 新用户引导：让客户尽快看到第一次价值
  6. Go 工作区入门：go work 如何解决本地多模块联调
  7. 游戏协议网关架构设计
  8. Steam 包、默认分支与可购买状态：上架前别让玩家下错版本

February 7

  1. 游戏服务器实体运行时所有权架构设计
  2. Go 模糊测试基础流程：从一个字符串解析函数开始
  3. Go Workspaces：多模块开发的利器
  4. SaaS 行业观察：可访问性与包容性设计的商业价值
  5. 游戏区服与世界架构设计
  6. Steamworks 权限与发布角色：小团队上架前必须分清谁能按按钮
  7. SaaS 购买地图：早期就要分清使用者、决策人和阻碍者

January 7

  1. SaaS 早期定位：不要同时服务所有客户
  2. SaaS 行业观察：平台战略与生态系统构建
  3. 游戏服务器权威状态架构设计
  4. Go 1.18 泛型初体验：先从三个小函数开始理解
  5. Steam Coming Soon 页面上线节奏：个人游戏别把预热页当占位符
  6. Go 1.18 泛型：期待十年的类型参数
  7. 游戏服务器登录准入控制架构设计
2021 357 篇文章

December 10

  1. 游戏服务器跨分片邮件路由架构设计
  2. 游戏服务器赛季商店库存架构设计
  3. 游戏服务器玩家举报证据流水线架构设计
  4. 游戏服务器 NPC 刷新租约架构设计
  5. 游戏服务器公会战报名与锁定架构设计
  6. 游戏服务器技能施放与打断架构设计
  7. 游戏服务器货币预占与托管架构设计
  8. 游戏服务器副本锁定与存档点架构设计
  9. 游戏服务器实体兴趣订阅架构设计
  10. 游戏服务器 RPC 超时预算架构设计

November 11

  1. 游戏服务器跨模式成长归一化架构设计
  2. 游戏服务器 PVE AI 导演预算架构设计
  3. 游戏服务器社交在线隐私架构设计
  4. SaaS 创业早期运营：让客户留下来比上线更重要
  5. 游戏服务器线上调试命令沙箱架构设计
  6. 游戏服务器私密房间邀请令牌架构设计
  7. 游戏服务器角色转服预检架构设计
  8. 游戏服务器战场目标计分板架构设计
  9. 游戏服务器场景物件持久化架构设计
  10. 游戏服务器伙伴指令归属架构设计
  11. 游戏服务器客户端能力协商架构设计

October 14

  1. 游戏服务器跨服务缓存预热架构设计
  2. 游戏服务器地图战争迷雾可见性架构设计
  3. SaaS 行业观察：并购整合与市场集中化趋势
  4. 游戏服务器资源制作流水线架构设计
  5. 游戏服务器协作解谜状态机架构设计
  6. 游戏服务器匹配处罚限制架构设计
  7. 游戏服务器外观装配校验架构设计
  8. SaaS 竞品拆解：不要抄功能，要拆客户、场景和收费逻辑
  9. 游戏服务器队伍配装锁定架构设计
  10. Steam 发售前媒体和 Key 管理：个人开发者如何避免乱发乱记
  11. 游戏服务器 Boss 仇恨表架构设计
  12. 游戏服务器成就触发聚合架构设计
  13. 游戏服务器世界天气控制面架构设计
  14. 游戏服务器网关连接排空架构设计

September 16

  1. 游戏运营熔断开关架构：线上出事时先止血再追因
  2. 状态校验和对账架构：服务端如何发现客户端悄悄跑偏
  3. 游戏服务器战果校验架构设计
  4. 移动游戏创业失败复盘：负债五百万后，我为什么选择断舍离
  5. SaaS 行业观察：开源 SaaS 的商业模式探索
  6. 维护模式排水架构：不停服世界如何温柔地关门
  7. 战斗回放确定性架构：为什么同一局不能每次重放都不一样
  8. 账号变更串行化架构：背包、货币与任务如何不互相踩踏
  9. SaaS 第一批客户怎么来：冷启动不是发广告
  10. 游戏实例调度约束架构：房间应该被放到哪台机器上
  11. 游戏配置灰度护栏架构：把热更风险关进笼子里
  12. 战斗输入仲裁架构：服务端如何在预测、延迟和公平之间取舍
  13. 移动游戏创业失败复盘：我是如何从不服输走到负债五百万的
  14. Steam 首发语言怎么选：个人游戏的本地化优先级与页面配置
  15. 游戏房间快照归档架构：让一次对局事后还能被解释
  16. 游戏服务器消息乱序缓冲架构：从丢包、重传到状态一致

August 29

  1. Steam 游戏性能预算实战：2021 年 8 月个人项目如何拆帧耗、资源、场景和低配优化
  2. 移动游戏创业失败复盘五：如果还有下一次，我会更慢也更坚定
  3. 分片本地缓存协同架构：快读、脏读和失效风暴之间的平衡
  4. Steam 游戏崩溃日志实战：2021 年 8 月个人项目如何做错误收集、玩家反馈包和版本定位
  5. 空间事件索引架构：地图上的触发器、采集点和区域效果如何高效查询
  6. Steam 游戏手柄 UI 导航实战：2021 年 8 月个人项目如何让菜单、背包和弹窗不用鼠标也能操作
  7. 移动游戏创业失败复盘四：我开始学习和失败长期相处
  8. 实时指令整形架构：限频不是把玩家操作简单丢掉
  9. Steam 云存档实战：2021 年 8 月个人游戏如何规划文件、冲突提示、容量和跨设备恢复
  10. 批量奖励领取架构：一键领取背后的幂等、容量和补偿
  11. 游戏服务器 PVE 波次导演架构设计
  12. SaaS 行业观察：产品分析与用户行为洞察
  13. Steam 排行榜实战：2021 年 8 月个人游戏如何做分数提交、回放校验、赛季和异常数据处理
  14. 副本进度保存与恢复架构：断线、重登和跨服失败后的继续游戏
  15. 移动游戏创业失败复盘三：小团队继续做游戏，必须换一种打法
  16. Steam 成就接入实战：2021 年 8 月个人游戏如何设计触发条件、离线缓存和反作弊边界
  17. 好友邀请一致性架构：申请、同意、拉黑和撤回如何不打架
  18. Steam 游戏音频混音实战：2021 年 8 月个人项目如何做音量分组、压低、循环和场景切换
  19. 排行榜写缓冲架构：高频积分变化如何不打垮排名服务
  20. 没有发行商也要做好 Steam 胶囊图：个人游戏的视觉素材工作流
  21. 移动游戏创业失败复盘二：比重新开始更重要的是重建判断力
  22. Steam 游戏本地化流程实战：2021 年 8 月个人项目如何管理文本、变量、字体和商店页语言
  23. 游戏通知优先级投递架构：红点、弹窗和系统消息不能抢同一条路
  24. Steam 游戏存档迁移实战：2021 年 8 月个人项目如何处理版本升级、字段缺失和坏档恢复
  25. 开放世界分区切换架构：玩家跨边界时服务端到底交接什么
  26. 移动游戏创业失败复盘一：失败之后，我为什么还没有完全放弃
  27. SaaS 客户成功会议：早期复盘应该问出续费和扩展线索
  28. Steam 游戏输入重绑定实战：2021 年 8 月个人项目如何做键鼠、手柄、冲突检测和配置保存
  29. 技能效果结算流水线架构：让伤害、控制与触发器各走其位

July 28

  1. 场景热对象拆分架构：一个世界 Boss 为什么会拖慢整张地图
  2. Steam 游戏伤害结算管线实战：2021 年 7 月个人项目如何处理命中、抗性、暴击、护盾和日志
  3. 2015年移动游戏创业失败复盘五：失败之后我才理解创业不是做一款游戏
  4. Steam 游戏隐私友好遥测实战：2021 年 7 月个人项目如何记录事件、复盘体验和保护玩家
  5. GM 操作双人审批架构：高风险后台工具不能只靠信任
  6. 游戏服务器玩家站内通知架构设计
  7. Steam 游戏 MOD 数据加载实战：2021 年 7 月个人项目如何设计可扩展数据、校验和安全边界
  8. Steam 愿望单冷启动：个人开发者如何用开发日志和小社区慢慢起量
  9. 2015年移动游戏创业失败复盘四：团队和现金流让错误决策不断放大
  10. 队伍跨场景跟随架构：队长进副本时队友为什么不能丢
  11. Steam 游戏 Feature Flag 实战：2021 年 7 月个人项目如何管理实验功能、Demo 内容和构建配置
  12. 库存预占架构：交易、合成和消耗如何避免同一件物品被用两次
  13. Steam 游戏开发者控制台实战：2021 年 7 月个人项目如何做命令、权限、日志和发行版清理
  14. 战斗服旁路计算架构：统计、AI 辅助和反作弊别挤占主循环
  15. SaaS 行业观察：全球化扩张的本地化挑战
  16. 2015年移动游戏创业失败复盘三：技术负责人最容易做错的产品决策
  17. Steam 游戏拍照模式实战：2021 年 7 月个人项目如何做暂停、镜头、滤镜、水印和截图分享
  18. 房间命令日志压缩架构：保留可回放能力又不让存储爆炸
  19. Steam 游戏地图与小地图实战：2021 年 7 月个人项目如何做探索、标记、迷雾和任务导航
  20. 客户端补丁门控架构：版本、资源和服务器能力如何对齐
  21. 2015年移动游戏创业失败复盘二：产品定位从一开始就不够锋利
  22. Steam 游戏合成与配方系统实战：2021 年 7 月个人项目如何做材料、解锁、预览和存档
  23. 世界对象租约架构：宝箱、机关和临时 Boss 谁来负责
  24. Steam 游戏刷怪导演系统实战：2021 年 7 月个人项目如何控制敌人波次、压力和性能
  25. 运营活动状态机审计架构：活动从预热到结算每一步都要可查
  26. 2015年移动游戏创业失败复盘一：我误判了手游市场的窗口
  27. 游戏会话票据续期架构：断线重连、顶号和长连接安全怎么一起处理
  28. Steam 游戏动画状态机实战：2021 年 7 月个人项目如何处理移动、攻击、受击与过渡

June 39

  1. Steam 游戏崩溃恢复实战：2021 年 6 月个人项目如何做安全恢复、备份和玩家提示
  2. 玩家在线状态对账架构：在线、离线、断线中和幽灵会话如何收敛
  3. 游戏客户端本地资源加密：保护成本和加载性能的取舍
  4. SaaS 早期定价：不要等产品完美后才收费
  5. Steam 游戏回放调试实战：2021 年 6 月个人项目如何记录输入、随机种子和关键状态
  6. 权威随机抽取架构：宝箱、卡池和掉落为什么不能只靠客户端表现
  7. 游戏客户端推送跳转：从通知栏到正确页面的状态恢复
  8. SaaS 行业观察：基于使用量的定价模式探索
  9. 投降投票状态机架构：竞技对局里的少数服从多数并不简单
  10. Steam 平台抽象层实战：2021 年 6 月个人游戏如何封装成就、云存档、覆盖层和离线模式
  11. 游戏客户端动态 UI 皮肤：节日换肤不能改坏基础界面
  12. 道具绑定规则架构：可交易、账号绑定和临时绑定不能靠硬编码
  13. Steam 游戏 NPC 日程与世界状态实战：2021 年 6 月个人项目如何做时间、位置和事件
  14. 游戏客户端任务对话分支：选择、条件和回滚都要可追踪
  15. 2015年游戏创业失败复盘五：失败之后，我真正学到的十件事
  16. 2015年游戏创业失败复盘四：不会发行的游戏，根本没有被看见的机会
  17. 游戏客户端活动小游戏容器：临时玩法也要有边界
  18. 玩法日历编排架构：限时玩法、重置和跨时区活动如何统一管理
  19. Steam 游戏程序生成实战：2021 年 6 月个人项目如何设计种子、规则、回放和坏图兜底
  20. 2015年游戏创业失败复盘三：团队、外包、现金流和自研之间的撕裂
  21. 游戏有状态服务发布架构设计
  22. 2015年游戏创业失败复盘二：第一款产品如何从热血变成失控
  23. Steam 发售前 QA 矩阵：个人开发者如何用有限设备做有效测试
  24. 2015年游戏创业失败复盘一：从大厂工程师到创业者的第一层错觉
  25. Steam 游戏物理交互实战：2021 年 6 月个人项目如何处理推箱、碰撞、机关和确定性
  26. 游戏客户端皮肤染色预览：颜色自由度和性能预算的平衡
  27. 副本实例暖池架构：高峰期开房不应该从零开始
  28. 匹配准备确认架构：十个人点准备背后的共识与超时处理
  29. 游戏客户端战斗回放裁剪：精彩片段不是完整录像
  30. Steam 游戏 VFX 与 Shader 实战：2021 年 6 月个人项目如何做特效预算、可读性和性能
  31. Steam 游戏摄像机系统实战：2021 年 6 月个人项目如何处理跟随、锁定、震动与场景构图
  32. 任务事件路由背压架构：别让一次击杀触发全服任务扫描
  33. 游戏客户端消耗道具确认：别让一个误点吃掉稀有物品
  34. 游戏客户端移动端技能瞄准：辅助不是替玩家操作
  35. Steam 游戏对话与过场系统实战：2021 年 6 月个人项目如何做脚本、分支、跳过和存档
  36. 公会贡献账本架构：贡献值、建设度和奖励资格不要混在一起
  37. 游戏客户端新手资源预热：第一小时不要让玩家等加载
  38. Steam 游戏库存与装备系统实战：2021 年 6 月个人项目如何做物品、堆叠、装备和存档
  39. 玩家称号与徽章读模型架构：展示系统不能拖慢核心状态

May 44

  1. Steam 发售候选分支治理实战：2021 年 5 月个人游戏如何冻结、验证和合并发布代码
  2. 玩家设置同步架构：画质、隐私、快捷键和玩法偏好如何跨端一致
  3. 游戏客户端安全区适配：刘海屏、圆角和手势条不能靠目测
  4. 游戏服务器对局大厅生命周期架构设计
  5. 性能优化实战：让你的 Go 应用飞起来
  6. 游戏客户端语言包下载：多语言资源不要拖慢首包
  7. Steam 游戏自动化烟测实战：2021 年 5 月个人项目如何检查启动、菜单、存档和关键流程
  8. 个人游戏要不要抢先体验：Steam Early Access 决策与执行清单
  9. 战斗观测采样架构：想看清战斗问题，也不能把房间日志打爆
  10. 分布式追踪：跨服务调用链路分析
  11. 奖励预览契约架构：客户端看到的奖励和最终到账为什么会不一致
  12. Steam 游戏可访问性实战：2021 年 5 月个人项目如何做字幕、色彩、输入与难度选项
  13. 游戏客户端匹配排队反馈：等待时也要让玩家安心
  14. Prometheus 监控：让你的应用可观测
  15. 游戏客户端排行榜页面：分页、我的名次和刷新节奏
  16. Steam 游戏设置兼容实战：2021 年 5 月个人项目如何处理画面、窗口、设备与安全模式
  17. NPC 对话状态架构：分支、条件和奖励触发如何避免客户端说了算
  18. 数据库事务：保证数据一致性的关键
  19. 跨服活动报名架构：名额、资格和分组不能靠最后一刻拼表
  20. 游戏客户端制作系统预览：材料、概率和结果要讲清楚
  21. Steam 游戏资源加载实战：2021 年 5 月个人项目如何处理首屏、流送、预加载与错误恢复
  22. SaaS 早期技术债：哪些可以欠，哪些第一天就不能欠
  23. SaaS 行业观察：数据隐私合规与用户信任建设
  24. gRPC 基础：构建高性能微服务通信
  25. Steam 游戏 Boss 生产实战：2021 年 5 月个人项目如何做阶段、招式、调试和 QA
  26. 场景门禁架构：等级、任务、队伍和活动窗口如何统一判定
  27. 游戏客户端坐骑与载具控制：移动手感、上下车和镜头协同
  28. Redis 集成：高性能缓存与数据存储
  29. 游戏客户端表情轮盘：快速表达、误触控制和网络广播
  30. Steam 游戏教程系统实战：2021 年 5 月个人项目如何做触发、跳过、复习与新手保护
  31. 赛季任务补发架构：漏计进度和迟到事件如何安全修复
  32. JWT 身份验证：构建安全的 API 认证系统
  33. 坐骑状态同步架构：上马、下马、加速和禁止区域如何服务端裁决
  34. Steam 游戏 AI 行为实战：2021 年 5 月个人项目如何做敌人状态、感知与调试
  35. 游戏客户端队伍语音：权限、设备和 UI 状态要一起设计
  36. WebSocket 实时通信：构建交互式应用
  37. Steam 游戏经济循环实战：2021 年 5 月个人项目如何设计货币、商店、奖励与消耗
  38. 临时属性快照架构：Buff、装备和活动加成如何在结算时说得清
  39. 游戏客户端好友在线与邀请：不要让社交状态变成玄学
  40. RESTful API 设计：构建优雅的 Web 接口
  41. 队伍语音令牌代理架构：实时语音接入不应该绑死在战斗服里
  42. 游戏客户端邮件附件：从红点到一键领取的可信闭环
  43. Steam 游戏任务系统实战：2021 年 5 月个人项目如何设计状态机、触发器与存档
  44. 中间件模式：构建灵活的 Web 应用

April 54

  1. Steam 商店承诺与开发实现对齐：2021 年 4 月个人游戏功能审计实战
  2. 游戏服务器新手引导进度检查点架构：可跳过、可恢复、可追踪
  3. 项目架构：构建可维护的 Go 应用
  4. 游戏客户端移动端输入框：软键盘、中文输入法和提交体验
  5. Steam 轻量联机开发实战：2021 年 4 月个人游戏如何判断要不要做多人模式
  6. Go 最佳实践：写出优雅的 Go 代码
  7. 游戏服务器战斗结算校验流水线：从结果上报到可信发奖
  8. 设计模式：Go 语言中的实践
  9. 游戏客户端背包排序筛选：让玩家在几百个物品里快速找到目标
  10. 游戏服务器防沉迷在线时长控制架构：合规规则如何落到实时链路
  11. Steam 游戏补丁内容组织实战：2021 年 4 月个人项目如何规划资源包、版本兼容与下载体积
  12. 性能分析：pprof 和 trace 工具
  13. SaaS 行业观察：移动化战略与多端体验设计
  14. Docker 部署：让你的应用随处运行
  15. 游戏服务器世界时钟与 Tick 架构设计
  16. 游戏客户端世界事件调度：倒计时、资源预取和入口状态
  17. Steam 游戏内测工具实战：2021 年 4 月个人项目如何做调试面板、测试指令和反馈入口
  18. 游戏服务器地图标记兴趣订阅架构：任务点、队友信号与世界事件怎么同步
  19. 信号处理：让你的应用优雅地退出
  20. 游戏客户端领奖事务：一个按钮如何避免重复、漏奖和弱网混乱
  21. 内存管理：Go 的垃圾回收机制
  22. 游戏服务器人机对局隔离架构：让机器人参与但不污染真实生态
  23. Steam 游戏数据驱动实战：2021 年 4 月个人项目如何管理数值表、配置与平衡
  24. 游戏客户端观战模式：延迟缓冲、导播相机和公平边界
  25. 缓存：让应用飞起来
  26. CGO 入门：Go 与 C 的桥梁
  27. 游戏服务器掉落表版本钉住架构：让奖励随机既公平又可追溯
  28. Steam 游戏 UI 架构实战：2021 年 4 月个人项目菜单、HUD 与状态管理教程
  29. 游戏客户端成就反馈：进度、弹窗和红点如何不打扰玩家
  30. 配置管理：让你的应用更灵活
  31. 游戏服务器角色外观组合架构：皮肤、染色与展示一致性
  32. reflect 包：运行时的魔法镜子
  33. GORM：Go 的 ORM 利器
  34. 游戏客户端公会界面：权限、成员列表和事务状态怎么拆
  35. Steam 游戏音频实战教程：2021 年 4 月个人项目音乐、音效与混音落地
  36. SaaS MVP 怎么做：把第一个版本缩到能收费
  37. 游戏服务器跨场景聊天路由架构：频道、房间与在线状态的边界
  38. unsafe 包：Go 的潘多拉魔盒
  39. 从原型到 Steam Demo：个人游戏如何做一个能带来愿望单的试玩版
  40. Steam 动作游戏战斗反馈实战：2021 年 4 月个人项目如何打磨命中感和可读性
  41. 游戏客户端伙伴表现系统：让宠物看起来聪明但不添乱
  42. 网络编程：用 Go 构建底层网络应用
  43. 构建约束：条件编译的艺术
  44. 游戏服务器公会角色权限架构：别让职位系统变成事故入口
  45. Steam 游戏关卡生产实战：2021 年 4 月个人项目从灰盒到可发布场景的流程
  46. 加密与安全：让你的 Go 程序固若金汤
  47. go:embed：把文件打包进二进制
  48. 游戏客户端战令页面性能：奖励很多时如何仍然滑得顺
  49. 游戏服务器体力恢复时钟架构：从定时任务到可解释的资源结算
  50. 错误处理的高级技巧
  51. Steam 游戏调试日志实战：2021 年 4 月个人项目如何定位崩溃、卡死与玩家反馈
  52. 字符串处理：那些被忽略的细节
  53. 游戏客户端每日签到日历：把 30 个格子做成可信的状态机
  54. 接口组合：Go 的设计哲学

March 44

  1. 游戏客户端诊断面板：线上问题要能让客服和工程师说同一种语言
  2. Steam 发布前 QA 实战教程：2021 年 3 月个人游戏回归测试、缺陷分级与候选版本
  3. 性能优化：让 Go 程序飞起来
  4. 游戏服务器世界资源刷新调度架构：采集点、争夺点与负载控制
  5. 游戏服务器快照增量同步架构设计
  6. 游戏服务器服务端剧情触发架构：让演出自由，但进度和奖励可信
  7. 日志处理：构建可观测的应用
  8. 游戏客户端小地图标记：方向、距离和图标密度都需要系统设计
  9. Steam 控制器兼容实战：2021 年 3 月个人游戏面向掌机和客厅场景的开发检查
  10. 游戏客户端 Toast 与通知队列：提示越短，规则越要清楚
  11. 游戏服务器组队阵型重连架构：队长切换、站位锁定与副本恢复
  12. gRPC：构建高性能微服务
  13. Steam 游戏性能优化实战：2021 年 3 月个人项目低配电脑测试与 Profiling 流程
  14. WebSocket：实现实时通信
  15. 游戏客户端设置系统：画质、音频、操作和账号选项不要散落在各处
  16. 游戏服务器道具堆叠拆分合并架构：背包格子、数量与绑定规则如何不出错
  17. Steam 游戏内本地化实战：2021 年 3 月个人项目文本、字体与多语言管线
  18. Steam 上架前 90 天计划：个人游戏如何把发行拆成可执行日程
  19. 游戏服务器活动脚本预算架构：给运营灵活性，也给线上稳定性护栏
  20. 模板引擎：text/template 和 html/template
  21. 游戏客户端拍照模式：截图按钮背后有暂停、构图、权限和资源问题
  22. Steam 构建流水线实战：2021 年 3 月个人游戏从本地打包到 SteamPipe 上传
  23. 泛型：Go 的类型参数革命
  24. 游戏客户端外观预览：试穿界面要隔离资源、镜头和真实角色状态
  25. 游戏服务器跨服排队令牌架构：活动入口、容量控制与掉线恢复
  26. Steam 成就与统计实战教程：2021 年 3 月个人游戏如何接入并测试
  27. 游戏客户端伤害数字：飘字越多，越要克制和分层
  28. 游戏服务器玩家改名索引架构：昵称唯一、历史追踪与社交一致性
  29. SaaS 行业观察：API 经济与开发者平台战略
  30. 命令行工具：用 Go 构建优雅的 CLI 应用
  31. Steam 游戏存档系统实战：2021 年 3 月个人项目从本地存档到云同步准备
  32. 反射：Go 的元编程魔法
  33. 游戏客户端聊天渲染：一条消息背后的性能、过滤和安全边界
  34. 游戏服务器战斗房间观测快照架构：观战、回放与异常排查共用一套事实层
  35. Steam 游戏输入系统实战：2021 年 3 月键鼠、手柄与可重绑定操作教程
  36. SaaS 手工交付：先用人工跑通，再决定哪些值得产品化
  37. 时间处理：掌握 Go 的 time 包
  38. 游戏客户端任务追踪：让玩家知道下一步去哪，而不是只显示一句目标
  39. 游戏服务器拍卖竞价冻结架构：保证金币、出价与成交结算都说得清
  40. Steam 游戏原型到可试玩切片：2021 年 3 月个人开发实战教程
  41. 数据库操作：Go 与 SQL 的完美邂逅
  42. 游戏服务器客户端命令回执架构：让点击、重试与状态确认不再互相打架
  43. Steam 个人游戏开发环境实战：2021 年 3 月从工程目录到版本控制的落地流程
  44. 游戏客户端新手引导：不要把玩家困在发光手指里

February 44

  1. 游戏服务器玩家家园拜访权限架构：访问控制、实例快照与互动安全
  2. 游戏客户端多人大厅状态：准备、邀请和匹配别写成一堆按钮回调
  3. Steam 上线首周运营复盘：2021 年 2 月个人游戏从反馈到补丁的闭环
  4. 正则表达式：文本处理的瑞士军刀
  5. 游戏服务器每日首胜奖励架构：跨模式、跨时区与重复领取控制
  6. 移动游戏客户端后台生命周期：切出去再回来，比冷启动更难处理
  7. 低预算 Steam 构建上传流程：个人开发者如何少踩 SteamPipe 的坑
  8. Go Modules：现代化的依赖管理
  9. Steam 主播与媒体 Key 发放：2021 年 2 月个人游戏上架前外部触达流程
  10. 游戏服务器 PVP 隐藏分校准架构：匹配质量、段位展示与赛季重置
  11. 游戏服务器命令去重架构设计
  12. 游戏客户端资源引用审计：包体膨胀通常不是一天发生的
  13. Steam 本地化商店页检查：2021 年 2 月个人游戏多语言上架流程
  14. Go 测试：让代码更可靠的秘密武器
  15. 游戏服务器 UGC 地图审核发布架构：玩家创作内容如何安全进入线上世界
  16. 游戏客户端配置灰度校验：比热更新更快的东西更需要刹车
  17. SaaS 行业观察：远程办公浪潮下的产品机遇
  18. Steam 首发折扣与地区价格检查：2021 年 2 月个人游戏上架定价指南
  19. HTTP 编程：用 Go 构建 Web 服务
  20. 从 0 开始做 SaaS：先验证问题，而不是先写代码
  21. 游戏服务器传送门校验架构：位置、资格与目标实例的一致性
  22. 游戏客户端时间线回放：把偶发战斗问题变成可复现问题
  23. JSON 处理：Go 与数据交换的桥梁
  24. 春节期间 Steam 游戏支持计划：2021 年 2 月个人开发者上线前客服准备
  25. 游戏服务器小队职业配额匹配架构：坦克、治疗与输出如何公平组队
  26. 文件 I/O：Go 的文件操作全攻略
  27. 移动游戏客户端误触防护：按钮不是画上去就结束了
  28. Steam 构建审核返工流程：2021 年 2 月个人游戏如何处理发布前问题
  29. 游戏服务器表情动作广播架构：社交表现如何不拖垮场景同步
  30. 游戏客户端战斗 HUD：高频状态更新不能靠每帧全量刷新
  31. Context：并发控制的指挥棒
  32. Steam Demo 与 Playtest 转化：2021 年 2 月个人游戏试玩到愿望单的流程
  33. 游戏服务器宠物伙伴成长状态架构：经验、技能、出战与继承规则怎么设计
  34. sync 包：Go 的同步工具箱
  35. Steam 标签与发现流量审计：2021 年 2 月个人游戏上架前的分类检查
  36. 游戏客户端设备分档：画质策略要能被数据解释
  37. 游戏服务器世界分线切换冷却架构：容量、体验与反刷之间的平衡
  38. Channel：Go 并发的灵魂
  39. 游戏客户端断点下载：资源更新失败时，别让玩家从零开始
  40. Steam 商店页首屏怎么改：2021 年 2 月个人游戏发现流量承接指南
  41. Goroutine：Go 的并发魔法
  42. 游戏服务器伤害统计聚合架构：让战斗数据既及时又可信
  43. 游戏客户端首包体验：先让玩家玩到核心，再谈完整世界
  44. 2021 年 2 月 Steam 发售日历：个人游戏如何避开春节节奏和审核风险

January 24

  1. 游戏客户端灰度开关：活动、实验和兜底都需要同一套规则
  2. Steam 首发复盘怎么做：2021 年 1 月个人游戏上线后的数据和动作闭环
  3. 移动游戏客户端内存水位：不要等系统杀进程才开始优化
  4. Steam 上线首周客服模板：2021 年 1 月个人游戏发布后的问题处理
  5. 游戏客户端技能表现编排：一次大招背后的镜头、特效和命中反馈
  6. Steam 发售前公告节奏：2021 年 1 月个人游戏如何唤醒愿望单玩家
  7. 游戏客户端动画事件管线：别把伤害、音效和特效都塞进帧回调
  8. SaaS 创始人时间预算：早期每天到底该做什么
  9. Steam 发售前测试招募：2021 年 1 月个人游戏从熟人测试到真实玩家反馈
  10. 游戏客户端离线与重试：不要让按钮点击变成请求风暴
  11. 游戏服务器会话粘性架构设计
  12. Steam 定价页与商店承诺对齐：2021 年 1 月个人游戏上架实操
  13. 游戏客户端资源清单：版本号、依赖和回滚要一起设计
  14. SteamPipe 上传与版本记录：2021 年 1 月个人游戏构建上架实操
  15. SaaS 行业观察：客户支持的演进与服务体系构建
  16. 第一次做 Steam 商店页：个人开发者如何把玩法说清楚
  17. 游戏客户端长列表优化：背包、邮件和排行榜为什么越滑越卡
  18. Steam Demo 截取范围怎么定：2021 年 1 月个人游戏试玩版上架流程
  19. 动作游戏客户端输入缓冲：手感来自被认真处理的几十毫秒
  20. Steam 胶囊图点击率自查：2021 年 1 月个人游戏商店曝光前的素材审计
  21. 游戏客户端场景切换：读条不是遮羞布
  22. Steam 商店页审核准备：2021 年 1 月个人游戏提交前逐项检查
  23. 游戏客户端登录状态机：别让一次重连变成一串弹窗
  24. 2021 年 1 月 Steam 游戏发售窗口规划：个人开发者的新年上架节奏