Go Language Overview, Project Practices, and New Features in Go 1.18

Go is a statically typed, compiled, concurrent language created by Google in 2009, featuring garbage collection and cross‑platform support. It was designed by Robert Griesemer, Rob Pike, and Ken Thompson, with later contributions from Ian Lance Taylor and Russ Cox.

The language solves concurrency and development‑efficiency challenges with a simple syntax, rich standard library, native goroutine and channel support, fast compilation, automatic garbage collection, easy deployment, and cross‑platform capabilities.

Many Chinese companies (Qiniu, Alibaba, ByteDance, Tencent, Baidu, Xiaomi, JD.com) use Go in cloud‑native, blockchain, gaming, micro‑service, and backend scenarios. Prominent open‑source projects such as Docker, Kubernetes, Etcd, CockroachDB, and Ethereum are also written in Go.

Project Practice 1 – Million‑level Concurrent State Machine (818 Interactive TV Event)

The 818 event required handling ~2 million concurrent WebSocket connections with real‑time state updates. A state machine built on Redis Pub/Sub delivered updates via WebSocket, with HTTP/2 polling as a fallback. Benchmarking showed Go responding faster and using less memory than a Java Spring implementation.

// WS long‑connection handler (Gin)
func WS(ctx *gin.Context) {
    conn, err := ws.Upgrade(ctx.Writer, ctx.Request)
    if err != nil { ctx.AbortWithStatus(400); return }
    // push first message, register connection, etc.
    monitor.PushEnter <- conn
    Read(conn)
}

Memory usage grew by ~21 GB when establishing a million WebSocket connections because each connection created a goroutine and associated buffers.

To reduce memory, an epoll‑based connection manager was introduced, allowing a single goroutine to handle all connections.

type epoll struct {
    fd          int
    connections map[int]*websocket.Conn
    lock        *sync.RWMutex
}
func MkEpoll() (*epoll, error) { /* create epoll fd */ }
func (e *epoll) Add(conn *websocket.Conn) error { /* register fd */ }
func (e *epoll) Wait() ([]*websocket.Conn, error) { /* poll events */ }

Using epoll reduced memory consumption by about 20 %.

Project Practice 2 – Embedded Edge‑Computing Network (Narrow‑band Live Streaming)

A 4G/5G backpack device running a Go‑based fragment aggregation program streams video using UDP and a custom protocol, leveraging Raspberry Pi hardware and OpenWRT.

package main
import (
    "fmt"
    "net"
    "log"
)
func main() {
    listen, err := net.Listen("tcp", ":8272")
    if err != nil { log.Fatal(err) }
    for { conn, err := listen.Accept(); if err != nil { continue }
        go handleConnection(conn) }
}

Cross‑compilation for ARM64 is as simple as: GOOS=linux GOARCH=arm64 go build -o app Project Practice 3 – Million‑DAU VR Panoramic Car View

The service, built entirely with Go, serves millions of daily users, runs in containers, and scales horizontally. New Go 1.18 features such as generics were applied to improve cache‑penetration protection and reduce reflection overhead.

New Feature 1 – Generics (Type Parameters)

Generics allow defining functions and types with type parameters, e.g.: func Less[T int | int64](a, b T) bool { return a < b } Constraints can be expressed using interfaces or the built‑in any and comparable types. Example of a generic sortable slice:

type Sortable interface { ~uint | ~int | ~float64 | ~string }
type SortSlice[T Sortable] []T
func (s SortSlice[T]) Len() int           { return len(s) }
func (s SortSlice[T]) Less(i, j int) bool { return s[i] < s[j] }
func (s SortSlice[T]) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
func Sort[T Sortable](s []T) { sort.Sort(SortSlice[T](s)) }

Generics also simplify singleflight cache‑penetration protection:

var g Group[Exterior]
v, _, _ := g.Do("key", func() (Exterior, error) { return fetch(), nil })
return v

Performance impact: compilation time for generic code is ~15‑18 % slower than non‑generic, but runtime overhead is negligible; generic code can be up to 90 % faster when it eliminates reflection.

New Feature 2 – Multi‑module Workspace

Go 1.18 introduces workspaces, allowing simultaneous development of multiple modules without replace directives. Example:

go work init
go work use ../dal
go work use .

New Feature 3 – Fuzzing

Fuzz testing (functions named FuzzXxx in *_test.go) automatically generates inputs to discover edge cases. It is experimental, may consume significant memory, and currently supports only basic types.

Limitations of Go 1.18 Generics

Type parameters cannot be used on struct methods.

Generic functions cannot declare nested types.

Embedded fields cannot be type parameters.

Overall, Go 1.18 marks a milestone by bringing generics, workspaces, and fuzzing to the language, paving the way for more robust and maintainable backend systems.

Future work includes deeper micro‑service research (go‑zero, kitex, dubbo‑go, tars‑go) and broader adoption of Go across business domains.