Go 101: a book focusing on Go syntax/semantics and all kinds of details

514 Pages·2019·3.246 MB·English

by  Tapir Liu

Contents
Contents
§0. About Go 101 - why this book is written.
§1. Acknowledgements
§2. An Introduction of Go - why Go is worth learning.
§3. The Official Go SDK - how to compile and run Go programs.
Become Familiar With Go Code
§4. Introduction of Source Code Elements
§5. Keywords and Identifiers
§6. Basic Types and Their Value Literals
§7. Constants and Variables - also introduces untyped values and type deductions.
§8. Common Operators - more type deduction rules are introduced.
§9. Function Declarations and Calls
§10. Code Packages and Package Imports
§11. Expressions, Statements and Simple Statements
§12. Basic Control Flows
§13. Goroutines, Deferred Function Calls and Panic/Recover
Go Type System
§14. Overview of Go Type System - a must read to master Go programming.
§15. Pointers
§16. Structs
§17. Value Parts - to gain a deeper understanding into Go values.
§18. Arrays, Slices and Maps - first-class citizen container types.
§19. Strings
§20. Functions - variadic functions, function types and values.
§21. Channels - the Go way to do concurrency synchronizations.
§22. Methods
§23. Interfaces - value boxes used to do reflection and polymorphism.
§24. Type Embedding - type extension in the Go way.
§25. Type-Unsafe Pointers
§26. Built-in Generics
§27. Reflections - the reflect standard package.
Some Special Topics
§28. Line Break Rules
§29. More About Deferred Function Calls
§30. Some Panic/Recover Use Cases
§31. The Right Places to Call the Built-in recover Function
§32. Code Blocks and Identifier Scopes
§33. Expression Evaluation Orders
§34. Value Copy Costs in Go
§35. Bounds Check Elimination
2
Contents
Concurrent Programming
§36. Concurrency Synchronization Overview
§37. Channel Use Cases
§38. How to Gracefully Close Channels
§39. Other Concurrency Synchronization Techniques - the sync standard package.
§40. Atomic Operations - the sync/atomic standard package.
§41. Memory Order Guarantees in Go
§42. Common Concurrent Programming Mistakes
Memory Relateds
§43. Memory Blocks
§44. Memory Layouts
§45. Memory Leaking Scenarios
Some Summaries
§46. Some Simple Summaries
§47. nil in Go
§48. Value Conversion, Assignment and Comparison Rules
§49. Syntax/Semantics Exceptions
§50. Go Details 101
§51. Go FAQ 101
§52. Go Tips 101
§53. More Go Related Topics
(The Go 101 book is provided as free ebooks. This book is still being improved
frequently from time to time. Please visit go101.org to get the latest version of
this book. BTW, Tapir, the author of the book, has developed several fun games.
You can visit tapirgames.com to get more information about these games. Hope
you enjoy them.)
3
§0. About Go 101
About Go 101
I feel it is hard to describe the contents in this article in the general description manner. So this
article will use the interview manner to make descriptions instead.
Hi Tapir, when and why did you plan to write this
book?
At about July 2016, after (not very intensively) using Go for two years, I felt that Go is a simple
language and I had mastered Go programming. At that time, I had collected many details in Go
programming. I thought I can archive these details into a book. I thought it should be an easy job.
I was wrong. I was overconfident. In trying to make explanations for some details, I found I
couldn't explain them clearly. With more and more confusions were gathered, I felt my Go
knowledge was so limited that I was still a newbie Go programmer.
I gave up writing that book.
Gave up? Isn't this book almost finished now?
It was that book being cancelled, not the book Go 101. I eventually cleared almost all the
confusions by reading many official Go documentations and all kinds of Go articles on Internet,
and by finding answers from some Go forums and the Go project issue tracker.
I spent about one year clearing the confusions. In the period, from time to time, once I had
cleared most confusions on a topic and regained the confidence on explaining that topic, I wrote
one blog article for that topic. In the end, I had written about twenty Go articles. And I had
collected more Go details than before. It was the time to restart the plan of writing a Go book.
I wrote another ten basic tutorial articles and twenty more articles on all kinds of other Go topics.
So now Go 101 has about 50 articles.
What were your ever confusions?
Some of the confusions were a few syntax and semantics design details, some of them involved
values of certain kinds of types (mainly slices, interfaces and channels), and a few of them were
related to standard package APIs.
What are the causes of your ever confusions do you
think?
Thinking Go is easy to master is considered harmful. Holding such opinion will make you
4
§0. About Go 101
understand Go shallowly and prevent you from mastering Go.
Go is a feature rich language. Its syntax set is surely not large, but we also can't say it is small.
Some syntax and semantics designs in Go are straightforward, some are a little counter-intuitive
or inconsistent with others. There are several trade-offs in Go syntax and semantics designs. A
programmer needs certain Go programming experiences to comprehend the trade-offs.
Go provides several first-citizen non-essential kinds of types. Some encapsulations are made in
implementing these types to hide the internal structures of these types. On one hand, the
encapsulations bring much convenience to Go programming. On the other hand, the
encapsulations make some obstacles to understand the behaviors of values of these types more
deeply.
Many official and unofficial Go tutorials are very simple and only cover the general use cases by
ignoring many details. This may be good to encourage new Go programmers to learn and use Go.
On the other hand, this also makes many Go programmers overconfident on the extent of their Go
knowledge.
Several functions and types declared in some standard packages are not got detailed explanations.
This is understandable, for many details are so subtle that it is hard to find proper wordings to
explain them clearly. Saying a few accurate words is better than says some lots of words with
inaccuracies. But this really leaves some confusions for the package users.
So do you think simplicity is not a selling point of
Go?
I think, at least, simplicity is not a main selling point of Go. After all, there are several other
languages simpler than Go. On the other hand, Go, as a feature rich language, is also not a
complicated language. A new Go programmer with right attitudes can master Go programming in
one year.
Then what are the selling points of Go do you think?
Personally, I think the fact that, as a static language, Go is flexible as many dynamic script
languages is the main selling point of Go language.
Memory saving, fast program warming-up and fast code execution speed combined is another
main selling point of Go. Although this is a common selling point of many C family languages.
But for web development area, seldom languages own the three characteristics at the same time.
In fact, this is the reason why I switched to Go from Java for web development.
Built-in concurrent programming support is also a selling point of Go, though personally I don't
think it is the main selling point of Go.
Great code readability is another important selling point of Go. I feel readability is the most
important factor considered in designing Go.
5
§0. About Go 101
Great cross-platform support is also a selling point of Go, though this selling point is not much
unique nowadays.
A stable core design and development team and an active community together can also be viewed
as a selling point of Go.
What does Go 101 do to clear these confusions?
Go 101 tries to clear many confusions by doing the followings.
1. Emphasizes on basic concepts and terminologies. Without understanding these basic
concepts and terminologies, it is hard to fully understand many rules and high level
concepts.
2. Adds the value part terminology and use one special article to explain value parts. This
article uncovers the underlying structures of some kinds of types, so that Go programmers
could understand Go values of those types more deeply. I think knowing a little possible
underlying implementations is very helpful to clear some confusions about all kinds of Go
values.
3. Explains memory blocks in detail. Knowing the relations between Go values and memory
blocks is very helpful to understand how a garbage collector works and how to avoid
memory leaking.
4. Views interface values as boxes for wrapping non-interface values. I found thinking
interface values as value boxes is very helpful to clear many interface related confusions.
5. Makes several summary articles and special topic articles by aggregating many knowledge
points and details, which would save Go programmers much learning time.
(The Go 101 book is provided as free ebooks. This book is still being improved
frequently from time to time. Please visit go101.org to get the latest version of
this book. BTW, Tapir, the author of the book, has developed several fun games.
You can visit tapirgames.com to get more information about these games. Hope
you enjoy them.)
6
§1. Acknowledgements
Acknowledgements
Firstly, thanks to the whole Go community. Without an active and responsive community, this
book couldn't have been finished.
I'd like to give special thanks to Ian Lance Taylor. Ian kindly answered my countless boring
questions on go-nuts group and the Go project issue tracker. Ian's answers helped me clear many
of my ever confusions in using Go.
I want to give thanks to the following people who participated in my question threads on go-nuts
and go-dev groups: Axel Wagner, Keith Randall, Russ Cox, Robert Griesemer, Jan Mercl,
Konstantin Khomoutov, Brad Fitzpatrick, Alan Donovan, Minux Ma, Dave Cheney, Volker
Dobler, Caleb Spare, Matt Harden, Roger Peppe, Michael Jones, peterGo, Pietro Gagliardi, Paul
Jolly, and Rob 'Commander' Pike, etc.
Also I learned so much from the Go project issue tracker. I give my thanks to the following
people who are active on the Go project issue tracker, including: Ian Lance Taylor, Robert
Griesemer, Brad Fitzpatrick, Russ Cox, Matthew Dempsky, Keith Randall, Bryan C. Mills, Joe
Tsai, Minux Ma, Josh Bleecher Snyder, Axel Wagner, Daniel Martí, Dave Cheney, Austin
Clements, Andrew Bonventre, Damian Gryski, Alberto Donizetti, Emmanuel T Odeke, Filippo
Valsorda, Dominik Honnef, and Rob Pike, etc.
I thank Martin Möhrmann for pointing out a mistake in one of my Go articles on reddit.
I also would like to thank all gophers who ever made influences on the Go 101 book, be it
directly or indirectly, intentionally or unintentionally.
I thank all Go 101 contributors for improving Go 101 articles, including: Amir Khazaie, Ziqi
Zhao, Artur Kirillov, Arinto Murdopo, Andreas Pannewitz, Jason-Huang, Joel Rebello, Julia
Wong, Wenbin Zhang, Farid Gh, Valentin Deleplace, nofrish, Peter Matseykanets,
KimMachineGun, Yoshinori Kawasaki, mooncaker816, Sangwon Seo, Shaun (wrfly), Stephan
Renatus, Yang Shu, stemar94, berkant (yadkit), Thomas Bower, Patryk Małek, kucharskim,
Rodrigue Koffi, Jhuliano Skittberg Moreno, youmoo, ahadc, Kevin, jojo (hjb912), Gordon Wang,
Steve Zhang, cerlestes, Bai Kai, Gleb Sozinov, Jake Montgomery, Erik Dubbelboer, Afriza N.
Arief, Maxim Neverov, Asim Himani, sulinehk, Grachev Mikhail, halochou, HaiwenZhu, Alisha
Sonawalla, SheldonZhong, wens.wq, xamenyap, etc.
I'm sorry if I forgot mentioning somebody in above lists. There are so many kind and creative
gophers in the Go community that I must have missed out on someone.
Thanks to the authors of the Bootstrap framework (https://getbootstrap.com/docs/3.3/), jQuery
library (https://jquery.com), code prettify (https://github.com/google/code-prettify) and prism
syntax highlighting (https://prismjs.com/) JavaSript packages, for supporting the go101.org
website. Thanks to the authors of the go-epub (https://github.com/bmaupin/go-epub) and calibre
(https://calibre-ebook.com/) proects for building Go 101 ebooks.
Special thanks to Renee French (http://reneefrench.blogspot.com) and Rob Pike. The vivid
7
§1. Acknowledgements
picture used in the covers of the digital and paper versions of this book is copied from one of
from Rob's slides (https://talks.golang.org/2012/waza.slide#19). Renee is the author of the lovely
gopher iconic mascots used in the picture.
(The Go 101 book is provided as free ebooks. This book is still being improved
frequently from time to time. Please visit go101.org to get the latest version of
this book. BTW, Tapir, the author of the book, has developed several fun games.
You can visit tapirgames.com to get more information about these games. Hope
you enjoy them.)
8
§2. An Introduction of Go
An Introduction of Go
Go is a compiled and static typed programming language born from Google. Many of the core Go
design and SDK development team members have many years of experience in the field of
programming language research.
Go has many features. Some are unique, some are borrowed from other programming languages:
built-in concurrent programming support
goroutines (green threads) and start new goroutines easily.
channels (based on CSP model) and select mechanisms to do synchronizations
between goroutines.
the container types map and slice are first-class citizens.
polymorphism through interfaces.
value boxing and reflection through interfaces.
pointers.
function closures.
methods.
deferred function calls.
type embedding.
type deduction.
memory safety.
automatic garbage collection.
great cross-platform compatibility.
Besides above features, further highlights are:
The syntax of Go is deliberately designed to be simple, clean, and similar to other popular
programming languages. This makes Go programming easy to pick up.
Go comes with a great set of standard code packages which provide all kinds of common
functionalities. Most of the packages are cross-platform.
Go also has an active community, and there are plenty of high quality third party Go
packages and projects (https://github.com/avelino/awesome-go) to import and use.
Go programmers are often called gophers.
In fact, although Go is a compiled and static typed programming language, Go also has many
features which are usually only available in dynamic script languages. It is hard to combine these
two kinds into one language, but Go did it. In other words, Go owns both the strictness of static
languages and the flexibility of dynamic languages. I can't say there are not any compromises
between the two, but the effect of the compromises is much weaker than the benefits of the
combination in Go.
Readability is an important factor which affects the design of Go heavily. It is not hard for a
gopher to understand the Go code written by other gophers.
Currently, the most popular Go compiler is written in Go and maintained by the Go design team.
9
§2. An Introduction of Go
Later we shall call it the standard Go compiler, or gc (an abbreviation for Go compiler, not for
garbage collection GC). The Go design team also maintains a second Go compiler, gccgo.
Nowadays it's use is less popular than gc, but it always serves as a reference, and both compilers
are in active development. As of now the Go team focuses on the improvement of gc.
gc is provided in the official Go SDK. Go SDK 1.0 was release at March, 2012. The version of
Go is consistent with the version of Go SDK. There were/are two major versions released each
year.
Since the release of Go 1.0, the syntax of Go has changed a little, but there were/are many
improvements for the tools in Go SDK, from version to version, especially for gc. For example,
noticeable lags caused by garbage collecting is a common criticism for languages with automatic
memory management. But since Go 1.8, improvements made for the concurrent garbage
collection implementation in gc basically eliminated the lag problem.
gc supports cross-platform compilation. For example, we can build a Windows executable on a
Linux OS, and vice versa.
Programs written in go language mostly compile very fast. Compilation time is an important
factor for the happiness in development. Short build time is one reason why many programmers
like programming with Go.
Advantages of Go executables are:
small memory footprint
fast code execution
short warm-up duration (so great deployment experience)
Some other compiled languages, such as C/C++/Rust may also have these three advantages (and
they may have their respective advantages compared to Go), but they lack three important
characteristics of Go:
fast compilation results in happy local development experience and short deployment
iteration cycles
flexible like dynamic languages
built-in concurrent programming supports
All the above advantages combined make Go become an outstanding language and a good choice
for many kinds of projects. Currently, Go is popularly used in network, system tools, database
development and block chain development areas. But there are also more and more game, big
data and AI projects starting to use Go.
Finally, Go is not perfect in all aspects. There are certain trade-offs in Go design. And the current
Go 1 really has some shortcomings. For example, Go doesn't support generics for custom types
and functions now. Go team members are not against introducing custom generics into Go, they
just haven't found a good solution yet which keeps Go clean and simple. Go 2 is in planning now.
Nothing is impossible in the future.
10