No problem can be solved at the same level of thinking that created it.¹ — “Albert Einstein”

Consistency Challenge

The first time I ran into X Macros was while debugging an out-of-bounds access issue.

Here is a simplified example:

// a.h
typedef enum {
    SYS_OK,
    SYS_ERR_TIMEOUT,
    SYS_ERR_BUSY,
    SYS_ERR_INVALID_ARG,
    SYS_ERR_NOT_FOUND
} SysState;

// a.c
const char *state_desc[] = {
    [SYS_OK] = "System OK",
    [SYS_ERR_TIMEOUT] = "Timeout",
    [SYS_ERR_BUSY] = "System Busy",
    [SYS_ERR_INVALID_ARG] = "Invalid Argument"
    // SYS_ERR_NOT_FOUND is missing here
};

int main()
{
    printf("State = %s\n", state_desc[SYS_ERR_NOT_FOUND]);
}

The issue is easy to spot: SYS_ERR_NOT_FOUND was added to the enum, but the string table was not updated.

When the program evaluates state_desc[SYS_ERR_NOT_FOUND], it reads past the end of the array and eventually crashes.

Of course, we could fix this by adding the missing entry to the string table. But that only fixes this specific bug — it does not prevent the same type of problem from happening again.

The underlying issue is that we are maintaining two pieces of information that must always stay consistent:

• the enum definition
• the string table

As long as these are maintained separately and rely on manual synchronization, mistakes like this are inevitable.

What we really need is a way to eliminate this class of problems entirely.

X Macros

While looking for a solution, I came across an article by Randy Meyers published in Dr. Dobb’s Journal titled The New C: X Macros ². The article introduces a technique that uses the C preprocessor to generate code from a single data definition.

This technique is commonly known as X Macros.

The idea is simple: maintain a single data list, and generate the necessary code structures by redefining a macro.

Let’s modify the previous example to see how this works.

First, define a Single source of truth:

#define SYS_STATE_LIST                         \
    X(SYS_OK,              "System OK")        \
    X(SYS_ERR_TIMEOUT,     "Timeout")          \
    X(SYS_ERR_BUSY,        "System Busy")      \
    X(SYS_ERR_INVALID_ARG, "Invalid Argument") \
    X(SYS_ERR_NOT_FOUND,   "Not Found")

This list becomes the master definition of our data. Each entry is wrapped inside a placeholder macro X().

The name X is simply a convention. It has no special meaning and can be replaced with any name.

Next, we define the macro X to generate the enum:

#define X(name, desc) name,
typedef enum {
    SYS_STATE_LIST
} SysState;
#undef X

Then we redefine X so that the same list generates the string table:

#define X(name, desc) [name] = desc,
const char *state_desc[] = {
    SYS_STATE_LIST
};
#undef X

If you come from dynamic languages such as Python or Java, this might look somewhat like a lightweight form of reflection.

