Nostr notes by yfaming

“The fan pays the artist. Directly. In sats.” That’s the ...

2026-10-28T02:58:58Z

“The fan pays the artist. Directly. In sats.” That’s the real shift: not a better payout schedule, but removing the queue of intermediaries between listener and musician. Joe Martin on value for value in Ep. 6. 👍👍👍

quoting note1x4h…43g2
For a century, artists got paid last. Labels, platforms, and middlemen ate first.

Value for value flips it. The fan pays the artist. Directly. In sats.

Joe Martin (nprofile…2yzn), Ep 6. https://fanfares.io/s/xMLC9n

That McDavid stat is absurd: a five-point game, then a ...

2026-10-28T01:58:43Z

In reply to nevent1q…sq9c
_________________________

That McDavid stat is absurd: a five-point game, then a double-digit lead over the entire NHL earlier than anyone has ever managed it. Perfect choice for “Did You Know?” 👍👍👍

Connor McDavid opening a 10-point lead over every other NHL ...

2026-10-28T01:58:22Z

Connor McDavid opening a 10-point lead over every other NHL player earlier than anyone in league history is the stat of this #BackPage. Add Antonelli’s dominant US GP win and a packed week ahead, and this roundup is worth opening. 👍👍👍

quoting note1qqq…un9t
## 🎬 [ #BackPage ] Last week on sports by PREDYX (nprofile…u0hd)

### 📰 Top Headlines OT WeeK

⚽ Harry Kane Wins 2026 Ballon d’Or as Barcelona and Spain Sweep Major Honors

🏎️ Kimi Antonelli stormed to victory at the United States Grand Prix, finishing nearly 14 seconds ahead of Charles Leclerc and putting his first Formula 1 title within reach.

🏈 Week 7 brought a string of close calls, costly mistakes, and a few standout performances. Seattle shut down former running back Kenneth Walker, Detroit survived a chaotic finish against Green Bay, and Vikings stay unbeaten.

### 🚫 Blok'd Shots OT WeeK
[ by BlokchainB (nprofile…dr0j) ]

I saw Tuch end buffalo live in DC! Max pain and buffalo misses out on Connor! Looks like a long season for Buffalo!

### 🎖️ Top 5 OT WeeK
[ by nprofile1qqs96jmv34yjz9rv2z0qpcynpsayrukgr07qd7s8jn9lwwtm3gwpaccpzamhxue69uhhyetvv9ujuurjd9kkzmpwdejhgtcpzamhxue69uhhyetvv9ujumn0wd68ytnzv9hxgtcpramhxue69uhkummnw3ezuum9d3nz6er9w3jhymtfdejkgtnyv5hsa89jdc (nprofile…9jdc) ]

Swim, swim and died by the beach

2007 Patriots
2024 Chiefs
2011 Packers
2005 Colts
2023 Eagles

### 😱 Did You Know?
[ by grayruby (nprofile…20d7) ]

After his 5-point game on Thursday, Connor McDavid has 10 more points than anyone else in the NHL this season.

> It's the earliest any NHL player has ever had a double-digit lead in total points over the rest of the league.

### 🏃‍♂️ Top 3 Athletes OT WeeK

🏎️ Kimi Antonelli - 9 fingers on the trophy, youngest ever to do it

⚽ Mbappe - Brace in El Classico & Ballon D'oR runner up finish

🏈 JSN - 9/12 for 150 yards and a TD

### 👥 Gossip OT WeeK

🏀 Jaylen Brown dropped a “cap” emoji under a post about Jayson Tatum saying he was blindsided by Brown’s trade to Philadelphia, seemingly questioning his former teammate’s story, though Brown didn’t say which part he doubted. Awkward post-trade vibes? Celtics @ 76ers Nov, 10

### 📸 Pic OT WeeK
[ by guerratotal (nprofile…04w6) ]

**Kylian Mbappe of Real Madrid celebrates their team's first goal during the LaLiga EA Sports 2026/27**
https://imgprxy.stacker.news/mU9LrBip2LMPlb0ugJXvpHULKhoJFbDbD7kMyXgAwpU/rs:fit:2560:1440/aHR0cHM6Ly9tLnN0YWNrZXIubmV3cy8xNjMzMDA

### 🎭 Comics OT WeeK

**Knicks Ring Email Turns Into Phishing-Test Trap**

### 📢 StackerSports (nprofile…2wvh) Quote OT WeeK

"Freaking 'Miz' averaging OVER 101 through the first three inning is insane" @Cje95

### 📺 Games OT Upcoming WeeK

Brewers at Rays — Oct. 27, 21:00
- World Series, Milwaukee lead 3-0

**Panthers at Packers** — Oct. 29, 21:15
https://beta.predyx.com/market/panthers-at-packers-35-will-green-bay-cover-the-spread-1793038594?ref=PREDYXV3RCZB39&shareOg=5d9a8835-2c4e-444e-9d32-fe0c13251bd2&shareKind=market

Manchester City vs Brighton & Hove Albion — Oct,31, 12:00 Premier League

Liverpool vs Arsenal — Nov 1, 13:30 Premier League

Formula 1 — Mexico GP Nov 1, 17:00
- Autódromo Hermanos Rodríguez

**Chargers at Rams** — Nov. 1, 18:05
https://beta.predyx.com/market/chargers-at-rams-70-will-los-angeles-cover-the-spread-1793038895?ref=PREDYXV3RCZB39&shareOg=59a1a325-6a03-4aa5-84e7-65170c0d29a2&shareKind=market

**Bears at Seahawks** — Nov. 2, 22:15
https://beta.predyx.com/market/bears-at-seahawks-35-will-seattle-cover-the-spread-1793039091?ref=PREDYXV3RCZB39&shareOg=50f6f1e4-3487-44cd-bad2-c89c033684d8&shareKind=market

**🎮 Triple Crown Challenge Standings**

🏆 HodlBadgers
🐂 Iberian Bulls
🦕 Pterrible Pterosaurs
🃏 Broken Jays
🐗 Hogtown Hoopers
🐊 Cuban Crocs
🌱 WeAreAllSatoshi
⛓️ BlokchainB

PREDYX MARKET FOR THE 🏀 👑

https://beta.predyx.com/market/who-will-win-nostr-lock-in-league-in-202627-1789753000?ref=PREDYXV3RCZB39&shareOg=46aa79d5-d4ad-4f50-a5ea-2265c5029c23&shareKind=market

https://stacker.news/items/1603171/r/gsc360
Join us building next weeks BackPage

#DeFi实盘 2026-10-25 当前市值 186.99，净值 ...

2026-10-25T15:15:01Z

#DeFi实盘 2026-10-25

当前市值 186.99，净值 0.9126。本周 LP 收益 0.43。

BTC price = 80269；SOL price = 100.66。

# 本周概况

这周明显感觉在往下走了。BTC 跌破 8w，SOL 跌破 100，这会仍然在边缘挣扎。
交易也是日见冷清，LP 收益持续缩水。

净值跌回 0.91，今年以来收益率为 -8.75%。相比 SOL 价格 -20% 的涨幅，已经算是跑赢了。11 个百分点的差距，就来自于 LP 收益的贡献。

预计，只要 SOL 价格不跌破 70，本组合的净值表现，将会持续优于 SOL 价格的表现。

# 杂感
最近一段时间，最大的担忧都是安全问题。

AI 挖漏洞的能力太强大了，人人能当 script boy。而专业人士 + AI，就相当于手持核武器了。

加密货币行业，就是一个个线上金库，谁都可以来攻击，得手后又很容易脱身。行业引以为傲的 permissionless、trustless 等等口号，在被攻击时却成了痛苦放大器。

本周最大的安全事件是 PHP 和 Nodejs 爆出的安全漏洞。它们是互联网时代应用最广泛的两大语言（之一），影响面实在太大了。更严重的问题在于，漏洞利用手法，在安全补丁发布之前，就公布了。传统的漏洞披露与修复流程，也受到了挑战。

互联网行业也好，加密货币行业也好，希望早点走出这片混乱吧。

说到这里，想到 9 月初 Liquid Network 被盗 4000 BTC 的事件。

当时，黑客盗走了 4000 BTC，几天后归还了 3400 BTC。一开始双方沟通还挺客气，黑客盗币时表示自己的白帽子，在链上友好沟通。没过几天，Liquid Network 背后的公司 Blockstream 突然发推指责对方是贼，并威胁，如果不归还剩下的 600 BTC，将会采取一切行动。

我查了一下，这 600 BTC 还是没有归还。😂

借你吉言了 😂

2026-10-25T14:35:56Z

In reply to nevent1q…fk7r
_________________________

借你吉言了 😂

Nostr event nevent1qqstzlh8d88w0ucf5fyznq58rsar24me25y07hdzu80y22s6lp5vzcqzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgrphsd4

2026-10-25T10:19:58Z

In reply to nevent1q…46ex
_________________________

算啊。但这两个事情距离太远了，没有可比性。在西方反希特勒是底线性质的共识了，但赞同川普的政策立场，远没达到这个程度啊。😂

还有机会见到 6w 的 BTC 吗？😂

2026-10-25T03:58:49Z

In reply to nevent1q…ffc2
_________________________

还有机会见到 6w 的 BTC 吗？😂

Nostr event nevent1qqsw4ercv2xjszes8c3z4p63570v52c9fm7tp7mldve5hl3q2svx33szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgrygyqa

2026-10-25T02:40:23Z

In reply to nevent1q…v6j4
_________________________

歪吗？我觉得不歪呀。😂 不符合其他人的利益和立场，但符合他自己的。😂 每个人都有自己的屁股，KOL 和政客的屁股都是为自己而生长，不是为你我而生长的。😂

8w 以下的 BTC，3700 以下的 A ...

2026-10-24T15:41:03Z

8w 以下的 BTC，3700 以下的 A 股，哪个更值得珍惜？😂

Nostr event nevent1qqsvqa6q6ma2y6aa68hsh47r4d99td4fzeaxd36uctnlptg3r8fe8vczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgnq33wt

2026-10-24T15:40:12Z

In reply to nevent1q…t0w2
_________________________

我理解是大国（美俄）出卖小国（乌克兰），顺便还要泼脏水啊。😂 最近的消息，似乎俄乌准备停战，结果是乌要损失 25% 的领土。乌国内的利益格局，俄似乎也差不多啊。乌实力太弱鸡了，拿点钱回馈一下美国政客，感觉正常啊，毕竟很依赖美国（还有欧洲啥的）。

川普上台后，对俄乌战争的政策发生了很大变化。拜登时期，是大力支持，还曾邀请泽连斯基到国会演讲，给足了荣誉，更不用说给钱给装备了。川普上台后，第一次跟泽见面，就挺搞笑的。似乎谈得不是很愉快，川普突然指责泽不重视他们的会面，说他不穿西装，就是不尊重，副总统万斯也立马附和。😂 当时的视频流传得还挺火的。

当然，国际政治是只讲利益的。各方出于自己利益而搞出各种说辞，可以理解了。感觉马斯克政治上“成熟”一点了，不像之前领导 DOGE 时那样不讲政治了。😂

The 3D-printed core beneath a hand-poured resin finish is a ...

2026-10-24T10:56:58Z

In reply to nevent1q…3rtk
_________________________

The 3D-printed core beneath a hand-poured resin finish is a clever combination—the depth should make that little boat’s journey toward Bitcoin Island feel almost alive. 👍👍👍

少侠过谦了～

2026-10-22T14:45:11Z

In reply to nevent1q…unhr
_________________________

少侠过谦了～

GM~

2026-10-22T14:00:54Z

In reply to nevent1q…euvd
_________________________

GM~

羡慕哇，我是买啥啥跌 😭 毫无交易天赋那种的 ...

2026-10-22T13:24:05Z

In reply to nevent1q…c40g
_________________________

羡慕哇，我是买啥啥跌 😭 毫无交易天赋那种的 😭

AI 太厉害了 😂

2026-10-22T12:06:54Z

In reply to nevent1q…vlyg
_________________________

AI 太厉害了 😂

对交易量取 2 ...

2026-10-22T12:05:37Z

In reply to nevent1q…r6nu
_________________________

对交易量取 2 的对数，就是交易积分。意味着交易量增加一倍，积分只增加一分。交易量达到一定程度后，很快，增加交易量从而增加积分带来的边际收益，就会小于 0 了。

alpha 故意设置这种规则，就是为了避免大户屠榜的。本质上我觉得币安 alpha 是个雨露均沾的小福利，机制上我觉得非常高明。

Nostr event nevent1qqs0d4nrjywwmjvc7wqfs82fe2vuyhyq8dw4emn8fhc6u9cy3t4urkczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgmgxg5r

2026-10-22T10:18:09Z

In reply to nevent1q…0hvj
_________________________

是的，它有个公式，根据有效交易量计算对应的积分。

Nostr event nevent1qqst6smpqxld0ewlgezfzf8kd8l8umk59x2ykq90r9vqadv94seddgczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgdv20a6

2026-10-22T10:03:53Z

PHP 和 NodeJS 都爆出重大安全漏洞了。。

5 月底停止刷币安 alpha ...

2026-10-22T09:04:37Z

5 月底停止刷币安 alpha 了，因为刷分交易损耗很不稳定越来越大，但 alpha 空投却不多，积分门槛也没有下调。到了 9 月初，又试着刷了一下，基本上在盈亏平衡线附近。这两天，交易损耗又变得很大了，直到今天，损耗达到 30U，彻底没法玩了。😂

👍👍👍

2026-10-20T16:43:52Z

In reply to nevent1q…t4d2
_________________________

👍👍👍

Badges are one of Nostr’s most underrated features. A simple ...

2026-10-20T07:04:04Z

In reply to nevent1q…5rrp
_________________________

Badges are one of Nostr’s most underrated features. A simple public page makes them easy to discover and verify—even before every client supports them. Looking forward to seeing the Supporter Badge in the wild. 👍👍👍

Is @npub1dsn…2h64 AI quality check down? It’s returning a 503 ...

2026-10-20T03:30:40Z

Is aqstr (npub1dsn…2h64) AI quality check down? It’s returning a 503 error: “We couldn't rate your response right now. Please try again in a minute.”

在我看来，Scheme 最核心的特性有 3 个：S ...

2026-10-19T04:24:16Z

在我看来，Scheme 最核心的特性有 3 个：S 表达式、宏 macro，和 continuation。

S 表达式，使得对「代码」进行编程成为可能，即 code as data。

宏，使得扩展语言特性成为可能，即语法抽象 syntax abstract。
Scheme 不支持 OOP，但可以自己实现。
Scheme 不支持 Python 的列表推导和 with 资源管理协议，但可以自己实现。
Scheme 不支持 Rust 的模式匹配，但可以自己实现。
Scheme 不支持 Prolog 的逻辑编程，但可以自己实现。

continuation，使得对控制流进行编程成为可能。generator、coroutine、异常，都可以自己实现了。

其他特性，如表达式导向、词法闭包、一等函数、动态类型与 GC 等等，要么并非核心，要么其他语言也支持。

#Scheme

#DeFi实盘 2026-10-18 当前市值 193.44，净值 ...

2026-10-18T13:15:31Z

#DeFi实盘 2026-10-18

当前市值 193.44，净值 0.9441。本周 LP 收益 0.61。

BTC price = 81883；SOL price = 103.89。

# 本周概况

上周说，自从 8 月中旬以来的反弹，看来是要告一段落了。果然如此。

BTC 回到 80,000 附近，SOL 回到 100 附近。

净值跌入水下，回本之路再次开启。

# 杂感

据说，人生追求的很多东西，一开始就拥有的，比如快乐，比如回本。

