pjcscoder

[Jesús Espino @jespinog]

My article about Cgroups is out.

Namespaces make a container see its own little world, but nothing stops it from eating every CPU core and every byte of RAM. That's the job of cgroups: namespaces change what a process can see, cgroups limit how much it can use.

In this article we explore an example of how cgroups work from the interface, to how is represented internally in the code, and even going through the process of a simple cgroup limit.

You can take a look here: https://t.co/Qbwlo9QsuI

#Linux #Containers #Cgroups

[lsm_ @thisispiyushK]

Wrote a new blog on GPU comms with a lot of SGLang internals.

[Tanel Poder 🇺🇦 @TanelPoder]

For io_uring nerds...

uringscope: eBPF tracer and analyzer for io_uring. Reconstructs per-request latency, io-wq punts, and batching from kernel tracepoints, then names the problem and suggests a fix.

https://t.co/hzXyjbu3ov

[Mashood K @fromcodetocloud]

A lot of infrastructure problems are networking problems wearing a different costume.

These 6 resources can help you build stronger networking fundamentals:

1. Beej's Guide to Network Concepts: https://t.co/JJpJ8YHBJF

2. Cloudflare Learning Center: https://t.co/y7R4lcwzEZ

3. Computer Networking: Principles, Protocols and Practice: https://t.co/XF4UxMGR23

4. Wireshark User's Guide: https://t.co/8c31M6qZ9f

5. Practical Networking: https://t.co/XFIK5Crf9Y

6. OverTheWire Bandit: https://t.co/Vtyo7a6KLq

Learn DNS, TCP, routing, TLS, ports and packet analysis.

Then troubleshoot a real connection failure using `dig`, `curl`, `ss` and Wireshark.

That's how networking knowledge starts paying off in DevOps.

[Gergely Orosz @GergelyOrosz]

Finding it very educational and interesting to learn about the hardware layer of GPUs: how they are structured, the obvious advantages and disadvantages bs CPUs.

