Mysql

防资损这道题,测试答不了

金融系统出bug和出资损,是两个完全不同的量级。功能写错了,改过来就是;页面丑了,迭代一轮就行;但钱算错了,那是客诉、是赔付、是监管约谈,严重的时候直接停业整改。

我观察到一个很普遍的反应模式:出了资损,先加测试用例;又出一次,加人肉对账;再出一次,加发版审批。每一步都在做加法,每一步都离根本原因更远。因为大部分人把资损当成了一种"严重的bug",用防bug的思路来防资损。这个认知偏差才是资损反复出现的根源。

 

资损不是bug的严重版

 

普通bug和资损的核心区别在于:bug是你功能做错了,资损是你的功能没做错,但钱错了。

一个理财产品页面,把年化收益率3.5%展示成3.8%,这是bug。但用户基于3.8%做了购买决策,实际到账按3.5%结算,用户体验上的落差就是资损——即使从功能角度看,展示模块和计算模块各自都"按逻辑运行"。

更典型的场景:用户申购一笔理财,网络超时,前端重试了一次,后端处理了两笔。这两笔处理的每一笔单独看都没"错"——接口接收请求、参数校验通过、数据库写入成功。但因为缺少幂等约束,结果就是资损。

代码的第一读者不是机器,是审计

上周组里一个产品上线前的合规评审会上,合规专员盯着一段前端代码问了一个问题:"这个收益率计算逻辑,用户在购买前看到的结果和购买后持仓页显示的结果,走的是不是同一条计算链路?"

在场的两个前端工程师面面相觑。答案是"不是"。购买前用的是推荐接口的预计算数据,持仓页用的是资产接口的实时结算数据。两条链路,两套精度处理,两组四舍五入规则。在普通业务里这根本不算事——数据来源不同,展示逻辑不同,非常自然。但在金融业务里,这意味着用户可能看到购买前年化3.52%,购买后变成3.51%。

0.01%的偏差,万亿规模下就是上亿的资金差异预期。合规专员当场拍了桌子,上线延期两周。

这个场景在互联网公司几乎不会发生。但在金融科技团队,它是日常。

 

金融业务的代码有两套读者

 

大部分工程师写代码时心里只有一个读者:运行时环境。代码能不能跑,跑得快不快,内存占不占得住——所有的优化方向都指向机器。

金融业务的代码不一样。它有两套读者:机器和审计。而且讽刺的是,审计这个读者往往比机器更难伺候。机器只要逻辑正确就行,审计要的是"逻辑正确且可追溯且可解释且可复现"。多出来的这三个"且",才是金融科技工程真正的成本。

DRY的幻觉:你消灭的重复,正以耦合的形式回来找你

DRY——Don't Repeat Yourself。这四个字母可能是软件工程里被引用最多、被误解最深的原则。

每个程序员入行第一天就被告知:重复代码是邪恶的,看到重复就要提取,看到提取就要抽象,看到抽象就要泛化。于是我们疯狂地消灭重复——公共函数、工具类、基础库、共享模块......代码库越来越"干净",重复率越来越低,CI里没有任何duplicate code的警告。

然后某一天,一个业务需求来了——需要改动某个"公共"逻辑。你打开那个被47个地方引用的utils函数,改了一行,跑了一下测试——绿了。上线,结果三个业务线同时报警。你突然发现,那三个业务线依赖的是同一个函数的三种不同行为,被那个"公共"函数强制统一了。

你消灭了重复代码,但你制造了耦合。而耦合,是比重复贵十倍的技术债。

 

重复代码不是问题,问题是不知道为什么重复

 

所有关于DRY的讨论,都默认了一个前提:重复等于坏。但这个前提本身就是幻觉。

重复代码至少有三种完全不同的面目。

第一种是意外重复——两个开发者不知道对方写了同样的功能,造了两个轮子。这种重复才是真正需要消灭的,因为它意味着信息浪费和潜在的不一致。

错误处理的谎言:你以为在兜底,其实在埋雷

打开任何一个前端项目的代码,搜索 `catch`,你大概率会看到这样的画面:

```javascript
try {
await fetchData();
} catch (e) {
console.error(e);
message.error('操作失败,请稍后重试');
}
```

