工具代码行数比较
├── cat        ~300 行 C
├── wc         ~200 行 C
├── echo       ~150 行 C
├── grep       ~1,000 行 C
├── sed        ~5,000 行 C
├── awk        ~8,000 行 C
├── vim        ~300,000 行 C
├── curl       ~130,000 行 C
└── Linux 内核 ~30,000,000 行 C

对比：
├── Windows 10 ~50,000,000 行
├── Google 代码库 ~2,000,000,000 行
└── Facebook 代码库 ~100,000,000 行

# BusyBox 将 300+ 个 Unix 工具编译到一个 ~1MB 的二进制中
# 是 Alpine Linux（Docker 默认镜像）的基础

# Alpine Linux 的包大小对比
docker run alpine:3.19 du -sh /bin/busybox
# 约 1 MB

# 对比 GNU coreutils
docker run ubuntu:22.04 du -sh /usr/bin/
# 约 50 MB（200+ 个独立工具）

# 功能对比
docker run alpine:3.19 busybox --list | wc -l
# 超过 300 个命令

# grep 只做一件事：搜索匹配行
# 它不会：
# ❌ 替换匹配的文本（那是 sed 的工作）
# ❌ 对结果排序（那是 sort 的工作）
# ❌ 统计匹配数量（虽然有 -c，但核心是搜索）
# ❌ 高亮显示（那是管道终端的功能）

# 如果 grep 试图做所有这些事，它会变成一个臃肿的工具
# 而 Unix 的方式是组合：
grep "pattern" file.txt | sed 's/old/new/' | sort | uniq -c

# ✅ 好的设计：成功时无输出
cp file.txt backup/
rm old_file.txt
mkdir /tmp/test
# 执行成功时没有任何输出

# ❌ 不好的设计：成功时输出噪音
cp file.txt backup/
# "File file.txt successfully copied to backup/file.txt"
# "Operation completed at 2026-05-10 10:30:00"
# "Thank you for using CopyTool v2.0!"

沉默设计的好处
├── 脚本友好 —— 输出不干扰数据处理
├── 管道安全 —— 成功的输出不会污染下游
├── 减少噪音 —— 运维人员只需关注错误
├── 语义清晰 —— 有输出 = 有问题需要处理
└── 日志可控 —— 用户决定是否需要详细日志

# 有些工具在设计时就考虑了信息输出
# 这些通常使用 -v (verbose) 选项控制

# tar: 默认不输出（脚本模式），-v 输出详情（交互模式）
tar czf archive.tar.gz dir/        # 静默
tar czvf archive.tar.gz dir/       # 详细

# make: 默认输出命令，-s 静默
make                               # 输出编译命令
make -s                            # 静默模式

# ssh: 默认输出连接信息，-q 静默
ssh user@host                      # 输出连接信息
ssh -q user@host                   # 静默

# 有些工具用不同的命令区分模式
ls      # 简洁列表（适合脚本）
ls -la  # 详细列表（适合交互）

# ✅ 好的设计：默认非交互，可选交互
rm file.txt           # 直接删除
rm -i file.txt        # 交互式确认

# ❌ 不好的设计：强制交互
rm file.txt
# "Are you sure you want to delete file.txt? (y/n): "

# ✅ 好的设计：从 stdin 接收配置
mysql -u root < script.sql

# ❌ 不好的设计：强制交互式输入
mysql -u root
# "Please enter your SQL commands:"

#!/bin/bash
# 使命令非交互运行

# apt: -y 自动确认
apt-get install -y package

# ssh: -o BatchMode=yes 禁止交互
ssh -o BatchMode=yes user@host "command"

# git: GIT_TERMINAL_PROMPT=0 禁止提示
GIT_TERMINAL_PROMPT=0 git clone url

# gpg: --batch --yes 非交互模式
gpg --batch --yes --passphrase "password" --decrypt file.gpg

# mysql: --batch 输出制表符分隔
mysql --batch -e "SELECT * FROM users"

# ❌ 过度设计的脚本
#!/bin/bash
# 多功能日志分析器 v2.0
# 支持：JSON、CSV、XML 格式
# 支持：MySQL、PostgreSQL、SQLite 存储
# 支持：邮件、Slack、钉钉通知
# 支持：Web 仪表板
# ... 实际上只需要分析 Nginx 日志

# ✅ 极简的脚本
#!/bin/bash
# 只做一件事：统计 Nginx 日志中的错误
awk '$9 >= 400' /var/log/nginx/access.log | wc -l