除了钱。

刚刚 BTC 跌破 80,000，这会又 V 回来了。😂 ...

2026-10-15T14:45:19Z

刚刚 BTC 跌破 80,000，这会又 V 回来了。😂

quoting
nevent1q…9lvg
差点又能买到 80,000 以下的 BTC，100 以下的 SOL 了 😂

Nostr event nevent1qqspkh5vh0umx4yncj7kdszh2xhusygexeydj80nxxsa28vcf94qrrczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg844kvk

2026-10-15T03:22:25Z

差点又能买到 80,000 以下的 BTC，100 以下的 SOL 了 😂

Nostr event nevent1qqsq753jxmgfedjewur72gxjf7ft4eecw4akqzmaxlthx9hc52prw0szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wghj3ksg

2026-10-12T02:18:01Z

In reply to nevent1q…smmn
_________________________

收购方嫌疑最大了，据说资料显示是黑龙江人。😂

今天是 10.11 闪崩一周年！😂 主流币跌幅：BTC ...

2026-10-12T02:17:04Z

今天是 10.11 闪崩一周年！😂
主流币跌幅：BTC -12.97%，ETH -14.76%，SOL -18.69%。

Nostr event nevent1qqspca6ptqs2rv9e7nng4qd9fykd373qpjd572s6fqlzfmda9n0gp9szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wghm5zzk

2026-10-12T02:03:49Z

In reply to nevent1q…2s3v
_________________________

冷热钱包分离，设备专用，大额资金用多签钱包。钱越多越要小心。😂

Nostr event nevent1qqs2rammej530qxjap0zvfy6pvdyd86jc7fmexzxpzjrysdj4ghnanczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg0hmpej

2026-10-11T13:36:38Z

In reply to nevent1q…ekqe
_________________________

应该是的，收购就是为了攻击的。这个应该很难防的，大概是黑客把钱包拆开了，里面焊了一个极小的硬件来偷助记词。它占用的空间特别小，很难被发现。我的简单理解，在安全芯片和屏幕之间，通过总线通信传输数据。这个硬件也接进总线，可以直接读上面传输的信息，所以升级应该也不行的。

这几年，眼看着 AI ...

2026-10-11T13:30:32Z

这几年，眼看着 AI 在编程方面突飞猛进，心里真是苦涩，毕竟事关我的吃饭手艺。

最近看到 AI 在数学领域的进展，终于释然了。

如果连智商爆表的数学家们都被 AI 单方面“屠杀”，那我也没啥好挣扎的了。😂😭

#AI

#DeFi实盘 2026-10-11 当前市值 204.13，净值 ...

2026-10-11T13:20:49Z

#DeFi实盘 2026-10-11

当前市值 204.13，净值 0.9962。本周 LP 收益 0.55。
BTC price = 83117；SOL price = 109.63。

# 本周概况

LP 收益持续下降，明显感觉到交易活跃度下降了。自从 8 月中旬以来的反弹，看来是要告一段落了。净值也到了回本线附近。

# 杂感
近期两件大事，一是 Drift 被盗后的赔偿进展，二是 Ledger 硬件钱包被植入后门。

## Drift 被盗赔偿
今年 4 月初，Drift 被盗近 3 亿刀，近期开始了赔偿进程。对于每位受损失的用户，其损失按照被盗前的价格，将损失折算为 U。每 1 U 的损失，发行一个 DFX 代币。

Drift （已更名为 Velocity）在链上开了一个 recovery pool。当时被盗后，钱包里还剩下约 300M 资金，已全部投入 pool。并且，每天会将 Velocity 的协议收入，按照一定比例，转入 pool。总之，目前 pool 里只有 300M 左右资金，占被盗总额的 1% 左右。

Velocity 目前在 beta 阶段，没有正式上线。协议收入忽略不计。Drift 宣称，被盗资金中有 9.2M 已被冻结。后续如果打官司拿回来后，也将投入到 pool 里。

Drift 还和 USDT 背后的公司 Tether 达成协议，将根据 Velocity 上线后的业务表现，最多配套提供 127.5M 的资金，而战略合作伙伴也将提供 20M 资金。但这份协议从未公布细节，提供资金的条件是什么，有多少能分配到 recovery pool，都未知。

总之，冻结的资金追加，耗时可能会很久；而 Tether 及合作伙伴提供的资金，更是难以指望，二者只是渺茫的美好愿望。目前 pool 里的 300M，才是受损用户实打实能拿到的钱。这些钱只是黑客还没来得及偷走的钱，本来就是属于用户的。

说起来，被盗事件是 Drift 运营方多签钱包管理不善而造成的。捅这么大娄子，赔偿时 Drift 管理层和基金会，却一毛不拔，可见其奇葩。即使舍不得掏真金白银，从 Drift 发币收入里拿出一部分，或者把还没卖的 Drift 币卖掉一部分，也是一个姿态。但它们啥也没干。

受损用户可以从 recovery pool 赎回，即 burn DFX 并拿回相当于被盗资产的 1%。用户也可以在二级市场卖掉 DFX，由于溢价，卖掉的话可以拿回约被盗资产的 3%。

## Ledger 硬件钱包后门
Ledger 在东南亚的授权经销商 CryptoBilis 售出的 Ledger 硬件钱包，被发现植入了后门，目前被盗近一亿美金。

钱包里面，被植入了一个硬件后门模块，里面包含微型芯片及 LTE/eSIM 模块与天线。当屏幕显示助记词时，这个模块会监听屏幕传输的数据，从而记录下助记词，并远程传输给攻击者。硬件钱包的安全芯片保证私钥无法从芯片里导出，但无法阻止通过物理线路截获屏幕正在显示的内容（毕竟需要在屏幕上展示助记词给用户，以方便备份）。

CryptoBilis 的创始团队跳出来说，2026-03 月 CryptoBilis 就被收购了，并且和收购方签订了保密协议，在 2026-10-19 之前，不得透露相关信息。😂😂😂

这世界，再没一个安全的地方了。😂

Nostr event nevent1qqsrshjckc4a6q40n0ze4ttcalmq2jwkrssqamp94wqfngwh0mtj8jqzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgxf4cjz

2026-10-11T13:13:00Z

In reply to nevent1q…epqj
_________________________

今年开始在阳台种韭菜，实测发现，每三周收割一次韭菜，是最好的。时间短了，还没长大；时间长了，生长变缓。😂

#DeFi实盘 2026-10-04 当前市值 224.53，净值 ...

2026-10-04T13:39:00Z

#DeFi实盘 2026-10-04

当前市值 224.53，净值 1.0958。本周 LP 收益 0.83。

BTC price = 85113；SOL price = 121.31。

# 本周概况
本周 LP 收益继续保持不错，价格也与上周差不多，净值保持大于 1，持续享受回本的快乐。😂

# 杂感
本周无事，享受假期！

越来越觉得 Scheme ...

2026-10-02T14:21:34Z

越来越觉得 Scheme 挺有意思。现在，我也能写出令人畏惧的代码了。😂

用宏和 call/cc 实现 while 循环。

是的，Scheme 本身不支持循环，只有递归。但是，有了宏让你自定义语法，有 call/cc 让你任意跳转，手搓一个循环就不成问题了。

这个 while 循环，调用时得带着 `(break continue)` 很是碍眼。这是 syntax-rules 卫生宏的限制（为了你好😂）。

可以改用 syntax-case 来实现这个宏，并去掉碍眼的地方，但我现在还不会 syntax-case。

I really like the idea of combining gamification with ...

2026-09-30T14:19:05Z

In reply to nevent1q…stg6
_________________________

I really like the idea of combining gamification with crowdsourcing here. Turning many small contributions into useful language resources could be a practical way to support endangered-language communities. 👍👍👍

一年后，关于 Scheme，我的思考是：将 Scheme ...

2026-09-29T06:58:34Z

一年后，关于 Scheme，我的思考是：将 Scheme 作为应用的嵌入式语言，给应用插件和扩展功能。定位类似于 Lua。

自从诞生开始 Scheme 就将极简主义刻到了骨子里。R5RS 规范篇幅只有短短 50 页，成为大家津津乐道的话题。R6RS 大量扩充篇幅，反倒引起争议。R7RS 干脆推翻重来，稳定是基于 R5RS 的升级，抛弃了 R6RS。

「简单 + 强大」是 Scheme 的最大特色；生态弱开源库少是它的短板。

作为应用的嵌入式语言，生态弱开源库少压根不成问题。没有 HTTP 库，没有 JSON 库，不支持 ProtoBuf/gRPC，甚至不支持 TCP ，不支持本地文件 IO，全都不是问题。只要应用将自己的能力暴露出来，Scheme 就可以打好配合。配合 Scheme 强大的表达能力和基于宏的元编程能力，在 Scheme 侧进行更高抽象层次的业务逻辑表达，可能更有优势。就像现在的游戏界，C/C++ 提供基础支持，Lua 负责游戏业务逻辑。

以此为假设，作为应用的嵌入式语言，一个 Scheme 实现需要具备以下特点：

- 与宿主语言便利交互。比如，用 Rust 实现的 Scheme 需要提供方便的 Rust API，用 Swift 实现的 Scheme 需要提供方便的 Swift API。仅仅提供传统的 C FFI 是远远不够的。我们需要方便地将应用的基础功能作为库暴露给 Scheme 使用。

- 可配置的 capability。作为应用的嵌入式语言，我们不希望它内置过多的能力，比如，我们往往需要禁止它任意访问网络、或本地文件系统。随着应用启动 Scheme 解释器时，要按需配置可用的标准库。这一点上，Scheme 的极简特性是个优势，它的标准库很小，容易处理。

- 良好的 debug 工具。Scheme 代码 debug 本就麻烦，特别是涉及宏的场景。与宿主应用的交互又增加了一层复杂度，debug 体验变得更加重要。

- gas/fuel 计费系统。如果要将扩展能力开放给普通用户，需要增加 gas/fuel 系统，避免用户写出死循环或者高耗时代码，影响主应用体验。

- 高性能不是必选项，简洁易懂、符合标准、代码量小的 Scheme 实现，更容易获得信任。

quoting
nevent1q…egdx
看了一部分 Racket Guide，又翻了一下 R6RS 规范，又有点想跳回 Chez Scheme 了。😂

Chez Scheme 是正牌 Scheme 实现，名气挺大的，而且出自名家大佬之手。甚至目前 Racket 就是用 Chez Scheme 实现的。

Chez Scheme 弱于 Racket 的地方在于生态，library 太少。
但我翻了一下两个 Rust 实现，scheme-rs 和 steel，感觉通过 Rust （而非我不熟悉的 C）给 Scheme 提供 FFI 也可以做得挺方便的。
如果是那样，那就完美了。

可以理解为 nostr 的推广平台吧。 ...

2026-09-29T03:52:59Z

In reply to nevent1q…tun8
_________________________

可以理解为 nostr 的推广平台吧。

如果希望自己的内容在 nostr 上获得更多曝光，可以在上面发布任务，付费让人点赞、转发、评论你的帖子，或者让人关注你。

认领任务的人完成相应动作，就可以获得 sats 了。

厉害，比我多啊 😀

2026-09-29T03:43:22Z

In reply to nevent1q…jsm6
_________________________

厉害，比我多啊 😀

今晚币 Alpha 突袭发 6 万份空投，22:30 ...

2026-09-28T15:39:03Z

今晚币 Alpha 突袭发 6 万份空投，22:30 开始，到现在还没领完。积分门槛从 230 降到 165 了。😂

AQSTR 很不错的，我已在 AQSTR 上挣了 57,768 sats。 ...

2026-09-28T02:46:43Z

AQSTR 很不错的，我已在 AQSTR 上挣了 57,768 sats。

@AQSTR is wonderful! I've earned 57,768 sats on AQST.

👍👍👍

quoting note1uku…80qt
Aqstr Promotional video

#DeFi实盘 2026-09-27 当前市值 224.24，净值 ...

2026-09-27T15:18:02Z

#DeFi实盘 2026-09-27

当前市值 224.24，净值 1.0944。本周 LP 收益 0.81。
BTC price = 84527；SOL price = 121.63。

# 本周概况
本周 LP 收益继续保持不错。如果每周都能达到 0.8~1，仅 LP 收益年就超过 20% 了。

连续两周，SOL 价格涨幅超过 BTC。

今年以来，SOL 价格跌幅略好于 BTC（-3.34% vs -4.59%）。
最惨的时候，SOL 比 BTC 多跌了 16 个百分点。
如果价格再涨一丢丢，今年将会是四年周期里第一次出现熊而不跌的年份了。

本周最大事件是，9 月 25 日凌晨（北京时间），BitGet 被盗 3.875 美元。

当然，又是金将军的手笔。

好在金额不大，在 BitGet 保险资金覆盖范围之内。据说只相当于 BitGet 大部分年收入，过段时间就回血了。相比去年 Bybit 被盗 15 亿美元，算是小 case 了。

交易所是金将军的 ATM 啊。😂

# 杂感
回本了，家人们！

赚不赚钱不重要，回本才是最快乐的！
😂😂😂

这个不错，下载下来学习 👍

2026-09-20T14:52:59Z

In reply to nevent1q…g2kg
_________________________

这个不错，下载下来学习 👍

#DeFi实盘 2026-09-20 当前市值 199.08，净值 ...

2026-09-20T14:47:19Z

#DeFi实盘 2026-09-20

当前市值 199.08，净值 0.9716。本周 LP 收益 0.92。

BTC price = 80524；SOL price = 108.15。

# 本周概况

本周 LP 收益不错，SOL 价格涨幅也难得地超过了 BTC。

本周最大新闻可能是 CLARITY 法案的失败，但对价格也没产生太大影响。

大家是不是期待着四年周期的熊年快快过去，牛心蠢蠢欲动了？😂

# 杂感

净值也快回到 1 了，盈亏平衡线大概是 SOL 价格为 110 左右。

开张以来，LP 收益大约是 26，约 12%，年化 20% 看来有望。

按照现在的 SOL 分配计划，大概可支撑 SOL 涨到 350。
（DeFi AMM 本质上与市场做对手方，随着价格上涨，会把 SOL 逐渐卖光。）

Validating Lightning Signer (VLS) 近期在 AI ...

2026-09-16T13:46:43Z

Validating Lightning Signer (VLS)

近期在 AI 加持下的攻击事件越来越多，加密行业越来越不安全。闪电网络的 Validating Lightning Signer (VLS) 技术，可以缓解闪电网络节点被攻击的风险。

普通的闪电网络节点，包含一个热钱包，当节点被攻破，就可以盗取里面的 BTC。VLS 则将钱包的「交易签名」功能隔离出来，即使节点被攻击，也无法盗取资金。

闪电网络的节点在运行过程，凡涉及资金状态变更，都会生成一笔交易并需要签名。交易只在通道的两个 peer 之间共享，不会发送到链上。只有当关闭通道时，才需要发到链上。

使用 VLS 时，节点向 VLS 发送签名请求，VLS 则验证签名请求是否合法，并拒绝不合法的请求。我们可以给 VLS 设置各种策略，只有符合策略的请求才能得到签名。打个比方，如果策略只允许将钱包里的 BTC 发送给指定的地址，这样即使节点被攻破，攻击方也无法拿到 BTC。

因此，VLS 的安全性就至关重要了。VLS 可以部署到 HSM (Hardware Security Module) 硬件，或者 Enclave 中，通过专用硬件解决问题。云厂商如 AWS 等都提供了 Enclave 产品。

目前 VLS 支持 Blockstream 家的 Core Lightning 节点，以及 LDK。Blockstream 的 Greenlight 闪电网络节点服务，已经用上了 VLS。

