In the Linux world, kernel releases follow MAJOR.MINOR.PATCH version format.
Semver is a similar concept. It advises to follow a simple set of rules:
Versions are always incremented and reset to zero:
func bytes.NewReader(b []byte) *bytes.Reader
NewReader returns a new Reader reading from b.
func bytes.NewBufferString(s string) *bytes.Buffer
bytes.NewBufferString on pkg.go.dev
NewBufferString creates and initializes a new Buffer using string s as its initial contents. It is intended to prepare a buffer to read an existing string.
// A Reader implements the io.Reader, io.ReaderAt, io.WriterTo, io.Seeker,
// io.ByteScanner, and io.RuneScanner interfaces by reading from
// a byte slice.
// Unlike a Buffer, a Reader is read-only and supports seeking.
// The zero value for Reader operates like a Reader of an empty slice.
The bufferString creates a mutable buffer.
go: cannot find main module, but found .git/config to create a module there, run: go mod
This problem occurred in a monorepo opened in VSCode. The repo has many services placed in isolated directories with respective go.mod files.
I realized from various sources that the problem is from two places:
$GOPATH/src.export GOPATH=$HOME/go/
export GOROOT=/usr/local/go
export PATH="$GOROOT/bin:$PATH"
export PATH="$PATH:$GOPATH/bin"
Do not add any other variable that affects gopls such as GO111MODULE=on.
Written with StackEdit.
Since go versions keep moving up, maintaining GOPATH inside a Go installation path is a pain.
export GOPATH=/home/a-user/go/1.14.9
ls /home/a-user/go/1.14.0/src
bitbucket.org github.com go.uber.org golang.org gopkg.in
mkdir $HOME/mywork
ls $HOME/mywork
bin pkg src
$HOME/mywork/src.
ls $HOME/mywork/src
project-01
# keep it at the end of the file
export GOENV_ROOT="$HOME/.goenv"
export PATH="$GOENV_ROOT/bin:$PATH"
eval "$(goenv init -)"
export PATH="$GOROOT/bin:$PATH"
export PATH="$PATH:$GOPATH/bin"
export PATH="$PATH:$HOME/bin"
# add personal directory
export GOPATH="$GOPATH:$HOME/mywork/"
$HOME/mywork/src/project-01 in VSCode workspace.If go to implementation doesn’t work, ensure that go is installed properly with src directory.
ls $HOME/go/1.14.0/
bin pkg src
That’s all folks!
This is a minimal list of Go development extensions in my opinion.
golang: How to Add Better Context to Errors
There are at least three ways to add more context to errors.
package main
import (
"errors"
"fmt"
werr "github.com/pkg/errors"
"go.uber.org/zap"
)
// 1. wraps with a message
func wrap(e error) error {
return fmt.Errorf("another layer - %w", e)
}
// 2. wraps with callstack and message
func betterWrap(e error) error {
return werr.Wrap(e, "a better layer")
}
// 3. wraps with the first callstack frame
func zapLogger(e error) {
logger, _ := zap.NewProduction()
defer logger.Sync()
logger.Info("failed to fetch URL",
// Structured context as strongly typed Field values.
zap.Error(e))
}
func main() {
e := errors.New("a test err")
fmt.Printf("err= %+v\n", wrap(e))
fmt.Printf("%+v\n", betterWrap(e))
zapLogger(e)
}
$ go run err_context.go
err= another layer - a test err
a test err
a better layer
main.betterWrap
/Users/xxx/go-code/blog/err/err_context.go:18
main.main
/Users/xxx/go-code/blog/err/err_context.go:35
runtime.main
/Users/xxx/.goenv/versions/1.14.0/src/runtime/proc.go:203
runtime.goexit
/Users/xxx/.goenv/versions/1.14.0/src/runtime/asm_amd64.s:1373
{"level":"info","ts":1604374256.270431,"caller":"err/err_context.go:25",
"msg":"failed to fetch URL","error":"a test err"}
I like the errors package the most. It has a relevant context to troubleshoot a problem.
Pro Way to Develop in Go
** I will try keep the list updated
It’s not a good idea to check an interface for nil.
Try the following code:
type user interface{}
type staff struct{}
func compareNil() {
var generic user
generic = nil
// works as expected
fmt.Printf("value=%v type=%T (generic==nil)=%v\n", generic, generic, generic == nil)
generic = (*staff)(nil)
// fails my expectation
fmt.Printf("value=%v type=%T (generic==nil)=%v\n", generic, generic, generic == nil)
}
go playground: https://play.golang.org/p/7J9DeIjgNia
value=<nil> type=*main.staff (generic==nil)=false
value=<nil> type=<nil> (generic==nil)=true
interface check for nil is specialAn interface is a tuple of [Value, Type]. The nil interface is a tuple [nil, nil]. However, the above code is an interface containing [nil, *main.staff] which is not nil.
We can check for nil as follows:
func isNil(i interface{}) bool {
return i == nil || reflect.ValueOf(i).IsNil()
}
Here i==nil means i has [nil, nil] or has a nil value in [nil, *main.staff].
But if the interface points to a type that has no Nil value:
s := "hello"
generic = s
fmt.Printf("value=%v type=%T type=%v\n", generic, generic, reflect.ValueOf(generic).IsNil())
The code panics:
panic: reflect: call of reflect.Value.IsNil on string Value
goroutine 1 [running]:
reflect.Value.IsNil(...)
/Users/xxx/.goenv/versions/1.14.0/src/reflect/value.go:1063
main.compareNil()
/Users/xxx/go/1.14.0/src/mygo/interfaces/interfaces.go:48 +0x3b1
main.main()
/Users/xxx/go/1.14.0/src/mygo/interfaces/interfaces.go:29 +0x142
exit status 2
The safest way to compare nil interfaces is switch on various types the interface can assume. Never check as myinterface == nil.
json: cannot unmarshal object into Go struct field
package main
import (
"encoding/json"
"fmt"
)
// DTO object
type mould struct {
Particle tiny
}
type tiny interface {
GetName() string
}
// Implement the interface
type speck struct {
Name string `json:"name"`
}
func (s *speck) GetName() string {
return s.Name
}
// Constructor
func NewSpeck(name string) tiny {
return &speck{
Name: name,
}
}
//
func main() {
dirt := NewSpeck("space")
brown := &mould{}
brown.Particle = dirt
brownBytes, err := json.Marshal(brown)
if err != nil {
panic("marshal error")
}
brownLike := &mould{} // unmarshal has no "idea" of how to unpack!
err = json.Unmarshal(brownBytes, &brownLike)
if err != nil {
panic("unmarshal err=%+v\n", err)
return
}
}
The error is:
go run unmarshal_interface.go
panic: json: cannot unmarshal object into Go struct field mould.Particle of type main.tiny
The problem with code is the inability of Go runtime to get target struct for unmarshaling.
Unmarshal essentially copies the byte array to a struct type. However, in the case of the unmarshal of the type tiny, runtime could not find any destination struct. The interface in Go just has behavior, not types.
// solution
brownLike2 := &mould{}
brownLike2.Particle = &speck{} // Now unmarshal "knows" how to unpack the byte array!
err = json.Unmarshal(brownBytes, &brownLike2)
fmt.Printf("brownLike2=%#v err=%+v\n", brownLike2.Particle.GetName(), err)
Written with StackEdit.
Simplify Complexities 
You must be logged in to post a comment.