/* C 语言的设计完全围绕 Unix 的需求 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

/*
 * C 语言体现的 Unix 哲学：
 * 1. 简洁 —— 没有隐式行为
 * 2. 高效 —— 接近硬件
 * 3. 可移植 —— 抽象硬件差异
 * 4. 正交 —— 少量基本概念自由组合
 */

int main() {
    // 文件描述符
    write(STDOUT_FILENO, "Hello\n", 6);

    // 进程控制
    pid_t pid = fork();
    if (pid == 0) {
        execlp("ls", "ls", NULL);
    }

    // 退出码
    return 0;
}

// Go 语言的设计者（Ken Thompson, Rob Pike）是 Unix 的创造者
// Go 的设计深受 Unix 哲学影响

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    // 1. 错误处理：显式返回 error，而非异常
    data, err := os.ReadFile("/etc/hostname")
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1) // Unix 风格的退出码
    }
    fmt.Print(string(data))

    // 2. 接口：隐式实现（组合优于继承）
    // io.Reader 和 io.Writer 就像 Unix 的 read/write

    // 3. 并发：goroutine 像进程，channel 像管道
    ch := make(chan string)
    go func() {
        ch <- "hello from goroutine"
    }()
    fmt.Println(<-ch)

    // 4. 标准库：Unix 工具集的编程版
    cmd := exec.Command("grep", "pattern", "file.txt")
    output, _ := cmd.Output()
    fmt.Print(string(output))
}

Go 语言的 Unix 基因
├── 错误处理 —— 退出码思维（返回 error，而非抛出异常）
├── 接口 —— 隐式实现（类似 Unix 的"鸭子类型"）
├── 并发 —— CSP 模型（goroutine + channel ≈ 进程 + 管道）
├── 组合 —— struct embedding（组合优于继承）
├── 简洁 —— 25 个关键字（C 有 32 个）
├── 工具链 —— go build/test/fmt/vet（Unix 工具思维）
└── 二进制 —— 静态编译，单一可执行文件（BusyBox 理念）

#!/usr/bin/env python3
"""
Python 体现了 Unix 的"胶水语言"理念
通过 subprocess 调用 Unix 工具，通过管道思维处理数据
"""

import subprocess
import sys
from pathlib import Path

# 1. subprocess —— Unix 管道的编程版
result = subprocess.run(
    ["grep", "-r", "TODO", "."],
    capture_output=True,
    text=True
)
print(result.stdout)

# 2. 上下文管理器 —— RAII 风格的资源管理
with open("/etc/hostname") as f:
    hostname = f.read().strip()

# 3. 生成器 —— 惰性数据流（类似 Unix 管道）
def read_large_file(file_path):
    """逐行读取大文件，内存友好"""
    with open(file_path) as f:
        for line in f:
            yield line.strip()

# 链式处理 —— Unix 管道风格
lines = read_large_file("/var/log/syslog")
errors = (line for line in lines if "error" in line.lower())
timestamps = (line.split()[0:2] for line in errors)
for ts in timestamps:
    print(" ".join(ts))

# 4. pathlib —— 文件系统操作的现代化
config_files = Path("/etc").glob("**/*.conf")
for conf in sorted(config_files):
    print(conf)

// Rust 在 Unix 哲学基础上增加了内存安全

use std::process::{Command, exit};
use std::fs;

fn main() {
    // 1. 显式错误处理 —— Result 类型
    let content = fs::read_to_string("/etc/hostname")
        .unwrap_or_else(|e| {
            eprintln!("Error: {}", e);
            exit(1);
        });
    println!("{}", content);

    // 2. 管道 —— 子进程的 stdin/stdout 重定向
    let output = Command::new("grep")
        .arg("pattern")
        .arg("file.txt")
        .output()
        .expect("failed to execute");
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // 3. 迭代器 —— 惰性数据流
    let top_errors: Vec<String> = fs::read_to_string("/var/log/syslog")
        .unwrap_or_default()
        .lines()
        .filter(|line| line.contains("ERROR"))
        .take(10)
        .map(|s| s.to_string())
        .collect();
}