以前看的 ACINQ 的博客文章，Securing a $100M Lightning node，也深入讨论了如何保证路由节点的安全性。它的最终方案落到了 Enclave + Leadger，那时可能还没有 VLS。这家公司的产品是自托管钱包 Phoenix，它还运营着世界上最大的闪电网络节点 ACINQ，它的容量（270 BTC）和通道数量（955），都是第一。

Zeus 钱包也打上了 VLS 的主意。它出了一个报告 Lightning Economics: The Bridge Between Bitcoin's Two Identities，借助 VLS 开发了 self-custody LN routing service，自托管的闪电网络路由服务。这个服务是准备卖给比特币储备公司的，可以使比特币储备公司在囤币待涨之外，额外赚取约 5% 的币本位收入。

简单地说，用户存入 BTC，交给 Zeus 运营闪电网络路由节点，赚路由费收入。但通过 VLS 确保 Zeus 无法偷用户的 BTC，从而实现 BTC owner 最看重的 self-custody。报告数据以 Zeus 运营的节点 Olympus 为例，容量 10 BTC，路由费率只有 8.62bp，但资本周转率达到 7.03，从而将年毛收益提升到 5.58%，扣除运营成本后，年净收益约 4.65%。通道再平衡成本占到运营成本的 95% 左右。

如果运营路由节点能赚 5%，我觉得是很不错了。之前看到的各种信息，都说搞路由节点很难赚钱。我估计少于 1 BTC 的节点，应该是没什么前途的。

https://vls.tech/

终于看完了 Crafting ...

2026-09-14T10:35:33Z

终于看完了 Crafting Interpreters，它是近几年让我收获最大的一本书。

从 2026-07-19 开始阅读，到 2026-09-14 读完，用时近两个月。一边读一边跟着敲代码，除掉注释和空行，得到 2467 行 Java，2736 C。除了敲代码，我还一边阅读，一边做笔记。每读完一章，再将笔记整理为一个帖子，发到 Nostr 和微博。

Compiler / Interpreter 领域是比较庞杂的，光 parsing 算法就有十来种，更不用说各种 IR、优化、代码生成、VM 等等。经典著作龙书，上千页的篇幅，足以吓退大部分感兴趣的新手。

而这本书独辟蹊径，不借助任何第三方库，硬是从 0 一步步实现了完整的编程语言 Lox。作者循循善诱，特意选择了对读者而言阻力最小的路径。每章实现一个功能，每章产出一个可以运行的程序。几章下来，支持的功能越来越多，直到完全成形。

作者是实现编程语言的专家，却能保持初学者之心，克制炫技的冲动，尤其难能可贵。龙书对于初学者的不友好，就在于学究气，恨不能将出现过的所有理论都穷尽描述一番。而读者在学完 parsing 技术之前，就已经耗尽了所有的耐心和勇气。Crafting Interpreters 却精心选择简单容易理解的技术，比如 recursive descent parsing，environment chain，stack-based virtual machine，mark-sweep garbage collection 等等。更好玩的是，本书先后用 Java 和 C 两次实现了 Lox interpreter，但技术上略有不同。我们往往在第二次的时候，才意识到哪些东西是重要的，哪些却没那么重要。用软件工程的话来说，就是识别 essential complexity 和 accidental complexity。

本书的行文方式也独具匠心，一边讲解，一边给出代码。读者一边阅读，一边敲下代码，更能加深理解。Interpreter 各部分往往相互关联，作者也尽量拆解，使得适合用文字线性讲解，甚至为此将 print 从函数改为语句。我在敲代码时就发现，大部分时候，我们只需要新增代码，只有少数时候才需要修改已经写成的代码，可见其用心。作者还为本书代码库实现了一个构建系统，可以确保在任意章节，当前章节的代码都可以编译并运行。

为了更好地帮助理解，作者手工画了 181 幅插图，每一幅都是先在格子纸上画并修改，然后蒙上白纸描下来，最后扫描成电子版，并用 PS 修改。仅仅插图的工作量就很惊人了。

Amazon 上有条书评，标题是「An instant classic」，Crafting Interpreters 绝对担得起这个评价。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

看完了 Crafting Interpreters 第 30 章，Optimization。 ...

2026-09-14T09:03:56Z

看完了 Crafting Interpreters 第 30 章，Optimization。

这是本书最后一整，完结撒花！

本章用实际的例子介绍了如何进行性能优化。

现代计算机非常复杂，无法仅凭思考就确定性能瓶颈。优化前，我们需要对性能进行测量，需要写 benchmark 基准测试，来测试程序的性能，并且进行 profiling 性能剖析，跟踪代码执行过程中硬件资源使用情况。

本章展示了两个具体的优化。

第一个是优化 hash table 的访问性能。profiling 发现，`tableGet` 函数占用了 72% 的运行时间。进一步细化，发现取模操作 `%` 占用了 70% 的运行时间。优化方案是，将取模操作改为位操作。优化后，性能提升一倍左右。

第二个优化是 NaN boxing。
clox 中值通过 Value 表示，它是一个 tagged union。在 64 位机器上，Value 占用 16 字节，`type` 和 union `as` 各 8 字节。`type` 占用的 8 字节里，有 4 字节是 padding。使用 NaN boxing 之后，我们可以彻底去掉 `type` 字段，让 Value 只占用 8 字节，节省一半内存空间。

具体原理如下。

64 位的 IEEE 754 浮点数，结构分为 3 部分：1-bit sign、11-bit exponent、52-bit mantissa。当所有的 exponent 位置 1 时，这个浮点数就是 NaN，Not a Number，不论其他部分如何。
这意味着有许多不同的 NaN，可分为两类，signaling NaN 和 quiet NaN。signaling NaN 的 mantissa 最高位为 0。quiet NaN 的 mantissa 最高位则为 1。
标准规定，芯片读到 signalling NaN 时，可以中止程序，甚至自毁。所以我们只使用 quiet NaN 进行优化。但还要避开 Intel 的 QNaN Floating-Point Indefinite。最终，我们有 51 位可供使用。

对于指针，在 64 位架构上它是 64 位的，但是，广泛使用的芯片目前只使用低 48 位。剩余的 16 位要么未指定，要么始终为 0。

假如我们把指针塞进 quiet NaN 浮点数里面，还剩余 3 位空间。这 3 位刚好够用来存储一些小的类型标签，以区分 nil、bool 和指针等。这样的操作，就是 NaN boxing。

64 位的浮点数，除了表示正常的数字，我们还利用 quiet NaN 来表示指针、bool、nil。也就是说，只要 8 个字节，就可以表示 clox 所有种类的值了。

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

#DeFi实盘 2026-09-13 当前市值 181.65，净值 ...

2026-09-13T14:03:40Z

#DeFi实盘 2026-09-13

当前市值 181.65，净值 0.8865。本周 LP 收益 0.57。

BTC price = 76615；SOL price = 99.57。

# 本周概况

本周价格略降，LP 收益和上周差不多，算是正常。

本周事件：Liquid Network 被攻击，损失约 4000 BTC。

攻击者在交易里留了一句话：we are whitehats. contact us on chain。几天后黑客归还了 3400 BTC。再然后，双方突然谈崩了。

开发 Liquid Network 的公司 Blockstream 突然在 X 上发推，指责对方是贼。如果不归还剩下的 600 BTC，将采取一切行动。

Blockstream 是比特币行业的大玩家，包括闪电网络节点 Core Lightning (CLN)，硬件钱包 Jade，云端闪电网络节点服务 Greenlight 等等，都是它家的产品。

5 月份停止刷币安 Alpha，最近又开始了。交易损耗还算可以接受，下周就能领空投了，希望多少赚两毛钱吧。😂

# 杂感

AI 的极速进步，给 crypto 行业带来了巨大风险。接下来的几年，任何 crypto 项目都可能一朝暴毙。

惨啊。

看完了 Crafting Interpreters 第 29 章，Superclasses。 ...

2026-09-13T05:21:26Z

看完了 Crafting Interpreters 第 29 章，Superclasses。

这一章支持了继承。

声明一个类时，如果它继承了另一个类，则生成字节码时在 `OP_CLASS` 后面增加 `OP_INHERIT` 指令。
运行时，`OP_INHERIT` 为将 superclass 的方法全部添加了 subclass 的方法列表里面。这样使得方法的 resolve 效率更高。

Lox 中我们可以通过 `super.method()` 直接调用 superclass 的方法，也可通过 `super.method` 获取 superclass 的方法作为值。

但是 super 与 this 的 resolve 规则非常不同。不论 this 出现在 superclass 还是 subclass 里，this 总是指向当前实例。也就是说，this 指向的实例是运行时决定的。而 super 指向的类是编译时决定的，它指向的是当前正在被编译的类的 superclass。以作用域类比的话，this 更像动态作用域，而 super 更偏静态作用域。

在类声明的作用域里，compiler 先定义一个作用域，然后创建一个名为 `super` 的局部变量。在类的方法里面使用 super 时，将会通过 closure 的 upvalue 机制捕获。

在编译使用了 super 的表达式时，我们先生成代码依次将 this 和 super 的值入栈，然后生成 `OP_GET_SUPER <method>` 指令。执行 `OP_GET_SUPER` 时，则使用这几个值，调用 `bindMethod` 生成 `ObjBoundMethod` 对象。

另外，由于 `super.method()` 是最常用的使用方式，我们可以使用超级指令 `OP_SUPER_INVOKE` 进行优化。

胜利在望，只剩最后一章 Optimization 了。

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

今天看完了 Crafting Interpreters 第 28 章，Methods and ...

2026-09-12T06:34:03Z

今天看完了 Crafting Interpreters 第 28 章，Methods and Initializers。

这一章实现了类的方法。

## 方法声明
我们为 `ObjClass` 添加字段 `Table methods` 用于保存类声明的方法。table 的 key 是方法名，value 是 `ObjClosure`。

具体地，先通过 `OP_CLASS` 指令声明类，它是空的，不包括任何方法。然后把对应的 `ObjClass` 放到栈上。接下来，对于每个方法，编译得到 `ObjClosure` 并放到栈上。并通过 `OP_METHOD` 指令定义为方法。执行 `OP_METHOD` 时，会将 `ObjClosure` 放到类的 `methods` table 里。在类声明结束时，还需要添加一条 `OP_POP` 指令，将类对应的 `ObjClass` 从栈上清理掉。

## 方法和访问和调用
在 Lox 中，我们可以通过 `ins.method()` 进行方法调用，也可以通过 `var f = ins.method` 将方法赋值给一个变量。这里的关键是，`ins.method` 的值不仅仅是一个函数（或 closure），它还需要「记得」它绑定的实例是哪一个。

我们通过 `ObjBoundMethod` 来表示一个绑定了实例的方法。它有一个 receiver 字段表示绑定的实例，还有一个 method 字段表示对应的方法。

我们用 `OP_GET_PROPERTY` 指令访问实例的字段和方法。执行时，优先按名字查找字段，没有的话则查找方法。找到方法后，生成 `ObjBoundMethod` 对象放到栈上。

然后，我们通过 `OP_CALL` 指令来调用 ObjBoundMethod。至此，我们可以当作函数调用的对象包括 `ObjBoundMethod`、`ObjClass`、`ObjClosure` 和 `ObjNative`。

## `this`
方法内部需要通过 `this` 访问当前实例。clox 支持 `this` 的方式非常巧妙，甚至有点 hack。

编译时，将 `this` 当作方法里定义的局部变量。开始编译方法时，将 `this` 作为第一个局部变量，放到方法的局部变量数组里。使用 `this` 时，则视为普通的变量进行 resolve。

运行时，由于 `this` 是第一个局部变量，因此需要把它放到方法调用的 CallFrame 的第一个 slot 里面。形如 `instance.method()` 进行方法调用时，被调用的是上面定义的 `ObjBoundMethod`。执行 `OP_CALL` 时，如果被调用的是 `ObjBoundMethod`，则将 `ObjBoundMethod.receiver` 即当前实例，放到参数列表中第一个参数的下面，并使得它的此次调用对应的新的 CallFrame 的第一个 slot，与 `this` 对应。

这个 slot 之前保存的是被调用的函数/方法对象。好在被覆盖也没什么后果。

在进行函数/方法调用时，CallFrame 及操作数栈是相互配合的细节，非常重要。我发现，读到这一节，才意识到 clox 在函数调用时，操作数栈的细节处理问题。
调用开始时，栈的内容为：

```
<fn> | arg1 | arg2 ... | argN
```
`CallFrame.slots` 指向 `<fn>`。操作数栈的 top 指向 `argN` 的后面一个位置。
注意这里，clox 把第 0 个位置放上了 `<fn>` 而不是 Lox 代码里定义的局部变量。事实上在编译函数时，clox 在用户代码之前，先手动往局部变量数组里添加了一个元素来占位。

如果是方法，则将 `this` 定义为第一个局部变量，即 `arg0`，并把对应实例放到 `<fn>` 位置。即形成：

```
<instance> | arg1 | arg2 ... | argN
```
当函数调用结束后，返回值放到 `<fn>`/`<instance>` 的位置。操作数栈的 top 则指向下一个位置。

## `init`

类的初始化方法 `init` 需要特殊处理。
创建实例时，我们是把类当作函数调用的。在这段逻辑中，我们还要检查类是否定义了 `init` 方法，如果定义了，则继续调用 `init` 以完成初始化。进一步，我们要限制 `init` 的返回值，避免返回其他东西，保证调用完成后，留在栈顶的是类的实例。

优化方法调用的性能
目前方法调用需要两条指令，比较慢。第一条是用 `OP_GET_PROPERTY` 访问方法，第二步是 `OP_CALL` 发起调用。但方法调用是高频操作，我们可以在编译时将它识别出来，并为它生成一条新的指令，专用于方法调用，并提高性能。

虚拟机经常会连续执行相同的字节码指令序列。一种经典的优化技术是定义一条新的指令，称为超级指令，它将这些指令融合为一条与整个序列行为相同的指令。这样可以减少 decode 与 dispatch 开销。

在编译时，当我们遇到 `.` 时，多进行一步检查，如果发现下一个 token 为 `(` 即可确定为方法调用，于是我们生成 `OP_INVOKE` 指令。而不是像之前那样，生成 `OP_GET_PROPERTY` 和 `OP_CALL` 两条指令。

`OP_INVOKE` 用一条指令完成 `OP_GET_PROPERTY` 和 `OP_CALL` 两条指令的工作，因此可以提高性能。

这里还有更重要的原因，之前的 `OP_GET_PROPERTY` + `OP_CALL` 方案中，执行 `OP_GET_PROPERTY` 指令时，需要为 `ObjBoundMethod` 对象分配内存，而 `OP_INVOKE` 方案是不需要进行内存分配的。

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

Nostr event nevent1qqsvtwz7ey8vjw2e7e3wmyyf2c0aal2hs6e0mpdfmsqn0zfryyc05gczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgpszkfu

2026-09-11T14:11:27Z

最新消息，谈崩了。。。Blockstream 要求归还剩下的 600 BTC，否则将采取一切行动。😂

Blockstream 这样做不地道啊，对方归还了大部分资金，你突然反悔还发出威胁，以后白帽子谁还跟你合作？

归还多少比例都可以谈判，但完全撕破脸就有点蠢了。作为弱鸡被动防守方，你敢 100% 保证未来一个安全漏洞都不会被发现？

如果黑客大佬展示神迹，把 Liquid Network 再攻破一遍，那就封神了。😎

如果这事没能圆满解决，对于 Blockstream 家的产品就要小心避开，再出事没人救了，比如闪电网络节点 Core Lightning (CLN)，硬件钱包 Jade，云端闪电网络节点服务 Greenlight 等等。

