Go语言到底适合做什么？：从万亿级微服务到嵌入式IoT，一份被92%CTO私藏的用途决策图谱

第一章：Go语言的核心定位与演进脉络

Go语言由Google于2007年启动设计，2009年正式发布，其核心定位是解决大规模工程中开发效率、运行性能与系统可靠性之间的三角张力。它并非追求语法奇巧或范式完备，而是以“少即是多”（Less is more）为哲学，聚焦于现代云原生基础设施所需的可维护性、并发可控性与部署简洁性。

设计初衷与关键取舍

Go刻意摒弃了类继承、泛型（早期版本）、异常机制和复杂的抽象语法，转而强化组合、接口隐式实现、轻量级协程（goroutine）与通道（channel）模型。这种取舍使开发者能用接近脚本的开发速度编写出媲美C语言的内存与调度效率的系统程序。例如，一个HTTP服务仅需5行代码即可启动：

package main
import "net/http"
func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, Go!")) // 直接响应文本，无中间件依赖
    })
    http.ListenAndServe(":8080", nil) // 阻塞启动，开箱即用
}

关键演进节点

• Go 1.0（2012）：确立兼容性承诺，保证未来所有1.x版本向后兼容；
• Go 1.5（2015）：自举编译器，移除C语言依赖，提升构建一致性；
• Go 1.11（2018）：引入模块（Go Modules），终结GOPATH时代，支持语义化版本依赖管理；
• Go 1.18（2022）：正式落地泛型，通过类型参数与约束（constraints）在保持类型安全前提下增强复用能力。

生态定位对比

维度	Go	Rust	Python
并发模型	goroutine + channel	async/await + tokio	threading/asyncio
内存管理	垃圾回收（低延迟）	零成本所有权系统	引用计数 + GC
典型场景	微服务、CLI工具、DevOps组件	系统编程、浏览器引擎	数据分析、胶水脚本

Go持续演进的方向始终锚定“工程可规模化”：从静态二进制分发、跨平台交叉编译到内置go test与go vet等质量保障工具链，每一步都服务于降低大型团队协作的认知负荷与运维熵值。

第二章：Go语言的底层特性解构

2.1 并发模型：Goroutine与Channel的理论本质与高并发压测实践

Goroutine 是 Go 的轻量级用户态线程，由 Go 运行时调度，初始栈仅 2KB，可轻松启动百万级并发；Channel 则是类型安全的通信管道，遵循 CSP（Communicating Sequential Processes）模型，以“通过通信共享内存”替代锁机制。

数据同步机制

ch := make(chan int, 10)
go func() {
    for i := 0; i < 100; i++ {
        ch <- i // 阻塞直到有接收者或缓冲区未满
    }
    close(ch)
}()
for v := range ch { // 自动阻塞等待，channel关闭后退出
    fmt.Println(v)
}

逻辑分析：make(chan int, 10) 创建带缓冲通道，避免生产者过早阻塞；close(ch) 标识数据流结束；range 语义确保消费端优雅退出。缓冲容量 10 是吞吐与内存的典型权衡点。

高并发压测关键参数对照

参数	推荐值	影响说明
GOMAXPROCS	CPU核心数	控制P数量，影响M-P-G调度粒度
channel 缓冲大小	业务QPS×平均延迟	避免goroutine频繁挂起
goroutine 池规模	50–500	防止过度创建导致GC压力陡增

graph TD
A[HTTP请求] –> B{限流器}
B –> C[Goroutine池]
C –> D[Channel分发]
D –> E[Worker处理]
E –> F[结果聚合]

2.2 内存管理：GC机制设计哲学与低延迟服务内存调优实录

低延迟服务对GC的“暂停不可见性”提出严苛要求——不是减少停顿，而是将停顿压缩至应用逻辑无感区间。

ZGC的染色指针哲学

ZGC通过元数据复用地址空间高位（如x64下第42–47位）标记对象状态，避免写屏障导致的缓存污染：

// ZGC中对象头隐式编码（伪代码）
long markWord = object.address() | (color << 42); // 0=white, 1=black, 2=gray
// 关键：读取对象时无需额外内存访问，颜色信息随地址原子获取