HTTP 协议的 Unix 基因
├── 文本协议 —— 人类可读（类似 Unix 的文本流）
├── 无状态    —— 每个请求独立（类似 Unix 进程）
├── 简单方法  —— GET/POST/PUT/DELETE（做一件事做好它）
├── 头部扩展  —— 自定义头部（可扩展性）
├── 状态码    —— 数字表示结果（类似退出码）
└── 内容协商  —— Accept 头部（接口契约）

# HTTP 请求就是文本流
# 手动构造 HTTP 请求（使用 telnet）
telnet example.com 80
# GET / HTTP/1.1
# Host: example.com
# (空行)

# 使用 curl（Unix 工具）
curl -v https://example.com

# HTTP 管道（类似 Unix 管道）
curl -s https://api.example.com/data | jq '.results[]' | grep "pattern"

# REST API 设计体现了 Unix 哲学
# GET    /users       → 获取用户列表（读取）
# POST   /users       → 创建用户（写入）
# GET    /users/123   → 获取特定用户
# PUT    /users/123   → 更新用户
# DELETE /users/123   → 删除用户

# JSON 替代了 Unix 的传统文本格式
# 但设计理念相同：文本优先、可读、可组合

# 传统 Unix 文本格式
cat /etc/passwd
# root:x:0:0:root:/root:/bin/bash

# JSON 格式
curl -s https://api.example.com/users/1 | jq .
# {
#   "name": "root",
#   "uid": 0,
#   "home": "/root",
#   "shell": "/bin/bash"
# }

# jq —— JSON 的 grep/sed/awk
curl -s https://api.example.com/users | jq '.[] | select(.age > 30) | .name'
curl -s https://api.example.com/data | jq 'map({name: .name, score: .value * 1.1})'

# jq 的管道组合
cat data.json | jq '.items[]' | jq 'select(.status == "active")' | jq -s 'length'

gRPC 的设计体现了现代的 Unix 契约思维

传统 Unix:
├── 接口: stdin/stdout（文本流）
├── 协议: 行分隔的文本
├── 工具: grep, sed, awk（文本处理）
└── 组合: 管道

gRPC:
├── 接口: Protocol Buffers（结构化二进制）
├── 协议: HTTP/2（多路复用）
├── 工具: protoc（编译器）
└── 组合: 服务间调用（微服务）

微服务 = Unix 哲学在分布式系统中的应用

Unix 工具                    微服务
├── cat (读取文件)          → 数据源服务
├── grep (过滤)             → 过滤服务
├── sed (转换)              → 转换服务
├── sort (排序)             → 排序服务
├── uniq (去重/聚合)        → 聚合服务
├── wc (统计)               → 统计服务
└── 管道 (|)                → 消息队列 (Kafka, RabbitMQ)

Unix 管道:
  cat data.txt | grep "error" | sort | uniq -c

微服务架构:
  DataStore → FilterService → SortService → AggregateService

# Kubernetes Deployment —— 声明式配置
# 体现了"做什么"而非"怎么做"
apiVersion: apps/v1
kind: Deployment
metadata:
  name: filter-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: filter-service
  template:
    metadata:
      labels:
        app: filter-service
    spec:
      containers:
      - name: filter
        image: myregistry/filter:latest
        resources:
          requests:
            memory: "128Mi"
            cpu: "250m"
          limits:
            memory: "256Mi"
            cpu: "500m"
---
# Service —— 服务发现
apiVersion: v1
kind: Service
metadata:
  name: filter-service
spec:
  selector:
    app: filter-service
  ports:
  - port: 8080

# Docker 的设计完全体现了 Unix 哲学

# 1. 镜像 = 只读的文件系统层
# 2. 容器 = 隔离的进程（namespace + cgroup）
# 3. Dockerfile = 声明式的构建脚本
# 4. 卷 = 持久化的数据（类似挂载点）
# 5. 网络 = 容器间的通信（类似 Unix Socket）