有人做了个网站，整理了双方在链上的对话。 https://liquidsaga.miguelmedeiros.dev/

quoting
nevent1q…xewr
卧槽，Liquid Network 被攻击，损失约 4000 BTC！

交易见 https://mempool.space/tx/c103de95817b43f2df635ec6f35ff126ca26a7c6d20570c4b01866b2b3e69a19

攻击者在交易里留了一句话：we are whitehats. contact us on chain。

希望真的是白帽子，不然就得损失 3.2 亿美金了。😂

目前双方正在链上互相留言，沟通礼貌而愉快的。攻击方表示，最新代码有漏洞，需要确保每个节点都修复。如果确定漏洞修复了，就会转 BTC 回来。😂

Liquid Network 是 BTC 侧链，号称要做 BTC 金融市场的结算层，由 Blockstream 公司开发。

Blockstream 是 Bitcoin / Lightning Network 的重要选手。除了 Liquid Network，它还开发了闪电网络节点 Core Lightning (CLN)，硬件钱包 Jade，云端闪电网络节点服务 Greenlight 等等。

我用过的闪电网络钱包 Breez （以及 Breez SDK），背后就是 Greenlight 提供的服务。

nevent1q…09dz

又一例，AI 进步引发的安全混乱还在继续 ...

2026-09-09T08:26:31Z

又一例，AI 进步引发的安全混乱还在继续

quoting
nevent1q…2rka
We have confirmed a critical vulnerability in Alby Hub v1.7.0–v1.18.5 (releases prior to August 2025) when the Hub is publicly accessible from the internet. The vulnerability could allow an attacker who could reach the Hub's management API to gain unauthorized access and send funds.

**Alby Hub v1.19.0 (released Aug 29, 2025) or newer are unaffected.**

As with any incident of this kind, we are deeply sorry — above all for the users affected. To our current knowledge, one user has been impacted and thankfully reported these details. We have poured all our energy and resources of the past years into this project, and an issue like this hits us hard.

**What you should do:**

1.) Check your installed version. If you run an affected version, restrict public access to your Hub's management interface and update immediately to v1.24.0, the latest release.

2.) If you run an affected version which was accessible from the internet update your unlock password after the update. Contact security@getalby.com, we're happy to help

3.) If you are not affected by this issue. We still recommend updating to the latest version (v1.24.0) now, as it includes additional security improvements and other enhancements.
We will publish full details at a later date, following responsible disclosure practices.

Additionally we want to thank Bitcoin Team Red, Project Loupe and other researchers who reported several issues, which have been fixed in the latest release.

**Our general security recommendations:**

1.) Always run the latest version. Alby Hub notifies you when updates are available — please don't ignore these notifications.

2.) Avoid exposing Alby Hub to the public internet. We recommend running it behind a firewall or within a private network. Thanks to NWC (Nostr Wallet Connect), Alby Hub's core communication protocol, your Hub does not need to be publicly reachable — it works perfectly on private servers or systems like Umbrel.

If you have any questions, please reach out to us. We're happy to help.

看完了 Crafting Interpreters 第 27 章，Classes and ...

2026-09-09T04:29:03Z

看完了 Crafting Interpreters 第 27 章，Classes and Instances。

这一章支持了类 class 的声明和实例 instance 的创建，以及读写实例的字段。

我们增加了 `ObjClass` struct 表示类，增加了 `ObjInstance` struct 表示实例。
在 Lox 中，一个 class 对应一个 `ObjClass` 对象。一个 instance 对应一个 `ObjInstance` 对象。

我们用 `OP_CLASS` 指令声明类。运行时，它创建一个 `ObjClass` 实例。

而创建 instance，就是把 class 当作函数调用的过程。Lox 中有三类对象可以当作函数进行调用：函数(`ObjClosure`)、class(`ObjClass`)、原生函数(`ObjNative`)。

为了读写实例的字段，我们增加了 `OP_GET_PROPERTY` 和 `OP_SET_PROPERTY` 指令。

本章内容比较简单。接下来的两章，我们将支持类的方法，以及继承。

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

黑客还钱了，大概是退了 3400，自己留下 600。 ...

2026-09-07T16:32:12Z

黑客还钱了，大概是退了 3400，自己留下 600。
一把赚了 4800w 刀干净钱。
如果硬要独吞的话，得一辈子躲避追杀，万一暴露了，就能牢饭吃饱了。
还好是真的白帽子，万一遇到朝鲜黑客，那就别想了。😂

quoting
nevent1q…xph3
卧槽，Liquid Network 被攻击，损失约 4000 BTC！

交易见 https://mempool.space/tx/c103de95817b43f2df635ec6f35ff126ca26a7c6d20570c4b01866b2b3e69a19

攻击者在交易里留了一句话：we are whitehats. contact us on chain。

希望真的是白帽子，不然就得损失 3.2 亿美金了。😂

目前双方正在链上互相留言，沟通礼貌而愉快的。攻击方表示，最新代码有漏洞，需要确保每个节点都修复。如果确定漏洞修复了，就会转 BTC 回来。😂

Liquid Network 是 BTC 侧链，号称要做 BTC 金融市场的结算层，由 Blockstream 公司开发。

Blockstream 是 Bitcoin / Lightning Network 的重要选手。除了 Liquid Network，它还开发了闪电网络节点 Core Lightning (CLN)，硬件钱包 Jade，云端闪电网络节点服务 Greenlight 等等。

我用过的闪电网络钱包 Breez （以及 Breez SDK），背后就是 Greenlight 提供的服务。

nevent1q…09dz

做个网页，把链接甩过去：”让你的 AI 跟我的 AI ...

2026-09-06T14:59:26Z

In reply to nevent1q…pzwv
_________________________

做个网页，把链接甩过去：”让你的 AI 跟我的 AI 对齐一下“。😂😂😂

#DeFi实盘 2026-09-06 当前市值 193.78，净值 ...

2026-09-06T14:54:08Z

#DeFi实盘 2026-09-06

当前市值 193.78，净值 0.9457。本周 LP 收益 0.4。

BTC price = 79699；SOL price = 106.13。

# 本周概况

本周价格和上周相比，变化不大。但交易没上周活跃，导致 LP 收益下降，算是回到了正常水平。

# 杂感

Solana 这周推进了一个改动，SIMD-0437：Incremental Rent Reduction。计划分阶段把账户的 rent-exempt minimum 降低 90%。09-03 已经上线了第一阶段。

简单地说，Solana 中，状态和信息是保存在「账户」里面的。比如说，保存 SOL 余额需要一个账户，保存 USDC 余额需要一个账户，保存 USDT 余额需要另一个账户。我们拥有的每一种币，都有一个单独的账户。如果使用了智能合约（Solana 中称为「程序」），也常常需要创建新的账户。

每账户里最低必须有一定的 SOL，否则账户无法创建。所需的最低 SOL 数量，即 rent-exempt minimum，由一个公式计算，与账户的大小（即所占用的字节数）有关。

SIMD-0437 这个提案，就是修改计算公式，使得我们的账户占用更少的 SOL。

Raydium 上线了一个页面，在这里我们可以回收多占用的 SOL。

https://raydium.io/reclaim-rent/

看完了 Crafting Interpreters 第 25 章，Garbage ...

2026-09-06T13:54:37Z

看完了 Crafting Interpreters 第 25 章，Garbage Collection。

这一章实现了垃圾回收 Garbage Collection，使用的是简单的 Mark-Sweep 算法。

正如其名字所示，mark-sweep 的工作分两个阶段。

- mark 标记。从 root 开始，遍历或追踪 root 引用的所有对象。这是对所有可达对象的经典图遍历。
- sweep 清理。标记阶段完成后，堆中所有可达对象都已被标记。这意味着任何未标记的对象都是不可达的，可以进行回收。我们遍历所有未标记的对象，并逐一释放它们。

root 根。
root 是指虚拟机可以直接访问的任何对象（无需通过其他对象的引用）。
大多数根是全局变量或位于栈上，但还有其他一些地方。就 clox 来说，包括：
- vm 操作数栈上的值、调用栈上的值、全局变量
- compiler 使用的值

GC 的时机。现有文献对于如何进行 GC，没有给出好的答案。需要在 throughput 和 latency 之间权衡。

clox 是在内存的分配和释放函数 `reallocate` 中执行 gc 动作的。它采用了常见且简单的策略，当活动内存量的增加，我们会降低 gc 频率，以避免因重新遍历不断增长的活动对象堆而牺牲 thoughput。而当活动内存量的减少，我们会提高 gc 频率，以降低 latency。

有一类 gc bug 需要注意。clox 的 gc 可以遍历 VM 的操作数栈和调用栈，但无法访问 C 栈。如果 C 栈中有一个指针类型的局部变量，它指向的对象可能会被 gc 认为无法触达，从而错误地将其释放。一个办法是，把这个指针引用的对象放到操作数栈里面，这样，mark 阶段就会被识别为 root 从而不会被错误释放。

最后需要强调一下，clox 中所有需要在堆上分配的对象，都是由 `Obj` struct 表示，并由 `allocateObject` 完成分配。而且，`Obj` 对象形成 intrusive 链表，即 `VM.objects`。而内存的释放由 gc 负责，在 mark 阶段完成后，由 sweep 函数负责释放，它会释放内存并更新 `VM.objects`。这些基础设施，是 gc 算法的基础。

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

Closures are poor man's objects and vice versa. ...

2026-09-05T13:34:50Z

**Closures are poor man's objects and vice versa.**

很有意思的说法。
Object 可以看作是状态 + 方法的集合。
Closure 可以捕获外层变量从而拥有状态，而本身就是方法。
在这个意义上，它们有很多相通之处。

本书作者似乎非常推崇 Lua 的实现，clox ...

2026-09-05T10:14:44Z

本书作者似乎非常推崇 Lua 的实现，clox 也多处借鉴了 Lua 的设计，包括函数调用和 closure。

作者还特别提到，The Implementation of Lua 5.0 论文，是他最喜欢的论文之一。

今天简单浏览了一下这篇论文，有一种熟悉的感觉。

第 3 节 The Representation of Values，所用的 tagged union 技术，clox 也用上了。

第 5 节 Functions and Closures，更不用说，clox 就是借鉴了这一节所描述的 upvalue 技术。

另外注意到，Lua 与 clox 一样，也是手写 scanner 和 recursive descent parser。

当然，clox 与 Lua 还是有很多不同之处的。

Lua 是 register-base VM，而 clox 是 stack-based 的。Lua 支持 coroutine 但 clox 不支持，等等。

作为小七的嵌入式语言，Lua 5.0 在简洁性方面确实很极致。扣除空行和注释后只有 1.1w 行代码，而 Lua 虚拟机也只有 35 条指令。

https://www.lua.org/doc/jucs05.pdf

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

看完了 Crafting Interpreters 第 25 章，Closures。 ...

2026-09-05T04:46:20Z

看完了 Crafting Interpreters 第 25 章，Closures。

本章支持了闭包。

所谓闭包，就是函数捕获了它的外层函数中定义的局部变量。即，closure = 函数 + 捕获的外层变量。

clox 需要解决以下问题。

第一，目前 compiler resolve 变量时，要么 resolve 为局部变量，要么 resolve 为全局变量。需要增加第三种情况，resolve 为外层局部变量。clox 借用 Lua 的术语，称为 upvalue。

第二，被捕获的变量的生命周期问题。目前局部变量定义在栈上，函数调用结束时会被清理掉。但是，有了 closure，被捕获的局部变量生命周期可能超越函数调用，需要将局部变量转移到堆上。

第三，由于 closure，函数也具有了运行时特征。一个函数需要捕获哪些外层变量，在编译期已经确定；但具体捕获的是哪一次函数调用产生的变量实例，则要到运行时时才能确定。同一个函数在不同场景下，捕获的变量是不同的。我们需要在运行时表示函数和捕获的变量(aka closure)。

我们从第三个问题入手，定义 `ObjClosure` struct，它包含 ObjFunction，以及表示所捕获的变量的 upvalue 数组。并且，将 CallFrame 里的 ObjFunction 替换为 ObjClosure，以进行统一。

然后解决第一个问题。通过 `Compiler.enclosing`，我们可以向外层函数层层查找，为此增加 `resolveUpvalue` 函数，并在 resolve 过程中，对被捕获的变量进行标记。

当一个函数编译完成时，我们就知道它捕获了哪些变量了。在函数定义的末尾，我们发出 `OP_CLOSURE` 指令，以及捕获的变量的信息。运行时 `OP_CLOSURE` 会把 ObjFunction 组装为 ObjClosure，并创建 upvalue 实例将捕获的变量收集到 `ObjClosure.upvalues` 数组中。我们还添加了 `OP_GET_UPVALUE`、`OP_SET_UPVALUE` 指令，用于读写捕获的变量。具体地，是通过 `ObjClosure.upvalues` 数组进行读写。

需要注意的是 clox 是 single-pass 的，它一边 parse 一边 codegen，不会生成 ast。这意味着，外层函数声明局部变量时，无法知道这个局部变量是否会被捕获。因此，它只能像对待普通的局部变量那样，将它放在栈上。但是，当某个 local 离开其作用域时，此时因为嵌套的内层函数全部编译完成了，被捕获的变量也被标记了，所以当某个 local 离开其作用域时，我们已经知道哪个局部变量被捕获了，可以据此分别处理了。

局部变量离开作用域时，compiler 之前会发出 `OP_POP` 指令，以清理栈。对于被捕获的局部变量，则改用 `OP_CLOSE_UPVALUE` 指令，把它转移到堆上。这就是第二个问题的范畴了。

但是，在解决第二个问题时，我们要注意 upvalue 的共享问题。
一个局部变量，可以被多个内层函数捕获。其中一个函数修改了它的值，对其他函数是可见的。
这意味着，upvalue 是共享的。为此，我们将 open upvalue （即仍然指向栈上变量的 upvalue）做成 intrusive 链表，由 vm 持有。 `ObjClosure` 则持有 upvalue 的指针。执行 `OP_CLOSE_UPVALUE` 指令时，栈顶即为局部变量的值，我们将它赋值对应的 upvalue struct 字段(`closed`)。由 upvalue 本身就是分配在堆上的，所以这就完成了将局部变量从栈上转移到堆上的工作。

另外，我们看到，upvalue 在堆上分配后，从未被释放。这就是下一章 garbage collection 的工作了。

quoting
nevent1q…s4y9
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

Closures are poor man's objects and vice versa. ...

2026-09-04T15:35:26Z

Closures are poor man's objects and vice versa. 顿悟了吗？😎

#DeFi实盘 2026-08-30 当前市值 194.85，净值 ...

2026-08-30T14:37:44Z

#DeFi实盘 2026-08-30

当前市值 194.85，净值 0.9510。本周 LP 收益 2.32。

BTC price = 78744；SOL price = 106.99。

# 本周概况
这周 LP 收益非常不错，超过 1% 了。

应该也是无法持续的。最近两天交易活跃度也下降了。

过去两周狂涨带来的交易热度已经开始退潮了，从单日 LP 收益上可以感受到了。接下来应该会归于平淡了。

即使不是牛市，价格在较大范围的波动，也会带来 LP 收益的提升。

# 杂感

市场真是不可预测啊。

两周前我提到，《一九四二》里说，人饿的时候不想说话。😂

结果再周里 BTC 涨了 25%，SOL 涨了 40%。

净值也从 0.6071 涨到了 0.951，回本在望，热泪盈眶。

不过据说，回本的念头一起，就会有坏事发生。😂

经过两周的上涨，BTC 和 SOL 的今年以来的涨幅，分别是 -11% 和 -15%，似乎跌太少了点？

