https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Error: Parsing the XML failed.

Golang Version History

Return to Golang, Version History, Versions, Golang Topics, Golang DevOps

Go, also known as Golang, is an open-source programming language developed by Google in 2009. It was designed for simplicity, efficiency, and scalability, making it popular for modern cloud-based, distributed systems and applications. Since its first stable release in 2012, Go has undergone several updates to improve its performance, add new features, and refine its standard library. Below is a comprehensive version history of Go, highlighting key features and changes in each major release.

Go 1.21 (August 2023)

Go 1.21 introduced several new features, performance improvements, and language enhancements aimed at increasing developer productivity.

Key features:

`Try` function: Introduced a new error-handling mechanism called `Try`, which simplifies handling errors in Go.
Improved caching for build and test: Optimizations were made to speed up build and test operations, especially in larger projects.
`New built-in functions`: Added `clear()` to clear maps and slices.

Official documentation: https://go.dev/doc/go1.21

Go 1.20 (February 2023)

Go 1.20 brought many improvements, especially in the area of toolchain optimizations and memory management.

Key features:

Go runtime improvements: Memory management optimizations were introduced to reduce garbage collection overhead, improving overall application performance.
Default memory limit: Introduced a `GOMEMLIMIT` environment variable to limit the memory usage of the Go runtime.
Language updates: Support for larger integers in `math/big` and `crypto/rand` packages.

Official documentation: https://go.dev/doc/go1.20

Go 1.19 (August 2022)

Go 1.19 focused on performance optimizations, language refinements, and improvements to the Go memory model.

Key features:

Go memory model: Clarifications were made to the Go memory model to better define the interaction between `goroutines` and shared memory.
Fuzzing improvements: Enhancements were made to the built-in fuzzing support introduced in Go 1.18.
CPU and memory profiling: Improved profiling capabilities for Go programs, making it easier to optimize and debug performance.

Official documentation: https://go.dev/doc/go1.19

Go 1.18 (March 2022)

Go 1.18 was a significant release, introducing one of the most requested features: generics.

Key features:

**Generics**: Go 1.18 introduced support for generics, enabling developers to write type-safe code that works with any data type, improving code reuse and reducing duplication.
**Fuzzing**: Built-in support for fuzz testing was added, making it easier to find vulnerabilities and bugs in Go programs automatically.
**Performance improvements**: Continued improvements in runtime and compiler optimizations for better performance.

Official documentation: https://go.dev/doc/go1.18

Go 1.17 (August 2021)

Go 1.17 focused on performance improvements and internal optimizations.

Key features:

Register-based calling convention: This new calling convention improved the performance of function calls, resulting in faster execution for certain workloads.
Compiler optimizations: Further improvements to escape analysis and inlining, reducing memory allocations and improving runtime performance.
Deprecation of `go get` for installing binaries: Encouraged the use of `go install` for installing specific versions of binaries.

Official documentation: https://go.dev/doc/go1.17

Go 1.16 (February 2021)

Go 1.16 introduced a number of important changes, including improvements to the build system and module management.

Key features:

**Go modules**: Go modules became fully enabled by default, simplifying dependency management.
**File embedding**: The `embed` package was introduced, allowing developers to embed static files directly in Go binaries.
**Runtime improvements**: Reduced memory usage and garbage collection overhead.

Official documentation: https://go.dev/doc/go1.16

Go 1.15 (August 2020)

Go 1.15 focused on compiler performance and runtime improvements.

Key features:

Compiler optimizations: Enhanced escape analysis and reduced memory allocations.
Improved linker performance: The linker was significantly faster and used less memory.
Deprecation of certain cryptographic algorithms: Older, insecure cryptographic algorithms were deprecated to enhance security.

Official documentation: https://go.dev/doc/go1.15

Go 1.14 (February 2020)

Go 1.14 improved the runtime scheduler and introduced various toolchain and library improvements.

Key features:

**Preemption improvements**: The scheduler became more preemptive, improving the performance of Go applications with heavy goroutine usage.
**TLS 1.3 support**: Enabled by default in the `crypto/tls` package, offering better performance and security for encrypted communications.
**Module proxy improvements**: Improved support for Go modules and module proxies.

Official documentation: https://go.dev/doc/go1.14

Go 1.13 (September 2019)

Go 1.13 introduced several language and standard library improvements.

Key features:

