Posts on Code Now

DeepSeek's Attention Evolution - [DSA, CSA, CSA2]

Thu, 01 Oct 2026 20:30:00 +0800

Note | Preface

This is the second post in the DeepSeek Attention evolution series. The previous one, DeepSeek’s Attention Evolution -【MLA】, covered the evolution from MHA to MLA; this post picks up with DSA, CSA and CSA2. MLA solved the storage form of the KVCache, but its compute complexity is still $O(N^2)$ and the KVCache is still $O(N)$, so it still struggles with 256K/1M long contexts. This post follows the DeepSeek V3.2-exp → V4 → V4.1-Flash line to see how it pushes the algorithmic and engineering tradeoffs to the limit, step by step, across sparse attention, KV compression and cross-layer sharing.

DeepSeek's attention evolution - [MLA]

Tue, 15 Sep 2026 23:30:00 +0800

Foreword: After reading the DeepSeekV4.1 paper and seeing that DeepSeek had once again made major changes to the model architecture, I was quite excited. So I looked back at DeepSeek’s incremental improvements to the model architecture and wrote this series of articles in the gaps while waiting for agents to finish running and slacking off at work — a summary of what I’ve learned about model architectures over the year since I moved into AI Infra.

[Model Inference] A Brief Look at CUDA Graph

Mon, 20 Apr 2026 04:27:43 +0000

CUDA Graph is probably one of the most frequently mentioned features in inference optimization. The principle isn’t complicated: package the kernels that were originally launched one at a time into a static graph, hand the whole thing to the GPU in one shot, and skip the scheduling overhead in between.

But how exactly does this “packaging” work? How do you use it in PyTorch? And most importantly — how much faster is it actually on an H200?

How to make Hugo support infographic

Tue, 06 Jan 2026 03:33:16 +0000

Introduction

infographic is a new component from Ant Group’s AntV team. Its goal is to provide easier-to-use visualization tools for AI, positioned similarly to mermaid. It offers a DSL that is easy for developers and AI to use: by quickly writing DSL, you can rapidly visualize all kinds of charts, such as line charts and pie charts, and you can also visualize tools like grid diagrams and SWOT diagrams that are typically needed in PPTs. It is very easy to use. So I wanted to bring it into my Hugo blog, and be able to quickly visualize my ideas through infographic in a markdown code block.

LLM Life from Scratch: How to Write an Agent

Tue, 27 May 2025 16:04:10 +0000

This article aims to explain what an LLM Agent is in plain language and to implement a simple Agent in Python.

1. Introduction to Agents

1.1 What Is an Agent?

There is no precise definition of an LLM Agent, but one core characteristic stands out:

An LLM serves as the main controller or “brain” that controls a flow of operations needed to complete a task or user request. —《Prompt Engineering Guide》

LLM Agent Programming from Scratch: The MCP Edition

Mon, 21 Apr 2025 08:23:57 +0000

1. What Is MCP (Model Context Protocol)

MCP (Model Context Protocol) is a communication protocol launched and open-sourced by Anthropic in 2024, designed to solve the connection problem between large language models (LLMs) and external data sources and tools. It defines the protocol for communication between the Model and external interfaces/data/Prompts. Tool/resource providers only need to implement the MCP protocol to connect with an LLM APP that implements an MCP client. During runtime, the LLM APP automatically retrieves the tool list/Prompt/resource list returned by the protocol from the MCP server via JsonRpc.

Data System Design Explained to My Wife: ACID Transactions

Sun, 09 Mar 2025 16:16:44 +0000

Why transactions exist

“In the harsh reality of data systems, many things can go wrong:

The database software or hardware may fail at any moment (including in the middle of a write operation).

The application may crash at any moment (including in the middle of a series of operations).

Network interruptions may unexpectedly cut the connection between the database and the application, or between databases.

Multiple clients may write to the database at the same time, overwriting each other’s changes.

A client may read nonsensical data because the data was only partially updated.

Race conditions between clients may cause surprising errors.” — Designing Data-Intensive Applications

In concurrent programming, we often care about the correctness of multiple threads/processes/coroutines modifying the same block of memory, and we solve this with atomic variables and locks to implement critical sections. In real life and in development, however, it’s more often the case that an actor completes a task through a series of operations, and here too we want something like an atomic variable to protect that series of operations, preventing unexpected situations when multiple actors operate at once.