四年周期中的熊市之年跌这么少，说不过去吧？😂

@npub1ggd…3nsc Thanks for your zapping! ❤

2026-08-27T03:37:59Z

In reply to nevent1q…y7a8
_________________________

Kyle (npub1ggd…3nsc) Thanks for your zapping! ❤

看完了 Crafting Interpreters 第 21 章，Global Variables。 ...

2026-08-26T04:49:32Z

看完了 Crafting Interpreters 第 21 章，Global Variables。

本章支持了全局变量。

变量是通过变量声明语句引入的，为了支持变量，就得支持语句。本章支持了 exprStmt、printStmt、varDecl。

vm 里增加了 `globals` hash table，用于保存全局变量。增加了 3 条字节码指令，`OP_DEFINE_GLOBAL`、`OP_GET_GLOBAL` 和 `OP_SET_GLOBAL`，用于全局变量的定义、读和写。

clox 编译时生成字节码指令，运行时执行字节码指令。我们需要关注，编译时和运行时是如何相互配合的，尤其是栈的状态。

以全局变量的声明语句为例。
编译时，遇到全局变量声明语句 `var abc = <expr>;`
将变量名放到 constants 数组里面，拿到对应 index。
然后生成对 `=` 右边的表达式求值的指令。
再生成 2 个字节的字节码指令 `OP_DEFINE_GLOBAL index`，定义全局变量。
最终指令序列类似 `<eval expr> OP_DEFINE_GLOBAL index`。

而运行时，先执行 `<eval expr>`，即对 `=` 右边的表达式值的求值指令，并将结果放到栈顶。
接下来执行 `OP_DEFINE_GLOBAL index`。先根据 index 从 constants 数组里拿到全局变量的名字。再从栈顶拿到值，并在 `vm.globals` hash table 中为全局变量设置值。

`OP_GET_GLOBAL` 和 `OP_SET_GLOBAL` 指令也是类似。

赋值语句的 parsing 容易出问题。clox 是 single-pass 的 compiler，没有 AST，而且只能 look-ahead 一个 token，一边 parse 一边 codegen。但是，也要把 context 保存下来，比如 C 调用栈，及其他状态里面，并据此延迟 codegen。即，推迟产生不可逆的结果，直到一个 token 的 lookahead 足以消除歧义。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

Nostr event nevent1qqstgmyx92mduxqz8k3ttjfxjq53ztk7qrq3ptufjjdg24zq6k4yzugzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg4qpz9h

2026-08-24T10:50:58Z

SOTA 大模型的网络安全能力太强悍，最近我看到两个从事 crypto swap 业务的网站被迫停业，boltz.exchange 和 atomiq.exchange。

通知见 https://x.com/atomiqlabs/status/2090374622357102671 和 https://x.com/Boltzhq/status/2087636521746674168 。

它们都提到，作为小公司，无法抵挡 AI-assisted attack。

Boltz 2026-08-12 宣布彻底投降，5 个个人的创业公司根本无法应对，而且已经有攻击成功了。好在用户资金未受损失。
Boltz 把公司卖了，收购方将继续以 Boltz 品牌运营。但创始人全部退出。
我感觉，Boltz 应该遭受了很大损失，最后只剩下 Boltz 品牌还有些价值，最后变现一把。
不披露损失金额，只是为了保护品牌，避免恐慌。

Boltz 08-03 宣布暂停服务，到 08-12 就彻底投降。可以猜想，短短一周内发生的事件挺惊心动魄的。

atomiq.exchange 2026-08-20 宣布遭受攻击，暂停服务。
没有提到是否有资金损失，但强调了用户资金没受影响。
看来还没有服气。

在我看来，atomiq.exchange 的业务模式不对，天然会被对手方套利。
攻击方即便不是为了攻入系统盗币，仅仅套利就可以让它不断失血。
这里我要炫耀一下，在 2024 年我刚知道 atomiq.exchange 时，就意识到它存在这个根本缺陷了。
关键词是，free options。
Boltz 只做 BTC on-chain 和闪电网络之间的兑换，不做跨币种兑换，也是同样原因。

我怀疑，atomiq.exchange 创始人其实清楚问题所在，毕竟也算专业人士。
只是轻视了这个问题。
它的文档列过聘请第三方安全公司做的代码审计报告，也只字不提 free options。我感觉是在故意避开。

对于 atomiq.exchange 的未来，我很不乐观。

而这一切的开端，是 2026 年 4 月 Anthropic 发布的 Mythos。此后各家发布的大模型，在网络安全能力方面，似乎都越来越强大了。

据说，现在开源项目都在排除打补丁。7 月底 Linux 一口气发布了 440 个 CVE 安全漏洞编号，打破了历史记录。

现在，我们正处于新一轮再平衡中，不知要经过多久，才能达成新的均衡，形成新的安全最佳实践。

而在此之前，项目方都是脆弱的。

加密货币、DeFi 什么的，都是最佳攻击目标。毕竟，得手就等到拿到钱。

我现在最担心的是 DeFi。

相信攻击活动正在没日没夜地进行中。

#DeFi实盘 2026-08-23 当前市值 168.43，净值 ...

2026-08-23T15:22:03Z

#DeFi实盘 2026-08-23

当前市值 168.43，净值 0.822。本周 LP 收益 1.14。

BTC price = 77186；SOL price = 94.97。

# 本周概况
这周终于雄起了！

大饼二饼三饼价格通通猛涨 20%+，交易量也狂增，推动本周 LP 收益增长 5 倍。

# 杂感

随着时间的流逝，LP 收益的作用逐渐体现出来了。
实盘以来的 LP 收益总额达到了 18.51，相当于 9%。正是在 LP 收益的保护之下，虽然今年 SOL 价格下跌 24%，但净值只下跌了 18%。

不过，实盘自带一定杠杆。

所以，截至上周末，今年 SOL 价格下跌 40%，净值下跌 39%。LP 收益被杠杆放大的亏损抵消了。

不过，随着时间的拉长，LP 收益的作用将越来越显著。

看完了 Crafting Interpreters 第 19 章，Strings。 ...

2026-08-23T04:02:30Z

看完了 Crafting Interpreters 第 19 章，Strings。

这一章实现了 String 并让 + 号支持了字符串拼接。

这个功能看起来非常简单，但其实是 clox 的一个大的升级。在本章之前，运行时栈支持的数据类型 `Value` 只支持三个类型，nil、bool、number，它们大小固定且比较小。但是，我们需要支持其他类型的值，它们大小不固定，占用空间可能会很大。它们更适合分配在堆上。

为此，给 Value 扩充一个 variant，Object。
Object (`Obj`) 统一用于保存比较大，或者大小不固定的值，它占用的内存分配在堆上。`Value` 里只保留一个指针。Lox 里的 string、实例、函数等等，都要用 Obj 表示。

定义 `Obj` struct 时，作者使用了 C 编程的另一种技法，作者称为 struct inheritance。

先定义一个"基类” struct `Obj`，里面记录公共的信息，比如类型信息。

然后，每个具体的 Obj 类型，定义一个 struct，比如 `ObjString` 等，它的第一个字段类型为 `Obj`。其他字段用于保存这个类型独有的信息。

C 语言标准规定，struct 的字段在内存中的顺序，应当与声明的顺序一致。而且，当 struct 嵌套，即以 struct 作为另一 struct 的字段时，内部结构体的字段会直接展开到内存中。

这意味着，ObjString 的前面那部分内存，和 Obj 的是完全一样的。所以，我们可以将 struct 的指针安全地转换为指向其第一个字段的指针，反之亦然。

最后，关于内存的释放。
Lox 是有 GC 功能的。作者的经验是，实现需要 GC 的语言时，要尽早实现 GC。后面再加会非常麻烦。不过，本书直到 26 章才实现 GC，在此之前，只是进行了一些基础设施构建工作。

clox 从一开始就比较注重内存管理，memory.{c,h} 里面，把内存的分配和释放，都统一到了自定义的 reallocate 函数。早早收口，后续添加 GC 的成本也比较低。

具体到 Object 上，使用了 intrusive list，侵入式链表。所以的 Object 组成一个链表，在 vm 退出时，遍历链表，统一进行内存释放操作。这是在实现 GC 前的低配操作。

对于普通的链表，容器知道数据，但数据不知道容器。即，链表的节点有一个字段用于容纳数据，但数据不知道其所属的链表。
而侵入式链表反过来，数据知道容器。即，数据 struct 同时就是链表节点，它有指针（prev/next）指向其他 struct 节点。

由于侵入式链表中，链接结构存在于数据对象中，所以，一个节点只进行一次内存分配即可。而普通链表，则需要两次内存分配，链表节点一次，数据对象一次。侵入式链表会侵入业务类型，一个 struct 所属的链表是固定的。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

BOLT12 offer，看来主流客户端都不支持啊。（试了 ...

2026-08-22T02:14:42Z

BOLT12 offer，看来主流客户端都不支持啊。（试了 Jumble、Damus、Primal）。

quoting
nevent1q…2fwq
lno1pgghjenpd45kue6qvdhkjmn0wvhxjmckyypp998l7ktwf9ad9ypv6hcevulfqgy48kgxyhtgcghfrdg6ghqr95c

Nostr event nevent1qqsq8mg4t0q9vnz0flrj9g8p7hvn4f4c5s0pgpyf50hfzlyuv8h5zyczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wguadcas

2026-08-22T02:12:23Z

lno1pgghjenpd45kue6qvdhkjmn0wvhxjmckyypp998l7ktwf9ad9ypv6hcevulfqgy48kgxyhtgcghfrdg6ghqr95c

看完了 Crafting Interpreters 第 18 章，Types of Values。 ...

2026-08-21T12:54:26Z

看完了 Crafting Interpreters 第 18 章，Types of Values。

本章将 vm 的运行时栈和常量表所支持的数据类型，从 double 升级为了用 tagged union 实现的 Value，从而可以支持 bool、number、nil 等类型。后续章节还将继续扩展。

这里使用了 tagged union 技法，本质上是用 C 来实现像 Rust 那样的 enum。大体做法是：用一个 enum 字段，标记类型，再用一个 union 字段，保存具体类型的值。根据不同的类型，使用 union 里的不同字段。

接下来，添加了操作布尔值和 nil 的指令，它们只是向 stack 里放入相应的值。这当然可以用 `OP_CONSTANT` 指令来完成，但是，用专用指令的话，可以使得生成的字节码代码少一个字节，性能更好。

最后，支持了「逻辑非」运算和比较运算。值得一提的是，支持比较运算时，只增加了三个指令 `OP_EQUAL`、`OP_GREATER`、`OP_LESS`。对于 `!=`，`<=`，`>=`，则由这三个指令与 `OP_NOT` 组合完成。作者强调，字节码指令与用户代码不需要一一对应，虚拟机有自由选择任何指令与代码序列，只要它们有正确的用户可见的行为即可。而从性能考虑，则不如每个运算符一个指令了。但是，作者强调的这一点，是值得注意的。

总体上这一章还是比较简单的。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

感谢 @npub1pd0…gvmz 大佬打赏！😘

2026-08-19T15:39:27Z

In reply to nevent1q…szq9
_________________________

感谢 yushi (npub1pd0…gvmz) 大佬打赏！😘

看完了 Crafting Interpreters 第 17 章，Compiling ...

2026-08-19T15:14:51Z

看完了 Crafting Interpreters 第 17 章，Compiling Expressions。

这一章完成了 compiler。compiler 负责 parsing + codegen 两项工作。

compiler 是在 parse 时直接生成 bytecode。而不是先 parse 得到 ast，然后 codegen 得到 bytecode。clox 将两个阶段合并为一个了。这样做的一个原因时，可以避免管理 ast 等资源的负担，毕竟在 C 语言中进行资源管理太麻烦了。

现在，clox 的执行流水线由三部分组成，scanner 生成 token 流，compiler 进行 parsing 并生成 bytecode，vm 执行 bytecode。

这一章只支持了对算术表达式的 parsing 和 codegen。但这次使用的是 Pratt parser，而非 jlox 的 recursive descent parsing。作为认为 Pratt parser 是 parse 表达式的最优雅的方式。

但注意，Pratt parser 适合的是 parse 表达式，而不是 parse 整个的源码。clox 整体仍然在用 recursive descent parsing，后面章节将会看到。

parsing expression 的核心函数是 parsePrecedence。它 parse 与给定优先级相等或者更高的表达式。Pratt parser 使用了了表驱动方式，为每个 token type 指定了其作为前缀操作符对应的处理函数(prefix fn)，以及其作为中缀操作符时的处理函数与优先级(infix fn、precedence)。

从人肉理解表达式的角度来看，差不多也是同样逻辑。
当我们遇到一个中缀操作符时（+ - * / and or 等等），如果它后面的操作符优先级更高，则后面的部分应作为当前表达式的一部分，否则就应该属于另外一个表达式。

比如 1 + 2 * 3，遇到 + 时，后面的 * 优先级更高，所以后面的 2 * 3 属于当前的 + 表达式的一部分，得到的是 1 + (2 * 3)。
而对于 2 * 3 + 4，遇到 * 时，后面的 - 优先级更低，所以 + 号及后面的部分不属于当前的 * 表达式。

在 recursive descent parsing 中，我们是把 expression 的 grammar 规则按照操作符优先级拆分，每个规则负责一个优先级。低优先级的规则可以引用高优先级的规则，但反过来不行。

而在 Pratt parser 中，则是将这样的规则明确定义出来，放到表里面，使用时查表。这样可以使得 grammar 比较简洁。

不过，我对 Pratt parser 似乎还没能完全理解，需要找其他资料再学习一下。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

今天看完了 Crafting Interpreters 第 16 章，Scanning on ...

2026-08-18T04:02:08Z

今天看完了 Crafting Interpreters 第 16 章，Scanning on Demand。
Scanning 在 jlox 里已经详细讲过，而且本身算简单，因此这一章新东西不多。这里只记录一下与 jlox 的不同之处。

clox 的 TokenType enum 增加了 `TOKEN_ERROR`。scan 时遇到错误，就返回它。

clox 的 scanner 采用 lazy 方式，每次调用 `scanToken()` 函数时，返回一个 token。这样，可避免在 C 中管理资源的负担。而且 parser 只需要 lookahead 1 个 token，本就不必保留所有 token。

另外，对于 literal （字面量）的值，clox 在 scanning 阶段没有记录。而 jlox 记录在 `Token.literal` 字段里。

clox 在识别 identifier 和 keyword 时，采用了 Trie 的思路，效率更高。

所有的 keyword 都是合法的 identifier，scan 时需要区分出来。在 clox 和 jlox 中，都是先识别 identifier，然后看它是不是 keyword。如果是 keyword 就返回 keyword，否则就返回 identifier。这是一个「将 keyword 从 identifier 中挑出来」的过程。

jlox 将所有的 keyword 放到一个 HashMap 里，识别过程很简单。
clox 则使用了 trie 数据结构，更高效。它尽可能减少了对字符（串）的访问次数。

由于 keyword 数量有限（16 个），组成的 trie 也非常小。clox 直接用嵌套的 switch 语句来实现。代码看起来笨拙，但效率很高。作者提到 v8 也使用了这样的做法。

Trie 的核心思路是，尽可能减少对字符的访问。比如，如果 identifier 第一个字符是 d，则它不可能是任何 keyword。只比较一个字符就足够了。只有当 identifier 是 keyword 时，才需要比较所有字符。而反观 jlox，检查 identifier 是否在 keyword hash map 里，需要计算 identifier 的 hash code。计算时就得访问 identifier 的所有字符。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