# Dockerfile —— 每个指令做一件事
FROM alpine:3.19           # 基础层（极简系统）
RUN apk add --no-cache nginx  # 安装软件
COPY nginx.conf /etc/nginx/   # 复制配置
COPY html/ /var/www/          # 复制内容
EXPOSE 80                     # 声明端口
CMD ["nginx", "-g", "daemon off;"]  # 启动命令

# 多阶段构建 —— 工具组合思维
FROM golang:1.22 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o server .

FROM alpine:3.19
COPY --from=builder /app/server /server
CMD ["/server"]

# 容器编排 = 管道组合
docker network create mynet
docker run -d --name db --network mynet postgres:16
docker run -d --name app --network mynet -e DB_HOST=db myapp:latest
docker run -d --name proxy --network mynet -p 80:80 nginx:latest

Kubernetes 的 Unix 基因

Unix 内核                    Kubernetes
├── 进程调度 (scheduler)     → Pod 调度 (kube-scheduler)
├── 进程管理 (init/systemd)  → Pod 生命周期管理
├── 文件系统 (/proc, /sys)   → API Server（统一资源抽象）
├── 进程间通信 (IPC)         → Service（服务发现和负载均衡）
├── 信号 (signal)            → Events（状态变更通知）
├── 权限模型 (chmod/chown)   → RBAC（基于角色的访问控制）
├── 设备驱动 (/dev/*)        → CSI/CNI/CRI（存储/网络/容器运行时接口）
└── Shell 脚本               → Helm Charts（声明式部署模板）

# 传统的 Unix 系统管理
#!/bin/bash
# 手动配置服务器
apt-get install -y nginx
cp nginx.conf /etc/nginx/
systemctl enable nginx
systemctl start nginx

# Ansible —— 声明式的服务器管理
# 体现了"声明目标，而非过程"的哲学

# Ansible Playbook —— 声明式配置
---
- name: Configure web servers
  hosts: webservers
  become: yes
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present

    - name: Deploy config
      template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
      notify: Restart nginx

    - name: Ensure nginx is running
      service:
        name: nginx
        state: started
        enabled: yes

  handlers:
    - name: Restart nginx
      service:
        name: nginx
        state: restarted

# GitHub Actions —— 管道组合
name: CI/CD Pipeline

on:
  push:
    branches: [main]

jobs:
  # Stage 1: 测试（类似 Unix 的 grep 验证）
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - run: make test

  # Stage 2: 构建（类似 Unix 的 make）
  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - run: make build
    - uses: actions/upload-artifact@v4
      with:
        name: binary
        path: ./build/

  # Stage 3: 部署（类似 Unix 的管道输出到文件）
  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
    - uses: actions/download-artifact@v4
    - run: ./deploy.sh

CI/CD 管道与 Unix 管道的对应

Unix 管道:
  make test && make build && make deploy

CI/CD 管道:
  Test → Build → Deploy → Monitor

两者共同点：
├── 阶段串联 —— 前一个阶段的输出是下一个的输入
├── 失败即停 —— 任一阶段失败，后续不执行
├── 幂等性   —— 多次执行结果相同
└── 可观测性 —— 每个阶段的输出可检查

# Git 的设计完美体现了 Unix 哲学

# 1. 小工具组合
git add .           # 暂存（标记要处理的文件）
git commit -m "msg" # 提交（保存快照）
git push            # 推送（同步到远程）
git log --oneline   # 日志（查看历史）
git diff            # 差异（比较变更）

# 2. 管道组合
git log --oneline | head -20
git log --format="%H %s" | grep "fix" | cut -d' ' -f1
git diff HEAD~1 | grep "^[+-]" | sort | uniq -c

# 3. 文本流输出
git log --format="%H %an %s" | awk '{print $2}' | sort | uniq -c | sort -rn

# 4. 退出码
git diff --quiet || echo "有未提交的变更"

# 5. .gitignore —— 简单的模式匹配（Unix glob 风格）
# *.o
# *.pyc
# __pycache__/

# npm 的设计灵感来自 Unix 包管理

# 1. 小模块组合
# npm 上有数百万个小模块，每个做一件事
# left-pad（11 行代码，补零操作）也曾是一个独立包

# 2. 管道思维
cat data.json | node -e "
const chunks = [];
process.stdin.on('data', c => chunks.push(c));
process.stdin.on('end', () => {
  const data = JSON.parse(Buffer.concat(chunks));
  console.log(JSON.stringify(data.filter(x => x.active), null, 2));
});"

# 3. npm scripts —— 像 Makefile 一样组合命令
# package.json:
# {
#   "scripts": {
#     "build": "tsc",
#     "test": "jest",
#     "lint": "eslint src/",
#     "deploy": "npm run build && npm run test && npm run push"
#   }
# }

# 4. npx —— 临时安装并执行（类似直接运行 Unix 命令）
npx create-react-app my-app
npx prettier --write "**/*.js"

# AI/ML 工具链也遵循 Unix 哲学

# 1. 数据处理管道
cat training_data.csv | \
    awk -F, '{if ($3 > 0) print}' | \  # 过滤
    cut -d, -f1,2,4 | \                # 选择列
    sort | \                            # 排序
    uniq > cleaned_data.csv             # 去重

# 2. 模型训练管道
python preprocess.py < raw_data.txt > processed.txt
python train.py --data processed.txt --model model.pkl
python evaluate.py --model model.pkl --test test_data.txt

# 3. 推理服务
curl -X POST http://localhost:8080/predict \
    -H "Content-Type: application/json" \
    -d '{"features": [1.0, 2.0, 3.0]}' | jq '.prediction'

# 4. LLM API —— 文本流
curl -s https://api.openai.com/v1/chat/completions \
    -H "Authorization: Bearer $API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello"}]}' \
    | jq -r '.choices[0].message.content'

