FromJavaToHaskell (@to_haskell) profile picture

Software developer. I am learning Haskell and other functional programming languages. Interested in writing performant bug free code. I mostly reply to tweets.

Joined November 2018
Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)Photo by FromJavaToHaskell (@to_haskell)
FromJavaToHaskell retweeted
几乎每一个刚从同步语言转写异步 Rust 的工程师,都踩过同一个隐蔽的深坑:在 async fn 里随手调了一个耗时几十毫秒的同步文件读写、BCrypt 密码哈希或者 std::thread::sleep,结果整个服务的并发尾延迟(P99)瞬间炸穿,连毫不相干的健康检查接口都开始大面积超时。 口头跟团队新人解释“不要阻塞协作式事件循环”总是很抽象,这周 r/learnrust 社区一位开发者直接搓了一个 Tokio 调度器单步可视化显微镜(Step-through Visualizer),把黑盒运行时的内部流转扒得明明白白。 在这个交互式沙盘里,Tokio 的多线程工作窃取(Work-Stealing)调度器被拆解成了可单步回放的慢动作:你可以亲眼看到每个异步 Task 是如何被推进 Worker 线程的本地队列(Local Queue)、如何在遇到 .await I/O 挂起点时毫秒级让出 CPU 槽位; 而一旦你在某个 Task 里注入一行同步阻塞调用,画面上对应的那个 Worker 线程就会像被点穴一样当场焊死——排在它本地队列后面的所有无辜任务全部陷入饥饿停滞,直到其他空闲线程触发跨队列窃取(Steal)才勉强救场。拿这个沙盘演示一遍,比看十篇异步原理长文都管用。
2
8
1
49
6,136
FromJavaToHaskell retweeted
玩本地大模型的人都知道稀疏混合专家模型(MoE)有一个极度拧巴的硬件悖论:在逐词生成的解码(Decode)阶段,因为每个 Token 只激活极少数专家,哪怕权重放在系统内存里也能跑得挺快;但一旦在开头喂入几千字的长提示词进入 预填充(Prefill)阶段,由于上下文中几乎所有专家(Experts)都会被同时唤醒,显存装不下的权重必须跨 PCIe 总线反复搬运,首字等待时间瞬间慢如幻灯片。 这周在 r/LocalLLaMA 引发高度关注的开源推理引擎 Betelgeuse,宣布正式攻克了这个困扰小显存玩家一年的 Out-of-Core MoE 预填充瓶颈。 作者展示了一套在平民级旧硬件上的实测数据:仅用一张 RTX 3060 12GB 显卡 配合 16GB 普通系统内存,去跑体积远超显存容量的 DeepSeek V4.1 Flash Q8_XL(1017) 高精度模型。 Betelgeuse 没有沿用传统按 Token 顺序触发专家加载的笨办法,而是通过按层批次重排专家调度与异步 DMA 流水线:在每一层内部,先将整批输入 Token 命中的所有专家归并去重,流式一次性过卡算完后再进入下一层,彻底消除了跨 PCIe 总线的重复权重抖动。最终在这张百元级 12GB 老卡上,硬生生跑出了 62 tok/s 的预填充速度与 19 tok/s 的解码速度!
21
37
3
416
32,398
FromJavaToHaskell retweeted
we're getting loops for dinner SenseNova-Loop-9B is on par with Qwen 3.8-27B with a looped-architecture and mHC
SenseTime's sensenova-loop-9b weights are now public on Hugging Face. • Open-weight model • Apache 2.0 license
24
41
15
881
45,217
FromJavaToHaskell retweeted
Today I learned ⊃∪∩∈ is a story about set theory.
163
1,652
126
19,958
584,288
FromJavaToHaskell retweeted
Qwen3.8-27B Goes From 82 to 381 Tokens/s on a Single RTX 3090 Qwen3.8-27B reportedly reached 381 tokens/s on a single RTX 3090 with 24GB VRAM. That’s roughly 4.6 times its original throughput, achieved without upgrading the GPU or changing the model. Developer TeksEdge achieved this through a series of inference optimisations involving Multi-Token Prediction (MTP), DFlash2, context lookup, prefix caching and faster verification. The interesting part is that the speedup didn’t come from one magical optimisation. It came from addressing several bottlenecks in the generation pipeline. How the Speed Improved TeksEdge reports the following progression: Standard decoding: 82 tokens/s Optimised MTP: 114 tokens/s DFlash2 + context lookup: 138 tokens/s Optimised lookup verification: 381 tokens/s The final jump is particularly interesting. It suggests that a significant amount of inference time can be recovered when the system reuses information and verifies multiple proposed tokens efficiently. Here’s how the individual techniques work. 1. Speculative Decoding Reduces Sequential Generation Most language models generate text autoregressively. They predict one token, feed it back into the model and then predict the next. This creates a sequential bottleneck because each generation step depends on the previous one. Speculative decoding attempts to reduce that overhead. A smaller drafting process proposes several future tokens, while the main model checks whether those predictions are correct. When multiple proposed tokens are accepted, the target model can advance several positions through a verification cycle rather than performing a separate generation step for every token. In this experiment, optimised MTP increased throughput from 82 to 114 tokens/s. Combining DFlash2 with context lookup pushed it further to 138 tokens/s. The acceptance rate is important here. More proposed tokens don’t guarantee more generated tokens. The target model must still verify them, and rejected proposals reduce the speed advantage. 2. Context Lookup Reuses Text Already Available This is one of the most interesting parts of the experiment. When a model is asked to reproduce or transform information already contained in its prompt, generating every token from scratch can be wasteful. Context lookup searches the existing input for matching sequences and proposes those tokens for verification. Instead of predicting an entire passage again, the inference engine can reuse matching text and ask the target model to verify it. TeksEdge reports lookup blocks of up to 16 tokens, with approximately 15 accepted tokens per block in its workflow. In a 25,000-token document reproduction test, throughput reportedly increased from around 260 to 382 tokens/s This approach is particularly useful for: Reproducing long documents Restructuring existing text Copying or transforming code Reusing information already present in the prompt However, it works best when the output overlaps significantly with the input. An open-ended conversation or a task requiring entirely new information offers fewer opportunities for context reuse 3. Prefix Caching Eliminates Repeated Computation Coding agents often send repeated instructions, tool definitions and repository context across multiple requests Without caching, the inference engine may repeatedly process large sections of an unchanged prompt Prefix caching addresses this by storing computations associated with previously processed prompt prefixes When a new request contains the same prefix, the engine can reuse the cached computation instead of starting from scratch TeksEdge reports reducing time to first token from 22.4 seconds to just 0.56 seconds That’s approximately a 40-fold reduction in initial waiting time For coding agents that repeatedly inspect files, call tools and submit follow-up requests, this can make a substantial difference 381 Tokens/s Isn’t Ordinary Chat Speed
11
19
4
157
34,073
FromJavaToHaskell retweeted
Qwen announces smaller Qwen4 models will be released soon! 🔥 Qwen4-27B will run on 16GB RAM setups.
📢 Meet Qwen4-Max, your new AI teammate for work, creativity, and discovery! Qwen4-Max is built on a new MoE architecture with native vision and a 1M-token context window. Highlights: - Outperforms Qwen3.8-Max with up to ~50% fewer tokens, while average cost per task drops over 60% in our internal evaluation. - Advances real-world productivity through greater proficiency with professional tools, stronger long-horizon execution, and higher-quality deliverables. - Handles real tasks, including 3D modeling, game development, manufacturing, finance, law, healthcare, and frontier scientific discovery. - $1.5/M tokens for input, $4.5/M tokens for output, and $0.075/M tokens for implicit caching — all lower than Qwen3.8-Max, with implicit caching down by 70%. The API is live on QwenCloud. You can also try Qwen4-Max on Qwen Studio, QwenWork and Qoder. Start building today! 🚀 - Blog: qwen.ai/blog?id=qwen4-max - API: qwencloud.com/models/qwen4-m… - Token Plan: qwencloud.com/pricing/token-… More to come! The open weights of smaller Qwen4 models will be released. Stay tuned. 👀
261
537
150
6,080
446,410
FromJavaToHaskell retweeted
If anyone needs to do accurate academic paper -> PDF parsing then I've released an experimental hybrid Nemotron/VLLM/PDF parser anil.recoil.org/notes/parsos… (I need this for a bazillion PDFs we have locally for)
1
5
42
1,321
FromJavaToHaskell retweeted
I asked Fable 5.2 to "go wild" making a game, and all I got was this Pong clone. And then I played it ... 👇
380
372
284
3,107
416,651
FromJavaToHaskell retweeted
Now you can really see everything
my vocal synth models the vocal tract as a network of branching acoustic tubes, unlike vocaloid which stitches together and pitch-shifts phoneme recordings. still working on improving naturalness by tuning it against recordings of real singers, but I'm already impressed at how cool it sounds!
199
853
160
10,038
650,680
FromJavaToHaskell retweeted
你现在打开 Mac 终端敲一行 man 8 knowledgeconstructiond,会看到一段只有寥寥几行的系统守护进程说明。 安全研究员 Dario Pasquini 和 Michał Bazyli 刚把这玩意儿连同它的搭档 intelligenceplatformd 彻底扒了一遍(今天直接冲上 HN 榜一):从 macOS 13 到现在的 macOS 26,每台 Mac 都在后台静默维护着一个名叫 ~/Library/IntelligencePlatform 的目录,里面躺着 51 个明文 SQLite 数据库。 最核心的 graph.db 是一个包含 181 种实体类、278 种谓词关系 的本地个人知识图谱(Personal Knowledge Graph)。它把你机器上的通讯录、相册人脸聚类、日历参与者、邮件与 iMessage 通联记录、医疗急救卡、家庭共享(含年龄)、位置轨迹甚至屏幕锁屏与环境光信号全绑在了一起。 拆解里最让人后背发凉的有三个细节: 1. 内置的「亲属关系打分器(Kinship Scorecard)」 哪怕你从来没在通讯录里填过谁是谁,守护进程也会跑一套 9 维交叉校验(近 12 个月最高频联系人、相册双人同框聚类、家庭共享 Token、紧急联系人、通话方向等),按 0.125、0.25、0.5、0.960 四档离散置信度,在表里默默给你的联系人打上 mother、father、partner、sibling、child 和 colleague 标签。在作者拆解的真机里,哪怕伴侣列是空的,联合查询依然精准把伴侣兼同事筛了出来。 2. 纯靠相册就能画出的社交隔离网 它的相册共现图(Face Co-occurrence Graph)完全不需要读一条短信或通讯录。光靠扫描 1,643 张多人照片里「谁和谁同框过」,就把机主左侧的家庭圈和右下角的同事圈分得泾渭分明——这两个圈子在物理空间里从来没有同框过一次。 3. 不存一句聊天正文,照样算出你几点睡觉 通信日志表里只存元数据(谁、几点、哪个 App、收还是发,0 正文)。但只要把这张表按「星期 × 24 小时」折叠成热力图,每天凌晨 1 点到 7 点那条雷打不动的空白带,就是你的真实作息表。 苹果做这套端侧图谱的初衷是给 Apple Intelligence 和 Siri 喂上下文,而且目录受 TCC 完全磁盘访问权限保护;但研究员指出,这也意味着你的 Mac 本地多了一个 「隐私单点故障(Privacy Single Point of Failure)」——一旦任何第三方软件或 Agent 拿到了 Full Disk Access,根本不需要自己去爬邮件和照片,直接读走这个现成的 graph.db,你全家的社会关系网就裸奔了。 作者顺手开源了一个零依赖(纯 Python 标准库、只绑本地 127.0.0.1、不联网)的可视化面板 iKnow,给终端授个权就能在浏览器里看你的 Mac 到底把身边人分成了什么关系。
3
2
26
3,382
FromJavaToHaskell retweeted
这个跟Jensen出轨的Alice我很熟悉,经常在密码学文章里见到她和一个叫Bob的把机密信息传来传去,应该是间谍
58
518
46
5,731
199,560
FromJavaToHaskell retweeted
Both @OpenAI and @AnthropicAI have started flagging #Rocq proofs generation as problematic. Someone needs to explain them that generating .v files has never hacked anyone.
11
22
6
163
20,182
FromJavaToHaskell retweeted
THIS IS HUGE !! Now you can run Qwen3.8-27B even faster !! @TencentHunyuan just released DSpine for Qwen3.8-27B and it beats DFlash2 really well. I ported this to llama.cpp and have created ggufs for it, find all my drafters in my hf link below. Since it's not supported in upstream llama.cpp, you can clone my updated fork and give it a spin. - Baseline: 28.2 tok/s - DFlash2: 50.6 tok/s. - DSpine: 94–132 tok/s DSpine's lead over DFlash2 is about 1.75x either way. DSpine predicts more tokens per verify step on math and code (7.3–7.6 vs 5.7–5.8), which is where its big wins come from. github.com/Ajay9o9/llama.cpp… All information is provided on model card. huggingface.co/aj9o9/Qwen3.8…
54
62
12
817
70,029
FromJavaToHaskell retweeted
I only make serious software
653
5,464
992
48,336
5,122,910
FromJavaToHaskell retweeted
No wonder when I typed my 257 character password I always got it right on the first try
6
34
1
944
20,644
FromJavaToHaskell retweeted
I could watch this all day long
399
7,865
315
148,546
12,309,885
FromJavaToHaskell retweeted
俯仰流年三十秋,方悟此身难自由。
4
12
74
2,579
FromJavaToHaskell retweeted
Good morning, we escaped the famous Firecracker VM and got root execution on the host. Full firecracker escape technical writeup and Proof of Concept code attached below.
34
151
69
1,037
125,912
FromJavaToHaskell retweeted
Adapted this one into a text clock with a group of hand cursors pulling the strings literally.
7
11
2
215
15,889