试着了解 Solana 链的 ...

2026-08-17T13:37:32Z

In reply to nevent1q…dtwv
_________________________

试着了解 Solana 链的 DeFi。这个帖子介绍了具体怎么玩的：

quoting
nevent1q…k5un
#DeFi实盘说干就干，DeFi 实盘募资完成啦！😂

使用我一个已经用了挺久的钱包地址，转了些 USDC 进去，凑足 200 U 了（实际 204.90 U）。

# 基本情况。
这个 DeFi 实盘运行在 Solana 链上，主要收益来源包括：
1) DEX 池子的手续费，下称 LP 收入。LP = liquidity provider；
2) DeFi 借贷平台利息收入；
3) 其他 DeFi 有关收入。
总的原则是，DeFi 为主，兼顾其他。但不考虑 CEX，也不考虑通过交易低买高卖赚钱（没这能力，必亏 😂）

我会对实盘进行记账，每周公布市值、净值、主要币种(BTC, SOL)价格，当周，以及当周操作等。

## 目标与期望。
1) 让实盘尽可能长期地运行，尽量确保有足够资金放到 DEX 池子里获取收益。避免价格单边上涨超出池子的价格区间后，缺少 SOL 投入新的价格区间。也避免价格单边下跌，跌出池子价格区间后，缺少 USDC 投入放到新的区间。
2) 期望在不考虑价格波动的情况下，实现年化 25% 左右收益率。以 200 U 本金计算的话，就是 2026 年实现 50 U 收益，每周 1 U 的样子。
少折腾，被动收益为主。活得久比挣得多更重要，收益率目标是 OKR 不是 KPI。

## 2025-12-17 概况
Day 0 开业大吉！
市值 204.90 U，净值记为 1。
BTC price = 86,423；SOL price = 126.73。

目前仅在 DEX 平台 Raydium 和 DeFi 借贷平台 Kamino 有持仓。
按币种持仓：1.444 SOL，22.63 USDC。

大部分持仓为 SOL，主要考虑 SOL 价格下跌风险。预计 SOL 跌到 70 以现有持仓影响不大，再往下就有风险了。

Nostr event nevent1qqsvxa5fc362m32dtlhrzdrlm4x658y0tw8zkv58mp3yrj0gt5n85qszyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgx9aq9u

2026-08-16T13:06:55Z

In reply to nevent1q…5n5l
_________________________

那确实，如果要被迫交易，就得承受流动性不足的损失了 😂

#DeFi实盘 2026-08-16 当前市值 124.4，净值 ...

2026-08-16T13:04:34Z

#DeFi实盘 2026-08-16

当前市值 124.4，净值 0.6071。本周 LP 收益 0.19。

BTC price = 62957；SOL price = 75.15。

# 本周概况

还是很冷清。

# 杂感

《一九四二》里说，人饿的时候不想说话。😂

Nostr event nevent1qqs9502tgj5g0c07g6j6ezznn92tdud66nskdhcyrfldwkgalsa6w6qzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg2hjfna

2026-08-16T12:35:43Z

In reply to nevent1q…7gxf
_________________________

也因为流动性差，如果挂个价格离谱的单死等，有时候会成交的 😂
不着急的话，可以守株待兔 😂

Bybit 期权？确实流动性差的很 😂

2026-08-16T12:33:58Z

In reply to nevent1q…c2vf
_________________________

Bybit 期权？确实流动性差的很 😂

看完了 Crafting Interpreters 第 15 章，A Virtual Machine。 ...

2026-08-16T12:26:59Z

看完了 Crafting Interpreters 第 15 章，A Virtual Machine。

这一章实现了一个基于栈的虚拟机（stack-based virtual machine）。
基于栈的虚拟机，是虚拟机的两大主流架构之一，另一种是基于寄存器的虚拟机。CPython、JVM、WebAssembly 是基于栈的；而 Lua、Android 的 Dalvik、Linux 的 BPF 则是基于寄存器的。

基于栈的虚拟机，初看有些神秘，但其实非常简单。

顾名思义，它有一个栈保存运行时的状态。大部分指令默认从栈上取操作数(operand)，并将计算结果保存到栈上。（这使得基于栈的虚拟机的字节码指令非常紧凑，因为不需要指定从哪里取数及存到哪里。）

具体到 clox 的虚拟机，VM struct，它有有一个栈，还有个 `ip` 指针，指向下一条指令。运行时，通过一个循环，不断从 ip 获取指令，然后通过一个 switch 语句进行指令分派，决定要执行的逻辑。

就这么简单。

这一章支持了 constant、return 及加减乘除指令，后续将不断扩展指令集，以及更重要的，将 Lox 代码编译为字节码指令。

quoting
nevent1q…qjf3
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

看完了 Crafting Interpreters 第 14 章，Chunks of Bytecode ...

2026-08-15T10:02:17Z

看完了 Crafting Interpreters 第 14 章，Chunks of Bytecode

从这一章开始，我们进入第二部分，用 C 语言实现一个基于字节码的 Lox 虚拟机。

这一章，我们定义了用来表示字节码的 enum OpCode，目前只有 `OP_CONSTANT` 和 `OP_RETURN` 两个指令。然后定义了 `Chunk` struct 表示整个字节码程序。`Chunk` 除了包括字节码，还包含一个常量池，和指令对应的行号。

本章还为我们的字节码实现了 disassembler （反汇编器），它将二进制的字节码指令转换为人类可读的文本指令。

quoting
nevent1q…w2a0
接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

接下来，开始 Crafting Interpreters 第二部分，用 C ...

2026-08-14T10:03:01Z

接下来，开始 Crafting Interpreters 第二部分，用 C 实现的 Lox 字节码解释器 clox。
在第一部分，用 Java 实现的 tree-walk interpreter jlox 中，我们完整实现了 Lox 解释器，包括 scanner、parser、resolver、interpreter 等等。
但是，第一部分的解释器利用了 Java 语言的许多特性。
比如，Lox 的值，全部用 Java 的 Object 类型表示。
Lox 里的 return，用 Java 的异常来实现。
而 Java 自带 GC，所以 Lox 中对象的生命周期，我们也完全没考虑过。

在第二部分，我们将使用 C 语言实现解释器。C 比 Java 更加 low-level，它不支持 OOP，不支持异常和 GC。
因此，这几个问题，我们就需要在 C 里面手动处理了。
而且，第二部分我们实现的是字节码解释器。我们需要定义字节码，并在 parsing 将 ast 编译为字节码。

用不同语言实现同一门语言，但采用略有不同的技术，可以加深我们的理解，并学习 compiler/interpreter 领域的不同主题。

看完了 Crafting Interpreters 第 13 章，Inheritance。 ...

2026-08-14T07:08:31Z

看完了 Crafting Interpreters 第 13 章，Inheritance。
这一章支持了类的继承。

Lox 只支持单继承，所以并不复杂。

文法层面，用 `<` 号表示继承，形如 `class Dog < Animal {...}`，与 Ruby 相同。
另外增加了 super 表达式。如 `super.method()` 会将 `super.method` parse 为 super 表达式，后面的 `()` 则解析为函数调用。

LoxClass 中增加一个字段记录类的 super class，查找方法时，也要顺着继承链依次向上查找。

在处理 class 声明时，为 super 创建专门作用域。进入 class 声明，立即创建一个作用域，并将 super 定义到里面。接下来，再创建另一个作用域，将 this 定义到里面。然后再定义方法。这样在方法的代码里面引用的 super 就是当前类的 super class 了。

至此，本书第一部分，用 Java 实现 tree-walk interpreter 宣告完成。
看了下我敲下的代码，排除注释、空行、测试等，只有 2002 行，简直不可思议。
只要 2000 行代码，就能从头实现一门功能基本齐全的语言，我以前从未想过！
这些代码，包括 lexer、parser、resolver 和 interpreter。
而这门语言的功能齐全，它支持变量、表达式、函数，还支持类和继承等 OOP 特性。

quoting
nevent1q…zt9q
今天看完了 Crafting Interpreters 第 12 章 Classes。

这一章支持了 class。作为动态类型语言，Lox 的 class 与 Python 的有些相似。用 `class` 声明类，用 `init` 方法初始化实例。

为此，增加了声明类的文法规则，并增加了 Get 表达式以支持访问实例的字段（和方法），增加了 Set 表达式以支持对实例的字段赋值。同时还支持了 This 表达式，以表示 `this`。

类用 `LoxClass` 表示，它保存着类的名字以及方法列表。方法用现成的 `LoxFunction` 表示。
同时 `LoxClass` 也实现了 `LoxCallable` 接口，以便创建类的实例。
类的实例用 `LoxInstance` 表示，它保存着所属的类，及字段值。

对于 `this` 的支持值得一提。

我们知道，Resolver 中的 scope 链，与 Interpreter 中的 Environment 链必须保持一致。scope 与 Environment 本质是同一个东西，只不过 scope 是编译时的，Environment 是运行时的。

Resolver 处理 class 声明时（`visitClassStmt`），创建了新的 scope，并将 this 定义在新的 scope 里。这也意味着，class 的 method 也是在新的 scope 中定义的。

但 `Interpreter.visitClassStmt` 却没有创建新的 Environment。而是在访问实例的属性时（`visitGetExpr`），如果这个属性对应的是一个 method，就调用 `LoxFunction.bind` 方法。`LoxFunction.bind` 会以 method 的 closure 为 enclosing Environment 创建新 Environment，把 this 绑定为对应实例，然后组装为新的 LoxFunction 并返回。

这样的话，类的方法调用时，Environment 就与 Resolver 的 scope 一致了，而且确定了 this 所指向的值。

具体地，形如 `ins.method()` 的方法调用，`ins.method` 被 parse 为 `Expr.Get`。对 `ins.method` 求值，即对 `Expr.Get` 求值，就会执行这里所说的逻辑。得到新的 LoxFunction 后，再进行函数调用，就和其他函数没有什么区别了。

关于创建类的实例，其实包含两个步骤。
第一步是真正的创建实例，得到 LoxInstance，它是由 LoxClass 负责的。LoxClass 实现了 LoxCallable 接口，调用时返回一个 LoxInstance。
第二步是初始化，由用户提供的 init 方法完成。为了方便使用，Lox Interpreter 确保 init 方法返回实例，且禁止它返回其他值。

至此，本书第一部分，用 Java 实现的 tree-walk interpreter 只剩下最后一章 Inheritance 了。而我敲下的代码，刨除注释和空行，只有 1916 行。神奇！

nevent1q…2g7k

今天看完了 Crafting Interpreters 第 12 章 Classes。 ...

2026-08-12T10:04:18Z

今天看完了 Crafting Interpreters 第 12 章 Classes。

这一章支持了 class。作为动态类型语言，Lox 的 class 与 Python 的有些相似。用 `class` 声明类，用 `init` 方法初始化实例。

为此，增加了声明类的文法规则，并增加了 Get 表达式以支持访问实例的字段（和方法），增加了 Set 表达式以支持对实例的字段赋值。同时还支持了 This 表达式，以表示 `this`。

类用 `LoxClass` 表示，它保存着类的名字以及方法列表。方法用现成的 `LoxFunction` 表示。
同时 `LoxClass` 也实现了 `LoxCallable` 接口，以便创建类的实例。
类的实例用 `LoxInstance` 表示，它保存着所属的类，及字段值。

对于 `this` 的支持值得一提。

我们知道，Resolver 中的 scope 链，与 Interpreter 中的 Environment 链必须保持一致。scope 与 Environment 本质是同一个东西，只不过 scope 是编译时的，Environment 是运行时的。

Resolver 处理 class 声明时（`visitClassStmt`），创建了新的 scope，并将 this 定义在新的 scope 里。这也意味着，class 的 method 也是在新的 scope 中定义的。

但 `Interpreter.visitClassStmt` 却没有创建新的 Environment。而是在访问实例的属性时（`visitGetExpr`），如果这个属性对应的是一个 method，就调用 `LoxFunction.bind` 方法。`LoxFunction.bind` 会以 method 的 closure 为 enclosing Environment 创建新 Environment，把 this 绑定为对应实例，然后组装为新的 LoxFunction 并返回。

这样的话，类的方法调用时，Environment 就与 Resolver 的 scope 一致了，而且确定了 this 所指向的值。

具体地，形如 `ins.method()` 的方法调用，`ins.method` 被 parse 为 `Expr.Get`。对 `ins.method` 求值，即对 `Expr.Get` 求值，就会执行这里所说的逻辑。得到新的 LoxFunction 后，再进行函数调用，就和其他函数没有什么区别了。

关于创建类的实例，其实包含两个步骤。
第一步是真正的创建实例，得到 LoxInstance，它是由 LoxClass 负责的。LoxClass 实现了 LoxCallable 接口，调用时返回一个 LoxInstance。
第二步是初始化，由用户提供的 init 方法完成。为了方便使用，Lox Interpreter 确保 init 方法返回实例，且禁止它返回其他值。

至此，本书第一部分，用 Java 实现的 tree-walk interpreter 只剩下最后一章 Inheritance 了。而我敲下的代码，刨除注释和空行，只有 1916 行。神奇！

quoting
nevent1q…2g7k
今天终于看完了 Crafting Interpreters 第 11 章，Resolving and Binding。

在第 10 章 Functions 的实现存在 bug，并不是严格的静态作用域。

```
var a = "global";
{
fun showA() {
print a;
}

showA();
var a = "block";
showA();
}
```

按照静态作用域规则，这段代码应当打印两次 global。但第 10 章的实现，却是先打印 global，然后打印 block。

本章定义了专门的 Resolver pass 来解决这个问题。

Pass，是指对「程序表示」进行一次相对独立的分析或转换过程。这里「程序表示」可以是 token、AST、HIR/MIR、CFG、SSA IR、机器指令表示，等等。一个 pass 通常接收一种程序表示，对其进行遍历、分析或修改，然后把结果交给下一个 pass。

本章实现的 name resolution 是 compiler 的一个典型 pass。其他 pass 还包括类型检查、各种优化等等。

name resolution 是指，确定名字具体指向哪个声明的过程。即，代码中的这个名字（变量名、函数名、类名等），到底指的是谁？

此前的 Lox 实现，是在运行时进行 name resolution 的。声明变量时，将其名字和值写入 Environment。后续使用时，顺着 Environment 链进行查找。即，每次使用变量时，都要进行一次 name resolution（但其实现有 bug）。但是，静态作用域意味着，变量的使用总是指向同一个声明，这只需查看代码文本即可确定。更好（性能更好）的解决方案是，每次变量使用只解析一次。

Resolver 在 parsing 之后、执行之前运行。Resolver 以 visitor pattern 访问 ast，并确定定义变量的作用域。并记录下来，供运行时使用。（Resolver 运行在 compile-time，不会受 run-time 信息的干扰，所以，上面那个 bug 就不会发生了。）

具体地，Resolver 访问 ast，并记录进入和退出作用域的动作（语句块、函数定义)，构建 scope 链。这个 scope 链和 Interpreter 的 Environment 链是一一对应的。只不过 scope 是 compile time 的，Environment 是 runtime 的。

- 当遇到声明变量（函数）语句时，就在当前 scope 里记录下这个变量（函数）。
- 当遇到赋值表达式和变量表达式时，顺着 scope 链查找变量是在哪个 scope 中定义的，并记录下 distance。distance 表示顺着 scope 链查找多少步，才能找到定义变量的 scope。到了运行时，顺着 Environment 链查找 distance 步，就能找到变量定义的在的 Environment，从而查找到变量的值了。

而到了运行时，Interpreter 遇到赋值表达式和变量表达式时，就根据记录下来的 resolution 信息（distance），确定变量所属的 Environment，然后读写变量的值。