X Macros gather scattered information into a single data list. By redefining and undefining X (#undef), the same data can be injected into multiple code templates. Adding, removing, or reordering entries will not introduce inconsistencies.

This technique works well in many situations where related data must stay synchronized, for example:

• Managing error codes, states, or event types together with their descriptions
• Generating command tables or protocol definitions
• Serialization and deserialization
• Configuration data initialization and access code generating

Advanced Notes

X Macros are powerful, but they do come with trade-offs. Macro-heavy code can reduce readability and make debugging more difficult.

Some practical tips:

• Improve readability: Andrew Lucas suggests passing the macro X as a parameter to the data list to make the structure clearer ³.

• Large data sets: If the list becomes very long, you may hit compiler line-length limits. Randy Meyers recommends placing the list in a separate.def or .h file and using #include to reuse it.

• Inspect preprocessed output: You can use gcc -E to view the expanded source code. Many modern IDEs with language servers can also show this.

• Team communication: Not everyone is familiar with this technique. Good comments and documentation help avoid confusion.

• Use it sparingly: Like most macro tricks, X Macros should be used thoughtfully rather than everywhere.

Summary

X Macros are essentially a lightweight metaprogramming technique built on top of the C/C++ preprocessor. In environments without reflection or code generation tools, they provide a practical way to keep related definitions synchronized.

By maintaining a Single Source of Truth and generating code through macro expansion, X Macros eliminate the risk of inconsistent duplicated definitions.

The idea dates back to assembly programming in the 1960s. Even today, whenever large amounts of structured data need to remain consistent, it remains a surprisingly useful technique — and a valuable tool in the C/C++ programmer’s toolbox.

The quality of machine translation today is, frankly, impressive. Most of the time, a light round of editing is enough before publishing.

And yet, something never quite sits right.

The sentences are correct. The meaning is intact. But the text feels… distant. As if there’s a thin layer between the words and the reader—hard to name, harder to ignore.

That unease sharpened one day when I worked on a longer piece. The translated version felt particularly off. So I did a side-by-side comparison of several posts, Chinese against English. The result was unsettling—like catching your reflection in a mirror and realizing, for a split second, that it isn’t you.

It brought to mind an old line of poetry about crossing a threshold and becoming a stranger ever after:

Once you enter the noble’s gate, it’s as deep as th sea; from then on, the former love is but a stranger.

The problem, I realized, wasn’t the translation. It was the Chinese.

For years, I’ve worked in environments where English is the default. Emails, documentation, code, comments—everything happens in English. Chinese never disappeared, but it retreated into casual conversation: chats, messages, everyday exchanges.

Looking back at my recent blog posts, I noticed something uncomfortable. The Chinese and the English versions aligned almost word for word. On the surface, they were written in Chinese. But structurally, they followed English logic so closely that they could be mapped directly onto each other.

Somewhere along the way, I had developed a habit. Whenever I “write,” my thoughts take a detour through English before landing in Chinese. What I had taken for Chinese writing was, in fact, English composition wearing Chinese characters.

No wonder it reads like a translation.

I suspect I’m not alone in this.

For many bilingual speakers, written expression gradually leans toward English. Chinese recedes into speech, rarely called upon for sustained, complex thought. And like any skill left unused, it begins to dull.

You don’t notice it at first. Only when you try to write something serious do you realize the words no longer come as easily.

Use it, or lose it.

In an odd way, this blog has been a wake-up call. It forced me to see the problem clearly. And the solution, though simple, is not easy: start writing in Chinese again—deliberately, persistently, and with attention.

As I write this, I find myself examining each sentence as it forms:

Could this be translated directly into English?

If the answer is yes, something is probably off.

One of the most common conflicts is with the command set-mark-command, which default binding is C-SPC~(Ctrl+Space)¹. On Windows, Ctrl+Space is often used to toggle between English and Chinese input methods, which can makeCtrl+Space unusable for marking in Emacs.

To resolve this issue, you can either use the alternative binding forset-mark-command, C-@, or disable the Ctrl+Space functionality in Windows. Additionally, since the spacebar can be operated easily with either thumb, there is a “third option”: you can configure the Ctrl+Space so that one side Ctrl+Space is reserved for Windows, while the other side Ctrl+Space is available for Emacs or other applications. This is the solution I adopted because it allows me to maintain my habit of using both thumbs for operation.

In the latest version of Windows 11, you can achieve this as follows:

1. Go to Settings > Time & Language > Language & region > Options > Microsoft Pinyin > Keys, and uncheck the Ctrl + Space box while leaving Shift checked.

2. Open PowerToys (install it if you don’t already have it). In the Keyboard Manager section, add a key remapping: map Ctrl(Left) + Space to Shift orWin(Left) + Space.

For older versions of Windows, where there’s a UI bug preventing such changes ², you can solve this by manually editing the registry:

1. Navigate to HKEY_CURRENT_USER\Control Panel\Input Method\Hot Keys\00000010. Modify the value of Key Modifiers to 02 80 00 00, or 02 40 00 00 ³.
2. If you want to apply this change for all new users, make the same modification under HKEY_USERS\.DEFAULT\Control Panel\Input Method\Hot Keys\00000010.

After making these changes, restart your computer to take effect.

It seems that only Ctrl+Space can be “split,” as other key combinations are naturally easier to reach with one hand. For example, Ctrl+a inherently impliesRight Ctrl+a.

This is an essential configuration for all the computers I use, all because of Emacs.

Emacs was originally developed as a set of macros for the TECO editor (Editing MACroS). At that time, the keyboard layout used by the developers placed the Ctrl key next to the spacebar¹, making it convenient for operation with the thumbs. For some reason, standard keyboards that became widespread with personal computers moved the Ctrl key to the outermost position, which forces usage with the pinky finger. This design easily fatigues the pinky.

Therefore, I choose to swap the Ctrl and Alt keys, returning the Ctrl key to a thumb-operable position, alleviating pinky strain and significantly improving efficiency.

Here’s how I do it:

• Windows: Using SharpKeys for key remapping.
• Linux (GNOME desktop): GNOME Tweak Tool makes this easy to configure².

This is a “once-you-use-it-you-can’t-go-back” configuration. It also has a‘hidden feature’ - driving others crazy when they try to use my keyboard.