**Error wrapping**: Enhanced error handling with support for wrapping errors, making it easier to manage error chains.
**Numeric literals**: Added support for binary literals and underscores in numeric constants (e.g., `0b1101`, `1_000_000`).
**Modules improvements**: Continued improvements in module support, particularly around version selection and proxy handling.

Official documentation: https://go.dev/doc/go1.13

Go 1.12 (February 2019)

Go 1.12 brought performance improvements, particularly around the web server and HTTP/2 handling.

Key features:

**Performance optimizations**: Go 1.12 included numerous optimizations in runtime performance, especially for the HTTP/2 protocol and web servers.
**Modules support**: Early support for Go modules, though not fully enabled by default.
**Improved macOS support**: Updated to better support modern macOS features.

Official documentation: https://go.dev/doc/go1.12

Go 1.11 (August 2018)

Go 1.11 was a pivotal release that introduced Go modules for dependency management.

Key features:

**Go modules (vgo)**: Introduced Go modules as an alternative to `GOPATH`, greatly simplifying dependency management for large projects.
**WebAssembly support**: Added initial support for compiling Go code to WebAssembly (Wasm), allowing Go code to run in web browsers.
**Performance improvements**: Continued compiler and runtime optimizations for better performance.

Official documentation: https://go.dev/doc/go1.11

Go 1.10 (February 2018)

Go 1.10 focused on tooling improvements and small language refinements.

Key features:

**Improved caching**: The Go compiler introduced build caching, speeding up incremental builds by avoiding unnecessary recompilation.
**Performance optimizations**: Compiler optimizations led to improved performance in compiled programs.
**Toolchain improvements**: Various updates to the Go tools, making them faster and more reliable.

Official documentation: https://go.dev/doc/go1.10

Go 1.9 (August 2017)

Go 1.9 brought updates to the type system and continued performance enhancements.

Key features:

**Type aliases**: Introduced type aliases, which provide a way to give a new name to an existing type without creating a distinct new type.
**Improved garbage collector**: Further optimizations to reduce garbage collection overhead, improving performance in memory-intensive applications.
**Concurrency improvements**: Enhancements to Go’s concurrency primitives, making `goroutines` and channels more efficient.

Official documentation: https://go.dev/doc/go1.9

Go 1.8 (February 2017)

Go 1.8 focused on performance improvements, particularly around garbage collection and memory management.

Key features:

**Simplified garbage collection**: Continued improvements to the garbage collector, reducing latency and improving memory usage.
**HTTP/2 support**: Go’s HTTP/2 server implementation received performance improvements and better default configurations.
**Standard library enhancements**: Several updates to the standard library, including better support for the `context` package and `time` handling.

Official documentation: https://go.dev/doc/go1.8

Go 1.7 (August 2016)

Go 1.7 introduced various performance optimizations and support for new architectures.

Key features:

**Compiler optimizations**: Improved support for SSA (Static Single Assignment) form in the Go compiler, leading to better optimization during compilation.
**Context package in standard library**: The `context` package, previously part of Go’s `x` libraries, was promoted to the standard library.
**ARM64 support**: Added official support for the ARM64 architecture.

Official documentation: https://go.dev/doc/go1.7

Go 1.6 (February 2016)

Go 1.6 continued to improve Go’s performance and introduce refinements to the runtime and standard library.

Key features:

**Vendoring support**: Go added official support for vendoring dependencies, allowing packages to include their own copies of dependencies to ensure compatibility.
**Performance optimizations**: Improvements in garbage collection and the Go scheduler made Go 1.6 more efficient in high-concurrency environments.
**Improvements to HTTP/2**: Better handling of HTTP/2 requests and connections, leading to performance gains in web applications.

Official documentation: https://go.dev/doc/go1.6

Go 1.5 (

August 2015)

Go 1.5 was a significant release that saw the transition of the Go compiler to Go itself, removing the dependency on C.

Key features:

**Self-hosting compiler**: The Go compiler was rewritten in Go, eliminating the need for C in the build process.
**Improved garbage collection**: Go 1.5 introduced a concurrent garbage collector that dramatically reduced pause times.
**Support for Android**: Initial support for compiling Go programs for Android.

Official documentation: https://go.dev/doc/go1.5

Go 1.4 (December 2014)

Go 1.4 was the last version to depend on C for compiling the Go toolchain.

Key features:

**Compiler written in C**: The Go compiler and toolchain were still dependent on C, though this was the last version before transitioning to a self-hosting compiler.
**Improvements to runtime**: Continued optimizations in garbage collection and scheduler performance.