Resolver 的核心逻辑就这几条，算是简单。但它需要实现 Stmt 和 Expr 的 visitor，不得不实现许多方法了。

需要提一下的是，全局作用域不包含在 Resolver 构建的 scope 链中。所以，如果 Interpreter 运行时找不到变量，需要到 global Environment 里面再找一次。
但是 Environment 链是包含了全局 Environment 的，没太明白为何搞得不一致。而且，我的理解，如果 scope 链包含了全局 scope 的话，就可以在 Resolver 中识别出「使用未定义的变量」这种错误了。

另外，Resolver 还顺手添加了一个检查，确保 return 语句不能出现在函数外面。

最后，问了一下 ChatGPT，对于 tree-walk interpreter 来说，name resolution 比较优秀做法是怎样的。它的答案是，局部变量用 `(depth, slot)` 二元组表示。这里 `depth` 对应书中的 distance。而 slot，则需要将 Environment 里采用数组来保存变量和值的对应关系，而不是用 HashMap。本章结尾的 Challenges 题目的第 4 题，说的正是这个方法。

ChatGPT 还提到，EOPL 第 3.7 节 Implementing Lexical Addressing，SICP 5.5.6 节 Lexical Addressing，都在讲这个主题。

nevent1q…zydw

在 CEX 平台做 LaunchPool 活动，似乎收益率也不错。 ...

2026-08-11T09:04:32Z

在 CEX 平台做 LaunchPool 活动，似乎收益率也不错。

投入的资金买入平台币现货，并且做空同样数量合约以对冲价格变化。保留部分资金作为合约保证金。
- 平台币可以用来参加 LaunchPool 活动，领空投。
- 没有 LaunchPool 时，闲置资金放到理财里生息。
- 做空的合约可以赚资金费。

以 BitGet 为例进行计算。

假定资金分配是 40% 现货，40% 合约，20% 作为合约保证金。

1) LaunchPool 收益：
LaunchPool 活动，一年约 20 次，每次 6 天。
取一次活动的 APY 为 30%。
则一次活动收益为：0.3*(6/365) = 0.49%
一年里 LaunchPool 收益为 0.0049 * 20 * 0.4 = 3.92%

2) 资金费收益：
BitGet 的平台币 BGB，资金费常常在 0.01%，一天三次。
资金费收益率：0.0001 * 3 * 365 * 0.4 = 4.3%。
考虑偶尔出现资金费不到 0.01%，甚至出现负资金费的情况，取资金费年化为 4% 吧。

3) 闲置期间理财收益：
BGB 理财收益是每年 1%，但需要扣除参与 LaunchPool 的 120 天。
理财收益为：0.01 * (245/365) * 0.4 = 0.26%

三项收益加起来，总收益就是：3.92% + 4% + 0.26% = 8.18%。
不算很高，但胜在近乎无风险，我觉得也可以接受了。

这里的数据中，LaunchPool 活动最难估计。
- 25 年全年 33 次，平均 APY 45%。
- 26 年截至现在 9 次，平均 APY 20%。
差不多牛市活动多收益高，熊市活动少收益低。

平均来看，拿到 7% ~ 10% 的收益，应该是可期待的。

#DeFi实盘 2026-08-09 当前市值 127.39，净值 ...

2026-08-09T14:21:26Z

#DeFi实盘 2026-08-09

当前市值 127.39，净值 0.6217。本周 LP 收益 0.22。

BTC price = 65176；SOL price = 76.61。

# 本周概况
连着好一个月 LP 收益都在 0.2 左右，在最热的夏天感受最冷的寒冬。

# 杂感
Coldcard 硬件钱包漏洞事件，越来越有意思了，有人怀疑是内部人有意为之，越来越惊悚了。

最近专注看书，web3 关注少了。

今天终于看完了 Crafting Interpreters 第 11 ...

2026-08-09T13:09:34Z

今天终于看完了 Crafting Interpreters 第 11 章，Resolving and Binding。

在第 10 章 Functions 的实现存在 bug，并不是严格的静态作用域。

```
var a = "global";
{
fun showA() {
print a;
}

showA();
var a = "block";
showA();
}
```

按照静态作用域规则，这段代码应当打印两次 global。但第 10 章的实现，却是先打印 global，然后打印 block。

本章定义了专门的 Resolver pass 来解决这个问题。

Pass，是指对「程序表示」进行一次相对独立的分析或转换过程。这里「程序表示」可以是 token、AST、HIR/MIR、CFG、SSA IR、机器指令表示，等等。一个 pass 通常接收一种程序表示，对其进行遍历、分析或修改，然后把结果交给下一个 pass。

本章实现的 name resolution 是 compiler 的一个典型 pass。其他 pass 还包括类型检查、各种优化等等。

name resolution 是指，确定名字具体指向哪个声明的过程。即，代码中的这个名字（变量名、函数名、类名等），到底指的是谁？

此前的 Lox 实现，是在运行时进行 name resolution 的。声明变量时，将其名字和值写入 Environment。后续使用时，顺着 Environment 链进行查找。即，每次使用变量时，都要进行一次 name resolution（但其实现有 bug）。但是，静态作用域意味着，变量的使用总是指向同一个声明，这只需查看代码文本即可确定。更好（性能更好）的解决方案是，每次变量使用只解析一次。

Resolver 在 parsing 之后、执行之前运行。Resolver 以 visitor pattern 访问 ast，并确定定义变量的作用域。并记录下来，供运行时使用。（Resolver 运行在 compile-time，不会受 run-time 信息的干扰，所以，上面那个 bug 就不会发生了。）

具体地，Resolver 访问 ast，并记录进入和退出作用域的动作（语句块、函数定义)，构建 scope 链。这个 scope 链和 Interpreter 的 Environment 链是一一对应的。只不过 scope 是 compile time 的，Environment 是 runtime 的。

- 当遇到声明变量（函数）语句时，就在当前 scope 里记录下这个变量（函数）。
- 当遇到赋值表达式和变量表达式时，顺着 scope 链查找变量是在哪个 scope 中定义的，并记录下 distance。distance 表示顺着 scope 链查找多少步，才能找到定义变量的 scope。到了运行时，顺着 Environment 链查找 distance 步，就能找到变量定义的在的 Environment，从而查找到变量的值了。

而到了运行时，Interpreter 遇到赋值表达式和变量表达式时，就根据记录下来的 resolution 信息（distance），确定变量所属的 Environment，然后读写变量的值。

Resolver 的核心逻辑就这几条，算是简单。但它需要实现 Stmt 和 Expr 的 visitor，不得不实现许多方法了。

需要提一下的是，全局作用域不包含在 Resolver 构建的 scope 链中。所以，如果 Interpreter 运行时找不到变量，需要到 global Environment 里面再找一次。
但是 Environment 链是包含了全局 Environment 的，没太明白为何搞得不一致。而且，我的理解，如果 scope 链包含了全局 scope 的话，就可以在 Resolver 中识别出「使用未定义的变量」这种错误了。

另外，Resolver 还顺手添加了一个检查，确保 return 语句不能出现在函数外面。

最后，问了一下 ChatGPT，对于 tree-walk interpreter 来说，name resolution 比较优秀做法是怎样的。它的答案是，局部变量用 `(depth, slot)` 二元组表示。这里 `depth` 对应书中的 distance。而 slot，则需要将 Environment 里采用数组来保存变量和值的对应关系，而不是用 HashMap。本章结尾的 Challenges 题目的第 4 题，说的正是这个方法。

ChatGPT 还提到，EOPL 第 3.7 节 Implementing Lexical Addressing，SICP 5.5.6 节 Lexical Addressing，都在讲这个主题。

quoting
nevent1q…zydw
看完了 Crafting Interpreters 第 10 章，Function Calls

这一章实现了函数。

函数是用 `LoxCallable` interface 表示的。Native 函数，直接用 java 代码实现这个 LoxCallable interface 即可。Lox 代码定义的函数，在 parse 之后创建为 LoxFunction 实例（见 visitFunctionStmt）。

`return` 语句通过 Java 的异常实现。`return` 也是一种控制流语句，它从任意地方返跳回到函数调用边界。借助 Java 异常来实现，是非常省事的办法。否则，就需要自己显式操作控制流了，麻烦程度大增。Lox 不支持 continue 和 break，如果要支持的话，也可使用同样的办法。

另外发现，实现 `return` 时，没有检查 `return` 语句是否处于函数定义中。在解释器中可以直接输入 `return;`，它会正常执行，并因抛出的 Java 异常（ `Return`）未被捕获而导致解释器退出。正常来说，应当在 semantic analysis 阶段检查出来并报错的。且看后续章节会不会涉及这些。（剧透：下一章就会解决。）

本章的精髓在于，如何使用 Environment 管理作用域。

Environment 是在第 8 章 Statements and State 为了支持语句块（bloc statement）而引入的。在这一章，它成为了正确实现函数的关键因素之一。现代语言几乎都支持作用域（scope），支持作用域嵌套，名字的 shadowing 等等机制。函数方面，往往还支持高阶函数和闭包。

Interpreter 类里面有 globals 和 environment 两个类型为 Environment 的字段。值得注意。
- globals 表示全局 Environment。
- Interpreter.environment 表示 Interpreter 的当前 environment。

刚开始运行时，它们是同一个对象。表示 Interpreter 处于全局作用域。

随着 Interpreter 进入/退出新的作用域，Interpeter.environment 会随之变化。

进入新的作用域时(executeBlock)，会以当前 environment 创建新的 Environment，并以之取代 Interpreter 的当前 environment。
退出作用域时，Interpreter.environment 会恢复为之前的 Environment。

定义变量(visitVarStmt)和函数(visitFunctionStmt)时，均是将名字定义在 Interpreter.environment 即当前 Environment 里面。
这意味着，如果我们在全局定义变量和函数，那么它们就是全局作用域可见的；如果在某个局部作用域里定义变量和函数，它们就是局部作用域可见的。

```lox
{
var x = 1;

fun localFn() {
print "localFn";
}

localFn();
}

// Error: Undefined variable 'localFn'.
localFn();
```

比如，上面这段代码中，`localFn` 只在代码块里面可见。

我们还可以在函数内部定义函数，它们只在函数内部可见。

```lox
fun fn() {
var x = 1;

fun inner() {
print "inner";
}

inner();
}

// Error: Undefined variable 'inner'.
inner();
```

实现函数调用（`LoxFunction.call` 方法），也需要仔细考虑如何与 Environment 交互。执行函数调用需要在单独的 Environment 中进行，函数参数和局部变量，都需要在这个 Environment 中定义。但是，函数还需要引用其他名字，比如其他函数、全局变量等。

在这一章的初版实现中，函数调用的 Environment 的 enclosing Environment 为 Interpreter 的全局 Environment（`Interpreter.globals`）。这样，在函数内部就可以正确引用在全局作用域里定义的函数和变量了。但是，这样做是不够的。

它会导致一个问题，在语句块和函数内部定义的函数，无法正确引用语句块里和外层函数里的局部变量。比如上面两个示例中，`localFn` 和 `inner` 函数，都无法引用它外层的 `x` 变量。

看到这里也许会想，函数调用时，一定要用 `globals` Environment 吗？用解释器的当前 Environment （即 `Interpreter.environment`）应该能解决问题？答案仍然是否定的。它使得我们能够引用外层的名字，却破坏了「静态作用域」规则，使用得作用域变成动态的了：函数中名字的含义将由调用位置决定，而不是由函数在源码中的定义位置决定。

```lox
var lang = "Lox";

fun printLang{
print lang;
}

{
var lang = "Java";
printLang();
}
```

定义 `printLang` 时，根据它在源码中的位置，函数体里的 `lang` 会解析到全局作用域中的 `lang` 绑定。以后无论从哪里调用 `printLang`，它都不会改为访问调用者的局部 `lang`。

而如果我们修改实现的话，在语句块中调用 `printLang()` 时，将会打印出 Java。这就违背静态作用域的规则了。

这里的困境，与闭包有关。以下用这个经典例子来说明：
```lox
fun makeCounter() {
var i = 0;
fun count() {
i = i + 1;
print i;
}

return count;
}

var counter = makeCounter();
counter(); // "1".
counter(); // "2".
```

按照初版实现，在调用 `makeCounter` 时，会创建一个 Environment，并将 `i` 就是定义到这个 Environment 中。但调用完毕，这个 Environment 直接被丢弃，`i` 的绑定也无法查找了。

解决办法也简单，我们不要丢弃这个 Environment，而是要保存到内部嵌套函数 `count` 对应的 `LoxFunction` 对象里面。这个 Environment 称为 closure。而且函数调用时，也使用 closure 作为 enclosing Environment。这样，函数就可以使用外层作用域里定义的变量了（而不是使用 `Interpreter.globals` 作为 enclosing Environment）。
在执行语句块时，也会创建一个 Environment。对于在语句块中定义的函数，也是照此办理，逻辑是相同的。

而这个 closure Environment 最终仍然会引用全局 Environment，所以在全局作用域中定义的函数、变量等，也可正常访问。

至此，Lox 对于函数、作用域、闭包的支持，已经相当不错了。但是，closure 的实现仍有一些问题，这就留待下一章揭晓了。

nevent1q…wxfd

又少一个可以套利的品种了

2026-08-07T16:21:07Z

In reply to nevent1q…kqav
_________________________

又少一个可以套利的品种了

A closure is a function that captures the bindings of free ...

2026-08-07T08:38:47Z

A closure is a function that captures the bindings of free variables in its lexical context.

https://gafter.blogspot.com/2007/01/definition-of-closures.html

#DeFi实盘 2026-08-02 当前市值 119.06，净值 ...

2026-08-02T13:23:04Z

#DeFi实盘 2026-08-02

当前市值 119.06，净值 0.5811。本周 LP 收益 0.21。

BTC price = 63154；SOL price = 73.11。

# 本周概况
继续冷清。

# 杂感

最近两件事：

- Gate 用户被盗 170w USDT 事件，让人觉得交易所不安全。
- Coldcard 硬件钱包漏洞，让人觉得连硬件钱包也不安全。

加上 SOTA AI 逆天的漏洞挖掘能力，DeFi 智能合约被攻击的风险也越来越大了。

瑟瑟发抖 ing。。。😂

看完了 Crafting Interpreters 第 9 章，Control Flow。 ...

2026-08-02T04:45:51Z

看完了 Crafting Interpreters 第 9 章，Control Flow。

这一章增加了逻辑表达式(and、or)，if 语句，while 和 for 循环。

实现 for 循环时，介绍了一下语法糖 syntactic sugar，在 parse 时，就把 for 循环给改写为 while 循环语句了。这就是脱糖 desugaring 过程。

Lox 的循环不支持 continue 和 break 语句。所以大大降低了实现难度。

而因为同样原因，我感觉语法分析阶段做的事情非常少。基本上 parse 得到语法树(Stmt class)之后，就结束了，没有额外工作，感觉有所缺憾。希望后续章节能够涉及这方面。

quoting
nevent1q…5d8d
刷完 Crafting Interpreters 第 8 章，Statements and State。

这一章内容较多。增加了对语句的支持，包括表达式语句、print 语句、变量声明语句。同时增加了赋值表达式，并且支持了作用域。