该设计消除了传统SATB写屏障的store-load依赖，使并发标记阶段吞吐提升37%（JDK 17基准测试）。

GC调优关键参数对照

参数	推荐值（低延迟场景）	作用说明
-XX:+UseZGC	必选	启用ZGC运行时
-XX:ZCollectionInterval=5	≤10s	控制最大无GC间隔，防内存缓慢泄漏
-XX:ZUncommitDelay=300	≥300s	延迟释放未使用堆页，减少OS级抖动

GC行为决策流

graph TD
    A[应用分配请求] --> B{堆使用率 > 85%？}
    B -->|是| C[触发自适应并发GC]
    B -->|否| D{上次GC后超300s？}
    D -->|是| C
    C --> E[并发标记→转移→重映射]

2.3 静态编译与零依赖分发：从容器镜像瘦身到跨平台嵌入式部署验证

静态编译是实现真正零依赖分发的核心手段。以 Go 为例，启用 -ldflags '-s -w' 可剥离调试符号并减小体积：

CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -a -ldflags '-s -w' -o app-static .

• CGO_ENABLED=0：禁用 cgo，避免动态链接 libc；
• GOOS/GOARCH：交叉编译目标平台；
• -s -w：移除符号表和 DWARF 调试信息，体积缩减约 30%。

容器镜像对比（Alpine vs scratch）

基础镜像	镜像大小	依赖风险	适用场景
alpine:3.19	~5.3 MB	有 musl libc 依赖	调试/开发阶段
scratch	~3.8 MB	零依赖	生产/嵌入式环境

构建流程关键路径

graph TD
    A[源码] --> B[CGO_ENABLED=0 静态编译]
    B --> C[strip + upx 可选压缩]
    C --> D[复制至 scratch 镜像]
    D --> E[ARM64 嵌入式设备验证]

2.4 接口即契约：非侵入式接口的抽象能力与微服务契约治理落地案例

微服务间协作的本质是契约共识，而非代码耦合。非侵入式接口通过定义纯抽象契约（如 OpenAPI + Protobuf Schema），使服务提供方与消费方解耦于实现细节。

契约即文档：OpenAPI 驱动的契约校验

# order-service.openapi3.yaml（节选）
paths:
  /v1/orders:
    post:
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateOrderRequest'
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Order'

该 YAML 定义了请求/响应结构、HTTP 语义及状态码，被用作自动化测试、Mock 服务与 SDK 生成的唯一事实源；$ref 机制支持跨服务复用通用 Schema（如 Money, Timestamp），避免重复定义。

契约治理流水线

阶段	工具链	治理动作
提交时	Spectral + GitHub CI	静态规则检查（如 required 字段、命名规范）
集成测试前	Pact Broker	消费者驱动契约（CDC）双向验证
生产发布前	API Diff Tool	向后兼容性断言（禁止删除/重命名字段）

服务间调用契约流

graph TD
    A[Order-Consumer] -->|1. 发起调用<br>携带契约版本 v1.2| B[API Gateway]
    B -->|2. 路由+契约校验| C[Order-Provider v1.2]
    C -->|3. 响应符合 OpenAPI v1.2| B
    B -->|4. 返回标准化 JSON| A

2.5 工具链原生性：go build/test/trace/profiling在CI/CD流水线中的深度集成

Go 工具链天然具备可脚本化、无外部依赖、输出标准化三大特性，使其成为 CI/CD 流水线的理想原生组件。

构建与测试一体化

# 在 GitHub Actions 中直接调用原生工具链
go build -ldflags="-s -w" -o ./bin/app ./cmd/app
go test -race -count=1 -json ./... > test-report.json

-ldflags="-s -w" 剥离调试符号与 DWARF 信息，减小二进制体积；-json 输出结构化测试结果，便于解析归档。

性能可观测性嵌入

工具	CI 场景	输出格式
go trace	热点函数采样（需 -gcflags="-l"）	trace.out（二进制）
go tool pprof	CPU/heap profile 分析	可导出 SVG/JSON

流水线执行流

graph TD
    A[Checkout] --> B[go build]
    B --> C[go test -json]
    C --> D[go run -trace=trace.out ./main.go]
    D --> E[go tool trace trace.out]