Official documentation: https://go.dev/doc/go1.4

Go 1.3 (June 2014)

Go 1.3 focused on performance optimizations and portability improvements.

Key features:

**Improved portability**: Significant changes were made to improve the portability of the Go runtime across different platforms and architectures.
**Runtime optimizations**: Better memory management and garbage collection, leading to reduced memory consumption and faster execution.

Official documentation: https://go.dev/doc/go1.3

Go 1.2 (December 2013)

Go 1.2 introduced a number of small but useful language and runtime improvements.

Key features:

**Improved garbage collection**: Reduced garbage collection latency, improving performance in memory-intensive applications.
**Concurrency improvements**: Optimizations in how Go handles concurrency, making `goroutines` more efficient.

Official documentation: https://go.dev/doc/go1.2

Go 1.1 (May 2013)

Go 1.1 was the first major update to Go after its official release and brought significant performance improvements.

Key features:

**Optimized runtime**: Go 1.1 introduced a number of optimizations to improve the efficiency of the Go runtime, particularly in the areas of garbage collection and memory management.
**Better precision in `time` handling**: Improved the precision of the `time` package, making it more suitable for real-time systems.

Official documentation: https://go.dev/doc/go1.1

Go 1.0 (March 2012)

Go 1.0 was the first official stable release of Go and established the foundation of the language, its toolchain, and standard library.

Key features:

**Stability**: Go 1.0 introduced a stable API that provided backward compatibility for future releases.
**Standard library**: A rich standard library was included with Go 1.0, covering networking, file I/O, HTTP, and much more.

Official documentation: https://go.dev/doc/go1.0

Conclusion

Since its official launch in 2012, Go has become a prominent language for building scalable, high-performance systems, especially in cloud computing, microservices, and distributed systems. Each release has added new capabilities, refined the language's toolchain, and improved performance, keeping Go competitive in the modern software development landscape. With features like generics introduced in Go 1.18 and ongoing improvements in memory management and concurrency, Go continues to evolve as a language designed for simplicity, efficiency, and scalability.

Fair Use Source: https://golang.org/doc/devel/release.html

Go version history

SYI LU SENG E MU CHYWE YE. NAN. WEI LA YE. WEI LA YE. SA WA HE.

Golang Vocabulary List (Sorted by Popularity)

SHORTEN THIS to 20 ITEMS! navbar_golang