# Kubeflow Pipeline —— ML 工作流的 Unix 管道
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  name: ml-pipeline
spec:
  entrypoint: ml-pipeline
  templates:
  - name: ml-pipeline
    dag:
      tasks:
      - name: preprocess
        template: preprocess
      - name: train
        template: train
        dependencies: [preprocess]
      - name: evaluate
        template: evaluate
        dependencies: [train]
      - name: deploy
        template: deploy
        dependencies: [evaluate]

  - name: preprocess
    container:
      image: myregistry/preprocess:latest
      command: [python, /app/preprocess.py]

  - name: train
    container:
      image: myregistry/train:latest
      command: [python, /app/train.py]

  - name: evaluate
    container:
      image: myregistry/evaluate:latest
      command: [python, /app/evaluate.py]

  - name: deploy
    container:
      image: myregistry/deploy:latest
      command: [python, /app/deploy.py]

WebAssembly (Wasm) 的 Unix 基因
├── 二进制格式 —— 像编译后的 C 程序
├── 沙箱隔离 —— 像 Unix 进程隔离
├── 线性内存 —— 像 Unix 虚拟内存
├── 导入/导出 —— 像 Unix 的函数接口
├── 组件模型 —— 像 Unix 的可组合性
└── WASI —— 像 POSIX 的标准化接口

Wasm 的应用前景
├── 浏览器 —— 高性能 Web 应用
├── 服务端 —— 轻量级容器替代（WasmEdge）
├── 边缘计算 —— Cloudflare Workers
├── 插件系统 —— Envoy, Extism
└── 区块链 —— 智能合约

# 使用 Rust + Wasm 构建可移植工具
# src/lib.rs
# use wasm_bindgen::prelude::*;
#
# #[wasm_bindgen]
# pub fn process(input: &str) -> String {
#     input.lines()
#         .filter(|line| line.contains("error"))
#         .collect::<Vec<_>>()
#         .join("\n")
# }

# 构建
wasm-pack build --target nodejs