第三章：Go在关键基础设施层的不可替代性

3.1 云原生控制平面开发：Kubernetes CRD控制器与Operator工程化实践

CRD（CustomResourceDefinition）是扩展Kubernetes API的基石，而Operator则是将领域知识封装为自动化运维逻辑的载体。工程化落地需兼顾可维护性、可观测性与生命周期健壮性。

核心架构分层

• 声明式模型层：定义CRD Schema（如spec.replicas, status.phase）
• 协调循环层：Reconcile函数响应事件，实现“Desired → Actual”对齐
• 运维能力层：集成备份、升级、扩缩容等业务逻辑

数据同步机制

func (r *DatabaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var db databasev1alpha1.Database
    if err := r.Get(ctx, req.NamespacedName, &db); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    // ✅ 检查条件：仅当status.phase != Ready且spec.paused == false时执行
    if db.Status.Phase == databasev1alpha1.PhaseReady || db.Spec.Paused {
        return ctrl.Result{}, nil
    }
    // 🔄 调用底层Provisioner执行创建逻辑
    if err := r.provisioner.CreateInstance(&db); err != nil {
        db.Status.Phase = databasev1alpha1.PhaseFailed
        r.Status().Update(ctx, &db)
        return ctrl.Result{Requeue: true}, err
    }
    db.Status.Phase = databasev1alpha1.PhaseReady
    return ctrl.Result{}, r.Status().Update(ctx, &db)
}

该Reconcile函数遵循Kubernetes推荐的幂等协调范式：

• client.IgnoreNotFound安全处理资源删除场景；
• 状态跃迁受Phase和Paused双重门控，避免误触发；
• Status().Update()原子更新状态子资源，不干扰spec字段。

Operator成熟度关键指标

维度	基础实践	工程化进阶
错误处理	日志+返回error	分级重试、事件上报、告警钩子
测试覆盖	单元测试Reconcile逻辑	e2e测试CR全生命周期+中断恢复
可观测性	Prometheus指标埋点	OpenTelemetry trace + structured log

graph TD
    A[API Server Watch] --> B[Enqueue Database CR]
    B --> C{Reconcile Loop}
    C --> D[Fetch CR & Dependencies]
    D --> E[Validate & Gate]
    E --> F[Execute Business Logic]
    F --> G[Update Status Subresource]
    G --> H[Return Result/Requeue]

3.2 高性能网络中间件：eBPF+Go构建可观测代理与流量染色系统

传统代理在高吞吐场景下易成性能瓶颈。eBPF 提供内核级零拷贝数据捕获能力，配合 Go 编写的用户态控制平面，可实现毫秒级延迟的流量染色与上下文注入。

流量染色核心逻辑

通过 eBPF 程序在 socket_filter 类型钩子中为 TCP 流打上唯一 trace ID：

// bpf_program.c：在 TCP SYN 包中嵌入 8 字节 trace_id
SEC("socket_filter")
int trace_socket(struct __sk_buff *skb) {
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;
    struct iphdr *iph = data;
    if (data + sizeof(*iph) > data_end) return 0;
    if (iph->protocol == IPPROTO_TCP) {
        struct tcphdr *tcph = data + sizeof(*iph);
        if (data + sizeof(*iph) + sizeof(*tcph) > data_end) return 0;
        if (tcph->syn && !tcph->ack) { // SYN only
            __u64 trace_id = bpf_ktime_get_ns() ^ bpf_get_prandom_u32();
            bpf_skb_store_bytes(skb, offsetof(struct tcphdr, ack_seq) + 4,
                                &trace_id, 8, 0); // 染色至未使用 TCP option 空间
        }
    }
    return 0;
}

逻辑分析：该程序在 SYN 包中复用 ack_seq + 4 后 8 字节（通常为空闲区域）写入 trace ID；bpf_ktime_get_ns() 提供高熵时间戳，bpf_get_prandom_u32() 增强唯一性；bpf_skb_store_bytes 原子写入，避免锁开销。

可观测性协同架构

组件	职责	性能特征
eBPF Loader	加载/校验 BPF 程序
Go Agent	解析染色包、上报 OpenTelemetry	≤50μs/包处理延迟
eBPF Map	共享 trace→service 映射	O(1) 查找