后端也好不到哪去:

```javascript
try {
await processOrder(orderId);
} catch (err) {
logger.error('订单处理失败', { orderId, error: err.message });
throw new BusinessException('系统异常,请重试');
}
```

这两段代码有一个共同的特质——它们让你觉得错误被"处理"了。日志打了,提示也弹了,异常也抛了,一切看起来都很体面。

但你仔细想想:用户看到"操作失败,请稍后重试"之后能做什么?重试?然后呢——再失败一次?运维看到一条"订单处理失败"的日志,能定位到什么?是库存扣减超时,还是支付回调丢失,还是风控拦截?

前端状态管理的终极错觉:我们都在重新发明数据库

前端的现状有点荒诞:我们嘴上说自己在写 UI,实际上大部分时间在跟数据较劲。Redux、Zustand、React Query、SWR、Dva、Pinia——每出一个新方案,大家就觉得"这次终于对了"。但如果你把所有这些方案放在一起,去掉它们的外壳看本质,会发现一个尴尬的事实:它们解决的问题,数据库几十年前就解决了,而且解决得更好。

我们不是在做状态管理,我们是在重新发明数据库。只是发明得很差。

 

一个 Redux Store 就是一个简化版数据库

 

Redux 可能是最明显的例子。你写一个 Redux store 的时候,本质上在做什么?

定义一个全局的数据结构——这叫 Schema。写 reducer 处理 action——这叫事务(Transaction),action 本身就是 WAL 日志。写 selector 查询数据——这叫查询引擎。写 middleware 拦截 action——这叫触发器(Trigger)。用 normalize 归一化数据——这不就是数据库范式吗?

Node.js的运行时幻觉:为什么你的服务能跑全靠运气

很多从前端转 Node.js 的开发者,对这门运行时的理解停留在"写 JavaScript,能跑服务"这个层面。开发环境跑得好好的,上了生产环境,问题一个接一个冒出来,而且每一个都反直觉。

这不是水平问题,是 Node.js 的运行时设计给了你一种安全感——一种在开发环境完全验证不了、只有在流量压上来的那一刻才会破碎的安全感。

我自己在做 BFF 层的这些年,踩过太多这种坑。最深的感触是:Node.js 不会替你兜底,它只是让你以为它会。

 

事件循环不是安全网

 

Node.js 的文档里有一句很关键的话:事件循环在单个线程中运行。但很多人对这句话的理解是——"异步代码就不会阻塞"。

这是最大的幻觉。

`async/await` 只是语法糖,它让异步代码看起来像同步代码,但它不会把同步操作变成异步的。当你在一个请求处理函数里做了这些事情,整个事件循环都会停住:

- `JSON.parse` 一个 50MB 的请求体
- 用正则表达式匹配一个精心构造的字符串(回溯攻击)
- 在同步循环里做密集计算,比如加密、排序大数据集
- 调用了某个底层 C++ 扩展的同步接口

Serverless:复杂度没有消失,只是换了地址

2018年前后,Serverless在国内技术圈火了一阵。各大云厂商轮番布道,"按需付费"、"零运维"、"自动扩缩容"——每个口号都精准戳中了团队的痛点。我当时也投入了不少精力研究,毕竟谁不想不用管服务器?

几年过去了,当初那些All in Serverless的团队,相当一部分已经在往回走。不是Serverless不好,而是很多人慢慢意识到:当初以为消灭的复杂度,其实只是搬了个家。

 

那些承诺里没写的小字

 

Serverless的核心承诺有三条,每一条都有对应的现实版本。

"不用管服务器"——开发者只需写业务逻辑,基础设施平台托管。这对前端团队尤其有吸引力,写完函数丢上去就能跑,不用折腾部署和运维。但现实是,你很快会发现自己需要关注函数的内存配置、超时时间、并发限制、冷启动策略、VPC配置、IAM权限……这些不叫"服务器运维",但本质上还是在管基础设施,只是换了个仪表盘。

"按需付费"——代码不运行就不收钱,空转成本消失。但下一句没人告诉你的是:按需付费的反面是成本不可预测。一个函数死循环触发重试,一个爬虫突然疯爬你的API,一个配置错误导致无限调用——这些异常场景下的账单,会让你深切怀念固定成本的日子。

