Go: A Documentary

by Changkun Ou <changkun.de> (and many inputs from contributors)

This document collects many interesting (publicly observable) issues, discussions, proposals, CLs, and talks from the Go development process, which intends to offer a comprehensive reference of the Go history.

Table of Contents

• Go: A Documentary
  • Disclaimer
  • Sources
  • Origin
  • Committers
    • Core Authors
    • Compiler/Runtime Team
    • Library/Tools/Release/Security/Community
    • Group Interviews
  • Timeline
  • Language Design
    • General
    • Slice (1.2)
    • Package Management (1.4, 1.5, 1.7)
    • Type alias (1.9)
    • Defer (1.14)
    • Error values
    • Channel/Select
    • Generics
    • Iterator
    • Compatibility
  • Compiler Toolchain
    • Office Hours
    • Compiler
    • Linker
    • Debugger
    • Race Detector
    • Tracer
    • Lock Analysis
    • Builder
    • Modules
    • gopls
    • Testing, x/perf
  • Runtime Core
    • Scheduler
    • Execution Stack
    • Memory Management
      • Allocator
      • Collector
    • Statistics
    • Memory model
    • ABI
    • Misc
  • Standard Library
    • syscall
    • os, io, io/fs, embed
    • go/*
    • sync
      • Map
      • Pool
      • Mutex, RWMutex
      • Groups
      • atomic
    • time
    • context
    • encoding
    • image, x/image
    • math
    • Mobile
    • log
    • misc
  • Unclassified But Relevant Links
  • Fun Facts
  • Acknowledgements
  • License

Disclaimer

• Most of the texts are written as subjective understanding based on public sources
• Factual and typo errors may occur. Referring to the original link if some text conflicts to your understanding
• PRs are very welcome for new content submission, bug fixes, and typo fixes
• Use Issues for discussions

Back To Top

Sources

There are many sources for digging the documents that relate to Go's historical design, and here are some of the official sources:

• go.dev/blog
• dev.golang.org
• build.golang.org
• farmer.golang.org
• go.dev/talks
• go.dev/doc
• go.dev/pkg
• github.com/golang/go
• github.com/golang/proposal
• github.com/golang/go/wiki
• go-review.googlesource.com
• groups.google.com/g/golang-nuts
• groups.google.com/g/golang-dev
• groups.google.com/g/golang-tools

Back To Top

Origin

Go is a big project driven by a tiny group of people and the crowd of wisdom from the language user community. Here are some core committers to the project if you are interested in following their excellent work.

Go's origin is attractive without doubts. By listening to the talks held by these people, you could learn more about their oral history and fun stories behind the great work.

For instance, here are some exciting talks regarding the historical feats in Go might be your starting points (as a subjective recommendation): talk/rob2007, talk/rob2009, talk/rob2010b, talk/rob2010d, talk/rob2011a, talk/rob2013a, talk/rob2019, talk/robert2015, talk/russ2014, steve2019b, etc.

Back To Top

Committers

Core Authors

The Go language was created by Rob, Robert, and Ken initially because Rob was bothered by slow C++ compiling times, talked to Robert, and luckily Ken was in the next office. Later, Ian joined the project after showing interest, and wrote the gccgo. Rob and Ken are retired. Robert and Ian currently work on adding generics to Go. Russ is also one of the core authors of the project in the early stage. Back then, he was a newcomer at Google, and Rob invited Russ for joining the Go team since he knew Russ from way back because of the Plan 9 project. Russ worked on the early Go compiler, runtime, as well as the leap of Go 1.5 bootstrap. Now, Russ is the tech leader of the Go team.

• Rob Pike. (Robert C. Pike, M. Sc.) Website, Blog, GitHub, Twitter, Reddit. (Retired)

  • Alma mater: University of Toronto (BS), California Institute of Technology
  • talk/rob2007
    Advanced Topics in Programming Languages: Concurrency/message passing Newsqueak. May 9, 2007

    Summary: Summary: In this Google Tech Talk from May 2007, Rob Pike, creator of UTF-8 and Plan 9 for Bell Labs, discusses his programming language, New Squeak, which features interesting mechanisms for concurrency and message passing. Pike argues that there are two ways to deal with the mismatch between the concurrent world we live in and the sequential computers we use to write programs: make the world look synchronous and sequential, or make software concurrent. Pike discusses the limitations of low-level concepts like threads, shared memory, and locks when it comes to programming for concurrency. New Squeak is a programming language that was created in 1988 to address issues that arise when writing software for a concurrent world. It has lambdas as functions, process management software, and channels as first-class citizens. The language inspired other languages and was used as a systems language at Bell Labs for a few years to build interesting tools. The talk focuses on processes and channels in New Squeak and how to write programs using these concepts. Channels are a communication tool used in programming that reduce the number of tokens needed for communication. Channels in CSP are introduced by the keyword Chan in New Squeak and are unbuffered synchronous communication ports that synchronize and communicate values between processes. New Squeak's channels and select statements enable potential communications and allow processes to block until one or more communications can proceed. The article introduces a simple language with n-way muxing and presents a program that prints sequential integers to a channel. It also explains the concept of a prime sieve and filter process to find all the primes that come out of a calculation. The system can also be used to manipulate power series. The article discusses the use of interfaces and channels in programming, with an example from the Newspeak language. The author discusses a system model used in building window systems in Plan Nine, which involves defining components as interfaces that capture communication and data flow through channels. This approach was used in all major user-level services in Plan Nine and was made easier by the author's previous experience with concurrency models in programming. The model allows for complex interactions between components and allows for composing interfaces themselves, rather than just state machines. The author also discusses the challenges of debugging concurrent programs and the limitations of CSP-like libraries for implementing select operations. They propose the idea of a shim interface that guarantees deadlock-free operation and can isolate and kill misbehaving clients. The Squint interpreter, a code from 1988, lacks many libraries for graphics and other functions. The idea of implementing a communication channel model on top of mutexes in C++ is discussed, and the cost of a channel versus a callback is debated. Optimizations can be made to generate more compact code for different forms of select.

  • talk/rob2009 The Go Programming Language. Nov 27, 2009.
  • talk/rob2010a
    Go Programming. Google I/O 2010. May 20, 2010

    Summary: In the Google I/O 2010 podcast episode titled "Go Programming, " Rob Pike and Russ Cox discuss the unique features and principles of the Go programming language. They emphasize the importance of using core concepts and idioms specific to Go, rather than translating code from other languages. One key feature of Go is its different types, including basic and composite types. Pike and Cox explain that Go is object-oriented but not type-oriented, meaning it does not have classes or inheritance. They also highlight the implicit nature of Go, where type declarations can be omitted. Concurrency is another significant aspect of Go programming. Pike and Cox explain that Go focuses on concurrent programming rather than parallel programming. They discuss the benefits of concurrency and how it allows for the construction of well-structured programs that can effectively utilize multiple cores. The podcast episode also delves into the use of interfaces in Go programming. Interfaces are used to define common methods that different types can implement, allowing for code reuse and flexibility. Pike and Cox provide examples of how interfaces are used in the block cipher package in Go. The speakers compare Go to other languages, such as Java, and highlight the advantages of using Go for implementing interfaces. They mention the flexibility of multiple wrappers and satisfying multiple interfaces. The concept of chaining readers together to decrypt and decompress data is also discussed in the episode. Pike and Cox explain the concept of load balancing in distributed systems and describe a simple model for distributing tasks to workers. They discuss the role of a load balancer in handling requests and the use of request and response channels. Throughout the episode, Pike and Cox emphasize the unique principles and features of Go, such as closures and channels, which make it a preferred choice for concurrent programming. They also mention the suitability of Go for different environments, such as server, desktop, and mobile. In conclusion, the "Go Programming" episode of the Google I/O 2010 podcast provides an in-depth overview of the Go programming language. Pike and Cox highlight its unique features, such as different types, concurrency, and the use of interfaces. They compare Go to other languages and discuss its advantages for concurrent programming. Overall, the episode showcases the power and efficiency of Go and its potential for various programming environments.

  • talk/rob2010b
    Origins of Go Concurrency style. Emerging Languages Camp 2010. July 21, 2010.

    Summary: In the podcast episode titled "Rob Pike. Origins of Go Concurrency Style, " Rob Pike discusses the origins and concepts of concurrency in the Go programming language. He highlights the influence of Tony Hoare's paper on communicating sequential processes (CSP) in 1978, which emphasized communication and parallel composition of sequential processes. Pike describes CSP as a mathematical and elegant language that focuses on communication and synchronization between sender and receiver. Pike explains how processes can be combined in parallel, resembling a pipeline, and mentions the limitations of CSP, such as the inability to dynamically create processes or use send as a guard, and the lack of support for threads or mutexes. He also discusses the development of concurrent programming models and the emergence of the Occam language, which laid out the foundations for programming multi-processors and concurrent algorithms without the need for locks. The podcast episode also touches on the development of the Limbo language into Go, highlighting the power of Go's CSP model and its use of channels for communication and concurrency. Channels are described as first-class values that enable the transmission of data and capabilities between processes. Pike mentions the development of the lf language, which faced challenges due to its lack of garbage collection, but Limbo addressed these issues and became more successful in its limited domain. The benefits of using concurrency in programming are discussed, particularly in the context of the CSP model. Pike emphasizes how concurrency allows for efficient computation in areas such as cryptography and graphics, while also providing the opportunity for code reusability. He recommends reading the original CSP paper for a deeper understanding of the language and discusses the concepts of process control and communication, emphasizing the importance of understanding the power of co-routines. Pike also highlights the ease and safety of writing concurrent programs in Go, emphasizing that Go's concurrency features are natural and easy to use. He mentions the safety of Go's memory system and type safety, cautioning against using the unsafe package. The language has been successfully used in various applications, including high-traffic websites, and offers powerful channel capabilities for communication. The podcast episode concludes by explaining the concept of channels in a systems language, where types determine what can be sent through a channel. It discusses the efficiency and flexibility of this approach compared to traditional sharing and locking models. Pike also mentions the concept of passing pointers in programming and how it relates to efficiency and ownership, emphasizing the importance of understanding that once a pointer is passed, it is no longer the concern of the original owner. The episode highlights the idea that making things easy can lead to increased efficiency, which is seen as a positive point.

  • talk/rob2010c
    Public Static Void. OSCON 2010. Jul 22, 2010.

    Summary: In the podcast episode titled "Public Static Void" from OSCON 2010, Rob Pike, a software engineer from Google, Inc. , discusses various topics related to programming languages and their complexities. Pike emphasizes the value of early programming languages, highlighting their simplicity and efficiency compared to the complexity and noise of modern software development. One of the challenges Pike addresses is the intricacy involved in calling functions in C++, as well as the absence of garbage collection. He also mentions the difficulty for non-expert programmers in choosing from different Boost templated pointer types for memory management. Pike acknowledges the complexity of sophisticated programming languages like C++ and the issues that arise from this. The significance of C++ and Java in programming, particularly in education and industry, is also discussed. Pike questions why these languages have become the standard and provides a simplified history of their development. He disagrees with the trend of using C++ and Java for teaching, arguing that both languages are too complex and verbose to be user-friendly. The limitations of using patterns in software development are highlighted, with the author suggesting that as programming languages improve, the need for patterns may decrease. Object-oriented programming languages are criticized for being bureaucratic and repetitive, and the text encourages awareness of alternative programming models. The issue of repetitive and nonsensical code is addressed, with an example given to illustrate the importance of avoiding such code in programming. The problems with using ambiguous integers and booleans in code are also discussed, emphasizing the need for clear data declarations. The bureaucratic nature of programming languages is explored, with popular languages like Python, Ruby, and JavaScript being criticized for becoming cumbersome. The emergence of new programming languages, such as Haskell and Scala, is seen as a response to the frustrations of working with older languages. The misconception that dynamic, interpreted languages are superior to compiled, static languages is challenged. The limitations of both old and new programming languages are discussed, and the need for a language that combines the benefits of both is argued for. In conclusion, the podcast episode delves into the complexities and challenges of programming languages. It highlights the importance of simplicity, efficiency, and user-friendliness in programming languages, and suggests that better solutions are needed to reduce the burden on developers. The Go programming language is mentioned as an attempt to fulfill these requirements, combining the safety and performance of a statically typed compiled language with the expressiveness and convenience of a dynamically typed interpreted language.

  • talk/rob2010d
    Another Go at Language Design. Aug 27, 2010.

    Summary: In the podcast episode titled "Another Go at Language Design, " Rob Pike, a Principal Engineer at Google, Inc. , discusses the development of the Go programming language. Pike explains that the creation of Go was driven by the need for a language that could address the challenges faced by large code bases. He emphasizes that the development of Go is a collaborative effort involving many talented individuals, and expresses gratitude for the talented individuals he is working with. Pike discusses the concept of a "one true way" in computer science and how it depends on tools, problems, and beliefs. He mentions an upcoming talk about dynamic languages and static techniques. Pike also shares a quote about the simplicity and effectiveness of early programming languages. The podcast episode highlights the challenges of managing dependencies in C and C++ programs, which can lead to slower compilation times and hinder scalability. It introduces Go as an alternative, highlighting its ability to handle packages and dependencies effectively. The benefits of Go are discussed, including its speed and the ability to compile and run programs faster. The author suggests including the compiler in the runtime system to make the process even more efficient. The value of a new and clean compiler is emphasized, as it can significantly reduce build times and improve overall performance. The episode also explains methods and interfaces in Go, covering the syntax and examples of method declarations. The use of interfaces to define behavior is discussed, as well as the concept of empty interfaces, which can be satisfied by any type. The power of empty interfaces in controlling printing behavior is explored, mentioning the implementation of the printf function. Implicit interfaces are introduced, emphasizing the importance of type safety and convention. The flexibility and abstraction provided by interfaces are discussed, using the example of the 'reader' interface. The use of mutex and channels in worker pools to manage data sharing and communication is explained. The importance of garbage collection in concurrent server software is discussed, and how Go provides intrinsic safety and simplifies interface design. The use of the 'unsafe' library in low-level programming is mentioned, along with its potential risks. The improved performance of bounds check loops in modern machines and the reduced risk of buffer overflow exploits in Go are highlighted. The advantages of using Go for systems development are discussed, including its features such as unsigned types, bit-level operations, and control over memory layout. The design principles of Go are emphasized, including its control, safety, simplicity, and clarity. The episode explains how Go provides control over memory allocation and usage while ensuring safety without sacrificing performance. The visibility rules and the concept of constants in Go are also mentioned. Overall, the podcast episode praises the simplicity, efficiency, and productivity benefits of the Go programming language. It highlights its use in large-scale software development, including within Google, and its favorable license and open-source development. The episode also discusses various concepts in programming, including package namespaces, exceptions, classes and inheritance, and channels in the concurrency model. It emphasizes the importance of teamwork and unanimous decision-making in the collaborative design process of Go.

  • talk/rob2011a Parallelism and Concurrency in Programming Languages. Feb 17, 2011.
  • talk/rob2011b Google Go: Concurrency, Type System, Memory Management and GC. Feb 25, 2011.
  • talk/rob2011c
    Lexical Scanning in Go. Aug 30, 2011.

    Summary: In this episode of the Google Technology User Group, Rob Pike delivers a talk on Lexical Scanning in Go. The talk, given on Tuesday, 30 August 2011, focuses on the Go programming language and its relevance to solving structural mismatch problems in computing. Pike begins by explaining the concept of lexemes and tokens in programming languages. He discusses the challenges of tokenization and the advantages and disadvantages of using lexical analysis tools. Pike argues that it is often more efficient to write a custom lexer and highlights the importance of adaptability across programming languages. The process of writing a lexer is then discussed, which involves defining states and actions. Pike proposes a better approach to the current state machine model by continuously moving to the next state instead of discarding the current state. He introduces the concept of state functions, which are functions that return another state function and can be used in a lexer to loop through different states. Pike also explains how Go channels can enable communication between a lexer and a parser. He provides an explanation of the purpose of variables such as 'start' and 'pause' in a lexer and describes the role of Lex Text in scanning the input. The structure of an action block and the process of transitioning to a new state are also discussed. The talk then delves into the process of parsing characters in a template system, including how different characters are handled and the use of helper functions. Pike explains the concept of acceptors in a lexer, which are helpful for scanning complicated input. He also discusses how to lex numbers in a string, including different number formats and the use of tools to find the end of a number. Pike emphasizes the importance of error checking in parsing and validating numeric input. He mentions the use of a parser library to convert the input into a number, relieving the programmer from manual conversion. The concept of error functions in state machines is also explained, along with their role in creating formatted error messages. The talk concludes with a discussion on the challenges of running Go routines to completion during initialization in Go programming. Pike suggests a solution by changing the input and using a traditional lexing API without channels. The process of transforming existing code to use a traditional lexing API is explained, along with the concept of a run loop and select statement in programming. Overall, Pike's talk provides valuable insights into lexical scanning in Go and offers practical solutions to common challenges faced by programmers.

  • talk/rob2012a
    Go Concurrency Patterns. Google I/O 2012. Jul 2, 2012.

    Summary: In the podcast episode titled "Google I/O 2012 - Go Concurrency Patterns, " Rob Pike discusses the importance of concurrency in designing high-performance network services. Pike, a renowned expert in programming, highlights Go's concurrency primitives, such as goroutines and channels, which provide a simple and efficient way to express concurrent execution. Pike begins by explaining the concept of concurrency and its practical uses. He clarifies that Go is a concurrent language, not a parallel one, and discusses how concurrent code can still have a useful structure even when running on a single processor. He also discusses the origins of concurrent programming ideas and languages, leading up to the development of Go. Pike emphasizes the unique features and intellectual depth of these languages. The podcast delves into the concept of goroutines in Go programming and how they allow for concurrent execution of multiple functions. Pike emphasizes the importance of communication and synchronization in creating proper concurrent programs. He provides a comprehensive explanation of channels in Go, which are essential for concurrent programming. Pike covers the declaration, initialization, sending, and receiving of values on channels. He highlights that channel operations are blocking and serve as a synchronization mechanism between goroutines. Pike also mentions the use of buffered channels and the Go approach of using channels for communication and synchronization instead of sharing memory. The episode explores the use of concurrency and the select statement in Go programming. The select statement is highlighted as a key feature of Go's concurrency model, allowing for easier control of program behavior based on communication. Pike discusses non-blocking communication, timeouts, and the use of a quit channel to signal the end of a process. He emphasizes the importance of proper communication to avoid premature program shutdown and the need for sophisticated communication between programs for synchronization. Pike also discusses the concept of goroutines, which are lightweight elements in programming. He uses the example of running 100, 000 gophers to illustrate the speed and efficiency of goroutines. Pike explains the process of how a Google search works, including the use of independently executing backends to find and deliver search results. He describes a process of testing the speed of a program and measures the time it takes for the search results to be obtained. Pike explains how launching goroutines for each backend makes the search process concurrent and parallel, reducing waiting time. The episode concludes by discussing the advantages of using concurrency in Go programming. Pike highlights the simplicity and reliability of using Go compared to other approaches. He also discusses the use of concurrency tools in software construction and the importance of caution when experimenting with concurrent programs. Pike addresses questions about channel locking, garbage collection, stack allocation, and the select control structure in Go. Overall, the podcast episode provides a comprehensive exploration of Go's concurrency features and their practical applications in designing high-performance network services.

  • talk/rob2012b
    Why Learn Go?. Sep 12, 2012.

    Summary: In this podcast episode titled "Why Learn Go?", Rob Pike, co-creator of the Go programming language, discusses the need for a new compiled language that can effectively handle the demands of modern computing. Pike argues that while languages like C, C++, and Java have been sufficient for server software development, they do not directly address the properties of the modern computing environment. With the rise of networking, cluster computing, and big data, there is a growing need for a language that is efficient and can run on multiple machines. Pike highlights the importance of dependency management in Go programming and how it contributes to faster build times. Unlike other languages, Go's import mechanism and clean dependency hierarchy prevent redundant imports and unnecessary recompilation. This results in significantly faster build times, with Go programs being built in seconds compared to minutes or hours for other languages. The recent release of Go version 1, which offers stability and locked-down APIs, has led to increased adoption of the language. Pike emphasizes that the Go community prioritizes effective use of the language rather than constantly releasing new versions. This focus on stability and usability has contributed to the language's popularity and widespread adoption. Pike concludes by expressing his appreciation for the opportunity to address the importance of utilizing an efficient and swift language for present tasks, rather than solely focusing on its development. He believes that Go is a next-generation language that is well-suited for today's modern computer environment, with its fluidity, ease of construction, and efficiency for building large programs. In summary, Rob Pike's podcast episode "Why Learn Go?" discusses the need for a new compiled language that can handle the demands of modern computing. He highlights the importance of dependency management in Go programming, which contributes to faster build times. The recent release of Go version 1, with its stability and locked-down APIs, has led to increased adoption of the language. Pike emphasizes the significance of utilizing an efficient and swift language for present tasks, rather than solely focusing on its development. Overall, Go is presented as a next-generation language for today's modern computer environment.

  • talk/rob2013a
    The path to Go 1. Mar 14, 2013.

    Summary: In the podcast episode titled "The path to Go 1, " Rob Pike and Andrew Gerrand discuss the development and release of Go 1 at OSCON 2012. The episode begins with a discussion on the development of the Go programming language, which was designed to solve software writing problems at Google. Go is a statically typed and compiled language that focuses on composing programs using interfaces and native concurrency support. The speakers then delve into the growth and development of the Go project, including the use of the mercurial version control system and the Rietveld code review plugin. They highlight the challenges faced in maintaining stability and the implementation of weekly snapshots to ensure stability. However, this caused confusion among contributors and users. To address version skew issues, a formal release process was implemented, but users still struggled to stay up to date. This led to the development of the powerful tool called "go fix, " which parses and rewrites Go code, making it easier for users to update their code to the latest version of the language. While beneficial for the Go project, the tool has drawbacks, such as an increase in code churn and the perception of Go as an unstable language, hindering adoption by some companies. The development process of Go version one is then discussed, with the goal of addressing concerns about its perceived instability and providing a reliable version for companies to depend on. The process involved addressing concerns, improving the language and its libraries, and building a new build toolset. The engagement of developers in the open-source community, particularly in Windows, was crucial. The release of Go 1 marked a shift in development approach, with a focus on long-term compatibility and improvements to Windows support. Language changes included the introduction of a new rune type and improvements to APIs. The introduction of a new "go" tool eliminated the need for make files and other build scripts, improving dependency management and the development workflow. Go 1 also brought improvements in documentation and testing, with a redesigned website providing streamlined installation instructions and comprehensive documentation. The release had a positive impact on the Go programming community, as developers redirected their efforts towards improving performance, stability, and bug fixing. The development team behind Go 1 has shifted their focus to using Go themselves and gathering feedback for future versions. Active development is ongoing, with a focus on stability, bug fixes, and efficiency improvements. Major improvements have been made to the compiler's code generation and the garbage collector. The team is also working on portability and developing new libraries. In conclusion, the podcast episode provides insights into the development and release of Go 1, highlighting the challenges faced, the improvements made, and the positive impact it had on the Go programming community. The speakers emphasize the importance of clean and rigorous dependency management and the need to reach a wider audience through diverse talks and engaging tutorials.

  • talk/rob2013b Go at Google. Apr 13, 2013.
  • talk/rob2013c Go Programming with Rob Pike and Andrew Gerrand. Aug 14, 2013.
  • talk/rob2013d
    Concurrency Is Not Parallelism. Oct 20, 2013.

    Summary: In the podcast episode titled "Concurrency Is Not Parallelism, " Rob Pike speaks at Heroku Waza 2012. He explores the difference between concurrency and parallelism in programming languages, with a focus on the Go programming language. Pike argues that concurrency is superior to parallelism and clarifies the misconceptions surrounding these concepts. Pike emphasizes the importance of communication in coordinating concurrent tasks and references Tony Hoare's paper on communicating sequential processes as a highly regarded resource. He also discusses the select statement in Go, which serves as a multi-way concurrent control switch. The episode delves into the practical problem of getting rid of obsolete manuals using gophers and the need for efficient execution tools. Pike introduces the idea of using multiple gophers to move books more efficiently, highlighting the concepts of concurrency and parallelism. By coordinating the actions of multiple gophers, the process can be sped up. The episode explores different design patterns and strategies for achieving higher throughput, such as introducing staging dumps and increasing the number of gophers involved. However, it acknowledges that the example used is simplistic and lacks real-world relevance. Pike also discusses the similarities between the design of a book pile and a web serving architecture. He introduces the concept of go routines in Go programming language, which are similar to threads but more efficient and easier to create. Go routines allow for parallel execution and increased efficiency in programming. The episode explains the use of channels in Go for communication between go routines and introduces the concept of select, which allows the program to listen to multiple channels at once. Pike highlights the advantages of go routines over traditional threads in terms of efficiency and cost-effectiveness. Furthermore, the episode discusses the use of closures and channels in concurrent Go programming. It explains how closures can be used to wrap background operations and perform tasks concurrently, highlighting their simplicity and efficiency. The episode also demonstrates the use of channels in building a load balancer, showcasing the ease of expressing concurrent operations and the benefits of using channels in Go. Overall, the episode explores the advantages of concurrency and its role in building efficient algorithms. It discusses load balancing in a busy system and the use of channels in the Go programming language for communication. The episode distinguishes between concurrency and parallelism and provides additional resources for further understanding. Pike expresses appreciation to Hiroko for the invitation. In conclusion, Rob Pike's podcast episode on "Concurrency Is Not Parallelism" provides valuable insights into the differences between concurrency and parallelism in programming languages, with a focus on the Go programming language. Pike emphasizes the importance of communication, introduces various concepts and tools in Go, and discusses the advantages of concurrency in building efficient algorithms.

  • talk/rob2014a
    Hello Gophers! Gophercon Opening Keynote. GopherCon 2014. Apr 24, 2014.

    Summary: In the GopherCon 2014 Opening Keynote by Rob Pike, the history and development of the Go programming language are explored. Pike discusses the initial discussions and drafting of the Go specification, as well as the challenges faced in creating the first Go compiler. He highlights the changes in syntax and functionality of the program over time, including the introduction of the 'print' keyword and the modification of the 'main' function. The significance of packages in the design of the Go programming language is emphasized. Pike explains the importance of wrapping up code into libraries, controlling dependencies, and ensuring fast build times. He also discusses the concept of package imports, the benefits of using linear compilation, and the use of the 'export' keyword. The importance of initialization in Go programming is also explored. Pike mentions the challenges faced in implementing controlled initialization in C and the importance of proper program initialization in Go. Various aspects of the Go programming language are discussed, including syntax, import and namespace, formatted printing, UTF-8 handling, and the history of semicolons. Pike explains the reflection-driven approach to formatted printing, the significance of UTF-8 in Go, and the unique handling of non-ASCII characters. The development and evolution of the Go programming language are highlighted, emphasizing the importance of collaboration and a small team in its design process. Pike mentions the first concurrent program written in Go, called the prime sieve, and its structure. He also discusses the evolution of the CSP programming language and the changes in the syntax of Go over time. The stability of the Go programming language is emphasized, as it has remained largely unchanged for almost five years. Pike mentions that this stability has instilled trust in users and attracted beginners with its fast compiler and binary execution. He also discusses the development process and the contributions of the open-source community. The 'select' feature in Go is highlighted as crucial for implementing concurrency and creating complex structures. Pike discusses the challenges of implementing a debugger for Go language and using Go as an embedded language. He mentions ongoing efforts in the open-source community to address these challenges. Overall, the GopherCon 2014 Opening Keynote by Rob Pike provides a comprehensive overview of the history, development, and unique features of the Go programming language.

  • talk/rob2014b
    Implementing a bignum calculator. Sydney Go meeup. Nov, 19 2014.

    Summary: In the Golang-syd podcast episode titled "Implementing a bignum calculator with Rob Pike, " Rob Pike, a renowned programmer, discusses his experience in developing an APL-like calculator language. The episode covers various topics related to the implementation of the calculator and the challenges faced during the process. Pike begins by reflecting on the history of the calculator, called Hawk, which was initially developed for educational purposes. He acknowledges the limitations of the calculator, such as lack of precision and floating point issues. Pike also mentions his involvement in publishing a book on the Unix programming environment. The discussion then moves on to the issues with the 30-year-old calculator, including inaccuracies in calculations and the absence of support for hexadecimal numbers. Pike expresses his desire for a calculator that can handle larger numbers and explains his decision to implement an APL interpreter in Go. APL, a programming language developed by Ken Iverson in the 1950s and 60s, is introduced as a groundbreaking language with a simple kernel based on linear algebra. Pike highlights the uniqueness of APL, which uses special characters instead of keywords, making it an interesting language to learn and use. He mentions the rarity of seeing APL in action and refers to a video showcasing the development of an APL expression. The episode also briefly touches upon IV, a programming language named after Ken Iverson, which is still in its early stages but has interesting features such as exact arithmetic with rationals and support for large numbers. Pike mentions IV's potential for certain cryptographic calculations. The podcast then delves into various mathematical concepts and operations in programming. It covers vectors, matrices, random numbers, and sorting, emphasizing the use of APL for calculations and its potential for creating complex programs. The limitations of the APL implementation, particularly in base 16, are also discussed. Pike further explains the process of scanning tokens, parsing them into a parse tree, and evaluating the result in the context of implementing a numerical processor in Go. He shares his experience in designing a lexical scanner based on concurrency and discusses bugs encountered and fixed during the development process. The episode concludes with Pike discussing the parsing of expressions in an arithmetic grammar and a programming language. He explains the rules for operands, binary operators, and statement lists, highlighting the simplicity of parsing in APL and the influence of recursive descent parsers. Overall, the episode provides insights into the implementation of an APL-like calculator language and the challenges faced during the process. Pike's expertise and experience in programming shine through as he shares his knowledge and enthusiasm for different programming languages.

  • talk/rob2015a
    The move from C to Go in the toolchain. GopherFest 2015. Jun 10, 2015.

    Summary: In this episode of GopherFest 2015, Rob Pike discusses the transition from using C code to Go code in the Go programming language. The decision to move the compiler from C to Go was driven by practical reasons such as easier writing and debugging, better modularity and tooling, and support for parallel execution. The benefits of the transition are already being seen, including simplifying the management of two co-existing languages, improving testing and profiling, and overall maintenance of the codebase. The challenges of implementing a concurrent garbage collector in C are discussed, including type ambiguity and aliasing issues. The use of segmented stacks and imprecise stack data collection in GCC Go is highlighted as a solution to these challenges. The development process involved transitioning from segmented to contiguous stacks for C code and converting the runtime to a type-safe language. The decision to translate the Go compiler from C to Go was made for correctness and to avoid introducing new bugs. A machine-generated Go compiler was created using a custom translator to convert code from C to Go. The resulting code is not optimal but can be improved using various tools. The use of a parser written in Yak and the need for manual configuration are mentioned. The text also explains how a source-to-source translator in Go works and how it was used to fix slow code generated by a previous compiler. The differences between the compiler and garbage collector in the Go programming language are discussed. The Go compiler does not free memory, leading to overhead. The Go compiler team has made optimizations to improve performance and memory usage, such as using the math big package, reducing memory usage, improving escape analysis, and hand tuning. Recent changes have increased compiler speed by 15%, including better escape analysis and unification of architectures. The Go Build tool simplifies the compilation of Go programs into different architectures and operating systems. It makes code more portable, reducing the need for duplicated code in C. A new portable assembler has been introduced, allowing for easier code development and compatibility across architectures. The tool also includes a linker with a translation tool and a library. The improvements and future plans for the Go programming language are discussed, with a focus on enhancing performance. The release of Go 1. 5 includes updates such as a new assembler, garbage collector, and scheduler, resulting in cleaner and faster code. The tool chain and runtime have also been improved, making the code easier to test and maintain. The goal is to make the language more portable and flexible, although challenges with different instruction sets remain.

  • talk/rob2015b
    Go Proverbs. Gopherfest. Nov 18, 2015.

    Summary: In this episode of Gopherfest 2015, Rob Pike discusses various topics related to the game of Go and programming in the Go language. He begins by introducing the book 'Go Proverbs Illustrated', which provides valuable insights into the principles of the game of Go and how they can be applied to programming. Pike emphasizes the difficulty that Westerners face in learning and excelling in the game of Go, highlighting the unique gameplay and strategic thinking required. Moving on to programming, Pike emphasizes the significance of code formatting and the benefits of adhering to Go's formatting guidelines, specifically gofmt. He stresses the importance of consistency and readability in code and discusses the advantages of using small interfaces and structuring APIs effectively. Pike also mentions the cultural aspect surrounding interfaces in the Go ecosystem and the need to make the zero value of all types in a package useful. Pike then delves into the topic of dependency trees in programming and advocates for keeping them small. He suggests that copying small portions of code instead of importing entire libraries can lead to faster compilation, easier maintenance, and simplicity. He also emphasizes the use of build tags in code to make it more compact and less dependent on other pieces, particularly when it comes to guarding syscall and cisco uses for portability and compatibility. The drawbacks of using the unsafe package in Go are discussed, with Pike discouraging its use due to the potential for crashes and instability. He emphasizes the importance of writing clear and simple code, avoiding clever coding techniques, and limiting the use of reflection in Go. Pike also highlights the significance of designing the architecture and naming components in building a big system in Go. He stresses the need for good names that aid in understanding the design and make programming feel natural. Additionally, Pike discusses the importance of user-focused documentation that explains the purpose and usage of functions. He suggests the use of proverbs in code documentation to effectively convey information and resolve arguments. In conclusion, this episode of Gopherfest 2015 provides valuable insights into the game of Go and programming in the Go language. Rob Pike emphasizes the importance of understanding key concepts in programming, such as code formatting, small interfaces, and effective API structuring. He also discusses the significance of keeping dependency trees small, avoiding the use of unsafe packages, and designing architecture and naming components in building big systems. Overall, this episode offers valuable advice and principles for programmers in the Go ecosystem.

  • talk/rob2015c
    Simplicity is Complicated. dotGo 2015. Dec 2, 2015.

    Summary: In the podcast episode titled "dotGo 2015 - Rob Pike - Simplicity is Complicated, " Rob Pike discusses the success and complexity of the programming language Go. Pike, a renowned expert in the field, explains that while Go is often described as a simple language, it is not as straightforward as it seems. Pike begins by highlighting the importance of simplicity in Go's success. Unlike other languages that incorporate features from various sources, Go stands out for its straightforwardness. However, Pike expresses concern over the trend of languages converging towards a single language by adopting features from others, as it limits diversity in problem-solving approaches. He emphasizes the importance of having different languages optimized for different domains and ways of thinking. The podcast also delves into the challenges of balancing conciseness and readability in code. Pike emphasizes that readable code is easier to understand, work on, extend, and fix. He uses an example in the APL dialect called dialogue to illustrate how a concise program can be difficult to read. Pike also discusses the trade-off between using more expressive programming features and the potential decrease in efficiency. He emphasizes the importance of finding the right balance and selecting the appropriate features to ensure both conciseness and expressiveness in programming. The complexity hidden behind Go's simplicity is explored in detail. Pike discusses various aspects of Go, such as data types, functions, interfaces, and concurrency. He emphasizes the importance of a good implementation and effective tooling. Pike also highlights the complexity of garbage collection in Go, despite its lack of user interface. He mentions the simplicity of Go's concurrency model, particularly go routines, which allow for lightweight sub-processes. However, he explains that go routines involve complex management behind the scenes. The podcast also touches on Go's support for Unicode UTF-8, magic packages like net/http, and concurrency. Pike emphasizes the simplicity and ease of use of Go, as well as its popularity. He explores how Go handles numeric types and constants, highlighting the complexities involved in designing the language. Pike discusses the challenges of working with constants and interfaces, and the importance of packages in scoping and compiling. Despite their simplicity in usage, Go packages hide a lot of complexity. In conclusion, the podcast episode provides a comprehensive overview of the features and advantages of the Go programming language. Pike's insights shed light on the complexity hidden behind Go's simplicity and emphasize the importance of finding the right balance between simplicity and expressiveness in programming.

  • talk/rob2016a
    The Design of the Go Assembler. GopherCon 2016. Aug 18, 2016.

    Summary: In the GopherCon 2016 podcast episode titled "The Design of the Go Assembler, " Rob Pike discusses the importance of assembly language for programmers. He explains that assembly language allows programmers to access system functions at the lowest level and optimize performance. It is necessary for tasks like bootstrapping environments and taking advantage of hardware features. Pike emphasizes that understanding assembly language provides a deeper understanding of how computers work. Pike goes on to discuss the structure of assembly language, highlighting common features such as labels, instructions, operands, and comments. He explains that most CPUs have a similar structure, allowing for a common grammar. Pike also mentions the development of a common grammar for all machines and the work of Ken Thompson in developing a C compiler. The podcast episode delves into the evolution of assemblers and compilers in the Go programming language. Pike explains that the transition from C code to a Go implementation began with the creation of a library called Liblink, resulting in faster builds. The Go compiler and linker have undergone significant changes, with the obsolescence structure selection being moved to the back end of the compiler and assembler. The old C source has been translated into Go programs and the labeling has been rewritten into a suite of libraries. Pike suggests replacing all assemblers with a single program written in Go. He discusses the use of the -S flag in a compiler to display assembler instructions, explaining that the instructions produced are pseudo instructions from the stat phase of the compiler. Pike highlights the advantages of using a common assembly language for easier programming and portability. The podcast episode also covers the development of a new assembler program that can assemble any machine by parsing the input language into binary form. Pike explains the process of text processing in assembler and the validation and testing methods used. He describes the development of a universal assembler that eliminates the need for hardware manuals and replaces multiple programs with a single one. The assembler is compatible with old ones and can handle multiple architectures. Pike concludes by mentioning the use of machine-generated disassemblers and the challenges of reverse engineering. The goal is to have a machine-generated assembler that can be used with different architectures, making it easier for developers. He describes the process of developing the assembler using the C programming language and finds it exciting and relatively easy. Overall, the podcast episode provides valuable insights into the design and evolution of the Go assembler, highlighting the importance of assembly language and the benefits of a common assembly language for programming and portability.

  • talk/rob2016b
    Stacks of Tokens: A study in interfaces. Sydney Go Meetup. September 19, 2016.

    Summary: In this episode of the Sydney Go Meetup, Rob Pike, a Distinguished Engineer at Google, discusses the use of interfaces to solve a specific problem. He emphasizes the importance of design, portability, and generating manuals. Pike explores the role of a lexer in extracting tokens from input and the challenges of converting assembler language code written in C to a new assembler. He also discusses the implementation of a new C compiler and its impact on the lecture, highlighting its ability to use assembly language programs and define constants, macros, and instructions. Pike then delves into the features and functionality of the C preprocessor, including enabling and disabling blocks of code, as well as the concept of a token reader for analyzing macro definitions in C programming. He provides an overview of token readers and stacks in the Go programming language, explaining how token readers are used to process files and includes, and how they are implemented as a stack. Pike discusses the process of pushing and popping token readers from the stack, as well as retrieving the top of the stack. He also mentions the implementation of a stack in the text and the overall process of building a text processor. Additionally, Pike explains the concept of an input in a parser and the need for additional pieces to handle specific tasks at the top level of the parser. He provides an overview of the C preprocessor and its various components, including parsing and invoking macros, preventing infinite recursion, and using hash functions to determine token types. Pike emphasizes the benefits of breaking down problems into simple components and combining them to solve complex problems. He also explains the process of file inclusion, macro definition, and the importance of input. next in the preprocessor. Throughout the episode, Pike reflects on his experience designing and implementing a parser and assembler. He discusses the benefits of structuring the program to implement one interface through all the pieces and using Graco interfaces to break down the problem. Pike praises the clean structure of the stack and the role of the tech scanner package in facilitating the implementation process. He also discusses the challenges of working with assembly code and the importance of thorough testing. Pike mentions the use of a concurrent scanner for lexical processing and his experience in writing a C preprocessor. Overall, this episode provides valuable insights into the use of interfaces, lexer, token readers, and stacks in solving complex programming problems. Pike's expertise and experience shine through as he shares his knowledge and practical tips for designing and implementing efficient parsers and assemblers.

  • talk/rob2017
    Upspin. Gopherfest 2017. Jun 22, 2017.

    Summary: In this episode of Gopherfest 2017, Rob Pike discusses Upspin, an experimental project aimed at creating a secure and uniform framework for naming and sharing files and data globally. The podcast begins by highlighting the challenges of managing personal data in the modern world, where downloading and sharing digital media often means renting and potentially losing access if the account is lost. The history of data management is explored, with a focus on the shift towards cloud storage. The dissatisfaction with the current state of data ownership is expressed, and the need for a system like Upspin is emphasized. Upspin is described as a global space for storing and organizing data, prioritizing personal privacy, security, and data ownership. Unlike platforms like Dropbox, Upspin is not meant for corporations and aims to provide a secure data storage system that allows access to specific groups of people. The podcast delves into the technical aspects of Upspin, explaining that it uses the Go programming language and provides a brief overview of the infrastructure involved. The system uses email addresses as usernames for verification purposes and utilizes end-to-end encryption to ensure only authorized individuals can access the data. Sharing within the Upspin tree is done in a way that makes it easy to understand who can access shared content. The Go Centric Model, consisting of a key server, storage server, and directory server, is introduced as the foundation of Upspin. The key server stores user data, the storage server allows users to retrieve and store data based on references, and the directory server handles second-order lookups. The Upspin file system, its design decisions, and components are discussed, including the storage server, directory server, and client library. The podcast also explores the potential applications of Upspin, such as securely accessing data from a nursery camera or sharing an iTunes library. The importance of secure and convenient information access in the modern world is emphasized. Overall, Upspin aims to provide users with fine-grained control over their data and a unified computing experience across multiple devices. The project is in its early development stages and encourages user input to improve functionality. While there are still areas that need improvement, such as documentation and design, Upspin differentiates itself from other global file systems by allowing the directory server and storage server to be separate machines. The podcast concludes by mentioning Keybase, a cloud provider that offers secure data access and sharing, and its integration with various platforms for consistent access, privacy, and security.

  • talk/rob2018a
    The History of Unix. Nov 7, 2018.

    Summary: In this episode of the podcast, titled "The History of Unix, " Rob Pike takes us on a journey through the evolution of computing and the development of Unix. As an insider in the field, Pike provides a personal account of the key pieces that shaped the modern computing world. Pike begins by discussing the early days of computing, where punch cards were used and the development of Unix was still in its infancy. He shares his experiences working with IBM computers and his fascination with ray tracing and designing optical systems. Pike reflects on the reliability of the technology and his determination to access more resources. Moving forward, Pike delves into the PDP-11 machine, highlighting its various components and features such as tape drives, disc racks, and the graphic wonder. He also mentions the challenges of graphics processing and the significance of a frame buffer. Pike provides insights into the visible components of the machines and the early days of computing. Pike then recounts his experience of bringing a Unix system to grad school in California and using it to run Voyager ground stations. He reflects on the challenges of importing software across the US border and the significance of translating fan fold to a photo phone. Pike also discusses his early work at Google, focusing on graphics and sound projects, and running the lab on a small amount of memory. The podcast episode also touches on Pike's time at Bell Labs in the 1980s, where he worked on interesting projects such as the Cardiac simulation and the development of the Multix operating system. Pike stumbled upon a PDP seven computer and created the Space War program, providing insight into early computer gaming. Throughout the episode, Pike emphasizes the importance of Unix and its impact on the computing world. He discusses the evolution of the operating system and his experience learning to program on Unix. Pike also highlights the significance of graphics and networking in the development of computing technology. Overall, this episode offers a fascinating glimpse into the history of Unix and the journey of Rob Pike as a key figure in the field of computer programming.

  • talk/rob2018b
    Go 2 Draft Specifications. Sydney Golang Meetup. Nov 13, 2018.

    Summary: In the Sydney Golang Meetup podcast episode featuring Rob Pike, the focus was on the draft specifications for Go 2. The episode covered a wide range of topics related to the Go programming language, including its popularity, the need for evolution, and proposals for improvements. The podcast highlighted the importance of Go's stability and compatibility, which allows developers to focus on writing code rather than the language itself. However, in order to reach a larger audience and address certain issues, the language needs to evolve without compromising compatibility. The Go team has been engaging in discussions and design drafts to explore potential improvements and changes to the language. These design drafts serve as a way to generate ideas and gather feedback, with the aim of ensuring compatibility and minimizing disruptions to existing code while making enhancements. Specific proposals were discussed in the episode, such as the use of a new keyword called 'check' to simplify error handling, the simplification of variable declarations, and the introduction of a function local error handling mechanism. The episode also emphasized the importance of better semantics and standardization in error handling, as well as the significance of having a standard error formatting in software packages. The concept of parametric polymorphism, also known as generics, in Java was also explored in the episode. The challenges faced in implementing this feature and the ongoing efforts to find a solution were discussed. The episode highlighted the importance of being able to sort and communicate between different types of data in programming, and the drawbacks of dynamic type checking and reflection. The episode also touched on the significance of contracts in programming, the role of the debugging tool Delve in the Go community, and the concepts of covariance and contravariance in object-oriented languages. Throughout the episode, the importance of collaboration and open-mindedness in language design and software engineering was emphasized. The collaborative effort involved in designing the Go programming language was discussed, highlighting the contributions of multiple individuals and the importance of reaching consensus. In conclusion, the Sydney Golang Meetup podcast episode featuring Rob Pike provided a comprehensive overview of the recent discussions and proposals surrounding the Go programming language, specifically focusing on the concept of Go 2. The episode highlighted the need for the language to evolve while maintaining compatibility, and discussed specific proposals and challenges related to error handling, parametric polymorphism, and contracts. The importance of collaboration and diverse perspectives in language design and software engineering was also emphasized.

  • talk/rob2019a Creating the Go programming language with Rob Pike & Robert Griesemer. Sep 10, 2019.
  • talk/rob2019b
    Rob Pike. A Brief History of Go. Dec 12, 2019.

    Summary: In this episode of the GolangSyd Meetup, Rob Pike delivers a talk titled "A Brief History of Go" on December 12, 2019. The video of the talk can be found on YouTube, and the audio has been enhanced to provide a better listening experience. Unfortunately, the slides from the talk are not available. During his speech, Pike reflects on the origins and development of the Go programming language. He discusses the challenges faced in creating the language and highlights its success and ongoing updates. The name "Go" is derived from the first two letters of "Google, " emphasizing the language's connection to the company. Pike also explores the collaborative efforts of individuals in organizing conferences and distributing software, showcasing the language's progress over the course of two years. He mentions a significant conference in April 2013 that played a crucial role in promoting Go. The evolution and popularity of gopher figurines are also discussed. Pike mentions their distribution and their particular appeal in China. He highlights a well-designed figurine by Renee and a strong figurine released in 2016. Additionally, he mentions the launch of a language-related project. The importance of the go-to process in management and deployment is emphasized. Pike explains the benefits of faster testing with a cache version and introduces three proposals for language changes. He also mentions an unexpected surprise related to these proposals. The episode celebrates the 10th anniversary of Open Source Police, a community with 115, 000 members. Pike highlights the proposal-making process, the scaling back of proposals, and the various community projects that have been undertaken. He expresses gratitude for the support received and reflects on the challenges faced in the early years of the project. Pike acknowledges the difficulties in managing a community at the start of a project but expresses optimism about the progress that has been made. He emphasizes the importance of effective community management from the beginning. Overall, this episode provides a comprehensive overview of the development and improvement of the Go programming language. Pike's insights and reflections offer valuable insights into the challenges and successes of creating and managing a programming language, as well as the importance of community involvement and collaboration.

  • talk/rob2020 A Rob Pike Interview. (Date Unclear) Apr 30, 2020.
  • talk/rob2021
    The Go Programming Language and Environment. John Lions Distinguished Lecture, UNSW, May 27, 2021.

    Summary: In this podcast episode titled "The Go Programming Language and Environment, " the last scheduled speaker was unable to attend due to illness. However, Rob Pike, a Google engineer and co-creator of the Go programming language, stepped in to speak. Pike expressed his gratitude for being able to attend virtually and shared his admiration for John Lyons, who had a significant influence on his career. He also mentioned how encounters with Lyons and an Australian named Ian Johnston led him to Bell Labs and eventually to Australia. Pike then delved into the success of the Go programming language. Initially disliked, Go has gained popularity in cloud computing due to its ability to address challenges faced by other languages. It offers scalability, security, performance, and automation. The language's success can be attributed to its reliable libraries, long-term stability, and better software writing capabilities. Go was designed with scalability in mind, focusing on concurrency and multi-core CPUs. One of the challenges in software development is the lack of multi-core languages and coordinating massive compute clusters. Building tools for languages like C++ and Java can be difficult due to their complexity and slow compilation. Pike discussed how Google's transition to a new build system reduced binary size by specifying dependencies more precisely. The podcast episode provides a comprehensive overview of Go programming, covering topics such as web server structure, interfaces, concurrency, and building a rate limiter. It explains how Go utilizes simple mechanisms like maps and arrays to compensate for the lack of parametric polymorphism, allowing for compatibility among different implementations. The significance of interfaces in Go is also highlighted, emphasizing their simplicity and flexibility. Pike further discussed how Go introduced goroutines for efficient parallelism and concurrency, and how channels and the select statement are used for communication and synchronization. The simplicity and safety of Go programming were emphasized, along with the importance of building libraries with built-in capacity. Go's safety features, including no pointer arithmetic and indexing checks, contribute to its reputation as a secure language. The podcast episode also touched on the evolution of Go's project structure, known as GOPATH, into the current module system, and its impact on program reasoning. Pike expressed his desire for additional language features like channel packages and multiplexers, as well as the difficulties faced in trying to make networking and channels work together. Overall, the episode highlighted the success and advantages of the Go programming language, including its compatibility, performance, and strong library support. Pike emphasized the importance of collaboration and code sharing in creating a thriving ecosystem in software development. The episode concluded with Pike expressing appreciation for a participant who couldn't attend and mentioning upcoming talks.

• Robert Griesemer. (Dr. Robert Griesemer) GitHub, Twitter

  • Alma mater: ETH Zürich
  • paper/robert1993 A Programming Language for Vector Computers. Doctor Dissertation. 1993.
  • talk/robert2012a
    E2E: Erik Meijer and Robert Griesemer. Going Go. Lang.NEXT. Mar 16, 2012.

    Summary: In this episode of E2E, Erik Meijer interviews Robert Griesemer, the designer of the Go programming language. Go is a concurrent, garbage-collected systems programming language with fast compilation. The conversation covers various topics related to Go and its suitability as a native language. The discussion begins with the question of whether Go is a native language. Griesemer explains that Go can be compiled to native code and has scripting capabilities, making it a versatile language for native development. He highlights the advantages of using Go, such as fast compilation and execution, as well as a new build tool called 'bill' that simplifies the development process. The conversation then delves into the significance of compilers in programming. Griesemer explains that faster startup times and code optimization are key benefits of using compilers. He also explores techniques used to optimize startup time in the JVM and the benefits of using native languages and natively compiled binaries. The philosophy of error handling in Go is another topic of discussion. Griesemer emphasizes the importance of handling errors rather than ignoring them and explains how Go simplifies error handling with its multiple return values feature. He also discusses different approaches to error handling, including the use of special error types and panics, and highlights the need to treat exceptional situations as such and not use exception handling as a control flow mechanism. The significance of interfaces in object-oriented programming, particularly in Go, is also explored. Griesemer explains how Go allows methods to be attached to various types and the use of interface types as specifications of methods. He suggests that implementation inheritance may be overrated and that embedding another type can achieve similar results. The Go programming language provides primitives for forwarding and delegation, allowing developers to build these concepts themselves. The debate surrounding the inclusion of generics in programming languages, particularly in the context of C++, is another topic discussed. Griesemer acknowledges the benefits of generics, such as improved code reusability and type safety, but also acknowledges the challenges they bring, including integration with existing language features. He discusses the trade-offs and challenges of using templates and explores alternative approaches to generics. The conversation concludes with a discussion of Go routines, which are lightweight threads in Go that offer strong support for concurrency. Griesemer explains their implementation and use case, as well as the benefits of using channels for communication between Go routines. Overall, the conversation provides valuable insights into the design and features of the Go programming language, making it a must-listen for developers interested in Go and native language development.

  • talk/robert2012b
    Go In Three Easy Pieces. Mar 19, 2012.

    Summary: In the podcast episode titled "Lang NEXT 2012 Go In Three Easy Pieces, " the speakers discuss various aspects of the Go programming language. They highlight its simplicity, compact size, and strong concurrency support, which have contributed to its growing popularity among developers. The episode begins by explaining the unique features of Go, such as its efficient implementation, powerful standard library, and a range of development tools. The language emphasizes comprehensibility and simplicity, making it easier for developers to understand and write code. It also has a different approach to exception handling and object-oriented programming, allowing methods to be defined without classes and providing built-in support for concurrency. The speakers then delve into the topic of string methods and type compatibility in Go. They explain how to use string methods using dot notation and static dispatch, and discuss the advantages of using them. They also discuss explicit conversion, particularly in the context of numeric types. The episode introduces interfaces and their ability to compose software effectively, with examples of dynamic dispatch and plug and play compatibility. The benefits of using interfaces in programming, such as flexible code reuse and the ability to interact with code without modification, are highlighted. The challenges of designing object hierarchies and implementing interfaces are also discussed. Next, the speakers discuss the use of file handlers in an HTTP application and the use of Ingo to present mandible images. They explain the implementation of a struct with various properties for the image and the methods used to generate it. The episode also mentions the use of a library function to encode the image as a PNG file. Additionally, the speakers discuss the use of closure generators to analyze the performance of a Mandelbrot server by measuring task execution time. The episode then focuses on the speed and efficiency of the Go programming language. It explains how Go can run code quickly and safely with features like garbage collection. The use of go routines and channels for lightweight and flexible code implementation is discussed. Channels are used for communication and synchronization between go routines, eliminating the need for manual synchronization. The speakers also discuss a typical Go concurrency pattern using channels and closures, as well as the concept of a work scheduler for efficient task execution. The process of transforming sequential code into concurrent code is explained, highlighting the benefits of faster computation and speedup. The episode concludes by discussing deferred statements in Go, which allow functions to be launched and suspended before executing the body. The panic and recovery mechanisms in Go for exception handling are also explained. The launch of Go is mentioned, highlighting its stability and backward compatibility. The use of Go in startups and its availability on App Engine are also mentioned. The episode ends by emphasizing the significance of language support in providing effective concurrency support in Go.

  • talk/robert2012c
    Lang.NEXT 2012 Expert Panel: Native Languages. Apr 11, 2012.

    Summary: In the podcast episode titled "Lang NEXT 2012 Expert Panel: Native Languages, " a panel of experts discusses the advantages and limitations of native code programming. The panelists share their experiences and preferences, with some favoring native code for its speed, efficiency, and control. They emphasize the importance of using the most advantageous mechanism for each situation, comparing it to the choice of programming languages for specific tasks. The panelists discuss the benefits of native code execution, such as optimized user experiences and the ability to work closely with hardware. They also highlight the ability to directly call C code as a major advantage of native code. However, they acknowledge the potential issues with virtual machine (VM) implementation. The panelists also explore the advantages and disadvantages of native code and managed code. Native code offers speed and control, while managed code allows for advanced processing during load time. The choice between the two depends on the biggest cost for the application. The panelists discuss the challenges faced by native languages in achieving interoperability and language design. They mention the development of protocols for interoperability by companies like Google and Facebook. The panel expresses optimism about research advancements in this area and the significance of a common interface for plug-and-play compatibility. The podcast also highlights the shift in Facebook's backend development from PHP to C++. This change has been driven by the need for more efficient power consumption and improved performance. The use of C++ allows for a more efficient use of power per user and enables the development of high-performance ads. The panelists discuss the trade-off between program productivity and performance in software design. They emphasize the importance of prevention over cure and the different approaches taken by managed and native languages. The significance of maintaining consistent databases in the web world is also emphasized. The podcast concludes with a discussion on the complexity of programming languages and the challenges of memory management. The panelists mention the need for research to determine the most complex language specification and highlight the trade-off between safety and efficiency in memory management. Overall, the episode emphasizes the importance of using the appropriate programming language for specific tasks and staying updated with advancements in the field. The panelists provide insights into the advantages and limitations of native code programming and the ongoing developments in the industry.

  • talk/robert2015
    The Evolution of Go. GopherCon 2015. Jul 28, 2015.

    Summary: In the podcast episode titled "GopherCon 2015: Robert Griesemer - The Evolution of Go, " Robert Griesemer discusses the evolution of the Go programming language. Griesemer begins by sharing his background in programming languages, including studying under the creator of Pascal. He reflects on the challenges of creating a good programming language and the difficulty of maintaining productivity in his career. After programming in C++ for 15 years, Griesemer decides to start a new project to create a better language. He emphasizes the importance of simplicity, safety, and readability in language design. Griesemer believes that these principles are crucial in creating an easy-to-use and understandable language. He also discusses the decision-making process involved in language design and the importance of making certain aspects of programming easy to write. Griesemer mentions the lack of literature on language design but recommends two papers by Tony Hoare. He also discusses the process of brainstorming and the importance of direction and collaboration in language design. The podcast episode explores the evolution of programming languages, focusing on successors of Pascal and the programming language Oberon. Griesemer highlights the similarities and differences between Pascal and C, as well as the introduction of new features in languages like Modula-2 and Oberon. He also discusses the similarities between the programming languages Go and Oberon, emphasizing their shared origins in Oberon and the influence of C on Go. Griesemer then delves into the development of the Go programming language, highlighting its roots in Oberon and the incorporation of object orientation. He emphasizes the importance of object orientation and interfaces in Go, drawing inspiration from Smalltalk. Griesemer also discusses dynamic dispatch and the absence of generics in Go, explaining the challenges and the Go team's decision to prioritize established mechanisms. The team is still evaluating the implications of introducing generics. The development of the Go programming language involved a thorough testing process and emotional discussions among the small team of creators. The addition of Ross Cox improved the development process, and multiple independent implementations revealed bugs in both the compilers and the specification. The inclusion of the go types package further validated the code. The language has undergone significant changes, resulting in a more robust language with tools for easy adjustments and backward compatibility. The future of Go looks promising based on clear targets, available libraries and tools, market readiness, technological breakthroughs, and unique features. The podcast episode concludes by questioning whether Go will become mainstream and mentioning the need to unify the Go community. It also discusses pitfalls in language design, the history of programming languages, and how they reflect their creators. The episode wonders if the new language Co can be successful.

  • talk/robert2016a
    Lightning Talk: Alias Declarations for Gom: A proposal. GopherCon 2016. Oct 9, 2016.

    Summary:

  • talk/robert2016b
    Prototype your design!. dotGo 2016. Nov 29, 2016.

    Summary: In the podcast episode titled "dotGo 2016 - Robert Griesemer - Prototype your design!", Robert Griesemer discusses the importance of prototyping in software design. He explains how prototyping can inform the existing design and lead to a better final design. Griesemer starts by emphasizing the significance of the design phase in the software development process. He mentions Stanford University's five-step design process as an example of how designing and prototyping are important in various industries. He highlights that designers are not just thinkers, but also doers. The main focus of the episode is on language design, specifically multi-dimensional slice support in the Go programming language. Griesemer explains that the Go community has been working on finding a solution for two-dimensional indexing, which is still a challenge. He proposes a solution to improve readability and performance in Go through multi-dimensional indexing. To implement this proposal, Griesemer emphasizes the importance of a rewriter prototype. This prototype allows for the analysis of design options and avoids making drastic changes to the compiler. He explains how index expressions can be manually or automatically rewritten into method calls using special method names and the plus operator for clarity. Griesemer discusses the process of rewriting and modifying code in the Go programming language. He explains how new index expressions can be given meaning by calling specific methods. He also mentions the importance of rewriting the syntax tree instead of the source code, as it allows for changes to be made to existing libraries with minimal code modifications. The episode also touches on the use of a Go type checker to improve accuracy and efficiency in the language. Griesemer explains how rewriting binary additions can address missing types and serve as the core of the prototype for experimentation and refinement. Throughout the episode, Griesemer emphasizes the importance of concrete implementation for testing and refining design. He highlights the surprise discovery of effective index operators and questions if they are sufficient for certain problems. He concludes by reiterating the value of prototyping in programming. In summary, the podcast episode explores the importance of prototyping in software design, specifically in the context of multi-dimensional slice support in the Go programming language. Griesemer discusses the process of rewriting and modifying code, as well as the use of a Go type checker for accuracy and efficiency. He emphasizes the significance of concrete implementation and the role of prototyping in informing and improving the final design.

  • talk/robert2017
    Opening Keynote: Exporting Go. GopherCon SG 2017. May 29, 2017.

    Summary: In the opening keynote of GopherCon SG 2017, Robert Griesemer discusses the Go programming language and its use of packages to divide large projects. He compares the export and import mechanism of packages to the simpler times of the 1970s when C was invented. Griesemer highlights the importance of using header files in creating a library in C, as they allow for the explicit declaration of library interfaces, making it easier for the C compiler to compile the program. However, he also acknowledges the limitations and challenges of using header files, such as information leakage and potential performance issues in large systems. Griesemer explains that package serialization is important in programming languages as it allows the compiler to understand and communicate imported packages. He discusses the process of compiling Go packages and the need for serialization, as well as the use of dot o and dot a files for exporting and importing data. He mentions that object files can be read using a text editor and explains the structure and content of a pre-1. 7 compiler object file, which includes redundant and unnecessary information. To address these issues, Griesemer explains that a binary export format was adopted, which is more compact and efficient. The new format also includes additional information and allows for easy extension without a full-fledged parser. He discusses the serialization of package interfaces in Go, which involves representing the internal data structure as a graph. Griesemer explains a serialization algorithm in Go that can be used for any graph data structure, involving assigning unique integer values to nodes and writing out their content. Griesemer emphasizes the need to efficiently process export data by re-engineering it for indexing, reducing processing waste. He discusses the differences between textual and binary export formats, with the binary format being more space-efficient. However, challenges remain in processing only required fields. Griesemer suggests re-engineering export data to make it indexable for more efficient access, especially for large data structures like protocol buffers. Overall, Griesemer's keynote provides insights into the inner workings of import and export mechanisms in Go, and how these mechanisms enable robust separate compilation of packages. He discusses the historical context of these mechanisms and the design trade-offs that affect scalability. The talk highlights the importance of package serialization and the challenges involved in creating efficient and compact export formats.

  • talk/robert2017
    A brief overview of Go. Aug 28. 2017.

    Summary: In this episode of the podcast, Robert Griesemer, one of the designers of the Go programming language, gives a brief overview of Go and its key features. He starts by explaining that Go was developed by Google as an alternative to C++ and has gained significant success and growth since its release. It is highly regarded by developers and has between 500, 000 to a million users. Griesemer highlights the compactness, readability, and conciseness of Go, as well as its garbage collection feature and support for concurrency. He mentions that big tech companies like Google, IBM, Microsoft, and Uber, as well as companies like the New York Times, BBC, Amazon, and Walmart, use Go. It is also one of the fastest-growing languages in China. The unique features of Go are discussed, including constant declarations and powerful composite literal constructors. Griesemer explains the simplified syntax and powerful constructors of a scripted language, as well as the use of functions as first-class objects and closures. He showcases a mathematical matrix multiplication example to demonstrate the simplicity and efficiency of Go. The concept of methods and interfaces in an object-oriented language without classes or inheritance is also explained. Griesemer addresses the lack of support for multi-dimensional matrices and provides a workaround. He also mentions dynamic dispatch in programming. The use of goroutines and channels in concurrent programming is introduced. Channels in Go are used for communication and synchronization between goroutines, allowing for efficient communication without sharing memory. Griesemer discusses the use of channels in Go for efficient communication between goroutines, highlighting their cost-effectiveness and efficiency in terms of memory usage and communication. The author then explores the use of concurrency in matrix multiplication. They discuss their experiment of rewriting code using concurrent concurrency and explain the use of goroutines and wait groups. The performance differences between traditional and concurrent multiplication are also discussed. The features and benefits of Go are further discussed, including its standard library, platform independence, and tools for manipulating the language. The ease of writing an HTTP server in Go and its popularity for containerization and cloud environments are highlighted. The text concludes by mentioning the tools and features of the Co programming language, as well as the challenges of using C++ in scientific computation with Go. The Go programming language has an active community and extensive libraries, with increasing popularity and regular conferences and meetups worldwide. The community is working on improving dependency management, user experience, and inclusivity, with the goal of making Go the language of choice for cloud systems.

  • talk/robert2019
    Go is 10! Now What?. Gopherpalooza 2019. Dec 2, 2019.

    Summary:In the podcast episode titled "Go is 10! Now What?" by Robert Griesemer, one of the creators of the Go programming language, he reflects on the 10-year anniversary of Go and discusses its developmental milestones and future plans. Griesemer begins by acknowledging the growth and success of Go over the past decade. He highlights the thriving community with numerous conferences and meetups worldwide. According to the 2019 JetBrains developer survey, Go is the third most wanted language for learning, and over one-third of developers plan to learn it in 2019. Companies like Pound and Capital One praise Go for its simplicity, strong typing, concurrency support, garbage collection, and fast compilation times. The development of Go started in 2007 out of frustration with existing languages, and it was publicly released after two years. Griesemer discusses the process leading up to the first public release of a project, including negotiations, decision-making, and making changes. Despite potential failures, the project was successfully released, resulting in positive and overwhelming responses. Griesemer also emphasizes the importance of clear goals, solid ideas, and external input in the project's success. He reflects on the challenges faced after the birth of their first baby and draws parallels to the importance of clear goals and external input in a project's success. The evolution of the Go programming language is another topic discussed in the episode. Griesemer emphasizes the importance of the compatibility guarantee and its impact on adoption. He also highlights the focus on community building and the proposal process for influencing the language's direction. The careful and gradual changes made to Go, including optional semicolons and the introduction of new functions, are mentioned. The proposal process itself is discussed in detail, outlining a simple four-step process that includes a GitHub issue, discussion, design document, and final decision by the code team. Griesemer stresses the need for well-written proposals that address important issues, have minimal impact, and provide clear solutions. He also mentions the introduction of proposal reviews and the consideration of existing code impact. Looking towards the future, Griesemer mentions the Go team's goals, which include module support and the possibility of breaking backward compatibility with modules. The team plans to make API changes, focus on generics and module support, and enable more community contributions as the language matures. In conclusion, the podcast episode provides valuable insights into the 10-year journey of the Go programming language. It highlights its growth, success, and the challenges faced along the way. Griesemer's reflections and future plans for Go demonstrate the team's commitment to continuous improvement and community involvement.

  • talk/robert2020a The latest on Generics with Robert Griesemer and Ian Lance Taylor. Jul 21, 2020.
  • talk/robert2020b
    Typing [Generic] Go. Nov 11, 2020.

    Summary:In the podcast episode titled "GopherCon 2020: Robert Griesemer - Typing [Generic] Go, " Robert Griesemer discusses the latest progress made on generics in the Go programming language. The episode begins by introducing the concept of generics and their importance in improving type safety, efficiency, and performance in Go. Griesemer explains that the design draft for generics in Go introduces the notion of type parameters and constraints. These type parameters simplify the design and ensure backward compatibility. He goes on to discuss how type parameters and constraints are used in function parameter lists and provides a concrete example of a generic API in the standard library. The motivation for implementing generics in Go is also explained, with Griesemer highlighting the need for type safety and the ability to work with different types without sacrificing performance. He discusses the concept of constraints and how they are implemented as interfaces to ensure type safety. The episode delves into the specifics of generic functions and type parameters in Go. Griesemer explains that type parameters are visible throughout the function and can be used in all parameter lists. He emphasizes the importance of satisfying constraints imposed by the type parameter and explains the process of instantiation, where the type argument is substituted for the type parameter in the function signature. Type checking and instantiation in Go are also covered, with Griesemer providing an example of instantiating a generic sort function. He discusses the benefits of using generic types and type parameters in Go, but also acknowledges the need for constraints to ensure type safety. The episode further explores the concept of type argument inference in generic functions, discussing the process of matching type structures and the use of type unification. Griesemer mentions the limitations of type inference and the need for providing required methods. The use of typelists in Go to write generic functions that can work with different types, including derived types, is also explained. Griesemer introduces the concept of constraints, such as the 'ordered' constraint, which ensures that the types used in the function support certain operators. Overall, the episode provides a comprehensive overview of the progress made on generics in the Go programming language. Griesemer emphasizes the importance of adopting generics and highlights the benefits they bring to Go. The Go team is actively working on implementing generics and welcomes feedback from the community. The current design is backward compatible and fits nicely with existing Go code, but caution should be exercised to avoid unnecessary complexity and consider potential drawbacks.

  • talk/robert2021
    Generics! Dec 17, 2021.

    Summary:In the GopherCon 2021 podcast episode titled "Generics!", Go Team members Robert Griesemer and Ian Lance Taylor discuss the upcoming release of Go 1. 18 and its support for generic functions and types. They highlight the expressive power that generics bring to the Go programming language and the responsibilities that come with using them effectively. The new features in Go 1. 18 include type parameters, more powerful interface types, and improved type inference. These features eliminate the need for type arguments, making programming with generics in Go more efficient. The update also introduces type constraints, which define valid types for a parameter, and interfaces that define sets of methods. Griesemer and Taylor provide guidance on when and where to use generic features in Go. They suggest starting with functions instead of type parameters and using type parameters for functions that operate on special types without assumptions about element types. They emphasize the flexibility and efficiency of type parameters compared to reflection or interface types, allowing for general-purpose data structures and fully type-checked code. The speakers also discuss the importance of understanding meta types and the use of interfaces as constraints in generic functions. They mention the introduction of syntactic sugar and the use of type parameters with slice types. They also touch upon type inference and its role in deducing type arguments from type parameter constraints. Griesemer and Taylor highlight the need to keep Go code readable, maintainable, and performing well when using generics. They advise using type parameters when multiple types share a common method with the same implementation and using interface types for generic programming and reading data from any value. They mention that reflection can be used in cases where type parameters are not helpful. Overall, the upcoming release of Go 1. 18 with support for generics brings significant expressive power to the language. Griesemer and Taylor provide valuable guidance on how to use generics effectively, emphasizing the importance of choosing the appropriate approach based on the specific requirements of the code. By following their advice, developers can leverage the benefits of generics while maintaining code readability, maintainability, and performance.

• Ken Thompson. (Kenneth Lane Thompson, M. Sc.) (Retired)

  • Alma mater: UC Berkeley
  • talk/ken1982a
    The UNIX System: Making Computers More Productive. 1982.

    Summary:In this episode of the AT&T Archives, titled "The UNIX Operating System, " the host and narrator, Victor Vyssotsky, takes us back to the late 1960s when Bell Laboratories computer scientists Dennis Ritchie and Ken Thompson embarked on a project inspired by the Multics operating system. Ritchie and Thompson aimed to create a more useful, flexible, and portable system for programmers to work with. The UNIX system, as it came to be known, revolutionized software development by providing a structure consisting of the kernel, shell, and useful programs. This structure simplified interactions and enabled efficient programming. With just a few lines of code, various applications could be created, making the UNIX system highly productive and efficient. One of the key benefits of the UNIX system is its ability to combine programs for different tasks using pipelining. The podcast highlights the example of a spell-checking program, which demonstrates how existing UNIX programs can be utilized to identify potential spelling mistakes in sentences. By splitting the sentence into words, comparing them to a dictionary, converting them to lowercase, and sorting them alphabetically, spelling mistakes can be easily identified and corrected. The UNIX system also offers a large collection of pre-built tools and the ability to easily build new ones. Powerful pattern matching algorithms can be quickly packaged into UNIX programs and shared with the community, further enhancing productivity and efficiency. The podcast also delves into the structure of operating systems and the need for better design tools for integrated circuits. It introduces Steve Johnson and his program Elgin, which was developed for logic circuit designs. The UNIX system, with its separate programs and hierarchical directory structure, proved to be a valuable tool for circuit design. Furthermore, the podcast mentions the creation of the C language by Dennis Ritchie during the development of the UNIX system. The C language allowed programmers to have more control and write operating systems that could be easily ported to different machines. This further solidified the popularity of the UNIX system for programming and its compatibility with other languages. In conclusion, the podcast emphasizes the evolution of computer technology and the need for more user-friendly design tools. The UNIX system, with its adaptable and efficient nature, played a significant role in shaping software development and continues to be a powerful tool for programmers.

  • talk/ken1982b
    UNIX: Making Computers Easier To Use.

    Summary:In the podcast episode titled "The Unix System: Making Computers Easier to Use - 1982, " the hosts discuss the development and significance of the UNIX operating system. The episode is aimed at students interested in engineering, math, computer science, and other sciences. It was released in December 1982, along with another film that provided a more detailed discussion of UNIX for computer science majors and corporate trainees. The hosts begin by explaining the distinction between application software and operating systems, emphasizing the role of operating systems in simplifying computing processes. They highlight the three main components of UNIX and provide an example of its practical use in finding spelling mistakes. They explain the process of converting sentences into individual words, sorting them alphabetically, and comparing them against a dictionary. Programs like 'make words' and 'lowercase' are used to identify and correct spelling mistakes. However, the hosts acknowledge that certain words like jargon and proper names may not be recognized as mistakes. They suggest using these words to improve the dictionary for future spell-checking. The hosts also discuss the productivity and flexibility of the UNIX system. They compare its file system to a file cabinet, allowing for easy retrieval of files. The flexibility of file formats makes programming easier, and the indexing system files are determined by the programmer. UNIX enables easy movement of data between files and the ability to process any file with any program. The hosts highlight the fundamental contribution of UNIX in pipelining, where multiple programs can be connected. The episode demonstrates how UNIX pipelines can be used for finding spelling errors and creating a talking calculator. It mentions the use of existing tools in UNIX program development and emphasizes the value of UNIX utilities in building valuable applications. The hosts also mention the development of the writers workbench, including a proofreading program, to improve documentation. This program analyzes the style of written text and suggests improvements. While UNIX has been instrumental in the development of programs and provides pre-existing modules, the hosts acknowledge the need for further advancements in computer technology to make it more user-friendly. Overall, the podcast episode provides a comprehensive overview of the UNIX operating system, its practical applications, and its contributions to the field of computing. It highlights the importance of UNIX in simplifying computing processes, improving productivity, and enabling the development of valuable applications.

  • talk/ken1982c
    Ken Thompson and Dennis Ritchie Explain UNIX (Bell Labs).

    Summary:Segment from an AT&T Bell Labs (BTL) promotional film (circa 1980s) featuring UNIX creators Ken Thompson and Dennis Ritchie briefly explaining the UNIX environment. In cameo roles you'll see UNIX luminaries Greg Chesson (in the wine red shirt) and Doug McIlroy (to the foreground of Greg). Also featured is a classic ASR-33 Teletype, BLIT displays (developed by Rob Pike, then of the Labs as well), and much more.

  • talk/ken1998
    Ken Thompson and Dennis Ritchie. National Medal of Technology Awards. 1998.

    Summary:Ladies and gentlemen the recipients of the 1998 National Medal of Technology Awards the recipients of the 1998 National Medal of Technology the team of Kenneth L Thompson and Dennis M Richie from Bell Laboratories loosened technology for Co inventing the UNIX operating system and the C programming language which together have led to enormous advances in computer hardware software and networking systems and have stimulated the growth of an entire industry thereby enhancing American leadership in the information.

  • talk/ken2013
    Systems Architecture, Design, Engineering, and Verification. Jan 17, 2013.

    Summary:Episode Title: Systems Architecture, Design, Engineering, and VerificationIn this episode, the panel discussion on systems architecture design and verification is chaired by Dahlia Malkhi. The panel features experts in the field, including Fernando J. Corbato, E. Allen Emerson, Joseph Sifakis, and Ken Thompson. The discussion explores the relationship between research and practice in the systems area of computer science. The panelists begin by reviewing their past award-winning research and its impact on the computing world. They emphasize the importance of algorithms in software development and the potential of artificial intelligence. The goal of simplifying computing and creating a small, simple operating system is highlighted. The panelists also discuss the challenges of implementing new solutions and the ability to store vast amounts of digital information. The influence of Turing's universal machine on operating systems is discussed, along with the challenges he faced. The evolution of time sharing in computing and the development of the Multics operating system are also mentioned, as they had a significant impact on computing. The panelists reflect on the legacy of early computing systems and their shaping of our approach to computing today. They mention the 2007 Turing Award recipients for developing model checking as an effective verification technology. The concept of model checking, challenges of expressiveness and efficiency, and the importance of reactive systems are discussed. The need for verification and system design to prevent errors and accidents is emphasized. The panelists also discuss the challenges and importance of rigorous system design in cyber-physical systems. They call for a methodology that formalizes the process from requirements to implementation and highlight the lack of coherence in the current system development flow. The significance of system design in computer science and the need for more attention from research communities are emphasized. The panel touches on the differences between transformational software and reactive systems and mentions the challenge of integrating heterogeneous mix technicality systems. They also discuss the importance of luck in computer research success and the synergism in system building. The panel concludes by discussing the future of operating systems, including UNIX and Linux, and the challenges and innovations they may face. Concerns about the complexity of computer systems and the risks of storing personal data in the cloud are highlighted. The need for users to be aware of the reliability and trustworthiness of cloud providers is emphasized. Overall, the panel discussion provides valuable insights into the relationship between systems research and engineering practice, highlighting the importance of proper system design, verification, and the need for practical applications in computer science.

  • talk/ken2019a
    The Thompson and Ritchie Story. Feb 18, 2019.

    Summary:In this episode of "Pushing the Limits of Technology: The Ken Thompson and Dennis Ritchie Story, " we delve into the groundbreaking development and lasting impact of Unix, the revolutionary operating system created by Ken Thompson and Dennis Ritchie. Prior to Unix, computers were large and expensive, but this game-changing operating system allowed for multitasking and personal use, forever changing the landscape of technology. The episode begins by introducing Ken Thompson and Dennis Ritchie, two brilliant minds who worked together at Bell Labs. They were determined to create an alternative to the batch processing systems that dominated the computer industry at the time. Their collaboration resulted in the birth of Unix, a multi-tasking, multi-user operating system that would revolutionize the field. The host shares their personal experience with Unix, highlighting the significant role it played in their life. They recall the excitement of being able to play games on their computer, thanks to Unix's multitasking capabilities. This personal anecdote helps to illustrate the impact that Unix had on everyday users, as it allowed for personal use and entertainment on a scale that was previously unimaginable. The episode also sheds light on the remarkable abilities and dedication of Dennis Ritchie. His mathematical prowess and unwavering commitment to his work were instrumental in the development of Unix. Ritchie's contributions to the field of computer science cannot be overstated, and his partnership with Thompson was a key factor in the success of Unix. Throughout the episode, the close collaboration between Thompson and Ritchie is emphasized. Their shared vision and complementary skills allowed them to push the boundaries of technology and create an operating system that would shape the future of computing. Their work at Bell Labs paved the way for the modern technology we rely on today. Even though Unix was developed decades ago, its impact continues to be felt in our everyday lives. The episode concludes by highlighting the lasting legacy of Unix and its ongoing influence on technology. From the way we use computers to the development of subsequent operating systems, Unix's impact is undeniable. In summary, this episode of "Pushing the Limits of Technology: The Ken Thompson and Dennis Ritchie Story" explores the development and impact of Unix, a groundbreaking operating system created by Ken Thompson and Dennis Ritchie. Their collaboration at Bell Labs resulted in the creation of a multi-tasking, multi-user operating system that revolutionized the field of technology. Unix's lasting legacy continues to shape our everyday lives, making it a pivotal milestone in the history of computing.

  • talk/ken2019b
    Brian Kernighan interviews Ken Thompson. VCF East 2019. May 4, 2019.

    Summary:In this podcast episode titled "Ken Thompson interviewed by Brian Kernighan at VCF East 2019, " Ken Thompson, co-inventor of the UNIX operating system, is interviewed by Brian Kernighan. The episode, which took place on May 4, 2019, provides insights into Thompson's journey at Bell Labs and his contributions to the field of computer science. The fireside chat begins with an introduction and updates from the Vintage Computer Federation (VCF). Thompson then shares how he ended up at Bell Labs, where he worked alongside Dennis Ritchie to create UNIX. He reminisces about the origins of UNIX and reveals that they were only three weeks away from creating an operating system. Thompson discusses the challenges they faced while working on the PDP-11 computer and the importance of porting and testing assembly language for DC. He highlights the introduction of disk and communications equipment, which facilitated the rapid development of UNIX. One of the significant contributions of UNIX was the invention of pipes, allowing for communication between processes. The evolution of interprocess communication is also explored, from a worthless interface to a groundbreaking idea through the implementation of pipes. The development of redirecting IO and the creation of a shell are discussed, as well as the origin of the file search tool grep and its connection to AT&T's slogan. The podcast episode also delves into the evolution of programming languages, from early languages like B Unbond to the present work with Go. Thompson praises the TMG compiler on the PDB seven computer for its beautiful handwriting and lack of errors. The importance of Fortran in computer sales is mentioned, along with the author's personal experience with writing Fortran code. Additionally, the episode touches on Thompson's journey with chess, from becoming hooked on the game to developing a chess machine. The author shares their passion for watching chess tournaments online and participating in a chess tournament with a C program they had created. They then describe the process of building a chess machine and the machine's success as the world and US champion. Overall, this podcast episode provides a comprehensive overview of Ken Thompson's contributions to the field of computer science, including his work on UNIX, programming languages, and chess. The interview with Brian Kernighan offers valuable insights into Thompson's journey and the development of groundbreaking technologies.

• Ian Taylor. (Ian Lance Taylor, B. Sc.) Website, GitHub, Quora

  • Alma mater: Yale University
  • talk/ian2007
    GCC: Current Topics and Future Directions. February 27, 2007.

    Summary:In this episode of Google Video Tech Talks, Ian Lance Taylor, a member of Google's GCC team, discusses the current topics and future directions of the GNU Compiler Collection (GCC). GCC is a widely used C and C++ compiler that has been under active development for over twenty years. Taylor begins by explaining that the release process of GCC has become more rigorous in recent years, resulting in a more stable product. The project has seen high activity with numerous contributors. He mentions that the compiler is undergoing a major rewrite to improve accuracy and performance, with the release of GCC 4. 2 expected in April or May. One of the main topics discussed in the episode is the improvement in warning about invalid aliasing. Taylor emphasizes the importance of understanding and addressing aliasing issues, as accessing memory through different pointers can have unpredictable consequences. He also mentions the implementation of a warning by GCC for type punning that may break strict aliasing rules. The episode also explores the limitations of the language standard and the implications of signed overflow in loop execution. Taylor highlights the new options introduced by GCC 4. 2 to address this issue, including loop optimization and a faster preprocessor. These improvements aim to improve compilation speed, especially for projects with many header files. The role of GCC in the development of virtual machines and intermediate languages is also discussed. Ongoing projects related to GCC include efforts to make it a compiler for fully free software and generate a specific intermediate language. Taylor mentions the University of Indiana's work on implementing whole program optimization in GCC, which allows for inlining functions across different files and improves program efficiency. The episode concludes by discussing the challenges of optimizing code using profile feedback, precompiled headers, auto vectorization, and memory optimization in the GCC compiler. Taylor mentions ongoing improvements by Google developers and collaboration with LOV. Overall, this episode provides a comprehensive overview of the current topics and future directions of GCC. It highlights the importance of addressing aliasing issues, the improvements in GCC 4. 2, and the ongoing projects related to GCC's role in virtual machines and intermediate languages. The challenges of optimizing code and the collaboration between Google and other organizations are also discussed.

  • talk/ian2018
    Transition to Go 2. Gopherpalooza 2018. Oct 24, 2018

    Summary:In the podcast episode titled "Gopherpalooza 2018 - Ian Lance Taylor: Transition to Go 2, " Ian Lance Taylor, a member of the Go team at Google, discusses the challenges of transitioning the Go programming language to its next version, Go 2. Taylor has been involved with Go since 2008 and has extensive experience in writing free software. The episode begins by highlighting the journey of Go from its early days to its current state of stability. The release of Go 1 in 2012 provided a stable platform for users, leading to the growth of the Go community. However, last year, the Go team announced significant changes to the language, including modules, generics, and improvements to error handling. Taylor focuses on how Go will move forward with these changes. The importance of managing the transition between programming language versions is emphasized, using C as an example. Despite undergoing significant changes, C has maintained backward compatibility by introducing new keywords and identifiers. On the other hand, C++ has experienced more significant changes and potential compilation errors. Both languages offer options to specify the language version during compilation. The text also discusses the importance of backward compatibility in programming languages, using C++ and Java as examples. It highlights the challenges of maintaining compatibility while making changes to the language. Java's process of deprecating features and the potential removal of deprecated functions are mentioned. The evolution of Perl and Python programming languages is also discussed. Perl 6 faced a lengthy transition period and competition from other languages, while Python 3 has become highly successful but faced challenges in its transition from Python 2. The lack of backward compatibility and the need for code rewriting and library adaptation have slowed down the transition process for Python 3. The text emphasizes the importance of removing features in programming languages without breaking existing code. It suggests using tools like go fix to automatically rename identifiers and removing features that break code with simple workarounds to improve the user experience. The idea of recording the version of the Go language used to build a package in the go. mod file is discussed. The importance of version compatibility is emphasized, and the suggestion is made to compile Go code with different language versions to ensure compatibility with older libraries and utilize new language features. The episode concludes by mentioning the need for compatibility between different versions of packages and suggests possible solutions. The transition from Go 1 to Go 2 is highlighted, and the possibility of a deprecation plan for older versions is mentioned. Taylor expresses excitement and gratitude for his experience with Go.

  • talk/ian2019a
    Generics in Go. GopherCon 2019. Aug 27, 2019

    Summary:In the podcast episode titled "GopherCon 2019: Ian Lance Taylor - Generics in Go, " Ian Lance Taylor discusses the advantages and requirements for implementing generics in the Go programming language. He highlights the need for generics and explains that the lack of this feature is a major problem in Go. Taylor provides examples to illustrate the limitations of not having generics in Go. He discusses the challenges and limitations of using interfaces as a form of generics and suggests alternative approaches. He argues that generics would allow for more efficient and reliable code reuse by eliminating the need for repetitive coding and testing. The importance of static type checking for efficient and reliable code reuse is emphasized throughout the episode. Taylor explains that generics can be added by introducing type parameters, and in most cases, the compiler can deduce the type argument, making calling a generic function similar to any other function in Go. The concept of type parameters and contracts in the Go programming language is explored. Taylor explains how type parameters define the types of arguments allowed in generic functions and the operations that can be performed on them. He also introduces the concept of contracts, which describe the relationship between the implementation and callers of a generic function. Taylor provides examples of functions that utilize sequence contracts and explains the use of contracts to specify the types that a generic function is expected to work with. He emphasizes the need for natural usage and easy debugging when implementing generics in Go, and highlights the challenge of maintaining simplicity while introducing this feature. The episode concludes by discussing the progress and plans for implementing generics in Go. Taylor emphasizes the importance of feedback and aims to design a system that allows users to write generic code without complicating the language. He expects further adjustments based on feedback and aims to propose the finalized design for future versions of Go. Overall, the podcast episode provides a comprehensive overview of the advantages and requirements for implementing generics in the Go programming language. It highlights the need for this feature and explores different approaches and concepts related to generics. The episode concludes with a focus on the importance of user feedback and the goal of designing a system that allows for easy and efficient generic code writing in Go.

  • talk/ian2019b Generics in Go. Aug 27, 2019.
  • talk/ian2020
    Go with Ian Lance Taylor. CppCast. Aug 9, 2020.

    Summary:In episode 259 of CppCast, Rob and Jason are joined by Ian Lance Taylor from Google to discuss the Go programming language. The episode begins with a discussion about various topics covered in different episodes of cppcast, including hurricanes and their impact, the benefits of using PCH support via CMake, the significance of the gold linker, the advantages of using Conan package manager, Go's package manager, and a tool for embedding content into SQL source binaries. The hosts then dive into the main topic of the episode, which is the Go programming language. They start by highlighting the differences between Go and C++, emphasizing Go's simplicity and ease of learning. They mention that Go was created in 2007 to address the slow build times and increasing complexity of C++. Go has built-in support for multi-threading and garbage collection, making it suitable for writing networking servers and various other applications. The discussion moves on to the use of Go at Google, where it has gained popularity and is used in various projects. The hosts talk about Go's features, such as go routines, channels, and the select statement, which enable the creation of new execution threads and communication between them. They also mention that while Go currently does not have generics, there is a push to add them in a way that aligns with the language's principles, with the goal of having generics available by the Go 117 release. The hosts then explain the concept of type arguments and constraints in programming, and how they can improve code reliability. They compare the design and power differences between Go and C++, highlighting Go's simplicity, lack of specialization, and substitution failure. They mention that Go is a statically typed language with dynamic components, similar to abstract-based classes in C++. It supports type reflection at runtime and does not have function overloading or implicit type conversion. The episode concludes with a discussion about the development process and design philosophy of the Go programming language. The hosts mention that Go encourages developers to write tests, resulting in better error messages. They also talk about the extensive standard library of Go, which includes support for network servers, HDP, and HTML. The hosts emphasize the importance of clarifying implementations in programming languages and encourage listeners to try out Go compared to C++. Overall, the episode provides a comprehensive overview of the Go programming language, its features, and its use at Google. It highlights the simplicity and multi-threaded support of Go, as well as its potential future addition of generics. The hosts also discuss the development process and design philosophy of Go, emphasizing the importance of writing tests and clarifying implementations.

  • talk/ian2021a
    Using Generics in Go. Dec 6, 2021.

    Summary:In the podcast episode titled "Go Day 2021 on Google Open Source Live | Using Generics in Go, " Ian Lance Taylor introduces the concept of generics in Go programming and discusses how to effectively use this new language feature. He begins by explaining the basics of generics, including type parameters and constraints. Taylor emphasizes the importance of writing code before defining types and provides guidelines for when to use generics and when not to use them. He highlights that generics should be used for code clarity rather than efficiency. He also mentions that type parameters can be used to create more general data structures and enable more efficient storage of data. The speaker provides examples of using generics to create functions and implement common methods for different types. He explains that type parameters are particularly useful when implementing methods that are the same for all relevant types, but not when interface types can provide the desired functionality. Taylor concludes the episode by mentioning that Go 1. 18 is expected to include support for generics, which will bring new possibilities for developers. He mentions the possibility of a generic function for sorting slices in future versions of Go. Overall, the podcast episode provides a comprehensive overview of generics in Go programming. It highlights the benefits of using type parameters and provides practical examples of their implementation. The speaker emphasizes the importance of using generics for code clarity and avoiding repetitive code. The episode concludes by mentioning the upcoming support for generics in Go 1. 18, which will undoubtedly enhance the programming experience for Go developers. For more information on Go programming and to stay updated on the latest developments, the podcast recommends visiting the team's website at golang. org. Additionally, the episode encourages listeners to check out all the Gaming Day sessions available on the Go Day 2021 event page.

  • talk/ian2021b
    Generics! Dec 17, 2021.

    Summary:In the GopherCon 2021 podcast episode titled "Generics!", Go Team members Robert Griesemer and Ian Lance Taylor discuss the upcoming release of Go 1. 18 and its support for generic functions and types. They highlight the expressive power that generics bring to the Go programming language and the responsibilities that come with using them effectively. The new features in Go 1. 18 include type parameters, more powerful interface types, and improved type inference. These features eliminate the need for type arguments, making programming with generics in Go more efficient. The update also introduces type constraints, which define valid types for a parameter, and interfaces that define sets of methods. Griesemer and Taylor provide guidance on when and where to use generic features in Go. They suggest starting with functions instead of type parameters and using type parameters for functions that operate on special types without assumptions about element types. They emphasize the flexibility and efficiency of type parameters compared to reflection or interface types, allowing for general-purpose data structures and fully type-checked code. The speakers also discuss the importance of understanding meta types and the use of interfaces as constraints in generic functions. They mention the introduction of syntactic sugar and the use of type parameters with slice types. They also touch upon type inference and its role in deducing type arguments from type parameter constraints. Griesemer and Taylor highlight the need to keep Go code readable, maintainable, and performing well when using generics. They advise using type parameters when multiple types share a common method with the same implementation and using interface types for generic programming and reading data from any value. They mention that reflection can be used in cases where type parameters are not helpful. Overall, the upcoming release of Go 1. 18 with support for generics brings significant expressive power to the language. Griesemer and Taylor provide valuable guidance on how to use generics effectively, emphasizing the importance of choosing the appropriate approach based on the specific requirements of the code. By following their advice, developers can leverage the benefits of generics while maintaining code readability, maintainability, and performance.

• Russ Cox. (Dr. Russell Stensby Cox) Website, Blog, GitHub, Twitter, Reddit, YouTube

  • Alma mater: MIT
  • paper/russ2008 An Extension-Oriented Compiler. Doctor Dissertation. Aug 20, 2008.
  • talk/russ2009 The Go Programming Language Promo. Nov 10, 2009.
  • talk/russ2012a A Tour of the Go Programming Language. Jun 24, 2012.
  • talk/russ2012b A Tour of the Acme Editor. Sep 17, 2012.
  • talk/russ2014 Go from C to Go. GopherCon 2014. May 18, 2014
  • talk/russ2015 Go, Open Source, Community. GopherCon 2015. Jul 28, 2015.
  • talk/russ2016 Codebase Refactoring (with help from Go). Dec 5, 2016.
  • talk/russ2017 The Future of Go. GopherCon 2017. Jul 24, 2017.
  • talk/russ2018a Dependencies and the future of Go. Apr 19, 2018.
  • talk/russ2018b Go and WebAssembly (Wasm). Apr 19, 2018
  • talk/russ2018c Opening keynote: Go with Versions. GopherConSG 2018. May 5, 2018
  • talk/russ2018d Go 2 Drafts Announcement. Aug 28, 2018.
  • talk/russ2019 On the Path to Go 2. GopherCon 2019. Aug 27, 2019.
  • talk/russ2020a go:build design draft. Jun 30, 2020.
  • talk/russ2020b io/fs draft design. Jul 21, 2020.
  • talk/russ2020c //go:embed draft design. Jul 21, 2020.
  • talk/russ2021 #PLTalk: 12 Years of Go with Russ Cox. Nov. 12, 2021.
  • talk/russ2022 Compatibility: How Go Programs Keep Working. GopherCon 2022. Oct 28, 2022.

Back To Top

Compiler/Runtime Team

Dmitry is not from the Go team but on the dynamic testing tools team from Google. He wrote the scalable goroutine scheduler, many other performance improvements, synchronization primitives, race detector, and blocking profiler that related to the Go runtime. Austin was an intern at Google who worked on the Go project in the early days while pursuing a Ph. D. Later, he joined the Go team after his academic career and work together with Rick for the Go's concurrent GC. He also worked on the current preemptive scheduler and linker. Now, he is leading the Compiler/Runtime team for Go. Keith and David together focus on the Go's compiler backend, notably the current SSA backend. Michael is a recent newcomer to the Go team, his work is mainly in the runtime memory system such as the refactoring of memory allocator and runtime metrics.

• Dmitry Vyukov. (Дмитрий Вьюков, M. Sc.) Website, GitHub, Twitter
  • Alma mater: Bauman Moscow State Technical University
  • talk/dmitry2014 Writing a functional, reliable and fast web application in Go. Sep 25, 2014.
  • talk/dmitry2015a Chat with Dmitry Vyukov on go-fuzz, golang and IT security. Jul 3, 2015
  • talk/dmitry2015b Go Dynamic Tools. GopherCon 2015. Jul 28, 2015.
  • talk/dmitry2016 Dmitry Vyukov Interview. Jun 1, 2016.
  • talk/dmitry2017 Fuzzing: The New Unit Testing. C++ Russia 2017. May 10, 2017.
  • talk/dmitry2018a Fuzzing: new unit testing. GopherCon Russia. Apr 2, 2018.
  • talk/dmitry2018b Syzbot and the Tale of Thousand Kernel Bugs. Sep 1, 2018.
  • talk/dmitry2019 Go scheduler: Implementing language with lightweight concurrency. Oct 14, 2019.
  • talk/dmitry2020 syzkaller: Adventures in Continuous Coverage-guided Kernel Fuzzing. BlueHat IL 2020. Feb 13, 2020.
• Austin Clements. (Dr. Austin T. Clements) GitHub, Scholar
  • Alma mater: MIT
  • paper/autin2014 The Scalable Commutativity Rule: Designing Scalable Software for Multicore Processors. Doctor Dissertation. May 21, 2014.
  • talk/austin2020 Pardon the Interruption: Loop Preemption in Go 1.14. Nov 12, 2020.
• Richard Hudson. (Richard L. Hudson, M. Sc.) GitHub (Retired)
  • Alma mater: University of Massachusetts Amherst
  • paper/rick Research List
  • talk/rick2015a Go GC: Solving the Latency Problem. GopherCon 2015. Jul 8, 2015.
  • talk/rick2015b Rick Hudson on Garbage Collection in Go. Dec 21, 2015.
• Keith Randall. (Dr. Keith H. Randall.) GitHub
  • Alma mater: MIT
  • paper/1998keith Cilk: Efficient Multithreaded Computing. Doctor Dissertation. May 21, 1998.
  • talk/keith2016 Inside the Map Implementation. GopherCon 2016. Jul 12, 2016.
  • talk/keith2017 Generating Better Machine Code with SSA. GopherCon 2017. Jul 24, 2017.
• David Chase. (Dr. David Chase) Website, Block, GitHub, Twitter, Scholar
  • Alma mater: Rice University
  • paper/1987david Garbage Collection and Other Optimizations. Doctor Dissertation. Aug 1987.
  • talk/david2017 All About The Go Compiler. Jul 20, 2017.
• Dan Scales.
  • talk/dan2020 Implementing Faster Defers. Nov 11, 2020
• Michael Knyszek. Website, GitHub
  • talk/michael2020 Evolving the Go Memory Manager's RAM and CPU Efficiency. Nov 11, 2020
• Than McIntosh. GitHub
• Cherry Zhang. GitHub

Back To Top

Library/Tools/Release/Security/Community

• Andrew Gerrand. GitHub, Twitter
• Brad Fitzpatrick. Website, GitHub, Twitter
  • talk/brad2010 Writing zippy Android apps. Google I/O 2010. May 27, 2010.
  • talk/brad2011 Palestra Brad FitzPatrick. Perl Workshop. Parte 1. May 12, 2011.
  • talk/brad2012 Behind the Scenes at LiveJournal: Scaling Storytime. Brad Fitzpatrick. May 21, 2012.
  • talk/brad2013a Software I'm excited about. dotScale 2013. Jul 30, 2013.
  • talk/brad2013b LiveJournal's Moscow office. Brad Fitzpatrick. Dec 15, 2013.
  • talk/brad2014a Camlistore. Go meetup. Jan 2014.
  • talk/brad2014b Camlistore & The Standard Library. GopherCon 2014. May 18, 2014.
  • talk/brad2014c The State of the Gopher. dotGo 2014. October 10, 2014.
  • talk/brad2014d Interview. dotGo 2014. Nov 6, 2014.
  • talk/brad2015a Hacking with Andrew and Brad: an HTTP/2 client. Feb 25, 2015.
  • talk/brad2015b HTTP/2 and Go. London Go Gathering 2015. Mar 4, 2015.
  • talk/brad2015c HTTP/2 for Go. Go Devroom FOSDEM 2015. Mar 4, 2015.
  • talk/brad2015d The state of the Gopher. Munich Gophers. Apr 18, 2015
  • talk/brad2015e The Go Language. devoxx poland 2015. June, 2015
  • talk/brad2015f Hacking with Andrew and Brad: tip.golang.org. Jan 8, 2015.
  • talk/brad2015g Lightning Talk: HTTP/2 in Go. GopherCon 2015. Aug 19, 2015.
  • talk/brad2015h Profiling & Optimizing in Go. Aug 27, 2015.
  • talk/brad2016a Introducing Go 1.6: asymptotically approaching boring. Gophercon India 2016. Mar 29, 2016.
  • talk/brad2016b Lightning Talk: My video & security system. GopherCon 2016. July, 2016.
  • talk/brad2016c Go 1.7. Seattle Go Meetup. Aug 25, 2016.
  • talk/brad2016d The Go Open Source Project's Innards. GothamGo 2016. Dec 15, 2016.
  • talk/brad2017 Half my life spent in open source. May 19, 2017.
  • talk/brad2018a Go: looking back and looking forward. Apr 2, 2018.
  • talk/brad2018b Go 1 11 and beyond. Aug 26, 2018.
  • talk/brad2018c Lightning Talk: The nuclear option, go test -run=InQemu. GopherCon 2018. Sep 11, 2018.
  • talk/brad2019 Brad Fitzpatrick likes Go better than C, C++, Rust, Perl, Python, Ruby, JavaScript and Java. Nov 28, 2019.
• Bryan C. Mills. GitHub
  • talk/bryan2017 Lightning Talk: An overview of sync.Map. GopherCon 2017. Jul 24, 2017.
  • talk/bryan2018 Rethinking Classical Concurrency Patterns. GopherCon 2018. Sep 14, 2018
• Dmitri Shuralyov. (Dmitri Shuralyov, M. Sc.) Website, GitHub, YouTube
  • talk/dmitri2016 Go in the browser. dotGo. Oct 10, 2016.
• Steve Francia. Website, GitHub, Twitter.
  • talk/steve2019a What Should A Modern Practical Programming Language Look Like. Landing Festival. April 4, 2019.
  • talk/steve2019b The Legacy Of Go. Go Lab. Oct 22, 2019.
• Jonathan Amsterdam.
  • talk/jonathan2020 Working with Errors. Nov 13, 2020.
• Daniel Martí. Website, GitHub, Twitter
• Nigel Tao. GitHub, Twitter
• Michael Matloob. GitHub, Twitter
• Jay Conrod. Website, Twitter
• Dave Cheney. Website, GitHub, Twitter
• Sam Boyer. GitHub, Twitter
• Fillippo Valsorda. Website, GitHub, Twitter
  • talk/filo2016 From cgo back to Go. July 12, 2016
  • talk/filo2017 From Go to Rust without cgo.
  • talk/filo2018 Why cgo is slow. CapitalGo 2018.
  • talk/speakerdeck

more people and talks should be added...

Back To Top

Group Interviews

• talk/goteam2012 Meet the Go Team. Google I/O 2012. Jul 2, 2012.
• talk/goteam2013 Fireside Chat with the Go Team. Google I/O 2013. May 18, 2013.
• talk/goteam2014 Inside the Gophers Studio with Blake Mizerany. GopherCon 2014. May 21, 2014
• talk/goteam2019 Meet the Authors: Go Language. Cloud Next '19. Apr 10, 2019.
• talk/goteam2020a GoLab 2020: Go Team AMA. Oct 22, 2020.
• talk/goteam2020b GopherCon 2020: Go Team AMA. Nov 16, 2020.
• talk/goteam2021 GopherCon 2021: Go Time Live - Go Team "Ask Me Anything", Dec 28, 2021.

Back To Top

Timeline

A timeline helps you identify the point in time about a document that is reflected in Go versions.

The historical release notes may helpful for general information:

• doc/go1release Go Release History
• doc/go1prerelease Pre-Go 1 Release History
• doc/go0release Weekly Release History (Before Go 1)

Back To Top

Language Design

General

• design/go0initial Rob Pike, Robert Griesemer, Ken Thompson. The Go Annotated Specification. Mar 3, 2008.
• design/go0spec0 The Go Programming Language. Language Specification. Mar 7, 2008.
• design/go0semicolon Rob Pike. Semicolons in Go. Dec 10, 2009.
• design/go11func Russ Cox. Go 1.1 Function Calls. February 2013
• design/go11return Russ Cox. Go “Return at End of Function” Requirements. March 2013
• design/go12nil Russ Cox. Go 1.2 Field Selectors and Nil Checks. July 2013.
• doc/go13todo Go 1.3 “To Do” List. Jun 1, 2014.
• doc/goatgoogle Rob Pike. Go at Google - Language Semantics. October 25, 2012.
• doc/makego Andrew Gerrand. How Go was Made. July 9, 2015.
• discuss/go1preview Russ Cox. Go 1 Preview. 2011.
• design/overlapping-interfaces Robert Griesemer. Proposal: Permit embedding of interfaces with overlapping method sets. Oct 16, 2019.
  • issue/6977 spec: allow embedding overlapping interfaces
• design/struct-conversion Robert Griesemer. Proposal: Ignore tags in struct type conversions. June 16, 2016.
  • issue/16085 Proposal: Ignore tags in struct type conversions
• design/go2trans Ian Lance Taylor. Proposal: Go 2 transition. October 15, 2018
• design/signed-int-shift Robert Griesemer. Proposal: Permit Signed Integers as Shift Counts for Go 2. January 17, 2019
  • issue/19113 proposal: spec: allow signed shift counts
• design/number-literal Russ Cox, Robert Griesemer. Proposal: Go 2 Number Literal Changes. March 6, 2019
  • issue/12711 proposal: different octal base literal representation
  • issue/19308 proposal: spec: binary integer literals
  • issue/28493 proposal: permit blank (_) separator in integer number literals
  • issue/29008 proposal: Go 2: hexadecimal floats
• discuss/delete-return why delete() doesn't return a bool ?
  • issue/5147 runtime: consider caching previous map hash value
  • issue/51405 proposal: Go 2: builtin: delete should return the deleted map item
• issue/33502 proposal: review meeting minutes
• issue/33892 proposal: Go 2 review meeting minutes
• issue/19623 proposal: spec: change int to be arbitrary precision
• design/unsafearithmetic Matthew Dempsky. Go 1.4: unsafe.Pointer arithmetic. Aug 2014.
• issue/19367 unsafe: add Slice(ptr *T, len anyIntegerType) []T
• issue/40481 unsafe: add Add function
• issue/53003 unsafe: add StringData, String, SliceData
• issue/43615 proposal: weak reference maps
• issue/48105 spec: clarify sequencing of function calls within expressions
• issue/56351 proposal: spec: add delete(m) to clear map
• issue/58233 proposal: spec: define return statement's result assignment order?
• issue/57616 proposal: spec: add simple string interpolation similar to Swift
• issue/57411 proposal: spec: define initialization order more precisely
• issue/56103 spec: disallow anonymous interface cycles
• issue/25448 spec: guarantee non-nil return value from recover
• issue/61372 proposal: spec: add untyped builtin zero
• issue/56351 spec: add clear(x) builtin, to clear map, zero content of slice
• issue/58625 unsafe: allow conversion of uintptr to unsafe.Pointer when it points to non-Go memory
• discuss/48305 doc comment revisions: headings, lists, and links
• issue/12445 spec: clarify how unsafe.Pointers may be used to determine offsets between addresses

Back To Top

Slice (1.2)

• design/read-only-slices Brad Fitzpatrick. Read-only slices. May 13, 2013
• design/read-only-slices-russ Russ Cox. Evaluation of read-only slices. May 2013.
• design/go12slice Russ Cox. Go Slice with Cap. June 2013.
• design/multidim-slice Brendan Tracey. Proposal: Multi-dimensional slices. November 17th, 2016.
• issue/41239 runtime: append growth sort of inconsistent and surprising
• discuss/why-slice-grow slices grow at 25% after 1024 but why 1024?
• cl/347917 runtime: make slice growth formula a bit smoother
  • doc/cl-347917-graph Graphs for CL 347917
• cl/418554 cmd/compile,runtime: redo growslice calling convention

Back To Top

Package Management (1.4, 1.5, 1.7)

• design/go14internal Russ Cox. Go 1.4 “Internal” Packages. June 2014.
• design/go14nopkg Russ Cox. Go 1.4 src/pkg → src. June 2014.
• design/go14customimport Russ Cox. Go 1.4 Custom Import Path Checking. June 2014.
• design/go15vendor Russ Cox. Go 1.5 Vendor Experiment. July 2015
• design/go17binarypkg Russ Cox. Proposal: Binary-Only Packages. April 24, 2016
  • issue/2775 cmd/go: work when binaries are available but source is missing

Back To Top

Type alias (1.9)

• design/type-alias Russ Cox, Robert Griesemer. Proposal: Type Aliases. December 16, 2016
  • talk/type-alias GopherCon 2016 - Lightning Talk: Robert Griesemer - Alias Declarations for Go, A proposal. Oct 9, 2016
  • issue/16339 proposal: Alias declarations for Go
  • issue/18130 all: support gradual code repair while moving a type between packages
• talk/refactor-video Russ Cox. Codebase Refactoring (with help from Go). GothamGo 2016. November 18, 2016.
  • doc/refactor Russ Cox. Codebase Refactoring (with help from Go).

Back To Top

Defer (1.14)

• design/open-defer Dan Scales, Keith Randall, and Austin Clements. Proposal: Low-cost defers through inline code, and extra funcdata to manage the panic case. 2019-09-23
  • issue/6980 cmd/compile: allocate some defers in stack frames
  • issue/14939 runtime: defer is slow #14939
• Unsolved defer recover() edge cases.
  • issue/10458 spec: panicking corner-case semantics
  • issue/23531 spec: recover() in nested defer
  • issue/26275 runtime: document the behaviour of Caller and Callers when used in deferred functions
  • issue/34530 spec: clarify when calling recover stops a panic
  • cl/189377 spec: specify the behavior of recover and recursive panics in more detail

Back To Top

Error values

Error handling includes two separate works: error values and error formatting. Historically, there was a try proposal that had been investigated for a year, however, due to its lack of simplicity and impact to stack tracing, it was rejected. In 1.13, error values received a large revision, and the package errors includes different APIs, such as errors.Is. Until recently (1.21), #53435 allows wrapping multiple errors, and there is a community repository that tries to implement the original try proposal.

• doc/err2011 Andrew Gerrand. Error handling in Go. July 2011.
• doc/err-values Rob Pike. Errors are values. January 2015.
• doc/err-philosophy Dave Cheney. My philosophy for error handling. April 2016.
• doc/err-gracefully Dave Cheney. Don’t just check errors, handle them gracefully. April 2016.
• doc/err-stacktrace Dave Cheney. Stack traces and the errors package. June, 12 2016.
• doc/err-upspin Rob Pike. Error handling in Upspin. December 06, 2017.
• doc/err-work Damien Neil and Jonathan Amsterdam. Working with Errors in Go 1.13. October 17, 2019.
• design/err-handling-overview Russ Cox. Error Handling — Problem Overview.
• doc/err-value-faq Jonathan Amsterdam and Bryan C. Mills. Error Values: Frequently Asked Questions. August 2019.
• design/err-handle-check Marcel van Lohuizen. Error Handling — Draft Design. August 27, 2018.
• design/err-try Robert Griesemer. Proposal: A built-in Go error check function, "try". Jun 12, 2019.
  • issue/32437 Proposal: A built-in Go error check function, "try". Decision response.
• design/err-inspect Jonathan Amsterdam, Damien Neil. Error Inspection — Draft Design. August 27, 2018.
• design/err-values-overview Russ Cox. Error Values — Problem Overview. August 27, 2018.
• design/error-values Jonathan Amsterdam, Russ Cox, Marcel van Lohuizen, Damien Neil. Proposal: Go 2 Error Inspection. January 25, 2019
  • issue/29934 Jonathan Amsterdam. proposal: Go 2 error values. Jan 25, 2019.
  • issue/29934-decision Damien Neil. Go 1.13 lunch decision about error values. May 6, 2019.
  • issue/29934-russ Russ Cox. Response, Response regarding "proposal: Go 2 error values". May 7, 2019.
• design/err-print Marcel van Lohuizen. Error Printing — Draft Design. August 27, 2018.
  • issue/30468 errors: performance regression in New.
• issue/40432 language: Go 2: error handling meta issue
• issue/40776 proposal: dynamic ignored error detector
• issue/41198 proposal: errors: add ErrUnimplemented as standard way for interface method to fail.
• issue/47811 proposal: errors: add Errors as a standard way to represent multiple errors as a single error
• issue/53435 proposal: wrapping multiple errors
• repo/try Try: Simplified Error Handling in Go

Back To Top

Channel/Select

• design/lockfree-channels Dmitry Vyukov. Go channels on steroids. Jan 28, 2014
  • issue/8899 runtime: lock-free channels
  • discuss/lockfree-channels update on "lock-free channels"
  • cl/112990043 runtime: fine-grained locking in select
  • cl/110580043 runtime: add fast paths to non-blocking channel operations
• issue/8898 runtime: special case timer channels
• issue/9120 runtime: remove implementation restriction on channel element size
• issue/37196 time: make Timer/Ticker channels not receivable with old values after Stop or Reset returns
• issue/8903 runtime: make chan-based generators faster.
• issue/21806 fairness in select statement.
• issue/40410 runtime: trim unnecessary fields from scase
• issue/40641 runtime: race between stack shrinking and channel send/recv leads to bad sudog values
• issue/37350 reflect: Select panics if array length greater than 1<<16

Back To Top

Generics

• doc/generics-discuss Summary of Go Generics Discussions
• doc/generics-dilemma Russ Cox. The Generic Dilemma. December 3, 2009.
• design/type-functions Ian Lance Taylor. Type Functions. June 2010.
• design/generalized-types Ian Lance Taylor. Generalized Types. March 2011.
• design/code-gen Russ Cox. Alternatives to Dynamic Code Generation in Go. September 2012.
• design/generalized-types2 Ian Lance Taylor. Generalized Types In Go. October 2013.
• design/type-parameters Ian Lance Taylor. Type Parameters in Go. December 2013.
• design/compile-time-function Bryan C. Mills. Compile-time Functions and First Class Types. September 2016.
• design/should-generics Ian Lance Taylor. Go should have generics. January 2011.
• design/should-generics2 Ian Lance Taylor. Go should have generics. Updated: April 2016.
  • issue/15292 proposal: spec: generic programming facilities
• design/generics-overview Russ Cox. Generics — Problem Overview. August 27, 2018.
• design/contracts Ian Lance Taylor, Robert Griesemer. Contracts — Draft Design. August 27, 2018, Updated: July 31, 2019.
  • cl/187317 Implementation prototype.
  • paper/featherweight-go Griesemer, Robert, et al. Featherweight Go. arXiv preprint arXiv:2005.11710 (2020).
  • talk/featherweight-go Phil Wadler: Featherweight Go. Jun 8, 2020.
• design/type-parameters2 Ian Lance Taylor, Robert Griesemer. Type Parameters - Draft Design. June 16, 2020, Updated: August 28, 2020.
  • cl/dev.go2go dev.go2go branch
  • doc/type-check-readme type checking.
  • doc/type-check-notes This file serves as a notebook/implementation log.
• discuss/generics-parenthesis Robert. Generics and parenthesis.
• discuss/generics-move Ian, Moving forward with the generics design.
• discuss/generics-implementation Implementing Generics
• design/generics-implementation-stenciling Generics implementation - Stenciling
• design/generics-implementation-dictionaries Generics implementation - Dictionaries
• design/generics-implementation-gcshape Generics implementation - GC Shape Stenciling
• design/generics-implementation-dictionaries-go1.18 Go 1.18 Implementation of Generics via Dictionaries and Gcshape Stenciling
• issue/43651 proposal: spec: add generic programming using type parameters
• design/type-parameters3 Type Parameters Proposal
• issue/45346 proposal: spec: generics: use type sets to remove type keyword in constraints
• issue/46477 proposal: spec: generics: type parameters on aliases
• issue/38907 proposal: spec: disallow impossible interface-interface type assertions
• discussion/48287 how to update APIs for generics
• Generics behavior
  • issue/48274 doc: update FAQ for the arrival of parametric polymorphism
  • issue/50202 spec: document that type parameters are not permitted as constant declaration types
  • issue/50272 spec: function type inference ignores type parameter constraints
  • issue/50954 go/types, types2: review error messages
  • issue/51110 spec: document behavior of type switches containing type parameter cases
  • any/comparable
    • issue/33232 spec: allow 'any' for 'interface{}' in non-constraint contexts
    • issue/46746 reflect: add Value.Equal, Value.Comparable
    • issue/49587 proposal: spec: add comparable w/o interfaces
    • issue/49927 builtin: add documentation for any and comparable to pseudo-package builtin
    • issue/49884 all: rewrite interface{} to any
    • issue/50646 spec: document/explain which interfaces implement comparable
    • issue/50646 spec: document definition of comparable
    • issue/51257 spec: any no longer implements comparable
    • issue/51338 proposal: spec: permit values to have type "comparable"
    • issue/52474 proposal: spec: permit non-interface types that support == to satisfy the comparable constraint
    • issue/52509 proposal: spec: allow interface types to instantiate comparable type parameters
    • issue/52531 proposal: spec: add new constraint kind satisfied by types that support == (including interface types)
    • issue/52614 proposal: type parameters are comparable unless they exclude comparable types
    • issue/52624 proposal: the comparable interface represents the comparable subset of run-time values
• Standard packages using generics
  • issue/45458 constraints: new package to define standard type parameter constraints
  • discuss/47319 proposal: constraints: new package to define standard type parameter constraints (discussion)
  • issue/45955 slices: new package to provide generic slice functions
  • discuss/47203 proposal: slices: new package to provide generic slice functions (discussion)
  • discuss/47331 proposal: container/set: new package to provide a generic set type (discussion)
  • discuss/47330 proposal: maps: new package to provide generic map functions (discussion)
  • issue/47649 maps: new package to provide generic map functions
  • issue/57436 maps: new standard library package based on x/exp/maps
  • issue/47657 proposal: sync, sync/atomic: add PoolOf, MapOf, ValueOf
  • issue/50792 constraints: move to x/exp for Go 1.18
  • issue/53427 proposal: x/sync/singleflight: add generic version
• Related packages
  • issue/47781 go/ast, go/token: additions to support type parameters
  • issue/47916 go/types: additions to support type parameters
  • issue/48525 x/tools/go/ssa: generics support
  • issue/50887 go/types, types2: document predicates on generic types
• issue/52654 spec: provide some way to refer to a generic function without instantiation
• issue/59488 cmp: new package with Ordered, Compare, Less; min, max as builtins
• issue/60648 cmp: document ordering for floating point values in cmp.Ordered
• issue/59531 all: ordering numeric values, including NaNs, and the consequences thereof
• issue/60519 math: remove Compare, Compare32
• issue/58650 spec: a general approach to type inference
• issue/59338 spec: infer type arguments from assignments of generic functions (reverse type inference)
• issue/58671 spec: type inference should be more lenient about untyped numeric literals
• issue/57644 proposal: spec: sum types based on general interfaces Back To Top
• issue/60353 spec: when unifying against interface types, consider common methods
• issue/57433 slices: new standard library package based on x/exp/slices
• issue/51259 proposal: spec: support for struct members in interface/constraint syntax
• issue/50285 proposal: generic should infer type from variable definition

Iterator

• issue/24282 proposal: Go 2: improve for-loop ergonomics
• issue/40605 proposal: Go 2: iterators
• issue/43557 proposal: Go 2: function values as iterators
• issue/47707 proposal: Go 2: spec: for range with defined types
• issue/48567 proposal: use channels as iterators
• issue/50112 proposal: package collection and iterator design for go
• issue/54047 proposal: Go 2: add a new iterator syntax, package, interfaces
• discuss/54245 discussion: standard iterator interface
• issue/20733 proposal: spec: redefine range loop variables in each iteration
• issue/56010 redefining for loop variable semantics
• issue/60078 spec: less error-prone loop variable scoping
• discuss/56413 user-defined iteration using range over func values
• issue/61405 proposal: spec: add range over int, range over func
• doc/coro Coroutines for Go
• issue/54650 x/exp/slices: memory leak on Delete

Back To Top

Compatibility

• doc/go1compat Go 1 and the Future of Go Programs
• discussion/55090 extending Go backward compatibility
  • issue/56986 extended backwards compatibility for Go
  • design/godebug Proposal: Extended backwards compatibility for Go
• discussion/55092 extending Go forward compatibility
  • issue/57001 extended forwards compatibility for Go
  • design/gotoolchain Proposal: Extended forwards compatibility in Go
• issue/33791 proposal: add explicit decision doc for large changes

Compiler Toolchain

Office Hours

• discuss/runtime-office-hours compiler & runtime office hours
  • talk/runtime-office-meeting1 Go compiler & runtime office hours 2022-12-19
  • talk/runtime-office-meeting2 Go compiler & runtime office hours 2023-01-19

Compiler

• code/gc0initial Ken Thompson. Go0 compiler initial version. 28 Mar 2008.
• code/6g Rob Pike. the first complete Go0 compiler. 4 Jun 2008.
• design/go12symtab Russ Cox. Go 1.2 Runtime Symbol Information. July 2013.
• design/go13compiler Russ Cox. Go 1.3+ Compiler Overhaul. December 2013
• design/go14generate Rob Pike. Go generate: A Proposal
• design/dev.cc Russ Cox. dev.cc branch plan. Nov 2014
• design/go15bootstrap Russ Cox. Go 1.5 Bootstrap Plan. January 2015.
• doc/escape-analysis Dmitry Vyukov. Go Escape Analysis Flaws. Feb 10, 2015.
• design/execmodes Ian Lance Taylor. Go Execution Modes. August, 2014 (updated January 2016)
• design/go17ssa Keith Randall. New SSA Backend for the Go Compiler. 2/10/2015.
• doc/compiler-optimization Compiler And Runtime Optimizations.
• issue/6853 all: binaries too big and growing.
• design/go19inlining David Lazar, Austin Clements. Proposal: Mid-stack inlining in the Go compiler.
  • issue/19348 cmd/compile: enable mid-stack inlining.
  • talk/go19inliningtalk David Lazar. Mid-stack inlining in the Go compiler
• design/dwarf-inlining Than McIntosh. Proposal: emit DWARF inlining info in the Go compiler. 2017-10-23.
  • issue/22080 cmd/compile: generated DWARF inlining info
• issue/23109 cmd/compile: rewrite escape analysis.
• issue/27167 cmd/compile: rename a bunch of things
  • doc/renames Proposed Go 1.12 toolchain renames
• GOEXPERIMENT=checkptr
  • issue/22218 proposal: add GOEXPERIMENT=checkptr
  • issue/34964 cmd/compile: enable -d=checkptr as part of -race and/or -msan?
  • issue/34972 all: get standard library building with -d=checkptr
  • discuss/checkptr
• issue/37121 runtime: unaligned jumps causing performance regression on Intel
• issue/16798 proposal: cmd/compile: add tail call optimization for self-recursion only. (declined)
• issue/22624 proposal: Go 2: add become statement to support tail calls (declined)
• design/64align Dan Scales. Proposal: Make 64-bit fields be 64-bit aligned on 32-bit systems, add //go:packed, //go:align directives. 2020-06-08.
  • issue/599 cmd/compile: make 64-bit fields 64-bit aligned on 32-bit systems
  • issue/36606 proposal: cmd/compile: make 64-bit fields be 64-bit aligned on 32-bit systems, add //go:packed directive on structs
• talk/gccgo Brief overview of gccgo, "the other" Go compiler. Aug 6, 2015.
• issue/28262 cmd/compile: feedback-guided optimization
• issue/55022 proposal: cmd/compile: profile-guided optimization
• issue/55025 proposal: design and implementation of Profile-Guided Optimization (PGO)
• design/pgo Proposal: profile-guided optimization
• design/pgo-implementation Design and Implementation of Profile-Guided Optimization (PGO) for Go
• issue/58409 telemetry in the Go toolchain
• issue/58894 all: add opt-in transparent telemetry to Go toolchain
• issue/54534 cmd/compile: design doc explaining unified IR implementation
• discuss/53060 discussion: clarify Go support policy for secondary ports
• issue/53383 clarify Go support policy for secondary ports

Back To Top

Linker

The Go Linker was written by Ken Thompson. Russ led a few more overhaul in Go 1.3. Austin led a rework to the linker together with Keith, Than, Cheery and many other brilliant brains, which was landed in Go 1.15 and Go 1.16.

• design/go13linker Russ Cox. Go 1.3 Linker Overhaul. Nov 2013.
• design/go116linker Austin Clements. Building a better Go linker. 2019-09-12.

Back To Top

Debugger

• doc/go13heapdump heapdump13
• doc/go14heapdump heapdump14
• doc/go15heapdump heapdump15 through heapdump17
• design/heap-viewer Michael Matloob. Proposal: Go Heap Dump Viewer. 20 July 2016
  • issue/16410 x/tools/cmd/heapdump: create a heap dump viewer
• design/profiler-labels Michael Matloob. Proposal: Support for pprof profiler labels. May 15, 2017.
  • issue/17280 pprof: add support for profiler labels

Back To Top

Race Detector

• issue/42598 runtime: apparent false-positive race report for a buffered channel after CL 220419

Back To Top

Tracer

• design/go15trace Dmitry Vyukov. Go Execution Tracer. Oct 2014
• design/tracefmt nduca@, dsinclair@. Trace Event Format. October 2016.
• issue/54466 runtime: rewrite gentraceback as an iterator API Back To Top

Lock Analysis

• issue/38029 x/build: linux-amd64-staticlockranking consistently failing
  • cl/192704 runtime: lock operation logging support
  • cl/207348 runtime: release timersLock while running timer
  • cl/207846 runtime: avoid potential deadlock when tracing memory code
  • cl/207619 runtime: static lock ranking for the runtime (enabled by GOEXPERIMENT)
  • cl/222925 cmd/go: define a build tag for any GOEXPERIMENT which is enabled
  • cl/228417 runtime: incorporate Gscan acquire/release into lock ranking order
  • cl/229480 runtime: added several new lock-rank partial order edges
  • cl/231463 runtime: add one extra lock ranking partial edge
  • cl/233599 runtime: add a lock partial order edge (assistQueue -> mspanSpecial)
  • cl/236137 runtime: add three new partial orders for lock ranking
• issue/40677 runtime: lock held checking

Builder

• design/go13nacl Russ Cox. Go 1.3 Native Client Support. October 2013.
• design/gobuilder Brad Fitzpatrick. Go Builder Plan. 2014-09-03.
  • discuss/gobuilder Changing how builders run
• design/go14android David Crawshaw. Go support for Android. June 2014.
• design/go-generate Rob Pike. Go Generate. January 2014.
• issue/13560 proposal: build: define standard way to recognize machine-generated files
• discuss/generatedcode Rob Pike's Final Comments on Issue 13560
• design/goenv Russ Cox. Proposal: go command configuration file. March 1, 2019
  • issue/30411 proposal: cmd/go: add go env -w to set default env vars
• design/go116build Russ Cox. Bug-resistant build constraints — Draft Design. June 30, 2020.
  • issue/41184 cmd/go: continue conversion to bug-resistant //go:build constraints
• Windows
  • issue/41191 toolchain directives
  • discuss/win2000-golang-nuts objections to removing Go support for Windows 2000 (x86-32)?
• design/wasm Richard Musiol. WebAssembly architecture for Go. 28th February 2018.
• design/wasm2 WebAssembly assembly files

Back To Top

Modules

• design/go-dep Go Packaging Proposal Process
• design/go-dep2 Dependency Management Tool
  • doc/go-dep Sam Boyer. The Saga of Go Dependency Management. Dec 13, 201
  • talk/go-dep GopherCon 2017: Sam Boyer - The New Era of Go Package Management. Jul 24, 2017
  • talk/go-dep-design dotGo 2017 - sam boyer - The Functional Design of Dep. Dec 8, 2017
  • discuss/go-dep Building Predictability into Your Pipeline :: Russ Cox; Jess Frazelle, Sam Boyer, Pete Garcin. Feb 22, 2018
• design/vgo Russ Cox. Proposal: Versioned Go Modules. March 20, 2018.
  • issue/24301 cmd/go: add package version support to Go toolchain
  • doc/deps Russ Cox. Our Software Dependency Problem. January 23, 2019.
  • doc/vgo Russ Cox. Go & Versioning
  • discuss/groups-gomod go modules have landed
  • discuss/go-dep-response Reddit discussion.
  • doc/go-dep-response Peter Bourgon. A response about dep and vgo. 2018-07-27.
  • discuss/go-dep-response2 Hacker News discussion.
  • discuss/go-dep-twitter Russ Cox's Twitter Storm
• design/sumdb Russ Cox, Filippo Valsorda. Proposal: Secure the Public Go Module Ecosystem. April 24, 2019.
  • issue/25530 proposal: cmd/go: secure releases with transparency log
• issue/23966 why go.mod has its own bespoke syntax?
• design/lazy-gomod Bryan C. Mills. Proposal: Lazy Module Loading. Feb 20, 2020
• issue/45713 proposal: cmd/go: add a workspace mode
  • design/workspace Proposal: Multi-Module Workspaces in cmd/go

Back To Top

gopls

• design/gopls-workspace Heschi Kreinick, Rebecca Stambler. Proposal: Multi-project gopls workspaces. Mar 9, 2020.

Back To Top

Testing, x/perf

• design/subtests Marcel van Lohuizen. testing: programmatic sub-test and sub-benchmark support. September 2, 2015.
  • issue/12166 proposal: testing: programmatic sub-test and sub-benchmark support
• design/gotest-bench Russ Cox, Austin Clements. Proposal: Go Benchmark Data Format. February 2016.
  • issue/14313 cmd/go: decide, document standard benchmark data format
• issue/20875 testing: consider calling ReadMemStats less during benchmarking
• issue/27217 testing: tiny benchmark with StopTimer runs forever
• issue/41637 testing: benchmark iteration reports incorrectly
• issue/41641 testing: inconsistent benchmark measurements when interrupts timer
• design/gotest-json Nodir Turakulov. Proposal: -json flag in go test. 2016-09-14.
• design/testing-helper Caleb Spare. Proposal: testing: better support test helper functions with TB.Helper. 2016-12-27
  • issue/4899 testing: add t.Helper to make file:line results more useful
• design/fuzzing Katie Hockman. Design Draft: First Class Fuzzing
• issue/43744 testing: benchmark unit properties
• issue/48803 all: Go compiler/runtime performance monitoring system
• issue/49121 x/perf/storage: support postgres for db
• issue/61179 proposal: testing: add identity function that forces evaluation for benchmarks

Back To Top

Runtime Core

Scheduler

• paper/work-steal Robert D. Blumofe and Charles E. Leiserson. 1999. Scheduling multithreaded computations by work stealing. J. ACM 46, 5 (September 1999), 720-748.
• cl/sched-m-1 Russ Cox, Clean up scheduler. Aug 5, 2008.
• cl/sched-m-n things are much better now, Nov 11, 2009.
• design/go11sched Dmitry Vyukov. Scalable Go Scheduler Design Doc, 2012
  • cl/7314062 runtime: improved scheduler
• design/sched-preempt-dmitry Dmitry Vyukov. Go Preemptive Scheduler Design Doc, 2013
• design/sched-numa Dmitry Vyukov, NUMA-aware scheduler for Go. Sep 2014.
• design/go15gomaxprocs Russ Cox. Go 1.5 GOMAXPROCS Default. May 2015.
• doc/go17sched Ian Lance Taylor. How does the golang scheduler work? July 16, 2016.
• design/sched-preempt-austin Austin Clements. Proposal: Non-cooperative goroutine preemption. Jan 2019.
  • cl/43050 cmd/compile: loop preemption with fault branch on amd64. May 09, 2019.
  • issue/10958 runtime: tight loops should be preemptible
  • issue/24543 runtime: non-cooperative goroutine preemption
  • issue/36365 runtime: clean up async preemption loose ends
• issue/14592 runtime: let idle OS threads exit
• issue/18237 runtime: scheduler is slow when goroutines are frequently woken
• issue/20395 runtime: terminate locked OS thread if its goroutine exits
• issue/20458 proposal: runtime: pair LockOSThread, UnlockOSThread calls
• issue/21827 runtime: big performance penalty with runtime.LockOSThread
• issue/27345 runtime: use parent goroutine's stack for new goroutines
• issue/28808 runtime: scheduler work stealing slow for high GOMAXPROCS
• issue/32113 runtime: optimization to reduce P churn.
• issue/43997 runtime: non-spinning Ms spin uselessly when work exists
• issue/44313 runtime: stopped Ms can't become dedicated or fractional GC workers
• issue/51071 runtime: investigate possible Go scheduler improvements inspired by Linux Kernel's CFS

Back To Top

Execution Stack

• design/contigstack Contiguous stacks
• doc/stackroots precise stack roots
  • discussion/stackroots Precise garbage collection of stack roots
• issue/17007 runtime: fatal error: bad g->status in ready
• issue/18138 runtime: new goroutines can spend excessive time in morestack
  • design/predict-stack-size Keith Randall. Determining a good starting stack size. 2021/08/18.
  • cl/341990 runtime: predict stack sizing
  • cl/345889 runtime: measure stack usage; start stacks larger if needed
• issue/26061 runtime: g0 stack.lo is sometimes too low

Back To Top

Memory Management

Allocator

A quick history about the Go's memory allocator: Russ Cox first implements the memory allocator based on tcmalloc for Go 1, mcache is cached on M. Then he revised the allocator to allow user code to use 16GB memory and later allows 128GB. However, the allocator (including scavenger) was suffered from massive lock contentions and does not scale. After Dmitry's scalable runtime scheduler, the allocator can allocate directly from P (with much less) lock contentions. In the meantime, the scavenger is migrated from an independent thread into the system monitor thread. Now, Michael is actively working on improving the memory allocator's scalability, such as migrating scavenger to user threads, bitmap-based page allocator, scalable mcentral.

• doc/tcmalloc Sanjay Ghemawat, Paul Menage. TCMalloc : Thread-Caching Malloc. Google Inc., 2009
• design/go113scavenge Michael Knyszek. Proposal: Smarter Scavenging. 2019-05-09.
  • issue/30333 runtime: smarter scavenging
  • issue/32012 runtime: background scavenger is overzealous with small heaps
  • issue/31966 runtime: background scavenger can delay deadlock detection significantly
  • issue/34047 runtime: potential deadlock cycle caused by scavenge.lock
  • issue/34048 runtime: scavenger pacing fails to account for fragmentation
  • issue/35788 runtime: scavenger not as effective as in previous releases
  • issue/36521 runtime: performance degradation in go 1.12
  • issue/36603 runtime: sysUsed often called on non-scavenged memory
• design/go114pagealloc Michael Knyszek, Austin Clements. Proposal: Scaling the Go page allocator. 2019-10-18.
  • issue/35112 runtime: make the page allocator scale
  • cl/200439 runtime: place lower limit on trigger ratio
• issue/8885 runtime: consider adding 24-byte size class.
• issue/37487 runtime: improve mcentral scalability
  • cl/221182 runtime: add new mcentral implementation
• issue/18155 runtime: latency in sweep assists when there's no garbage
• issue/19112 runtime: deadlock involving gcControllerState.enlistWorker
• issue/23687 runtime: use MADV_FREE on linux as well
  • cl/135395 runtime: use MADV_FREE on Linux if available
• issue/29707 cmd/trace: failed to parse trace: no consistent ordering of events possible
• issue/35954 runtime: handle hitting the top of the address space in the allocator more gracefully
• issue/37927 runtime: GC pacing exhibits strange behavior with a low GOGC
• issue/38130 runtime: incorrect sanity checks in the page allocator
• issue/38404 runtime: STW GC stops working on arm64/mips64le
• issue/38605 runtime: pageAlloc.allocToCache updates pageAlloc.searchAddr in an invalid way
• issue/38617 runtime: scavenger freezes up in Go 1.14 in Windows due to coarse time granularity
• issue/38966 runtime: aix-ppc64 builder is failing with "bad prune", "addr range base and limit are not in the same memory segment" fatal errors
• issue/39128 runtime: linux-mips-rtrk builder consistently failing with "bad prune" as of CL 233497
• issue/40191 runtime: pageAlloc.searchAddr may point to unmapped memory in discontiguous heaps, violating its invariant
• issue/40457 runtime: runqputbatch does not protect its call to globrunqputbatch
• issue/40641 runtime: race between stack shrinking and channel send/recv leads to bad sudog values
• issue/42330 runtime: default to MADV_DONTNEED on Linux
  • cl/267100 runtime: default to MADV_DONTNEED on Linux
• issue/46787 runtime: provide Pinner API for object pinning
• issue/51317 proposal: arena: new package providing memory arenas
• issue/59960 runtime: improve heap hugepage utilization Back To Top

Collector

• paper/on-the-fly-gc Edsger W. Dijkstra, Leslie Lamport, A. J. Martin, C. S. Scholten, and E. F. M. Steffens. 1978. On-the-fly garbage collection: An exercise in cooperation. Commun. ACM 21, 11 (November 1978), 966–975.
• paper/yuasa-barrier T. Yuasa. 1990. Real-time garbage collection on general-purpose machines. J. Syst. Softw. 11, 3 (March 1990), 181-198.
• design/bettergc Dmitry Vyukov. Better GC and Memory Allocator for Go. May 20, 2013
  • discuss/bettergc Better GC and Memory Allocator for Go
• design/go13gc Dmitry Vyukov. Simpler and faster GC for Go. July 16, 2014
  • cl/106260045 runtime: simpler and faster GC
• design/go14gc Richard L. Hudson. Go 1.4+ Garbage Collection (GC) Plan and Roadmap. August 6, 2014.
• design/go15gcpacing Austin Clements. Go 1.5 concurrent garbage collector pacing. Mar 10, 2015.
• discuss/gcpacing Austin Clements et al. Discussion of "Proposal: Garbage collector pacing". March 10, 2015.
• issue/11970 runtime: replace GC coordinator with state machine
• design/sweep-free-alloc Austin Clements. Proposal: Dense mark bits and sweep-free allocation. Sep 30, 2015.
• issue/12800 runtime: replace free list with direct bitmap allocation
• design/decentralized-gc Austin Clements. Proposal: Decentralized GC coordination. October 25, 2015.
• issue/12967 runtime: shrinkstack during mark termination significantly increases GC STW time
• issue/14951 runtime: mutator assists are over-aggressive, especially at high GOGC
• design/eliminate-rescan Austin Clements, Rick Hudson. Eliminate STW stack re-scanning. October 21, 2016.
  • issue/17503 runtime: eliminate stack rescanning
• design/concurrent-rescan Austin Clements, Rick Hudson. Proposal: Concurrent stack re-scanning. Oct 18, 2016.
  • issue/17505 runtime: perform concurrent stack re-scanning
• design/soft-heap-limit Austin Clements. Proposal: Separate soft and hard heap size goal. October 21, 2017.
• issue/22460 runtime: optimize write barrier
• design/roc Request Oriented Collector (ROC) Algorithm
  • cl/roc runtime: ROC write barrier code
  • cl/generational-gc runtime: trigger generational GC
• doc/ismm-gc Rick Hudson. Getting to Go: The Journey of Go's Garbage Collector. 12 July 2018.
• discuss/ismm-gc Garbage Collection Slides and Transcript now available
• design/simplify-mark-termination Austin Clements. Proposal: Simplify mark termination and eliminate mark 2. Aug 9, 2018.
  • issue/26903 runtime: simplify mark termination and eliminate mark 2
• design/gcscan Proposal: GC scanning of stacks
  • issue/22350 cmd/compile: compiler can unexpectedly preserve memory,
• issue/27993 runtime: error message: P has cached GC work at end of mark termination
• issue/37116 runtime: 10ms-26ms latency from GC in go1.14rc1, possibly due to 'GC (idle)' work
• issue/42430 runtime: GC pacer problems meta-issue
  • issue/39983 runtime: idle GC interferes with auto-scaling
  • issue/17969 runtime: aggressive GC completion is disruptive to co-tenants
  • issue/14812 runtime: GC causes latency spikes
  • issue/40460 runtime: goroutines may allocate beyond the hard heap goal
  • issue/29696 proposal: runtime: add way for applications to respond to GC backpressure
  • issue/23044 proposal: runtime: add a mechanism for specifying a minimum target heap size
• issue/42642 runtime: multi-ms sweep termination pauses (second edition)
• issue/44163 runtime: remove idle GC workers
• issue/44167 runtime: GC pacer redesign
  • design/gc-pacer-redesign GC Pacer Redesign
• issue/44309 proposal: runtime/debug: user-configurable memory target
• issue/48409 proposal: runtime/debug: soft memory limit
  • design/user-configurable-memory-target User-configurable memory target
  • design/soft-memory-limit Soft memory limit
• issue/45894 runtime: mark termination is slow to restart mutator
• issue/45315 runtime: runtime.GC can return without finishing sweep
• issue/49075 runtime: possible memory corruption
• issue/52433 runtime: heap goal overrun due to scheduler delays in mark termination
• doc/gc-guide A Guide to the Go Garbage Collector
• issue/12234 runtime: revisit non-constant assist ratio
• issue/27732 runtime: mark assist blocks GC microbenchmark for 7ms
• design/batch-wb Keith Randall. Batching Write Barriers. 2022 Oct, 25.
• issue/31222 runtime: long pauses STW (sweep termination) on massive block allocation

Back To Top

Statistics

• issue/16843 runtime: mechanism for monitoring heap size
  • cl/setmaxheap Austin Clements. runtime/debug: add SetMaxHeap API. Jun 26 2017.
• design/go116runtime-metric Michael Knyszek. Proposal: API for unstable runtime metrics. Mar 18, 2020.
• issue/19812 runtime: cannot ReadMemStats during GC
• issue/38712 runtime: TestMemStats is flaky
• issue/40459 runtime: ReadMemStats called in a loop may prevent GC

Back To Top

Memory model

The Go memory model consists the following parts:

• Memory order regarding atomic operations

• Memory order regarding the sync package APIs

• Memory order regarding runtime mechanism (i.e. Object finalizer)

• doc/refmem Rob Pike and Russ Cox. The Go Memory Model. February 21, 2009.

• issue/4947 cmd/cc: atomic intrinsics

• issue/5045 doc: define how sync/atomic interacts with memory model

• issue/7948 doc: define how sync interacts with memory model

• issue/9442 doc: define how finalizers interact with memory model

• issue/33815 doc/go_mem: "hello, world" will not always be printed twice

• cl/75130045 doc: allow buffered channel as semaphore without initialization

• doc/gomem Russ Cox. Go’s Memory Model. February 25, 2016.

• doc/go2017russ Russ Cox. My Go Resolutions for 2017: Memory model. January 18, 2017.

• doc/atomic-bug Package atomic

• discuss/atomic-mem-order specify the memory order guarantee provided by atomic Load/Store

• issue/37355 runtime/race: running with -race misses races (mismatch with memory model)

  • cl/220419 runtime: swap the order of raceacquire() and racerelease
  • issue/42598 runtime: apparent false-positive race report for a buffered channel after CL 220419
  • cl/271987 runtime: check channel's elemsize before calling race detector
  • [paper/fava2020fix] Fava, Daniel Schnetzer. "Finding and Fixing a Mismatch Between the Go Memory Model and Data-Race Detector." International Conference on Software Engineering and Formal Methods. Springer, Cham, 2020.

• doc/mm Russ Cox. Memory Models. June, 2021.

  • doc/hwmm Russ Cox. Hardware Memory Models. June 29, 2021.
  • doc/plmm Russ Cox. Programming Language Memory Models. July 6, 2021.
  • doc/gomm Russ Cox. Updating the Go Memory Model. July 12, 2021.
  • discuss/47141 Updating the Go memory model.
  • issue/50860 proposal: sync/atomic: add typed atomic values
  • issue/50859 proposal: doc: update Go memory model
  • doc/out-of-thin-air Hans-J. Boehm. P1217R2: Out-of-thin-air, revisited, again. 2019-06-16.
  • doc/cpp-memory-model Hans-J. Boehm, Sarita V. Adve. Foundations of the C++ Concurrency Memory Model. May 21, 2008.
  • cl/381315 doc: update Go memory model
  • cl/381316 runtime, sync, sync/atomic: document happens-before guarantees

Back To Top

ABI

• design/cgo-pointers Ian Lance Taylor. Proposal: Rules for passing pointers between Go and C. October, 2015
  • issue/12416 cmd/cgo: specify rules for passing pointers between Go and C
• design/internal-abi Austin Clements. Proposal: Create an undefined internal calling convention. Jan 14, 2019.
  • issue/27539 proposal: runtime: make the ABI undefined as a step toward changing it.
  • issue/31193 cmd/compile, runtime: reduce function prologue overhead
• design/register-call Austin Clements, with input from Cherry Zhang, Michael Knyszek, Martin Möhrmann, Michael Pratt, David Chase, Keith Randall, Dan Scales, and Ian Lance Taylor. Proposal: Register-based Go calling convention. Aug 10, 2020.
• issue/18597 proposal: cmd/compile: define register-based calling convention
• issue/40724 proposal: switch to a register-based calling convention for Go functions
  • cl/266638 reflect,runtime: use internal ABI for selected ASM routines, attempt 2
  • cl/259445 cmd/compile,cmd/link: initial support for ABI wrappers
• design/internal-abi-spec Go internal ABI specification.

Back To Top

Misc

• issue/20135 runtime: shrink map as elements are deleted
• issue/48687 runtime: enhance map cacheline efficiency
• issue/54766 runtime: use SwissTable

Standard Library

syscall

• design/go14syscall The syscall package.
• issue/51087 runtime: clean up system call code

Back To Top

os, io, io/fs, embed

In Go 1.16, tons of major rework and improvements surround the new os/fs package.

• design/draft-iofs Russ Cox, Rob Pike. File System Interfaces for Go — Draft Design. July 2020.
  • issue/13473 proposal: os: Stdin, Stdout and Stderr should be interfaces
  • issue/14106 proposal: os: File should be an interface
  • issue/19660 proposal: io/ioutil: rename to io/fileio or similar
  • issue/40025 proposal: io/ioutil: move Discard, NopCloser, ReadAll to io
  • issue/42027 proposal: path/filepath: add WalkDir (Walk using DirEntry)
  • issue/41190 io/fs: add file system interfaces
  • issue/41467 os: add ReadDir method for lightweight directory reading
  • issue/41974 proposal: io/fs, filepath: add more efficient Walk alternative
  • issue/42026 proposal: os: add ReadDir, ReadFile, WriteFile, CreateTemp, MkdirTemp & deprecate io/ioutil
  • issue/43223 proposal: io/fs, net/http: define interface for automatic ETag serving
• design/go116embed Embedded files - Russ & Braid
  • issue/41191 embed, cmd/go: add support for embedded files
  • issue/42321 embed: warn about dotfiles in embed.FS documentation
  • issue/42328 proposal: cmd/go: avoid surprising inclusion of "hidden" files when using //go:embed
  • issue/43216 proposal: embed: remove support for embedding directives on local variables
  • issue/43217 proposal: embed: define String and Bytes type aliases that must be used with //go:embed
  • issue/43218 embed: resolve string, []byte issues
  • issue/44166 io/fs,os: fs.ReadDir with an os.DirFS can produce invalid paths
  • issue/42322 io/fs: add func Sub(fsys FS, dir string) FS
• issue/45757 proposal: io/fs: add writable interfaces
• issue/9051 io: no easy way to fan out to multiple readers

Back To Top

go/*

• doc/gotypes Alan Donovan. go/types: The Go Type Checker.
• talk/gotypes Alan Donovan. Using go/types for Code Comprehension and Refactoring Tools. October 2, 2015.
• design/modular-interface Alan Donovan. Proposal: a common interface for modular static analyses for Go. 9 Sep 2018
  • cl/134935 go/analysis: a new API for analysis tools

Back To Top

sync

• design/percpu-sharded Sanjay Menakuru. Proposal: percpu.Sharded, an API for reducing cache contention. Jun 12, 2018.
  • issue/18802 proposal: sync: support for sharded values
  • cl/4850045 co: new package
• issue/37142 sync: shrink types in sync package
• issue/56102 sync: add OnceFunc, OnceValue, OnceValues

Back To Top

Map

• issue/21031 sync: reduce pointer overhead in Map
• issue/21032 sync: reduce (*Map).Load penalty for Stores with new keys
• issue/21035 sync: reduce contention between Map operations with new-but-disjoint keys
• issue/37033 runtime: provide centralized facility for managing (c)go pointer handles
• issue/51972 sync: add new Map methods CompareAndSwap, CompareAndDelete, Swap

Back To Top

Pool

• discuss/add-pool gc-aware pool draining policy
• issue/4720 sync: add Pool type. Jan 28, 2013.
• cl/46010043 sync: scalable Pool. Jan 24, 2014.
• cl/86020043 sync: less agressive local caching in Pool. Apr 14, 2014.
• cl/162980043 sync: release Pool memory during second and later GCs. Oct 22, 2014.
• issue/8979 sync: Pool does not release memory on GC
• issue/22331 runtime: clearpools causes excessive STW1 time
• issue/22950 sync: avoid clearing the full Pool on every GC.
  • cl/166960 sync: use lock-free structure for Pool stealing.
  • cl/166961 166961: sync: smooth out Pool behavior over GC with a victim cache.
• issue/24479 sync: eliminate global Mutex in Pool operations

Back To Top

Mutex, RWMutex

• cl/4631059 runtime: replace Semacquire/Semrelease implementation.
• issue/9201 proposal: sync: prohibit unlocking mutex in a different goroutine
• issue/13086 runtime: fall back to fair locks after repeated sleep-acquire failures.
  • cl/34310 sync: make Mutex more fair
• issue/17973 sync: RWMutex scales poorly with CPU count
  • cl/215361 sync: Implement a version of RWMutex that can avoid cache contention

Back To Top

Groups

• cl/134395 errgroup: rethink concurrency patterns
  • cl/131815 errgroup: handle runtime.Goexit from child goroutines
  • issue/15758 testing: complain loudly during concurrent use of T.FatalX and T.SkipX
  • issue/25448 proposal: promote panic(nil) to non-nil panic value

atomic

• issue/8739 runtime,sync/atomic: unify API for runtime/internal/atomic and sync/atomic
• issue/20164 proposal: atomic: add (*Value).Swap
• discuss/atomic-value
• issue/36606 proposal: cmd/compile: make 64-bit fields be 64-bit aligned on 32-bit systems, add //go:packed directive on structs
• issue/37262 runtime: can't atomic access of first word of tiny-allocated struct on 32-bit architecture

Back To Top

time

• design/monotonic-time Russ Cox. Proposal: Monotonic Elapsed Time Measurements in Go. January 26, 2017.
  • issue/12914 time: use monotonic clock to measure elapsed time
• Scalable Timer
  • cl/34784 runtime: improve timers scalability on multi-CPU systems
  • issue/6239 runtime: make timers faster.
  • issue/15133 runtime: timer doesn't scale on multi-CPU systems with a lot of timers
  • issue/27707 time: excessive CPU usage when using Ticker and Sleep.
• Followup latency issues
  • issue/18023 runtime: unexpectedly large slowdown with runtime.LockOSThread
  • issue/25471 time: Sleep requires ~7 syscalls
  • issue/38070 runtime: timer self-deadlock due to preemption point
  • issue/36298 net: 1.14 performance regression on mac
  • issue/38860 runtime: CPU bound goroutines cause unnecessary timer latency
    • cl/216198 runtime: add goroutines returned by poller to local run queue
    • cl/232199 runtime: steal timers from running P's
    • cl/232298 runtime: reduce timer latency
  • issue/44343 runtime: time.Sleep takes more time than expected
  • issue/44868 time, runtime: zero duration timer takes 2 minutes to fire

Back To Top

context

• issue/8082 proposal: spec: represent interfaces by their definition and not by package and name
• issue/14660 proposal: context: new package for standard library
• issue/16209 Proposal: relaxed rules for assignability with differently-named but identical interfaces
• issue/20280 proposal: io: add Context parameter to Reader, etc.
• issue/21355 proposal: Replace Context with goroutine-local storage
• issue/24050 testing: test with child process sometimes hangs on 1.10; -timeout not respected
• issue/27982 proposal: Go 2: bake a cooperative goroutine cancellation mechanism into the language
• issue/28342 proposal: Go 2: update context package for Go 2
• issue/29011 proposal: Go 2: use structured concurrency
• doc/context-go-away Michal Štrba. Context should go away for Go 2. 2017/08/06
• doc/context Go Concurrency Patterns: Context.
• doc/context-isnt-for-cancellation Dave Cheney. Context isn’t for cancellation. August 20, 2017.
• issue/36503 proposal: context: add Merge
• issue/42564 context: cancelCtx exclusive lock causes extreme contention
• issue/51365 proposal: context: add APIs for writing and reading cancelation cause
• issue/56661 context: add APIs for setting a cancelation cause when deadline or timer expires
• issue/57928 context: add AfterFunc

Back To Top

encoding

• design/go12encoding Russ Cox. Go 1.2 encoding.TextMarshaler and TextUnmarshaler. July 2013.
• design/go12xml Russ Cox. Go 1.2 xml.Marshaler and Unmarshaler. July 2013.
• design/natural-xml Sam Whited. Proposal: Natural XML. 2016-09-27
  • issue/13504 encoding/xml: add generic representation of XML data
• design/zip Russ Cox. Proposal: Zip-based Go package archives. February 2016
  • issue/14386 proposal: use zip format inside .a and .o files
• design/xmlstream Sam Whited. Proposal: XML Stream. Mar 9, 2017.
  • issue/19480 encoding/xml: add decode from TokenReader, to enable stream transformers
• design/raw-xml Sam Whited. Proposal: Raw XML Token. Sep 1, 2018.
  • issue/26756 proposal: encoding/xml: add RawXML token

Back To Top

image, x/image

The following issues are surrounding by the color management of the image standard library. At the moment, Go's image library doesn't read or write meta information from an image in the encoding or decoding phase. Therefore the color information could go wrong while processing an image such as scaling in a non-linear sRGB space. A universal solution is to design image metadata APIs to aware the color profile in an encoded image file.

• issue/11420 x/image/draw: color space-correct interpolation
  • issue/20613 image/png: don't ignore PNG gAMA chunk
  • issue/27830 proposal: image: decoding options
  • cl/253497 x/image/draw: gamma corrected non linear interpolation
  • issue/37188 image/color: documentation doesn't include links to relevant color theory resources
• issue/33457 proposal: image: add generic metadata support for jpeg, gif, png
  • discuss/image-metadata image.Metadata interface type
  • issue/18365 image/png: no support for setting and retrieving the PPI/DPI
  • cl/208559 image: New metadata-aware read/write API
  • cl/216799 image: metadata API sketch
• issue/44808 image, image/draw: add interfaces for using RGBA64 directly
• issue/46395 image/draw: increase performances by applying special case if mask is *image.Alpha
• issue/8055 image: decode / resize into an existing buffer
• issue/11793 image/color: NRGBA(64).RGBA() optimization
• issue/15759 image: optimize Image.At().RGBA()
• issue/20851 image: Decode drops interfaces
• issue/24499 image/jpeg: Decode is slow

Back To Top

math

• issue/8037 cmd/internal/obj/x86: add fma
• issue/17895 spec: allow the use of fused multiply-add floating point instructions
  • cl/40391 spec: clarify use of fused-floating point operations
• issue/24813 math/bits: add extended precision Add, Sub, Mul, Div
• issue/25819 math: add guaranteed FMA

Back To Top

Mobile

• design/go14android David Crawshaw. Go support for Android. June 2014.
• design/gobind David Crawshaw. Binding Go and Java. July 2014

Back To Top

log

• discussion/54763 discussion: structured, leveled logging
• design/structured-logging Proposal: Structured Logging
• issue/56345 proposal: log/slog: structured, leveled logging
• issue/58243 log/slog: make the current context easily available to loggers
• issue/59928 proposal: testing: Add log/slog support

misc

• design/mobile-audio Jaana Burcu Dogan. Proposal: Audio for Mobile. November 30, 2015.
  • issue/13432 proposal: x/mobile audio
• design/localization Marcel van Lohuizen. Proposal: Localization support in Go. Jan 28, 2016.
  • issue/12750 x/text: localization support
• design/unbounded-queue Christian Petrin. Proposal: Built in support for high performance unbounded queue. October 2, 2018
  • issue/27935 proposal: add container/queue
• design/lockfile Adrien Delorme. Proposal: make the internal lockedfile package public. 2019-10-15.
  • issue/33974
• design/cidr Rudi Kramer, James Forrest. Proposal: Add support for CIDR notation in no_proxy variable. 2017-07-10
  • issue/16704 net/http: considering supporting CIDR notation in no_proxy env variable
• design/dns Sam Whited. Proposal: DNS Based Vanity Imports. 2018-06-30.
  • issue/26160 proposal: use DNS TXT records for vanity import paths
• issue/46518 net/netip: add new IP address package, use in net
• issue/53171 proposal: add package for using SIMD instructions
• issue/54880 math/rand: seed global generator randomly

Back To Top

Unclassified But Relevant Links

• Using Go Guru: an editor-integrated tool for navigating Go code By Alan Donovan
• Plan for Go Guru (née Oracle) By Alan Donovan
• (Abandoned WIP) Why is X in the standard library?
• go oracle: design By Alan Donovan
• go oracle: user manual By Alan Donovan
• cgihttpproxy
• sqldrivers
• go2designs
• Notes on Programming in C By Rob Pike
• "The Best Programming Advice I Ever Got" with Rob Pike
• An Interview with Brian Kernighan By Mihai Budiu
• Language Design with Brian Kernighan Holiday Repeat By SE Daily
• "C" Programming Language: Brian Kernighan - Computerphile
• Debugging performance issues in Go* programs By Dmitriy Vyukov
• Interesting papers I'd like to implement (or at least have implementations of)
• golang/wiki/ResearchPapers

Back To Top

Fun Facts

• cl/1 Brian Kernighan. Go's first commit. Jul 19, 1972.
• issue/9 I have already used the name for MY programming language. Nov 11, 2009
• issue/2870 9 is prime if it's a hot day. Feb 3, 2012
• doc/gophercount How Many Go Developers Are There?. November 1, 2019.
• discuss/google-owns-go Russ Cox's response on "Go is Google's language, not ours"

Back To Top

Acknowledgements

The document author would like to first thank the TalkGo community creator Mai Yang's champion sponsorship for the golang.design initiative. His creation of the TalkGo significantly changed the Go community in China. He is also a great person that is actively contributing to all kinds of Go related projects.

It is also important to thank the continuing, inspiring discussion and sharing with the TalkGo community core members qcrao, aofei, and eddycjy.

The document would not be organized without all of the supports from them.

Back To Top

License

golang.design/history | CC-BY-NC-ND 4.0 © changkun