100 Java Mistakes and How to Avoid Them MEAP V05

Acknowledgments
About Go Details & Tips 101
	About the author
	Feedback
Syntax and Semantics Related
	Zero-size types/values
	How zero-size values are allocated is compiler dependent
	Don't put a zero-size field as the final field of a struct type
	Simulate for i in 0..N in some other languages
	There are several ways to create a slice
	for i, v = range aContainer actually iterates a copy of aContainer
	Array pointers could be used as arrays in several situations
	Some function calls are evaluated at compile time
	The official standard Go compiler doesn't support declaring package-level arrays with sizes larger than 2GB
	Addressabilities of slice/array/map elements and struct fields
	Composite literals are unaddressable, but they may be taken addresses
	One-line trick to create pointers to a non-zero bool/numeric/string values
	Unaddressable values are not modifiable, but map elements may be modified (in a whole)
	The second argument of a make call to create a map is viewed as a hint
	Use maps to emulate sets
	Map entry iteration order is randomized
	If a map entry is created during iterating the map, the entry may show up during the iteration or may be skipped
	The keys in a slice or array composite literal must be constants
	The constant keys in a map/slice/array composite literal must not be duplicate
	A compile-time assertion trick by using the fact mentioned in the last section
	More compile-time assertion tricks
	The return results of a function may be modified after a return statement is executed
	For a deferred function call, its arguments and the called function expression are evaluated when the deferred call is registered
	Method receiver arguments are also evaluated at the same time as other arguments
	If the left operand of a non-constant bit-shift expression is untyped, then its type is determined as the assumed type of the expression
	aConstString[i] and aConstString[i:j] are non-constants even if aConstString, i and j are all constants
	The result of a conversion to a parameter type is always viewed as a non-constant
	The type deduction rule for a binary operation which operands are both untyped
	An untyped constant integer may overflow its default type
	The placement of the default branch (if it exists) in a switch code block could be arbitrary
	The constant case expressions in a switch code block may be duplicate or not, depending on compilers
	The switch expression is optional and its default value is a typed value true of the builtin type bool
	Go compilers will automatically insert some semicolons in code
	What are exactly byte slices (and rune slices)?
	Iteration variables are shared between loop steps
	int, false, nil, etc. are not keywords
	Selector colliding
	Each method corresponds a function which first parameter is the receiver parameter of that method
	Normalization of method selectors
	The famous := trap
	The meaning of a nil identifier depends on specific context
	Some expression evaluation orders are unspecified in Go
	Go supports loop types
	Almost any code element could be declared as the blank identifier _
	Copy slice elements without using the builtin copy function
	A detail in const specification auto-complete
Conversions Related
	If the underlying type of a named type is an unnamed type, then values of one of the named types may be implicitly converted to the underlying type, and vice versa
	Values of two different named pointer types may be indirectly converted to each other's type if the base types of the two types shares the same underlying type
	Values of a named bidirectional channel type may not be converted to a named unidirectional channel type with the same element type directly, but may indirectly
	The capacity of the result of a conversion from string to byte slice is unspecified
Comparisons Related
	Compare two slices which lengths are equal and known at coding time
	More ways to compare byte slices
	Comparing two interface values produces a panic if the dynamic type of the two operands are identical and the identical type is an incomparable type
	How to make a struct type incomparable
	Array values are compared element by element
	Struct values are compared field by field
	The _ fields in struct comparisons are ignored
	NaN != NaN, Inf == Inf
	Some details in using the reflect.DeepEqual function
	The return results of the bytes.Equal and reflect.DeepEqual functions might be different
	A type alias embedding bug
Runtime Related
	In the official standard compiler implementation, the backing array of a map never shrinks
	64-bit word alignment problem
	Let go vet detect not-recommended value copies
	Values of more types in the standard packages should not be copied
	Some zero values might contain non-zero bytes in memory
	The address of a value might change at run time
	The official standard Go runtime behaves badly when system memory is exhausted
	Currently, a runtime.Goexit call may cancel the already happened panics
	There might be multiple panics coexisting in a goroutine
	The current Go specification (version 1.19) doesn't explain the panic/recover mechanism very well
Standard Packages Related
	Use %w format verb in fmt.Errorf calls to build error chains
	Small differences between fmt.Println, fmt.Print and print functions
	The reflect.Type/Value.NumMethod methods will count unexported methods for interfaces
	Values of two slices may not be converted to each other's type if the element types of the two slices are different, but there is a hole to this rule
	Don't misuse the TrimLeft function as TrimPrefix in the strings and bytes standard packages
	The json.Unmarshal function accepts case-insensitive object key matches
	The spaces in struct tag key-value pairs will not be trimmed
	How to try to run a custom init function as early as possible?
	How to resolve cyclic package dependency problem?
	Deferred calls will not be executed after the os.Exit function is called
	How to let the main function return an exit code?
	Try not to use exported variables