This is from Modal’s excellent “GPU Glossary” print book @can gave me (the PDF is free here: https://t.co/ltzxXm1GSi)

[Jesús Espino @jespinog]

Did you know?

https://t.co/HIfp7Nbpwa

[GitHubDaily @GitHub_Daily]

Ilya 推荐过一份 30 篇的 AI 论文清单，说真读懂了这些，就懂了当下 AI 90% 的要点。

不少人都存过，可真打开第一篇，满屏公式就读不下去了。

30u30 把这份清单拆成了 30 天的课，一天啃一篇，从 RNN、LSTM 一路学到 Transformer，最后落在 ChatGPT 背后的 RLHF。

GitHub：https://t.co/0RJTmmwJVE

每篇都有一份大白话讲解，外加一页「讲给 5 岁小孩听」的速览，再从零把代码写一遍，配图看着学。

每天还有 5 道练习题，答案也附上了。代码在普通电脑的 CPU 上就能跑，几分钟出结果。

一天一篇、读完就动手写，这个节奏我觉得比对着原文硬啃靠谱多了。

想转 AI 方向的学生，或者用了很久 ChatGPT、想弄明白背后原理的，可以从第一天开始跟。

[Vivek Galatage @vivekgalatage]

Enter into the world of CPU

https://t.co/7aFQgcEzKD

[Math Cafe @Riazi_Cafe_en]

MIT's "Artificial Intelligence" (6.034)
by Patrick Winston

Covers search, learning, neural nets & probabilistic inference.

Course website: https://t.co/AIitDdkcXL
Videos: https://t.co/kfuvOQWL1x

[Antonio Lupetti @antoniolupetti]

"Mathematical Theory of the Transformer" is an extensive, 825-page mathematical monograph exploring the theoretical foundations of Transformer architectures.

It covers a remarkable range of topics, including embeddings and positional encoding, self-attention and multi-head attention, matrix decompositions, linear algebra, spectral analysis, information geometry, training dynamics, redundancy, optimization, and incremental Transformer architectures.

This is an advanced, mathematically rigorous read for anyone interested in understanding the mathematical structures underlying Transformer-based AI systems, including modern generative AI.

https://t.co/wwa1ucTYiF

[纳米AI @antiAIvo]

整理了《从零手写大模型之从GPT-2到LLaMA》学习教程

GPT-2到LLaMA，中间隔了4年
最关键的改动，集中在4个零件上
手写完GPT-2之后，我一直卡在一个问题上：
2019年的GPT-2
和今天的LLaMA、Qwen、DeepSeek，到底差在哪？

带着这个问题，我把LLaMA的结构拆开
一个零件一个零件对着GPT-2去学
学下来发现，骨架还是那个Transformer
真正变的是几个关键零件

每一篇都用同一个小例子“猫吃鱼”贯穿到底
数字小到可以手算，配套代码也能直接跑
看完可以自己跟着练一遍

最后整理成了这5篇：
01 RMSNorm：简化归一化
02 SwiGLU：升级前馈网络
03 RoPE：旋转位置编码
04 GQA：分组查询注意力
05 LLaMA：组装完整模型

对我自己来说，这一段是承上启下：
手写GPT-2，让我搞懂了Transformer怎么跑
学完零件替换，才算明白现代大模型为什么长这样

整理好的完整版放在这里
如果你也是从GPT-2入门的，可以直接接着看：
https://t.co/RBKakC5da6

[Mashood K @fromcodetocloud]

FORGET TOY PROJECTS FOR A MOMENT

These 7 GitHub repositories can help you understand how real engineering systems are built.

1. Kubernetes https://t.co/f6WB613LPA

2. Prometheus https://t.co/mkM23Rrjrj

3. Cilium
https://t.co/VM8r4z0OBf

4. Envoy
https://t.co/VXBjEOzzDf

5. Backstage https://t.co/HAGce7Amc2

6. Argo CD
https://t.co/OwpC1wKpfF

7. OpenTelemetry Collector
https://t.co/PKuwTdUJtV

Here's the trick:

Don't try to understand the entire codebase.

Pick one component, trace how a request flows through it, and follow the code.

Reading production code is a skill worth developing.

[meng shao @shao__meng]

斯坦福新课 CME 295：Transformers & Large Language Models

@stanfordnlp 双胞胎兄弟（Afshine & Shervine Amidi @afshinea @shervinea 的课程已经来到了第四讲：
Reinforcement learning with LLMs

视频和讲义都公开了：
https://t.co/mVogPIzyiH
https://t.co/nB1wGBz1t1

这一讲，从 RL、Reward Design 一直降到 PPO、GRPO、RLVR 和 DAPO，把每个符号都讲清楚了，非常适合用来系统补充 RL 知识！

[meng shao @shao__meng]

MIT 课程 MAS.S62「How to AI an AI」：提示优化、Harness 演化、模型自博弈与任务生成四层演化

@pliang279 老师的 Lecture 4-5 连续两讲「Harness evolution」强烈建议阅读学习，分别覆盖了 Harness Evolution（harness 组件、记忆、工具与技能演化）和 Multi-Agent Evolution（规划、任务分解、多 agent 系统与演化）

# Lecture 4：先给 Harness 做解剖，再谈让它演化
https://t.co/4emiLkozt1

课程把 Harness 解剖为五个组件，这个框架贯穿两讲：
· Context：提示、记忆、检索信息
· Control：规划、路由、多 agent 编排
· Action：工具、技能、RAG、API、环境
· Evaluation：验证、安全、人类反馈
· Evolution：反思、更新、学习

记忆部分：一张三轴分类法 + 四个代表系统
讲义用三个轴组织整个记忆研究空间：存什么（反馈/技能/轨迹/语义事实）、如何表示（文本/结构化/多模态/参数）、存在哪里（上下文/参数/外部），外加如何复用（检索/改编/组合/迁移）。

然后沿“存在哪里”排布了四个系统：
· @MemGPT（外部记忆）：把 LLM 类比为操作系统，记忆的读写变成 agent 自己的函数调用；
· @mem0ai（外部记忆）：记忆结构化为实体-关系三元组图，支持 add/update/delete/noop 四种操作；
· MEM1（上下文内记忆，授课者自己组的工作）：这是本讲着墨最多的部分。针对“推理上下文不断增长导致复杂度与遗忘”的问题，MEM1 让模型每步生成一个整合了推理与记忆的内部状态，然后丢弃全部历史；上下文大小恒定，且可用结果奖励端到端训练模型学会“压缩”。实验展示了三个涌现行为：分类存储每个问题的关键信息、答完一题先更新记忆再进入下一题、多次搜索无果后学会跳过该题。这些行为没有任何一个是显式编程的。
· Reflexion / ExpeL（经验化记忆）：轨迹存短期记忆、自我反思存长期记忆；ExpeL 进一步把“这条经验是否有用”的反馈也存进去。

Context Language Models（CLM） 是记忆部分的收束：让模型把自己的整个上下文当作一个文件，用 Bash 命令随意编辑，编辑与真实上下文同步；创建/删除上下文文件即可实例化/终止子 agent；记忆、上下文管理和多 agent 结构被统一成“文件操作”。

工具与 Skills 部分：从 Toolformer 到 Meta-Harness
谱系是：Toolformer（模型自学单步工具调用）→ ToolLLM（扩展到多步、16000+ API）→ CodeAct（关键论断：代码是元工具，一次动作即可组合控制流、库与多次操作，实验显示用代码做工具调用成功率最高、交互轮数最少）→ Skills 层：Skills 可以表示为文本或代码（后者更可组合）、可作为代码中的抽象类（PolySkill）、可从成功与失败的轨迹中归纳为可复用工作流（Agent Workflow Memory）→ Voyager 的 Skills 库（自动课程生成 + 环境反馈 + Skills 归纳进库）。

压轴的 Meta-Harness 把整讲推向顶点：现有 LLM 优化方法只给优化器看“简短摘要、标量分数、部分历史候选”，而 harness 复杂得多。Meta-Harness 把整个 harness 表示为文件系统，完整源代码、分数、全部执行轨迹都放在里面，让 proposer（Claude Code，用 grep/cat 阅读）把失败回溯到具体的 harness 决策上，反馈信息量是 prior 方法的近 400 倍（1000 万 token 对 2.6 万）。提示、RAG、Skills、工具、记忆、程序循环全部统一为文件系统中可优化的对象。

本讲最重要的一页：抽象阶梯
最后一页总结是全讲义的精华，Liang 老师点出他最欣赏的三个方法共享同一模式：
· MEM1：把记忆当作上下文中的内部状态，由 LLM 自主更新
· CLM：把整个上下文当作持久文件，由 LLM 自主维护改写
· Meta-Harness：把整个 harness 当作文件系统，由 LLM 自主修改

共同点：简单、无手工设计、端到端；可自主优化的对象沿“记忆 → 上下文 → harness”不断升维；且同一范式在 zero-shot、上下文学习、微调三种模式下都可扩展。这是整门课“自演化”思想最凝练的表达：不让 AI 在某一点上变强，不断扩大“什么是可以被 AI 自己改写的”边界。

# Lecture 5：从规划到多 Agent，把玄学变成实证科学
https://t.co/9MfFAfLJV3

规划部分：三个关键问题
讲义先明确规划的核心问题：规划何时有用、何时有害？计划如何表示？何时该改计划？ 结论清晰：基于提示的规划（CoT、Least-to-Most）适用于纯文本、无副作用、可回退的场景；一旦计划作用于真实世界、改变 agent 状态、不可逆，就必须“规划-执行-观察-重规划”。后续案例展示了谱系：大小模型分工（大模型规划 + 7B 模型执行 GUI 动作）、人在回路的不确定性澄清、合成数据训练规划器、采样多条计划估计不确定性（校准规划）、以及“Thinking vs Doing”，测试时不只是想，而是真实执行、看反馈、再重试。

多 Agent 部分：五条实证发现
这部分以 Towards a Science of Scaling Agent Systems（Nature Machine Intelligence 2026）为主线，讲义没有停留在“多 agent 更强大”的流行叙事，而给出五条冷静的实证结论：
1. 多 agent 只对特定任务结构有效。金融 agent 任务天然可分解（收入/成本/市场），MAS 赢 81%；PlanCraft 类任务有强顺序依赖，拆分反而伤害，MAS 输 70%。指南：可并行 → 集中式；需探索 → 去中心化；顺序依赖 → 单 agent。
2. 收益随基座模型而异：OpenAI 模型成本增加性能却平台化；Google 模型成本高性能高；Anthropic 模型上 MAS 甚至可能伤害性能。
3. agent 数量越多不一定越好：工具密集型任务（16 个工具的工作流）受协调开销拖累，且惩罚随环境复杂度复利式累积。
4. 异构混合可以打败更强的单一基座：不需要处处用贵模型，“廉价编排器 + 昂贵执行子 agent”是好用配置；且若单 agent 基线已超 45%，MAS 反而有害。
5. 性能可预测：以模型、任务、MAS 配置为参数的 scaling law 能以 87% 的准确率预测最优架构，从“碰运气试配置”走向 agent 设计的原则性科学。

这五条与阅读清单里的 "Why Do Multi-Agent LLM Systems Fail?" 一起，构成课程对多 agent 热潮的实证纠偏。

多 Agent 演化：CORAL
既然多 agent 的设计空间（任务、基座、拓扑）如此敏感，下一步就是让它自主演化；可以演化的对象有三个层次：个体 agent（模型/上下文/harness）、系统结构（角色/通信/拓扑）、共享信息（公共记忆/工具/Skills）。代表工作 CORAL（正是本课 TA Ao Qu 的一作论文）：多 agent 专业化、高度自主、共享记忆、心跳机制维持持续运行；在数学、算法、系统优化等 8 个任务上取得新 SOTA，多 agent 演化比单 agent 带来 4%–20% 提升。其分析回答了“为什么共同演化有用”：36% 的演化尝试以其他 agent 为父节点，这些尝试的改进率 17%（平均仅 9%）；跨 agent 的信息转移是收益的真实来源；各 agent 探索方向重叠度低（Jaccard 0.3–0.4，一半以上探索是独特的）；贡献均衡，无搭便车者。

# 两讲放到一起看：自主优化的边界在哪里？

第四讲沿“对象升维”推进：记忆 → 上下文 → 整个 harness（文件 → 文件系统），每一级都是把更大的一块系统交给 LLM 自主改写；

第五讲沿“系统升维”推进：个体 agent 的规划 → 多 agent 编排 → 多 agent 系统本身的演化（角色/拓扑/共享记忆），每一级都是把更大的设计空间交给自主搜索。

而两讲都保持着同一分批判克制：第四讲强调“简单、无手工设计、端到端”才可扩展，第五讲用五条实证发现反复提醒“多 agent 不是免费午餐”。先建立严格的分类学与实证规律，再把剩余的设计空间交给自主演化，这既是这两讲的教学结构，也是这门课对“如何研究自演化 AI”这一元问题给出的方法论答案。

[Aritra 🤗 @ariG23498]

If you want to write compute kernels and distribute them to the whole wide world, we have a doc for you.

https://t.co/HbY3NVy0ma 😎

[DeepSeek @deepseek_ai]

🚀 Introducing DeepInfer, our in-house inference framework, now fully open source!

Powering DeepSeek-V4.1-Flash at scale with high throughput and low latency. We’re sharing our production stack to help the community lower compute costs, reduce energy use, and make AI more affordable.

🔗 https://t.co/JGAik1kgk0

1/4

[Tianyi Cui @tianyi]

DeepSeek just open sourced its high-performance, large-scale inference framework DeepInfer in Apache-2.0 license.

https://t.co/W2cfi6O9LO

Supported features:

- Optimized kernels, model and sampler runtime
- Parallelism: Attention DP / balanced CP, MoE EP + EPLB
- DSpark and confidence-scheduled verification
- SWA bounded replay
- Asynchronous scheduling (zero-overhead batch scheduler)
- Batch-invariant inference
- Deterministic sampling
- Structured output

[Linux Inside: The Ideal Blog for Sysadmins & Geeks @tecmint]

In Chapter 6 of our #Linux for #DevOps course, you'll learn how to manage team SSH keys from a single source of truth, secure an automation key with `restrict` and `from=`, rotate a lost key, and fix common SSH permission errors.

Read the chapter: https://t.co/3I6lBUDXPH

Follow @tecmint to get notified whenever a new chapter is released.

[Shubham Mishra 🐐 @shubh6200]

I was reading this paper on Amazon MemoryDB and just finished it. One of the things I love about reading systems papers is that you go in curious about a technology and come out appreciating the engineering decisions behind it.

Amazon MemoryDB: A Fast and Durable Memory-First Cloud Database -
https://t.co/KSy1mPk7PC

The question that caught my attention was this: how do you build something that takes advantage of the speed of memory without compromising on durability?

RAM is incredibly fast, but it's volatile. Building a database that is fast is one thing. Making sure it can recover from failures, preserve committed data, and remain highly available is a whole different challenge.

MemoryDB approaches this by using Redis as its in-memory engine and a separate, distributed transaction log for durability.

What I found interesting is the thinking behind the architecture. It's not just about squeezing out more performance; it's about deciding which responsibilities belong where and understanding the trade-offs that come with those decisions.

That led me to explore this AWS collection on in-memory databases, which connects some of these ideas to real-world systems:

A few resources I'm adding to my reading list:

→ Yahoo: Processing 1.3 million advertising events per second
https://t.co/hlTYGKmAC1

→ Building real-time applications with Amazon MemoryDB
https://t.co/iYBDjXgLMa

→ Samsung SmartThings and Amazon MemoryDB
https://t.co/9mpTNMDlV3

→ Amazon ElastiCache learning resources
https://t.co/uFIO9WW4zQ

Here's the full AWS roundup that brought these resources together:
https://t.co/5eFy0Lqyli

I always find it worthwhile to read the paper first and then look at how the ideas translate into actual systems. The theory becomes much more interesting when you start thinking about the failures, workloads, and constraints engineers have to deal with in production.
If you're interested in databases or distributed systems, I'd recommend giving the paper a read. It's a good reminder that some of the most interesting engineering work happens in the decisions users never see.

#DistributedSystems #Databases #SystemDesign #AWS

[Ren @Ryrenz]

🗂️ 学 Linux 不用自己从头整理笔记了，linux-basics-for-hackers-notes 把 18 个模块从终端基础一路理到内核模块。

GitHub 上 1833 star，底子是 No Starch Press 出的《Linux Basics for Hackers》，作者 OccupyTheWeb，这套笔记是记录者自己边做实验边记的，最早写在 Obsidian 里，后来才整理成现在这套结构。

对着书学这类东西最容易卡的不是看不懂，是合上书就不知道该敲什么。linux-basics-for-hackers-notes 每个模块都是同一个骨架：先用大白话把概念讲明白，再给命令示例，接着一张速查表，配上图解，最后留练习题。权限、命令管道、文件系统树、内核空间这些光读文字很难有画面的地方，干脆都画成了结构图。

模块顺序也是照真实学习路线铺的：先把实验环境搭起来，再练终端和文本处理，往后才是网络管理、软件包、权限、进程和 Bash 脚本，最后才压到无线网络和可加载内核模块这些硬的。想练手也不用自己找题，笔记里列了 OverTheWire 的 Bandit、TryHackMe 的 Linux Fundamentals、CMD Challenge 这些免费的靶场。

有一点得说清楚：这份资料自己写明只作教育用途，练习都应该在自己的实验环境里做。

打基础这件事没有捷径，但有人把路铺平了。

GitHub：https://t.co/MH7BTNWDum