EM Algorithm Notes

Tue, 14 Apr 2020 17:57:00 +0000

I recently ran into the EM algorithm again. Too often I just use something without knowing why, so this time, before using it, I went back and read up on it some more.

Where the EM algorithm applies: maximum likelihood estimation of the parameters of a probabilistic model that has hidden variables.

First question: what is a hidden variable?

Latent Variables

Something that cannot be directly observed, but that influences the state of the system and the outputs that can be observed. It refers to an unobservable random variable. Latent variables can be inferred from observed data by using a mathematical model.

Python Basics: Decorators

Fri, 20 Mar 2020 16:54:00 +0000

A decorator is a callable object whose argument is another function (the decorated function). The decorator may process the decorated function and then return it, or replace it with another function or callable object.

1@test
2def target():
3 print("run target function!")

It works the same as the following code

1def target():
2 print("run target function!")
3target = test(target) # In the test function, the function will be enhanced or replaced

Function decorators run at import time, while the decorated function only runs when it is explicitly called.

[Python Basics] Namespaces, Scope, and Closures

Fri, 20 Mar 2020 16:53:00 +0000

A namespace is a mapping from names to objects. Most namespaces are currently implemented as Python dictionaries, but that’s normally not noticeable in any way (except for performance), and it may change in the future.

Namespaces are an important structure for avoiding name collisions. Namespaces are dynamic: they come into being as the interpreter executes, and they are maintained throughout the life of the program.

Namespaces:

Built-in namespace: the namespace that comes with the Python interpreter as soon as it starts, and stops when the Python interpreter ends.
Global namespace: the set of global names of a Python module — names defined directly in the module, such as classes, functions, other imported modules, and so on. Destroyed when the interpreter exits.
Local namespace: the namespace inside a function or a class. It is created when a function is called, and deleted when the function returns or raises an error that is not handled inside the function.
The attribute namespace of an object
Class namespace

Scope

A scope is a textual region of a Python program where a namespace is directly accessible. “Directly accessible” here means that an unqualified reference to a name attempts to find the name in the namespace.

Inversions in an array

Tue, 10 Mar 2020 18:11:00 +0000

Interview Question 51. Inversions in an Array Given two numbers in an array, if the earlier number is greater than the later one, the two numbers form an inversion. Given an array, find the total number of inversions in it.

Example 1:

Input: [7,5,6,4]
Output: 5

Constraints: 0 <= array length <= 50000

Approach

Brute-force solution

Just scan it mindlessly

 1class Solution {
 2public:
 3 int reversePairs(vector<int>& nums) {
 4 if (nums.size() == 0)
 5 return 0;
 6 int sum = 0;
 7 for (int i = 0; i < nums.size() - 1; ++i) {
 8 for (int j = i+1; j < nums.size(); ++j) {
 9 if (nums[i] > nums[j])
10 sum++;
11 }
12 }
13 return sum;
14 }
15};

Time complexity $O(n^2)$, space complexity $O(1)$

Fenwick Tree (Binary Indexed)

Tue, 10 Mar 2020 17:30:00 +0000

First, many thanks to the Bilibili creator 鹤翔万里 for the video; I recommend watching https://www.bilibili.com/video/av69667943?from=search&seid=10916758362943551299. This article is a summary I wrote for the 算法笔记 collection accompanying that video.

Problem setup: given an array of length n, support the following two operations

Output the sum of every number in the interval [x, y]
Add k to the x-th number

The most basic algorithm:

Maintain an array sum, where sum[i] stores the sum from 0 to i. Its recurrence relation is sum[i] = sum[i-1] + nums[i], where sum[0] = nums[0].
The interval sum can then be computed using sum_xy = sum[y] - sum[x-1].
To add v to the x-th number, since all values of sum[x]...sum[n] must be updated, the time complexity is $O(n)$
If k operations are performed, add, then the time complexity is $O(kn)$, and the time complexity of k interval-sum queries is $O(k)$

In many scenarios with frequent updates, the $O(kn)$ time complexity is unacceptable.