graph TD
    A[Client Request] --> B[eBPF Socket Filter]
    B -->|注入 trace_id| C[Kernel Network Stack]
    C --> D[Go Agent via perf_event]
    D --> E[OTLP Exporter]
    E --> F[Jaeger/Tempo]

3.3 分布式协调服务：基于Raft的轻量级共识组件在边缘集群中的裁剪与验证

为适配边缘设备资源受限特性，我们对标准 Raft 实现进行三方面裁剪：

• 移除非必要日志压缩模块，仅保留快照触发阈值（snapshot_threshold = 1024）
• 将心跳超时从 500ms 动态缩放至 200–300ms（依据节点 CPU 负载自适应）
• 禁用远程调试端点，关闭 Prometheus 指标暴露

数据同步机制

核心状态机精简后仅维护 term、votedFor 和 log[] 三个字段，日志条目结构如下：

type LogEntry struct {
    Term    uint64 `json:"term"`    // 提议该日志的领导者任期
    Index   uint64 `json:"index"`   // 日志全局唯一索引（单调递增）
    Cmd     []byte `json:"cmd"`     // 序列化后的客户端请求（≤512B）
}

该设计确保单条日志内存开销 Cmd 字段强制截断保障边缘节点不会因大请求 OOM。

裁剪效果对比

维度	标准 Raft	轻量裁剪版	下降幅度
内存常驻占用	4.2 MB	1.3 MB	69%
启动延迟	320 ms	87 ms	73%
最小可行节点	3× ARM64	2× Cortex-A53	✅ 支持双节点降级模式

graph TD
    A[Client Request] --> B{Leader?}
    B -->|Yes| C[AppendLog → Replicate]
    B -->|No| D[Forward to Leader]
    C --> E[Quorum ACK?]
    E -->|Yes| F[Apply to FSM]
    E -->|No| G[Retry with Backoff]

第四章：Go在业务架构纵深场景的决策标尺

4.1 微服务网格化演进：从单体拆分到Service Mesh数据面（Envoy Go Extension）实战

随着单体架构向微服务持续演进，通信治理复杂度陡增。Service Mesh 通过将网络逻辑下沉至数据面，解耦业务与基础设施。Envoy 作为主流数据面代理，其 Go Extension 机制允许在不修改核心 C++ 代码的前提下，安全注入定制化流量处理逻辑。

Envoy Go Extension 核心优势

• 零侵入：基于 envoy-go-extension SDK 编写独立 Go 模块
• 热加载：动态注册 HTTP 过滤器，支持灰度更新
• 安全沙箱：运行于隔离 goroutine，异常不中断主事件循环

HTTP 请求拦截示例

// 注册自定义请求头注入过滤器
func (f *HeaderInjector) OnRequestHeaders(ctx http.HttpContext, headers api.RequestHeaderMap, endStream bool) types.Action {
    headers.Set("X-Envoy-Go-Ext", "v1.2") // 注入追踪标识
    headers.Set("X-Service-Version", f.version)
    return types.Continue
}

该过滤器在请求进入时注入元数据，f.version 来自插件初始化配置，确保多租户环境下的版本可追溯性；types.Continue 表明流程继续交由后续过滤器处理。

能力维度	原生 Envoy C++	Go Extension
开发语言	C++	Go
编译依赖	Bazel 构建链	go build
调试效率	需 GDB/LLDB	支持 delve

graph TD
    A[客户端请求] --> B[Envoy Proxy]
    B --> C{Go Extension 加载}
    C -->|成功| D[执行 OnRequestHeaders]
    C -->|失败| E[降级为默认链路]
    D --> F[转发至上游服务]

4.2 实时数据管道构建：Go+Apache Kafka/Pulsar的万亿级事件流处理吞吐优化

高吞吐生产者调优策略

Kafka 生产者启用异步批量与压缩（lz4），Pulsar 则优先采用 BatchBuilder.DEFAULT + ProducerOptions.WithMaxPendingMessages(10000)，显著降低网络往返开销。

Go 客户端关键配置对比