AI+机器人创业:软件思维才是最大的坑

过去一年,我接触了不少AI和机器人方向的创业团队。有做具身智能的,有做服务机器人的,有做工业检测的,也有做消费级陪伴机器人的。聊完之后一个很强烈的感受:大量的创业者——尤其是技术背景出身的——正在用软件的思维做硬件的生意,用SaaS的逻辑评估一个物理世界的项目。

这个错位,比大多数人以为的要严重得多。

 

Demo到产品的距离,在硬件世界里是光年

 

软件创业的核心叙事是MVP——最小可行产品。两周上线一个版本,收集用户反馈,快速迭代。这套方法论在过去十年被验证了无数次,几乎成了互联网创业的圣经。

但这个叙事在机器人领域完全不成立。

一个做餐厅配送机器人的团队跟我说,他们的软件系统三个月就搭好了,SLAM算法调了两个月效果不错,避障也过得去。但整机跑起来之后,发现轮子打滑导致里程计漂移,激光雷达在不同光照条件下噪点差异巨大,电池在冬天衰减了30%导致续航不达标,餐厅地面的油渍让轮子寿命从设计的一半都不到。每一个都是"小问题",但要解决任何其中一个,都需要改模具、换供应商、重新做可靠性测试——一个循环下来三个月起步。

软件出bug可以热修复,硬件出问题只能召回。软件改一行代码的成本是几分钟,硬件改一个结构件的成本是几万块起,加上开模周期至少四周。这不是量变,这是质变。

从Redux到Signal,状态管理为什么换了三代还是不满意

前端开发有一个有趣的规律:每隔两三年,社区就会宣布一个新的状态管理"最佳实践"。Redux曾是不可撼动的标准,然后MobX说响应式才是正道,Dva试图让Redux更人性化,Zustand说状态管理不该这么啰嗦,Jotai说应该是原子化的,现在Signal又告诉你要从原语层面重新思考这个问题。每一次更迭都伴随着"旧方案已死"的宣言,和一波迁移重构。

但有一个问题始终没人回答:如果每个新方案都比上一个好,为什么我们还是不满意?

经历过Redux到Dva再到Zustand的完整迁移,我发现每一次换库的时候,团队都觉得这次终于对了。每一次,半年后又会发现新的别扭。这种循环让人不得不怀疑——问题可能根本不在库里。

 

Redux的铁律和代价

 

Redux的核心思想并不复杂:单一数据源,纯函数更新,不可变数据。这三条铁律在2016年前后确实解决了一个真实痛点——复杂应用中状态变化的不可预测性。组件树里的状态到处飞,回调层层传递,谁能改、谁不能改、改了之后谁是新的,没人说得清。Redux用一套严格的规则堵住了这个口子。

缓存的一致性幻觉:为什么缓存越多数据越不可信

每个做过高并发系统的人,大概都经历过这样的时刻:线上出了个数据不一致的bug,排查一圈发现是缓存没更新。修完之后加个主动失效,觉得踏实了。过几天又出现,这次是另一个缓存层级。再修。再过段时间,用户反馈看到的金额对不上——你一查,三个缓存层级,两个过期时间不一样,一个还挂着CDN缓存头。

这不是段子,这是每天都在生产环境里上演的日常。

团队解决性能问题的第一反应永远是加缓存。页面慢?加个Redis。接口慢?加个本地缓存。前端渲染慢?加个HTTP Cache-Control。数据库扛不住?加个查询缓存。每一层缓存都在解决一个真实的问题,但每一层缓存也在制造一个你暂时看不见的新问题——等到它浮现的时候,往往已经是你最不想看到的形态。

 

缓存是性能的银弹,也是一致性的地雷

 

这里有个反直觉的事实:缓存从不制造bug,它只是把bug从"现在就暴露"延迟到"不知道什么时候暴露"。

一个没有缓存的系统,数据读出来就是最新的,哪怕慢一点,至少不会错。但当你开始在链路上堆缓存,你事实上引入了一个隐含假设:旧数据在一段时间内是可以接受的。这个假设在大部分场景下成立,但"在大部分场景下成立"和"在你的场景下成立"是两回事。

页面