# 在任何 Wasm 运行时中使用
node -e "const m = require('./pkg'); console.log(m.process('line1\nerror line2'))"

eBPF (Extended Berkeley Packet Filter) 的意义

传统 Unix:
├── 内核功能在编译时确定
├── 添加新功能需要内核模块
└── 安全风险高

eBPF:
├── 在运行时向内核注入小程序
├── 类似 Unix 的过滤器模式
├── 安全沙箱验证
└── 无需修改内核代码

eBPF 的应用
├── 网络过滤 —— Cilium, Calico
├── 性能分析 —— bpftrace, BCC
├── 安全监控 —— Falco, Tetragon
├── 可观测性 —— Prometheus + eBPF
└── 跟踪 —— OpenTelemetry

# bpftrace —— eBPF 的 awk
# 类似 Unix 的 awk，但在内核级别工作

# 跟踪系统调用
bpftrace -e 'tracepoint:syscalls:sys_enter_openat { printf("%s %s\n", comm, str(args->filename)); }'

# 统计进程的系统调用次数
bpftrace -e 'tracepoint:raw_syscalls:sys_enter { @[comm] = count(); }'

# 跟踪文件 I/O 延迟
bpftrace -e 'tracepoint:block:block_rq_complete { @usecs = hist(args->nr_sector); }'

Unix 对开源运动的影响
├── 代码共享文化 —— 1970 年代 Unix 在大学间的分发
├── 工具协作 —— 程序员互相改进对方的工具
├── Bug 报告 —— 公开的 Bug 追踪和修复
├── 文档共享 —— man page 的传统
└── 社区治理 —— 扁平化的技术决策

代表项目
├── GNU Project (1983) —— 自由的 Unix 工具
├── Linux (1991) —— 开源内核
├── Apache (1995) —— 开源 Web 服务器
├── Git (2005) —— 分布式版本控制
├── Docker (2013) —— 容器化
└── Kubernetes (2014) —— 容器编排

Unix 哲学对编程文化的塑造
├── KISS 原则 —— Keep It Simple, Stupid
├── YAGNI 原则 —— You Ain't Gonna Need It
├── DRY 原则 —— Don't Repeat Yourself
├── 代码审查 —— 同行审阅代码（源自 Bell Labs）
├── 自动化测试 —— make test 的传统
├── 文档即代码 —— README.md, man page
└── 命令行优先 —— CLI 是一切自动化的基础

# Unix 的 Hacker 精神
# 1. 用工具解决问题
# 2. 先让代码工作，再优化
# 3. 简单优于复杂
# 4. 透明性优于隐蔽性
# 5. 实践优于理论

# Hacker 名言
# "Talk is cheap. Show me the code." — Linus Torvalds
# "Any sufficiently advanced technology is indistinguishable from magic." — Arthur C. Clarke
# "The best way to predict the future is to invent it." — Alan Kay
# "Premature optimization is the root of all evil." — Donald Knuth

Unix 哲学的核心教训
├── 简洁是终极的复杂 (Simplicity is the ultimate sophistication)
├── 模块化优于整体化 (Modularity over monolithicity)
├── 组合优于继承 (Composition over inheritance)
├── 文本是通用接口 (Text is the universal interface)
├── 沉默是金 (Silence is golden)
├── 小工具，大组合 (Small tools, big compositions)
├── 可移植性优于性能 (Portability over performance)
└── 先让代码工作 (Make it work first)

作为开发者，你应该：
├── 学习 Unix 命令行 —— 这是一切自动化的基础
├── 理解 Shell 脚本 —— 系统管理和 DevOps 的入门
├── 掌握文本处理工具 —— grep/sed/awk 永远有用
├── 阅读经典著作 —— TAUP, K&P, Stevens
├── 实践组合思维 —— 用小工具解决大问题
├── 写可组合的代码 —— 你的程序应该能被管道使用
├── 保持简洁 —— 不要过度设计
└── 参与开源 —— Unix 文化的延续