Go Weekly #8: Go 1.27.4 Rolls Back ML-DSA in TLS Handshakes, net/http Drops Its Separate HTTP/2 Pool, cgo Takes Over Linux Signals Dynamically

Go · Weekly #8

Go Weekly #8: Go 1.27.4 Rolls Back ML-DSA in TLS Handshakes, net/http Drops Its Separate HTTP/2 Pool, cgo Takes Over Linux Signals Dynamically

goGoLanguage WeeklyNetwork ProtocolsRuntime OptimizationGenerics Evolution

Sources:GitHub Releases + 官方博客 + HN

📦 Releases

Stable Releases and Tip Progress

On November 10, 2026, the Go team shipped the latest stable patches, Go 1.27.4 and Go 1.26.11. They fix security vulnerabilities in cgo, the compiler, the linker and net/http (CVE-2026-97033 through CVE-2026-97043, plus CVE-2026-97054), along with several networking and compilation bugs. For the architecture and headline features of Go 1.27, see our earlier deep dive: Go 1.27 in Depth.

Summary of release and tip (Go 1.28-devel) changes:

Component / MechanismSourceApproachImpact
crypto/tls middlebox compatibilityIssue #82536Drop the post-quantum ML-DSA signature from the signature_algorithms_cert extensionAvoids handshake failures where outdated middleboxes mistake ML-DSA for an OpenSSL DoS attack.
net dial validationIssue #82023Dialer.Dial{TCP,UDP,IP} now validates the target address format up frontFixes malformed IP strings silently parsing as :: (the IPv6 unspecified address), which caused misrouted connections and port exhaustion.
SSA branch elimination fixIssue #81866cmd/compile’s branchelim pass now respects dominator-tree constraintsStops the compiler from wrongly deleting side-effecting Store instructions inside branches, eliminating a silent miscompilation.
HTTP connection pool consolidationCL 861962 (#82272)Remove the client’s separate HTTP/2 pool; Transport manages everythingEnds broken connection limits, missing request coalescing and LIFO connection leaks, and unifies scheduling state.
cgo takes over signals dynamicallyCL 856781 (#81450)On Linux, drop the C _cgo_sigaction and call libc dynamically from pure GoRemoves an external C compiler dependency, advancing the C-toolchain-free build goal for Go 1.28.
SIMD vector equalityCL 861618 (#73787)Replace the non-comparable marker with [0]uint64, preserving 8-byte alignment, and lower SSA == / !=Lets SIMD vectors serve as map keys and satisfy the generic comparable constraint.

The same day, Austin Clements published “Go Turns 17” on the official blog, laying out key Go 1.28 plans: inferring redundant types in composite literals (#12854), a general-purpose collections library (Set and OrderedMap, #80590) delivered in golang.org/x/exp, graduating the simd package, emitting export data early in the compiler for better build parallelism, and C-compiler-free cgo builds.


📝 Deep Dives

net/http Drops the Separate HTTP/2 Pool: One Merge Closes 14 Long-Standing Bugs (CL 861962 / #82272)

  • What happened: On November 13, Damien Neil landed CL 861962, removing the HTTP/2 client’s private connection pool and handing every HTTP/2 connection to the shared net/http.Transport pool. It closes 14 historical issues at once, including #25761, #34944 and #82272.
  • Why it matters: With two pools, HTTP/2 escaped the global MaxConnsPerHost limit, concurrent dials weren’t coalesced, and LIFO reuse could trigger retry jitter after the server silently dropped a connection. A single pool brings cross-protocol timeout handling and concurrent-stream control, and removes the out-of-sync state between pools.
  • Who is affected: Backend engineers building microservice gateways, high-throughput reverse proxies, and anything that leans heavily on connection pooling for downstream RPC.

cmd/cgo Moves Toward a C-Free Toolchain: Pure-Go Dynamic sigaction on Linux (CL 856781 / #81450)

  • What happened: On November 13, Michael Matloob landed CL 856781. On linux/amd64 and linux/arm64, the C-written _cgo_sigaction is replaced by a native Go implementation that calls libc’s sigaction symbol dynamically through a runtime function hook.
  • Why it matters: cgo has long required gcc/clang on the host, slowing CI and breaking cross-compilation consistency. Moving the glue logic to pure-Go dynamic symbol calls steadily removes cgo’s hard dependency on a C compiler, advancing the C-free delivery blueprint in issue #81450.
  • Who is affected: Platform engineers who slim down container images, run cross-architecture build pipelines, or ship lightweight Linux infrastructure.

simd / archsimd Vectors and Masks Get Full Comparison and Map-Key Support (CL 861618 / #73787)

  • What happened: On November 12, Austin Clements submitted a patch implementing == and != for simd and simd/archsimd vectors and masks. Under the hood, [0]func() is replaced by [0]uint64, which keeps 8-byte alignment, and the operators are lowered in SSA.
  • Why it matters: Vector types previously couldn’t be compared, couldn’t satisfy the generic comparable constraint, and couldn’t be map keys. The new mechanism follows floating-point semantics (NaN is unequal, +0 equals -0) and supplies the language groundwork for opening up a high-level SIMD API in Go 1.28.
  • Who is affected: High-performance computing engineers working on vector databases, audio/video algorithms and inference engines.

cmd/compile Removes Quadratic nilcheck Traversal: 64% Faster Builds for Generated Code (CL 837893)

  • What happened: On November 12, the compiler team merged a refactor of nilcheckelim that tracks dirty entries in an incremental list, replacing the full clear of XPosMap previously performed for every basic block.
  • Why it matters: The old code walked the whole table at O(blocks × PosBases), stalling compilation of large, deeply inlined functions. In benchmarks on a tree-sitter parser generated by wasm2go, single-package compile time dropped from 12.51s to 4.51s, a 64.0% speedup.
  • Who is affected: Teams maintaining large parsers, complex business state machines, or codegen-heavy projects that emit huge amounts of struct code.

🔥 Community Buzz

1. The fmt.ErrorAppender Proposal: Embedded Zero-Allocation Needs Meet Standard Library Governance

  • Heat: GitHub Issue #83013, with 25 long technical comments and dense back-and-forth with the core team in 7 days.
  • What happened: soypat, maintainer of the embedded network stack lneto, proposed declaring an ErrorAppender interface (ErrorAppend(b []byte) []byte) in fmt. Built-in errors such as net.ParseError could then append text directly to an existing slice, avoiding the heap allocation from repeated Error() string calls.
  • The debate:
    • Performance at the limit (soypat and others): On TinyGo microcontrollers or high-throughput gateways, error-log concatenation triggers brief GC pauses and long-tail latency. Standard library errors give no control over allocation, so low-level developers avoid standard types. A lightweight interface opens a zero-allocation call chain at minimal cost.
    • Governance restraint (Ian Lance Taylor, Sean Liao and others): A specialized append interface just for errors lacks global consistency, and overlaps heavily with a general StringAppend (#71854). Retrofitting the standard library would add a heavy maintenance burden and risk behavioral drift across multiple methods.

2. JetBrains’ 2026 Report: net/http at 46%, Level with Gin as Full-Stack and Terminal AI Reshape Workflows

  • Heat: JetBrains published “The State of Go in 2026” (28,945 developers surveyed worldwide, including 1,836 Go engineers); widely shared on Hacker News and Reddit.
  • What happened: Native net/http as a web framework climbed from 32% in 2025 to 46%, nearly matching Gin’s steady 48%. Projects pairing Go with TypeScript jumped from 24% in 2024 to 43%. 86% of Gophers use AI coding agents in the terminal CLI weekly, while 79% still review code line by line by hand.
  • The debate:
    • Standard-library minimalists: Since Go 1.22 added routing wildcards and HTTP methods natively, the core moat of third-party routers has weakened. AI agents also tend to generate dependency-free standard-library code, so developers are cutting heavy frameworks to lower supply-chain audit costs.
    • Middleware realists: Large production environments still need the parameter binding, structured validation and tracing plugins that Gin or Echo provide. Native net/http has no unified business-error interception, and in big teams it tends to decay into scattered glue code.

3. Hardware-Aware Blocked Bloom Filters: Cache-Line Partitioning Challenges the Classic Bloom Filter

  • Heat: Hacker News 61 points and 7 long comments; the blog and repo topped the day’s recommendations.
  • What happened: Developer Anton Zhiyanov released unsure, a lightweight pure-Go library of probabilistic data structures (Bloom filter, Count-min sketch, HyperLogLog, T-digest and Top-k). It demonstrates deduplicating 1 million 8-byte strings in 1.24 MB at a 1% false-positive rate, 98% less than the 64 MB of a regular set.
  • The debate:
    • Hardware-fit camp (kristianp and others): The library uses a blocked Bloom filter, splitting the bit array into 512-bit blocks exactly as wide as a CPU cache line. One hash per query is enough to probe every bit within a single cache line, eliminating cross-line jumps from multiple hashes and greatly improving hit rates.
    • Feature-completeness camp (donatj, ncruces and others): Blocking partly breaks global bit-distribution uniformity, and Bloom filters can’t delete. For workloads needing deletion or a lower false-positive rate, a Cuckoo filter or an SQLite virtual-table extension is the sturdier engineering choice.

Next Week

  • Composite literal inference lands: Track the front-end parser changes on Go 1.28 tip for omitting redundant types in composite literals (#12854).
  • x/exp generic collections under review: Follow the interface draft and test results for the standard generic Set and OrderedMap (#80590) headed for golang.org/x/exp.