Abstract Syntax Trees, Absolute Time, Advanced Go Concurrency Patterns, Alias Declarations, Alternate Package Names, Anonymous Fields, Anonymous Functions, Append Function, Array Types, Assertion of Types, Assignability Rules, Atomic Package, Augmented Assignment, Authentication with Context, Auto-Increment Versions, Backward Compatibility, Basic Types, Benchmark Functions, Binary Package, Blank Identifier, Block Statements, Boolean Expressions, Bridge Methods, Build Constraints, Build Tags, Builtin Functions, Byte Order, Byte Slices, Bytes Package, Caching Modules, Cancellation with Context, Cap Function, Channel Direction, Channel Operations, Channel Types, Channels, Character Literals, Closure Functions, Code Generation, Code Formatting, Code Review Comments, Collecting Garbage, Composite Literals, Composition over Inheritance, Concurrency Patterns, Conditional Compilation, Constant Declarations, Constant Expressions, Context Package, Continue Statements, Control Flow, Convert Function, Copy Function, Cross Compilation, Cyclic Dependencies, Cyclic Imports, Data Alignment, Data Race Detection, Deadlock Detection, Defer Statements, Deferred Function Calls, Deleting Map Entries, Dependency Management, Design Philosophy, Detecting Deadlocks, Directive Comments, Directory Structure, Discarded Errors, Documentation Comments, Dot Imports, Dynamic Linking, Effective Go, Empty Interface, Embedding Interfaces, Embedding Structs, Embedded Files, Encoding Binary, Encoding CSV, Encoding JSON, Encoding XML, Endianness, Enforcing Contracts, Error Handling, Error Interface, Error Types, Escape Analysis, Executable Packages, Exit Codes, Expvar Package, Exported Names, Expression Statements, Extending Interfaces, External Linking, Fallthrough Keyword, Fatal Errors, Field Tags, File Inclusion, File I/O, File Paths, First-Class Functions, Floating-Point Numbers, FMT Package, For Loops, Format Specifiers, Formatting Source Code, Function Declarations, Function Literals, Function Types, Functional Options, Garbage Collection, GC Tuning, Generics, Global Variables, Go Build Command, Go Command, Go Concurrency Patterns, Go Doc Tool, Go FMT Tool, Go Generate Command, Go Get Command, Go Install Command, Go Modules, Go Playground, Go Run Command, Go Test Command, Go Toolchain, Go Vet Tool, Go Workspaces, GOB Encoding, Godoc Documentation, Gofmt Formatting, Goroutine Leaks, Goroutines, Gosec Security Scanner, GOTRACEBACK Environment Variable, Gotype Tool, GOVERSION File, Gowork Files, Heap Allocation, Heap Dump, HTML Templates, IOTA Identifier, Iota Enumerations, IO Package, IO Reader, IO Writer, Import Declarations, Import Paths, Imports Formatting, Incremental Compilation, Indentation Rules, Index Expressions, Indexed Elements, Initialization Order, Init Functions, Input Validation, Integer Overflow, Integer Types, Integration Testing, Interface Assertions, Interface Embedding, Interface Satisfaction, Interface Types, Internal Packages, Internationalization, Interoperability with C, Invariably Safe Initialization, IO Utility Functions, JSON Marshalling, JSON Unmarshalling, Keywords, Lambda Functions, Language Specification, Lateral Type Inference, Lazy Initialization, Leaking Goroutines, Len Function, Linter Tools, Literal Types, Live Variable Analysis, Load Testing, Logging Conventions, Logging Package, Loop Control Statements, Magic Comments, Make Function, Map Types, Maps, Memory Allocation, Memory Model, Memory Profiling, Method Declarations, Method Expressions, Method Sets, Methods, Module Compatibility, Module Caching, Module Proxy, Module Replacements, Module Versions, Module-aware Mode, Modules, Mutexes, Named Return Values, Name Mangling, Name Resolution, Name Shadowing, Naming Conventions, Nesting Structs, Net HTTP Package, Net Package, Nil Interface, Nil Pointer Dereference, Nil Slices, Nil Values, Non-Blocking Channels, Number Literals, Object Files, Octal Literals, Open Source License, Operator Precedence, Optimization Flags, Order of Evaluation, OS Package, Package Documentation, Package Initialization, Package Names, Package Visibility, Packages, Packages with Main, Panic and Recover, Panic Defer Recover, Parallel Testing, Parsing Techniques, Path Separators, Performance Optimization, Performance Profiling, Pipeline Patterns, Plain Functions, Pointer Arithmetic, Pointer Receivers, Pointers, Polymorphism, Portability, Postfix Operators, Predeclared Identifiers, Predefined Constants, Preemption in Scheduler, Primitive Types, Print Functions, Profiling Tools, Project Layout, Protobuf Integration, Public and Private Identifiers, Punctuator Tokens, Race Conditions, Race Detector, Range Expressions, Range Loops, Read-Only Interfaces, Receiver Functions, Receiver Types, Recover Function, Recursion, Reflection, Regular Expressions, Relative Imports, Relocation Information, Remote Import Paths, Repeatable Builds, Replace Directive, Reserved Words, Resource Management, Response Writers, RESTful APIs, Return Statements, Reusing Code, Rune Literals, Runes, Runtime Package, Satisfying Interfaces, Scopes, Select Statements, Selective Imports, Self-Referential Functions, Semaphore Patterns, Send-Only Channels, Shadowing Variables, Short Declarations, Signals Handling, Signed Integers, Simple Statements, Single Assignment, Single Binary Applications, Slice Expressions, Slice Internals, Slice Length and Capacity, Slice of Slices, Slices, Source File Organization, Source to Source Compilation, Space Optimization, Spawned Processes, Specification Compliance, Split Package, Sprint Functions, Stack Traces, Standard Library, Static Analysis, Static Linking, String Conversions, String Formatting, String Literals, Strings Package, Struct Embedding, Struct Literals, Struct Tags, Struct Types, Structs, Subtests, Switch Statements, Synchronization Primitives, Syntactic Sugar, System Calls, Tab Characters, TCP Connections, Template Parsing, Template Rendering, Template Syntax, Templates Package, Ternary Operators, Testing, Testing Package, Text Templates, Third-Party Packages, Thread Safety, Time Package, Timeouts, TLS Configuration, Tokenization, Toolchain, Trace Tool, Tracing, Tracking Dependencies, Type Aliases, Type Assertions, Type Declarations, Type Embedding, Type Inference, Type Parameters, Type Switches, Typed Constants, Types, UID and GID, Unhandled Errors, Unicode Characters, Unicode Package, Unique Package Names, Unsafe Package, Unstructured Concurrency, Untyped Constants, Unused Imports, Unused Variables, Update Statements, URL Parsing, UTF-8 Encoding, Value Receivers, Variable Declarations, Variadic Functions, Vendor Directory, Vendoring, Version Control, Version Pinning, Visibility Rules, WaitGroup, Walkthrough Examples, Web Applications, Whitespace Rules, Wildcards in Imports, Write Barriers, Zero Initialization, Zero Values