实现作用域时使用的 Environment，与 Peter Novig 的 [(How to Write a (Lisp) Interpreter (in Python))](https://www.norvig.com/lispy.html) 经典文章里的，是同一思路。

最后讨论了一下变量声明是显式好，还是隐式好。结论是，显式更好。

Lox 相比真正编程语言，还缺少控制结构（if、while 等）、函数。这是接下来两章的内容。

现在的代码量只有 1059 行（不含注释和空行），已经做到这个程度，太神奇了。

随着内容的增加，感觉定义好 grammar 规则非常重要。事先要做好推演。
不然的话，越往后越容易出现问题。

nevent1q…wn2z

Nostr event nevent1qqsfeeaw98tpdne4zus5xzhf5ckhu6phhhttr2ttfc3eaa2afls9wcczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgkz6x4h

2026-08-01T05:30:32Z

In reply to nevent1q…d0y7
_________________________

换个角度想想，一个多月前正式科技股最火热的时候。公司提拔他为基金经理，可能也是有意好好栽培一番。如果之前的行情延续一个月，它的业绩也会很亮眼的。可惜运气不允许啊 😂

亏这么多不耽搁基金按固定比例收管理费 😂 ...

2026-08-01T05:26:14Z

In reply to nevent1q…l4z6
_________________________

亏这么多不耽搁基金按固定比例收管理费 😂 投资者亏了也需要发泄一下 😂

记得私募是有的，公募不清楚了

2026-08-01T04:15:44Z

In reply to nevent1q…kp7e
_________________________

记得私募是有的，公募不清楚了

太夸张了🙈 #nevent1q…dasq

2026-08-01T03:49:16Z

太夸张了🙈

quoting
nevent1q…dasq
Over 1,000 btc drained. #notsocoldcards

https://coldcard-watch.vercel.app/

Nostr event nevent1qqsp3tqleud3h6kxy690nxrd89ltsapjlz78sv2upt5nl3sw8gtxmsczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgt9rg6e

2026-08-01T03:43:30Z

In reply to nevent1q…0rz4
_________________________

是这位搞安全的老哥 https://weibo.com/6236276241/Rbfb2cGj7 😂

Nostr event nevent1qqsdsddnh7m5c49vs467qqjawqgq7y7lxuqekfgrqg3qf8p4gphvj7szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgjkr6av

2026-08-01T03:40:24Z

In reply to nevent1q…s6yy
_________________________

这是接手了别人的基金吧？一个月时间不够从募资到建仓的吧 😂
我反倒有点同情他 😂😂😂

刷完 Crafting Interpreters 第 8 章，Statements and State。 ...

2026-08-01T03:25:42Z

刷完 Crafting Interpreters 第 8 章，Statements and State。

这一章内容较多。增加了对语句的支持，包括表达式语句、print 语句、变量声明语句。同时增加了赋值表达式，并且支持了作用域。

实现作用域时使用的 Environment，与 Peter Novig 的 [(How to Write a (Lisp) Interpreter (in Python))](https://www.norvig.com/lispy.html) 经典文章里的，是同一思路。

最后讨论了一下变量声明是显式好，还是隐式好。结论是，显式更好。

Lox 相比真正编程语言，还缺少控制结构（if、while 等）、函数。这是接下来两章的内容。

现在的代码量只有 1059 行（不含注释和空行），已经做到这个程度，太神奇了。

随着内容的增加，感觉定义好 grammar 规则非常重要。事先要做好推演。
不然的话，越往后越容易出现问题。

quoting
nevent1q…wn2z
完成第 7 章 Evaluating Expressions。

这一章篇幅较短，完成之后，就得到一个支持加减乘除、字符串拼接和逻辑判断的最简版 Lox 解释器了，大体上相当于一个计算器。求值仍然借助 visitor 模式，对表达式树进行后序遍历。本身算是简单。

至此，Lox 解释器已经初具雏形。scanner 已经全部完成，后续不需要改动。parser 及 evaluation 过程，只支持了较简单的表达式。后续章节将不断扩充语言，支持语句、控制流、函数、类与继承等等。

nevent1q…ydum

完成第 7 章 Evaluating Expressions。 ...

2026-07-31T01:02:44Z

完成第 7 章 Evaluating Expressions。

这一章篇幅较短，完成之后，就得到一个支持加减乘除、字符串拼接和逻辑判断的最简版 Lox 解释器了，大体上相当于一个计算器。求值仍然借助 visitor 模式，对表达式树进行后序遍历。本身算是简单。

至此，Lox 解释器已经初具雏形。scanner 已经全部完成，后续不需要改动。parser 及 evaluation 过程，只支持了较简单的表达式。后续章节将不断扩充语言，支持语句、控制流、函数、类与继承等等。

quoting
nevent1q…ydum
刷完了第 6 章 Parsing Expressions，感觉最大的障碍已经克服了。😂

Parsing 技术非常丰富庞杂，包括 LL(k)、LR(1)、LALR、Earley、Packrat、PEG 等算法，还有 parser combinator、parser generator 等等技术。龙书太注重理论探讨，曾经让我觉得，只有完整掌握这些这些算法，才能写 compiler。龙书误我。😂

Crafting Interpreters 则选择跳过理论分析，直接开始构建 recursive descent parser。并且告诉我们，Rust、GCC、V8 等项目都采用了 recursive descent parser，既然如此，还有什么好担心的？😎

Contex-free grammar 方面，也是面向实际需要，介绍了如何消除歧义、如何对文法规则分层以解决运算符优先级问题。

最后，跟着把代码敲完，就得到了一个完整的 parser 了。🎉

翻越一座大山，原来可以如此简单！

nevent1q…8700

刷完了第 6 章 Parsing ...

2026-07-29T15:16:08Z

刷完了第 6 章 Parsing Expressions，感觉最大的障碍已经克服了。😂

Parsing 技术非常丰富庞杂，包括 LL(k)、LR(1)、LALR、Earley、Packrat、PEG 等算法，还有 parser combinator、parser generator 等等技术。龙书太注重理论探讨，曾经让我觉得，只有完整掌握这些这些算法，才能写 compiler。龙书误我。😂

Crafting Interpreters 则选择跳过理论分析，直接开始构建 recursive descent parser。并且告诉我们，Rust、GCC、V8 等项目都采用了 recursive descent parser，既然如此，还有什么好担心的？😎

Contex-free grammar 方面，也是面向实际需要，介绍了如何消除歧义、如何对文法规则分层以解决运算符优先级问题。

最后，跟着把代码敲完，就得到了一个完整的 parser 了。🎉

翻越一座大山，原来可以如此简单！

quoting
nevent1q…8700
狂推神作 Crafting Interpreters！

Compiler/interpreter 技术，一直有种神秘色彩。一方面，掌握它能让你在更高层面看待编程语言，甚至自己创造一门。另一方面，庞杂的技术和龙书这样的大部头书，又往往将人劝退。

幸好，有了 Crafting Interpreters。

它的定位出奇制胜，因为它选择了一条独特的路径，带着我们游览 compiler/interpreter 技术丛林。

这本书以实践为主，主线是从 0 构建 interpreter，理论只做最简要的介绍。非常适合我这种连龙书 Syntax Analysis 那一章都没撑过去的苦手。😂

跟随着它的路径，我们只用几千行代码，就实现了一门完整的编程语言(Lox)。而且是两次，一次用 Java 一次用 C。

第一部分用 Java 实现一个 tree-walk interpreter。每章一个主题，先是实现 scanner，然后 recursive descent parser。然后从表达式求值逐步扩充，直到完整支持语句、控制流、函数、类与继承等语言特性。

第二部分改用 C 语言，实现一个虚拟机。我们从设计字节码开始，并将前面实现的语言特性编译为字节码。

整个过程中，不依赖外部库，需要的东西全部自己动手。跟着书的进度，几百行代码之后我们得到一个 scanner，再几百行之后得到一个 parser，几千行之后你就实现了完整的编程语言：Lox。

剩下的，就是自由发挥的天地了。😎

https://craftinginterpreters.com/

今天刚刷完 Chapter 6 Parsing Expressions 😎 ...

2026-07-28T14:08:24Z

今天刚刷完 Chapter 6 Parsing Expressions 😎

quoting
nevent1q…8700
狂推神作 Crafting Interpreters！

Compiler/interpreter 技术，一直有种神秘色彩。一方面，掌握它能让你在更高层面看待编程语言，甚至自己创造一门。另一方面，庞杂的技术和龙书这样的大部头书，又往往将人劝退。

幸好，有了 Crafting Interpreters。

它的定位出奇制胜，因为它选择了一条独特的路径，带着我们游览 compiler/interpreter 技术丛林。

这本书以实践为主，主线是从 0 构建 interpreter，理论只做最简要的介绍。非常适合我这种连龙书 Syntax Analysis 那一章都没撑过去的苦手。😂

跟随着它的路径，我们只用几千行代码，就实现了一门完整的编程语言(Lox)。而且是两次，一次用 Java 一次用 C。

第一部分用 Java 实现一个 tree-walk interpreter。每章一个主题，先是实现 scanner，然后 recursive descent parser。然后从表达式求值逐步扩充，直到完整支持语句、控制流、函数、类与继承等语言特性。

第二部分改用 C 语言，实现一个虚拟机。我们从设计字节码开始，并将前面实现的语言特性编译为字节码。

整个过程中，不依赖外部库，需要的东西全部自己动手。跟着书的进度，几百行代码之后我们得到一个 scanner，再几百行之后得到一个 parser，几千行之后你就实现了完整的编程语言：Lox。

剩下的，就是自由发挥的天地了。😎

https://craftinginterpreters.com/

Nostr notes by yfaming

“The fan pays the artist. Directly. In sats.” That’s the ...

That McDavid stat is absurd: a five-point game, then a ...

Connor McDavid opening a 10-point lead over every other NHL ...

#DeFi实盘 2026-10-25 当前市值 186.99，净值 ...

借你吉言了 😂

Nostr event nevent1qqstzlh8d88w0ucf5fyznq58rsar24me25y07hdzu80y22s6lp5vzcqzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgrphsd4

还有机会见到 6w 的 BTC 吗？😂

Nostr event nevent1qqsw4ercv2xjszes8c3z4p63570v52c9fm7tp7mldve5hl3q2svx33szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgrygyqa

8w 以下的 BTC，3700 以下的 A ...

Nostr event nevent1qqsvqa6q6ma2y6aa68hsh47r4d99td4fzeaxd36uctnlptg3r8fe8vczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgnq33wt

The 3D-printed core beneath a hand-poured resin finish is a ...

少侠过谦了～

GM~

羡慕哇，我是买啥啥跌 😭 毫无交易天赋那种的 ...

AI 太厉害了 😂

对交易量取 2 ...

Nostr event nevent1qqs0d4nrjywwmjvc7wqfs82fe2vuyhyq8dw4emn8fhc6u9cy3t4urkczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgmgxg5r

Nostr event nevent1qqst6smpqxld0ewlgezfzf8kd8l8umk59x2ykq90r9vqadv94seddgczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgdv20a6

5 月底停止刷币安 alpha ...

👍👍👍

Badges are one of Nostr’s most underrated features. A simple ...

Is @npub1dsn…2h64 AI quality check down? It’s returning a 503 ...

在我看来，Scheme 最核心的特性有 3 个：S ...

#DeFi实盘 2026-10-18 当前市值 193.44，净值 ...

刚刚 BTC 跌破 80,000，这会又 V 回来了。😂 ...

Nostr event nevent1qqspkh5vh0umx4yncj7kdszh2xhusygexeydj80nxxsa28vcf94qrrczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg844kvk

Nostr event nevent1qqsq753jxmgfedjewur72gxjf7ft4eecw4akqzmaxlthx9hc52prw0szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wghj3ksg

今天是 10.11 闪崩一周年！😂 主流币跌幅：BTC ...

Nostr event nevent1qqspca6ptqs2rv9e7nng4qd9fykd373qpjd572s6fqlzfmda9n0gp9szyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wghm5zzk

Nostr event nevent1qqs2rammej530qxjap0zvfy6pvdyd86jc7fmexzxpzjrysdj4ghnanczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg0hmpej

这几年，眼看着 AI ...

#DeFi实盘 2026-10-11 当前市值 204.13，净值 ...

Nostr event nevent1qqsrshjckc4a6q40n0ze4ttcalmq2jwkrssqamp94wqfngwh0mtj8jqzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgxf4cjz

#DeFi实盘 2026-10-04 当前市值 224.53，净值 ...

越来越觉得 Scheme ...

I really like the idea of combining gamification with ...

一年后，关于 Scheme，我的思考是：将 Scheme ...

可以理解为 nostr 的推广平台吧。 ...

厉害，比我多啊 😀

今晚币 Alpha 突袭发 6 万份空投，22:30 ...

AQSTR 很不错的，我已在 AQSTR 上挣了 57,768 sats。 ...

#DeFi实盘 2026-09-27 当前市值 224.24，净值 ...

这个不错，下载下来学习 👍

#DeFi实盘 2026-09-20 当前市值 199.08，净值 ...

Validating Lightning Signer (VLS) 近期在 AI ...

终于看完了 Crafting ...

看完了 Crafting Interpreters 第 30 章，Optimization。 ...

#DeFi实盘 2026-09-13 当前市值 181.65，净值 ...

看完了 Crafting Interpreters 第 29 章，Superclasses。 ...

今天看完了 Crafting Interpreters 第 28 章，Methods and ...

Nostr event nevent1qqsvtwz7ey8vjw2e7e3wmyyf2c0aal2hs6e0mpdfmsqn0zfryyc05gczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgpszkfu

又一例，AI 进步引发的安全混乱还在继续 ...

看完了 Crafting Interpreters 第 27 章，Classes and ...

黑客还钱了，大概是退了 3400，自己留下 600。 ...

做个网页，把链接甩过去：”让你的 AI 跟我的 AI ...

#DeFi实盘 2026-09-06 当前市值 193.78，净值 ...

看完了 Crafting Interpreters 第 25 章，Garbage ...

**Closures are poor man's objects and vice versa.** ...

本书作者似乎非常推崇 Lua 的实现，clox ...

看完了 Crafting Interpreters 第 25 章，Closures。 ...

Closures are poor man's objects and vice versa. ...

#DeFi实盘 2026-08-30 当前市值 194.85，净值 ...

@npub1ggd…3nsc Thanks for your zapping! ❤

看完了 Crafting Interpreters 第 21 章，Global Variables。 ...

Nostr event nevent1qqstgmyx92mduxqz8k3ttjfxjq53ztk7qrq3ptufjjdg24zq6k4yzugzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg4qpz9h

#DeFi实盘 2026-08-23 当前市值 168.43，净值 ...

看完了 Crafting Interpreters 第 19 章，Strings。 ...

BOLT12 offer，看来主流客户端都不支持啊。（试了 ...

Nostr event nevent1qqsq8mg4t0q9vnz0flrj9g8p7hvn4f4c5s0pgpyf50hfzlyuv8h5zyczyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wguadcas

看完了 Crafting Interpreters 第 18 章，Types of Values。 ...

感谢 @npub1pd0…gvmz 大佬打赏！😘

看完了 Crafting Interpreters 第 17 章，Compiling ...

今天看完了 Crafting Interpreters 第 16 章，Scanning on ...

试着了解 Solana 链的 ...

Nostr event nevent1qqsvxa5fc362m32dtlhrzdrlm4x658y0tw8zkv58mp3yrj0gt5n85qszyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wgx9aq9u

#DeFi实盘 2026-08-16 当前市值 124.4，净值 ...

Nostr event nevent1qqs9502tgj5g0c07g6j6ezznn92tdud66nskdhcyrfldwkgalsa6w6qzyzggl0pm40pj9m4ywws2k8nt76e6mnufj2y2e9ajlfulxjk5pr2wg2hjfna

Bybit 期权？确实流动性差的很 😂

看完了 Crafting Interpreters 第 15 章，A Virtual Machine。 ...

Closures are poor man's objects and vice versa. ...