{"id":617,"date":"2026-09-06T10:52:53","date_gmt":"2026-09-06T13:52:53","guid":{"rendered":"https:\/\/www.linuxpro.com.br\/2026\/09\/a-historia-da-linguagem-go\/"},"modified":"2026-09-08T13:02:09","modified_gmt":"2026-09-08T16:02:09","slug":"a-historia-da-linguagem-go","status":"publish","type":"post","link":"https:\/\/www.linuxpro.com.br\/en\/2026\/09\/a-historia-da-linguagem-go\/","title":{"rendered":"The history of the Go language"},"content":{"rendered":"

\"Mascote<\/p>\n

Go was born on a Google whiteboard on 21 September 2007 because C++ took too long to compile. In November 2025, the language celebrated 16 years of open source. In September 2026, the stable series is 1.27.1<\/strong>. Docker, Kubernetes, Terraform, the go<\/code> you install on Linux \u2014 all of it stems from that meeting of three people.<\/p>\n

<\/p>\n

Why a new language<\/h2>\n

Google toward the end of the 2000 decade: servers in C++ and Java, builds lasting three quarters of an hour, manual concurrency, dependencies that would not resolve. Rob Pike described the message in Go at Google: Language Design in the Service of Software Engineering<\/em>: it was not a language fad, it was software engineering at scale. Compile quickly, use static typing, talk to the network without a threading framework, and produce a single binary.<\/p>\n

The official FAQ pins down the origin: Robert Griesemer, Rob Pike, and Ken Thompson started sketching goals on the whiteboard on 21 September 2007. Within days it became a plan. In January 2008, Ken already had a compiler that emitted C. In May, Ian Lance Taylor independently began a GCC frontend. Russ Cox joined in late 2008 and took the prototype out of the lab.<\/p>\n

Unix, Plan 9, CSP<\/h2>\n

The three r\u00e9sum\u00e9s explain the language's taste. Ken Thompson co-created Unix and the B language. Pike came from Plan 9 and Inferno, co-invented UTF-8 with Thompson, and spent decades on concurrent languages \u2014 Newsqueak, Alef, Limbo \u2014 all following Tony Hoare's CSP (1978). Griesemer came from compilers: Java's HotSpot, V8. Go inherits Unix minimalism, CSP channels, and the stubbornness of a runtime that compiles in seconds.<\/p>\n

The name appeared in Pike's email on 25 September 2007: \u201cgo.\u201d Short, a verb, an easy domain. \u201cGolang\u201d is the search nickname \u2014 golang.org<\/code> existed because go.org<\/code> was not available. The canonical website today is go.dev<\/a>.<\/p>\n

The central idea: goroutines and channels<\/h2>\n

Before continuing the chronology, it is worth seeing what the language does differently \u2014 because it is not the syntax, it is the concurrency model.<\/p>\n

A goroutine<\/em> is not a system thread. It is a function that the Go runtime schedules across a handful of real threads, with an initial stack of a few kilobytes that grows on demand. That is why you launch ten thousand of them without a second thought \u2014 which with pthread<\/code> would be irresponsible:<\/p>\n

go processar(pedido)   \/\/ \u00e9 isso. N\u00e3o h\u00e1 pool, n\u00e3o h\u00e1 executor, n\u00e3o h\u00e1 Future.<\/code><\/pre>\n
Communication between them is the other side of the design, and it comes straight from Tony Hoare's CSP: instead of sharing memory and protecting it with a mutex<\/em>, you pass data through a channel. The community's motto sums it up: \u201cdo not communicate by sharing memory; share memory by communicating\u201d<\/em>.<\/p>\n
resultados := make(chan string)\n\nfor _, host := range hosts {\n    go func(h string) {\n        resultados <- checar(h)      \/\/ envia pelo canal\n    }(host)\n}\n\nfor range hosts {\n    fmt.Println(<-resultados)        \/\/ recebe, bloqueando at\u00e9 chegar\n}<\/code><\/pre>\n
And select<\/code> is the epoll<\/code> of the language: it waits on multiple channels at once, including a timeout channel.<\/p>\n
select {\ncase r := <-resultados:\n    fmt.Println(r)\ncase <-time.After(2 * time.Second):\n    fmt.Println(\"estourou o tempo\")\n}<\/code><\/pre>\n
It is this combination \u2014 cheap goroutines, channels, select<\/code>, and a static binary without a VM \u2014 that explains why virtually every infrastructure tool of the past decade chose Go. It is not the most expressive language; it is the one an entire team reads the same way on Monday.<\/p>\n
10 November 2009<\/h2>\n
Go became a public project that day. The mascot \u2014 the blue gopher with enormous eyes \u2014 came with the launch. Ren\u00e9e French, who had already drawn the Plan 9 bunny (and is married to Pike), adapted a gopher from a WFMU T-shirt. It was called Gordon for a while; since 2010 it has simply been \u201cthe Go gopher.\u201d GopherCons around the world came from there.<\/p>\n
It was not Go 1 yet. There were two compilers: gc<\/code> (the Plan 9 line, 6g\/8g) and Taylor's gccgo. The standard library echoed Plan 9's taste \u2014 the package fmt<\/code> even its name.<\/p>\n
Go 1.0 and the promise<\/h2>\n
28 March 2012: Go 1.0. The contract that sustained adoption: a program written for Go 1 keeps compiling on any 1.x. There will be no Go 2 that breaks the world. Companies committed. The cadence became twice a year (February and August, with delays of days, not years).<\/p>\n
Milestones that matter on Linux:<\/p>\n