复杂度带来的问题
├── 开发时间 —— 更多功能 = 更多开发和测试时间
├── 维护成本 —— 更多代码 = 更多需要维护的部分
├── Bug 数量 —— 代码行数与 Bug 数量成正比
├── 学习曲线 —— 功能越多，用户越难学会
├── 安全风险 —— 攻击面随功能增加而增大
└── 性能开销 —— 不必要的功能消耗资源

# Unix 工具的错误处理通常是轻量级的：
# 1. 用退出码表示成功/失败
# 2. 将错误信息输出到 stderr
# 3. 不捕获所有异常

# ❌ 过度错误处理
#!/bin/bash
try {
    result=$(command)
} catch Exception as e {
    log_error(e)
    send_alert(e)
    write_to_database(e)
    retry(3)
    fallback_to_default()
}

# ✅ Unix 方式
#!/bin/bash
command || { echo "Error: command failed" >&2; exit 1; }

# 好的退出码设计：
# 0   — 成功
# 1   — 通用错误
# 2   — 用法错误（参数不正确）
# 126 — 权限不足
# 127 — 命令未找到
# 128+N — 被信号 N 终止

# 在脚本中使用退出码
#!/bin/bash
set -e  # 任何命令失败即退出

cd /app
make
make install
echo "安装成功"

# Unix 工具通常有合理的默认值，不需要配置文件
# grep 默认搜索 stdin 或文件参数
# sort 默认按字典序
# head 默认显示前 10 行
# tail 默认显示后 10 行

# 配置文件的极简设计
# /etc/ssh/sshd_config 中的约定
# Port 22          # 默认端口 22
# PermitRootLogin yes  # 默认允许 root 登录

# 环境变量优于配置文件
export EDITOR=vim      # 默认编辑器
export PAGER=less      # 默认分页器
export LANG=en_US.UTF-8  # 默认语言

Linux 文件系统层次标准（FHS）中的约定
├── /bin     — 基本命令（所有用户可用）
├── /sbin    — 系统管理命令
├── /etc     — 配置文件
├── /var     — 可变数据（日志、缓存）
├── /tmp     — 临时文件（重启后可能清空）
├── /home    — 用户主目录
├── /usr     — 用户级程序和数据
├── /opt     — 第三方软件
└── /proc    — 进程信息（虚拟文件系统）

# Unix 的 API 是极简的：open/read/write/close

# 对比 Windows 的文件 API：
# CreateFile, ReadFile, WriteFile, CloseHandle
# + 安全描述符 + 共享模式 + 缓冲策略 + 异步 I/O

# Unix 的进程 API：fork/exec/wait
# 对比 Windows：CreateProcess + 安全属性 + 启动信息 + 线程属性

# 结果：Unix 的 API 学习成本低，组合能力强

HTTP 协议也体现了 Unix 极简精神：
├── 文本协议 —— 人类可读
├── 无状态    —— 每个请求独立
├── 简单方法  —— GET/POST/PUT/DELETE
├── 统一资源  —— URL 标识一切资源
└── 可扩展    —— 通过头部扩展功能

REST API 与 Unix 哲学的对应：
├── 资源 = 文件
├── URL = 路径
├── HTTP 方法 = open/read/write/close
├── JSON = 文本流
└── 状态码 = 退出码

// Go 语言体现了 Unix 极简精神
// 1. 没有继承
// 2. 没有泛型（直到 1.18）
// 3. 没有异常（只有 error 返回值）
// 4. 标准库小巧但强大

package main

import (
    "fmt"
    "os"
)

func main() {
    // Go 的文件操作也是极简的
    data, err := os.ReadFile("/etc/hostname")
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }
    fmt.Print(string(data))
}

# SQLite 是极简设计的典范
# - 一个文件就是一个数据库
# - 没有服务器进程
# - 代码约 150,000 行（含测试）
# - 支持完整的 SQL 标准

# 使用方式
sqlite3 database.db "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);"
sqlite3 database.db "INSERT INTO users VALUES (1, 'Alice');"
sqlite3 database.db "SELECT * FROM users;"

# Docker 的设计体现了 Unix 极简精神
# 1. 每个容器只做一件事
# 2. 通过 Dockerfile 声明式构建
# 3. 通过 Docker Compose 组合
# 4. 镜像是只读的层

# 极简的 Dockerfile
FROM alpine:3.19
COPY app /app
CMD ["/app"]

# 不是这样（过度设计）
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y everything
RUN install-logging-agent
RUN install-monitoring-agent
RUN install-security-agent
CMD ["supervisord"]  # 在一个容器里运行多个服务