组件	Kafka (segmentio/kafka-go)	Pulsar (apache/pulsar-client-go)
批量大小	BatchSize: 1000	MaxPendingMessages: 5000
重试机制	RetryBackoff: 100ms	MaxReconnectDelay: 30s
序列化	gob/Protobuf（零拷贝推荐）	原生支持 Protobuf Schema

// Kafka 生产者：启用零拷贝写入与连接复用
conn, _ := kafka.DialLeader(context.Background(), "tcp", "kafka:9092", "metrics", 0)
conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
_, err := conn.WriteMessages(
    kafka.Message{Value: protoMarshal(event)}, // Protobuf 序列化降低序列化耗时 62%
)

该写入跳过 bufio.Writer 中间缓冲，直通 socket send buffer；protoMarshal 比 JSON 快 3.8×，且避免 GC 压力。

graph TD
    A[Go App] -->|Protobuf Batch| B[Kafka Producer Pool]
    B --> C{Batch Timer / Size Threshold}
    C -->|Flush| D[Kafka Broker Network Layer]
    D --> E[Zero-Copy Sendfile syscall]

4.3 IoT边缘智能：ARM64交叉编译、资源受限设备上的协程调度器行为观测

在ARM64嵌入式目标（如Raspberry Pi 4/CM4、NXP i.MX8M Mini）上部署轻量级协程运行时，需严格约束内存与调度开销。

构建链配置要点

• 使用aarch64-linux-gnu-gcc工具链，启用-Os -mcpu=cortex-a53 -mfloat-abi=hard
• 链接时添加-Wl,--gc-sections -Wl,--no-as-needed裁剪未用符号

协程栈行为实测（2KB栈限制下）

事件类型	平均切换延迟	栈峰值占用
同优先级让出	380 ns	1.2 KB
I/O阻塞唤醒	1.7 μs	1.8 KB
异常嵌套调用	—	OOM crash

// 协程切换汇编桩（ARM64 AAPCS64 ABI）
__attribute__((naked)) void ctx_switch(u64 *sp_from, u64 *sp_to) {
    __asm volatile (
        "stp x19, x20, [x0, #-16]!\n\t"  // 保存callee-saved寄存器
        "stp x21, x22, [x0, #-16]!\n\t"  // x0 = sp_from
        "mov x0, x1\n\t"                 // x1 = sp_to
        "ldp x21, x22, [x0], #16\n\t"    // 恢复目标上下文
        "ldp x19, x20, [x0], #16\n\t"
        "ret"
    );
}

该内联汇编严格遵循AAPCS64调用约定：仅保存x19–x22（callee-saved），避免压栈x0–x18（caller-saved），将上下文切换开销压至sp_from/sp_to为双字对齐的栈顶指针，由C层调度器动态维护。

graph TD
    A[协程就绪队列] -->|tick触发| B[时间片检查]
    B --> C{剩余时间>0?}
    C -->|是| D[继续执行]
    C -->|否| E[保存SP到TCB]
    E --> F[选择下一就绪协程]
    F --> G[加载SP并ret]

4.4 Serverless函数运行时：冷启动优化、上下文复用与无状态FaaS框架定制

Serverless函数的性能瓶颈常集中于冷启动延迟。主流云平台通过预热容器池、分层镜像（如 AWS Lambda 的 /opt 层）和运行时快照（如 Cloudflare Workers 的 V8 isolate warm-up）缓解该问题。

冷启动关键路径优化

# 示例：基于上下文复用的初始化隔离（Python Runtime）
import time
_global_cache = {}  # 模块级缓存，跨 invocation 复用
def handler(event, context):
    if 'db_client' not in _global_cache:
        _global_cache['db_client'] = init_db_pool()  # 仅首次加载
        _global_cache['init_time'] = time.time()
    return process_request(event, _global_cache['db_client'])

逻辑分析：利用 Python 运行时进程生命周期长于单次调用的特性，将耗时初始化（如数据库连接池、模型加载）提升至模块作用域；_global_cache 在同一实例内持久化，避免重复初始化。注意：不可存储 request-scoped 状态，须保证无状态性。

FaaS框架定制核心维度

维度	原生限制	可定制策略
初始化时机	启动即执行	延迟加载 + 首调触发预热
上下文生命周期	由平台隐式管理	显式 context.retain()（如阿里云FC）
状态边界	强制无状态	通过外部存储+本地 LRU 缓存协同