Golang: Golang Fundamentals, Golang Inventor - Golang Language Designer: Ken Thompson, Robert Griesemer, Rob Pike of Google, Go abstraction, Golang Glossary - Glossaire de Golang - French, Go agile, Go ahead-of-time (AOT), Go AI, Go algebraic data types, Go algorithms, Go Android, Go anonymous functions, Go AOP, Go AOT, Go APIs, Go arguments, Go ARM, Go arithmetic, Go arrays, Go aspect-oriented, Go assignment, Go associative arrays, Go async, Go asynchronous callbacks, Go asynchronous programming, Go automatic variables, Go automation, Go Avro, Go backend, Go backwards compatibility, Go block scoped, Go Booleans, Go Boolean expressions, Go buffer overflow, Go builds, Go built-in types, Go bytecode, Go cache, Go caching, Go call by reference, Go call by value, Go callbacks, Go call stack, Go casting, Go characters, Go Chocolatey, Go CI/CD, Go classes, Go CLI, Go client-side, Go closures, Go cloud (Go Cloud Native-Go AWS-Go Azure-Go GCP-Go IBM Cloud-Go IBM Mainframe-Go OCI), Go code smells, Go coercion, Go collections, Go command-line interface, Go commands, Go comments, Go compilers, Go complex numbers, Go composition, Go configuration, Go concurrency, Go concurrent programming, Go conditional expressions, Go conferences, Go constants, Go constructors, Go containers, Go control flow, Go control structures, Go coroutines, Go crashes, Go creators, Go currying, Go databases, Go data manipulation, Go data persistence, Go data science, Go data serialization, Go Built-In Data Types, Go data structures, Go data synchronization, Go dates, Go dates and times, Go deadlocks, Go debugging, Go declarative, Go deferred callbacks, Go delegates, Go delegation, Go dependency injection, Go design patterns, Go designers, Go destructors, Go DevOps, Go dictionaries, Go dictionary comprehensions, Go DI, Go distributed software, Go distributions, Go distros, Go DL, Go Docker, Go do-while, Go DSL, Go duck typing, Go dynamic binding, Go dynamic scope, Go dynamically scoped, Go dynamically typed, Go dynamic variables, Go eager evaluation, Go embedded, Go encapsulation, Go encryption, Go enumerated types, Go enumeration, Go enums, Go environment variables, Go errors, Go error handling, Go evaluation strategy, Go event-driven, Go event handlers, Go event loops, Go exception handling, Go executables, Go execution, Go expressions, Go FaaS, Go Facebook, Go fibers, Go fields, Go file input/output, Go file synchronization, Go file I/O, Go filter, Go first-class functions, Go fold, Go foreach loops, Go fork-join, Go floating-point, Go FP, Go frameworks, Go FreeBSD, Go frontend, Go functions, Go functional, Go functional programming, Go function overloading, Go garbage collection, Go generators, Go generator expressions, Go generics, Go generic programming, Go GitHub, Go global variables, Go GraphQL, Go gRPC, Go GUI, Go hashing, Go heap, Go heap allocation, Go hello world, Go higher-order functions, Go history, Go Homebrew, Go HTTP, Go idempotence, Go IDEs, Go import, Go imperative, Go immutable values, Go immutability, Go inheritance, Go influenced, Go influenced by, Go installation, Go integers, Go integration testing, Go interfaces, Go internationalization, Go interpreters, Go interprocess communication (IPC), Go iOS, Go IoT, Go IPCs, Go ISO Standard, Go iteration, Go JetBrains, Go JIT, Go JSON, Go JSON-RPC, Go JSON Web Tokens, Go JSON Web Token (JWT), Go Just-in-time (JIT), Go JWT, Go K8S, Go keywords, Go lambdas, Go language spec, Go lazy evaluation, Go lexically scoped, Go lexical scoping, Go libraries, Go linters, Go Linux, Go lists, Go list comprehensions, Go literals, Go localization, Go local variables, Go locks, Go logging, Go logo, Go looping, Go macOS, Go map, Go mascot, Go math, Go member variables, Go memoization, Go memory addressing, Go memory allocation, Go malloc, Go memory management, Go memory safety, Go message queues, Go metaclasses, Go meta-programming, Go methods, Go method overloading, Go MFA, Go ML, Go microservices, Go Microsoft, Go mobile dev, Go modules, Go modulo operators, Go monitoring, Go multiprocessing, Go multi-threaded, Go mutable values, Go mutability, Go mutex (Go mutual exclusion), Go namespaces, Go natural language processing (NLP), Go networking, Go network programming, Go NLP, Go non-blocking, Go non-blocking I/O, Go null, Go null reference, Go null coalescing operators, Go numbers, Go number precision, Go OAuth, Go objects, Go object code, Go object comparisons, Go object creation, Go object creators, Go object destruction, Go object destructors, Go object lifetime, Go object-oriented constructors, Go object-oriented programming, Go object serialization, Go observability, Go OOP, Go operators, Go operator overloading, Go optimizations, Go organizations, Go ORMs, Go packages, Go package managers, Go pass by reference, Go pass by value, Go parallel computing, Go parallel programming, Go parallelism, Go parameters, Go people, Go performance, Go persistence, Go pipelines, Go pointers, Go polymorphism, Go primitives, Go primitive data types, Go probability, Go procedural, Go processes, Go producer-consumer, Go programmers, Go programming, Go programming paradigm, Go program structure, Go program termination, Go Protocol Buffers (Protobuf), Go Protocol Buffers, Go Protobuf, Go proxies, Go public-key encryption, Go PKI, Go pure functions, Go race conditions, Go random, Go reactive, Go readability, Go records, Go recursion, Go reentrancy, Go refactoring, Go reference counting, Go reference types, Go referential transparency, Go reflection, Go regex, Go remote procedure calls (RPC), Go REPL, Go reserved words, Go REST, Go REST APIs, Go RHEL, Go RPCs, Go runtimes, Go safe navigation operators, Go SDK, Go secrets, Go security, Go serialization, Go serverless, Go server-side, Go sets, Go set comprehensions, Go side effects, Go signed integers, Go SMTP, Go Snapcraft, Go social media, Go sockets, Go source code, Go source-to-source compiler, Go SQL, Go SSL - Go SSL-TLS, Go Single sign-on (SSO), Go SSO, Go StackOverflow, Go stack, Go stack allocation, Go Stack overflow, Go standards, Go standard errors, Go standard input, Go standard library, Go standard operators, Go standard output, Go state, Go statements, Go strings, Go string concatenation, Go string functions, Go string operations, Go scheduling, Go scientific notation, Go scope, Go scope rules, Go scoping, Go scripting, Go static analyzers, Go statically scoped, Go static scoping, Go statically typed, Go static variables, Go statistics, Go strongly typed, Go structural typing, Go synchronization, Go syntax, Go systems programming, Go TCP/IP, Go TDD, Go testing, Go test frameworks, Go threads, Go thread-local storage (TLS), Go TLS, Go thread locking, Go thread locks, Go thread safety, Go thread scheduling, Go thread synchronization, Go times, Go timers, Go to JavaScript, Go tools, Go toolchain, Go transpiler, Go transpiling to JavaScript, Go truth values, Go tuples, Go type checking, Go type conversion, Go type inference, Go type safety, Go type system, Go web dev, Go while loops, Go work stealing, Go values, Go value types, Go variables, Go variable lifetime, Go variable scope, Go versions, Go virtual environments, Go virtual machine, Go Ubuntu, Go Unicode, Go unit testing, Go unsigned integers, Go usability, Go weakly typed, Go Windows, Go wrappers, Go written using, Go x86-64-Go AMD64, Go XML, Go YAML, Go Awesome list;

Go topics-Go courses-Go books-Go docs. (navbar_golang and navbar_golang_detailed)

navbar_programming and navbar_programming_detailed

Table of Contents

Golang Version History

Conclusion

Golang Vocabulary List (Sorted by Popularity)