graph TD
    A[函数请求到达] --> B{实例是否存在？}
    B -->|否| C[拉取镜像→解压→初始化运行时→执行handler]
    B -->|是| D[复用内存中_global_cache→跳过DB/ML初始化]
    D --> E[毫秒级响应]

第五章：Go语言的边界反思与未来演进

Go在超大规模微服务治理中的内存压测瓶颈

某头部云厂商在将核心计费系统从Java迁移至Go后，单体服务拆分为237个gRPC微服务。压测中发现：当并发连接数突破12万时，runtime.mcentral锁争用导致GC STW时间突增至87ms（远超SLA要求的15ms）。根本原因在于Go 1.19默认的GOMAXPROCS=逻辑CPU数未适配NUMA架构，且sync.Pool在跨NUMA节点分配时引发远程内存访问放大。解决方案包括：显式设置GOMAXPROCS=物理核数、为每个NUMA zone初始化独立sync.Pool实例，并通过debug.SetGCPercent(10)降低堆增长敏感度——实测STW降至9.2ms。

泛型落地后的类型擦除陷阱

Go 1.18引入泛型后，某日志聚合组件使用func Log[T any](v T)封装结构化日志，但在处理map[string]interface{}嵌套数据时出现panic。经go tool compile -S反编译发现：当T为接口类型时，编译器生成的runtime.ifaceE2I调用未做nil检查。修复方案采用类型约束限定：func Log[T ~string | ~int | ~bool | struct{}](v T)，并为复杂类型提供专用重载函数。该案例已在Kubernetes v1.28的client-go日志模块中复现并修复。

Go与eBPF协同的可观测性实践

下表对比了三种Go应用性能采集方案在生产环境的实测指标：

方案	CPU开销	延迟注入	数据完整性	部署复杂度
pprof HTTP端点	3.2%	12μs	采样丢失率17%	低
go.opentelemetry.io	8.9%	41μs	全量上报	中
eBPF+libbpf-go	0.7%		内核态零拷贝	高

某金融风控系统采用eBPF方案，在net/http.serverHandler.ServeHTTP函数入口处注入探针，捕获所有HTTP请求的TCP建连耗时、TLS握手延迟及goroutine阻塞栈，数据直接写入ring buffer避免用户态内存拷贝。

// eBPF程序片段：捕获goroutine阻塞事件
func (p *Probe) onGoroutineBlock(ctx context.Context, data *blockEvent) {
    if data.Duration > 10_000_000 { // 超过10ms
        p.blockChan <- &BlockAlert{
            GoroutineID: data.GoroutineID,
            Stack:       p.getStack(data.StackID),
            Duration:    time.Duration(data.Duration),
        }
    }
}

错误处理范式的代际冲突

Go 1.20引入try关键字提案虽被否决，但社区已形成新共识：在CLI工具链中采用errors.Join构建复合错误，在Web服务中则用fmt.Errorf("failed to %s: %w", op, err)保持错误链。某CI/CD平台将Git操作错误分类为三类：网络类（可重试）、权限类（需人工介入）、仓库损坏类（触发灾备流程），通过自定义错误类型实现自动化决策：

type GitError struct {
    Op      string
    Code    GitErrorCode
    RawErr  error
}

func (e *GitError) IsRetryable() bool {
    return e.Code == NetworkTimeout || e.Code == RateLimitExceeded
}

模块依赖图谱的演化风险

使用go mod graph | grep "cloud.google.com/go@"分析某AI平台的依赖树，发现google.golang.org/api v0.123.0间接引入golang.org/x/net v0.15.0，而主模块直接依赖golang.org/x/net v0.18.0，导致http2包存在两个版本共存。通过go mod edit -replace强制统一版本后，HTTP/2连接复用率从63%提升至92%，长连接保活失败率下降4个数量级。

graph LR
    A[main.go] --> B[cloud.google.com/go/storage]
    B --> C[golang.org/x/net/http2]
    A --> D[golang.org/x/net/http2]
    C -.-> E[conflict: v0.15.0 vs v0.18.0]
    D -.-> E