golang on The Writer At Heart

Cool tricks with goroutine

Sun, 26 Jun 2022 09:00:03 +0700

Using `runtime.Gosched()` to force schedule Goroutines

A goroutine can run and occupy a thread for a long time. This should be avoided by using runtime.Gosched() to force schedule Goroutines to switch context.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


package main

import (
 "fmt"
 "time"
)

func main() {
 go func() {
 for i := 1; i <= 50; i++ {
 fmt.Println("I am Goroutine 1")
 }
 }()

 go func() {
 for i := 1; i <= 50; i++ {
 fmt.Println("I am Goroutine 2")
 }
 }()

 time.Sleep(time.Second)
}

// The result will look like below,
// one goroutine held the thread for so long.
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 2
// I am Goroutine 2
// I am Goroutine 2
// I am Goroutine 2
// I am Goroutine 2
// I am Goroutine 2
// I am Goroutine 1
// ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


package main

import (
 "fmt"
 "runtime"
 "time"
)

func main() {
 go func() {
 for i := 1; i <= 50; i++ {
 fmt.Println("I am Goroutine 1")
 runtime.Gosched()
 }
 }()

 go func() {
 for i := 1; i <= 50; i++ {
 fmt.Println("I am Goroutine 2")
 runtime.Gosched()
 }
 }()

 time.Sleep(time.Second)
}

// The result will look better like below
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 2
// I am Goroutine 2
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 1
// I am Goroutine 2
// I am Goroutine 2
// ...

Một vài lỗi tôi gặp phải với Go và Goland

Mon, 23 May 2022 09:00:03 +0700

Từ khi chuyển qua xài đồ của nhà Jetbrains (Goland) thì tôi khá lúng túng trong việc dùng cái IDE vì nhiều chức năng hơn. Tuy nhiên, trải nghiệm code đúng là tuyệt vời hơn hẳn VSCode ở việc gợi ý syntax và auto import code.

Riêng extension vim tôi chưa dùng nổi vì nhiều phím tắt trong Goland mình chưa thành thạo. Thêm vào đó, nhiều phím tắt cũng bị ghi đề khi dùng với vim và việc phải config lại chúng và nhớ phím tắt mới khiến việc code trở nên rất khó chịu. Hi vọng trong thời gian tới tôi sẽ thành thạo Goland hơn.

Sau đây là một vài lỗi tôi đã từng gặp khi code Go bằng Goland. Hi vọng là chúng giúp ích cho bạn.

How to fix IntelliJ cannot resolve symbol

Thi thoảng, tôi gặp trường hợp Goland bị làm sao đấy mà không tìm thấy được cái package được import vào ở từng file.

![Screen Shot 2022-05-22 at 11.50.23 AM.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1653238217374/7yjLLYgHc.png align=“center”)

Cách tôi fix là chọn File Menu → Invalidate Caches / Restart. Chờ một vài giây cho IDE restart lại thì lỗi sẽ được fix. Ngoài ra, nếu bạn vẫn còn gặp lỗi thì nên xem cái link này để tham khảo các cách giải quyết khác.

A fatal error has been detected by the Java Runtime Environment

Tôi bị lỗi này sau khi cập nhật Goland lên phiên bản mới. Chạy một lúc là IDE bị dừng lại và restart rồi lại dừng và restart. Google ra thì mới biết là mặc định Goland dùng JRE (Java runtime enviroment) làm JetBrains Runtime. Trường hợp của tôi theo như các issues trên Github chỉ thì do JetBrains Runtime bị lỗi nên cần đổi sang một JRE khác.

As a Java application, IntelliJ IDEA requires a Java runtime environment (JRE). By default, IntelliJ IDEA uses JetBrains Runtime (a fork of OpenJDK ), which is included with the IDE. JetBrains Runtime fixes various known OpenJDK and Oracle JDK bugs, and provides better performance and stability. However, in some cases you may be required to use another Java runtime or a specific version of JetBrains Runtime.

Cách khắc phục là chọn JRE khác như hướng dẫn của JetBrains ở đây. Chọn Help | Find Action → Choose Boot Java Runtime for the IDE -> OK

C compiler “gcc” not found: exec: “gcc”: executable file not found in $PATH

Khi run test trong Dockerfile với cú pháp RUN go test ./..., có thể bạn sẽ gặp lỗi không tìm thấy package gcc.

![Lỗi ko tìm thấy package gcc khi chạy go test trong Dockerfile.](https://cdn.hashnode.com/res/hashnode/image/upload/v1653238321681/N3L89IVtY.png align=“center”)

Cách fix là disable CGO (công cụ hỗ trợ các lời gọi hàm từ C trong Go, nhờ đó, ta có thể sử dụng Go để đưa thư viện động của C (C dynamic libraby) sang các ngôn ngữ khác.) thông qua việc thêm CGO_ENABLED=0. Bên zalo có một seris bài rất hay về lập trình CGO, bạn có thể đọc để tham khảo thêm ở đây.

1
2
3
4


## before: C compiler "gcc" not found: exec: "gcc": executable file not found in $PATH 
RUN go test -v ./....
## after: success
RUN CGO_ENABLED=0 go test -v ./...

Where to learn Go?

Thu, 03 Feb 2022 21:49:28 +0700

I started to learn Go last year. Go is one of the most popular programming languages and is the trend in recent years. Also, for a JavaScript-based developer like I, Go is considered an easier approach to learning a strong-typed language compared to C and Java.

This article is about my thoughts on some resources that I used to learn Go. Hope it helps you.

Go tour websites

One of the best places to start is the official Go Tour website: https://go.dev/tour. This is an interactive tutorial that you can use to learn Go by running your own code snippets on the website itself.

The tour is divided into a set of modules each explaining a different concept with a couple of exercises at the end of each module.

Effective Go

Effective Go is another official resource that is available for free from the official Go website https://golang.org/doc/effective_go.html. I found it really useful especially because is not just a syntax reference but a more complete description of all the major Go features and constructs and how to use them effectively.

Go by example

If you’re already understood the basics of the language, https://gobyexample.com is another great website where can find a full code implementation.

200lab

200lab is created by Viet Tran, a solution architect and technical advisor in Vietnam.

I learned Golang for scalable backend course. I found the course is really helpful. They don’t teach you basic syntax where you can google it as Udemy courses, but great APIs architecture and other tricks to improve your backend performance.

They also have a Q&A group where you can post your questions and get answers within a day.

They don’t teach you how SQL and docker work or their syntax, so you have to google them.

The only disadvantage is the content is in Vietnamese.

Go101

If you’re preparing for a Go interview. Or you just want to broaden your knowledge. Go101 is definitely for you. They have quizzes, tricks, and great books. They also cover advanced topics such as Go optimizations.

GoExercises

GoExercises is another awesome website to practice Go concepts via mini-projects.

Hàm init trong Go

Mon, 24 Jan 2022 09:08:51 +0700

Bài này ghi lại những thứ tôi hiểu về hàm init trong Go.

Khi tạo ứng dụng với ngôn ngữ Go, bạn cần khởi tạo biến cùng giá trị của chúng. Một trong những cách để làm điều này là khởi tạo chúng ở đầu hàm main() hoặc khởi tạo chúng như biến global. Hàm init() cho phép bạn chạy code trước hàm main() và sau khi biến global được khởi tạo.

Concepts

Hàm init() sẽ được gọi trước hàm main() theo thứ tự như hình dưới.

Requirements

Để chạy được phần code demo, bạn cần cài Go và nodemon. Bạn có thể chọn bất kỳ editor nào. Tôi dùng Visual Studio Code.

Demo

Hàm init() chỉ chạy một lần.
Hàm init() sẽ chạy sau khi biến global của package được khởi tạo và trước hàm main().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
 "fmt"
)

func main() {
 fmt.Println("run main")
}

func init() {
 fmt.Println("init package main")
 fmt.Println("x =", x)
}

var x int = 1 // biến global

1

nodemon --exec go run main.go --signal SIGTERM

1
2
3


init package main
x = 1
run main

Hàm init() bên trong package sẽ chạy khi import package bất kể bạn có sử dụng package này hay không.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import (
 "fmt"
 _ "learn/internal/collections"
)

func main() {
 fmt.Println("run main")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package collections

import "fmt"

func init() {
 fmt.Println("init package collections")
}

func main() {
 fmt.Println("run main in collections")
}

1
2


init package collections
run main

Nếu có nhiều hàm init() trong một file thì thứ tự chạy init() sẽ từ trên xuống dưới.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package main

import (
 "fmt"
)

func init() {
 fmt.Println("run init 1")
}

func init() {
 fmt.Println("run init 2")
}

func main() {
 fmt.Println("run main")
}

1
2
3


run init 1
run init 2
run main

Nếu có nhiều hàm init() giữa các file trong một package, thứ tự chạy theo tên file tăng dần theo bảng chữ cái tiếng anh.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
 "fmt"
 _ "learn/pkg/collections"
 _ "learn/pkg/rabbits"
)

func init() {
 fmt.Println("init package main")
}

func main() {
 fmt.Println("run main")
}

1
2
3
4
5
6
7


package collections

import "fmt"

func init() {
 fmt.Println("init package collections")
}

1
2
3
4
5
6
7


package rabbits

import "fmt"

func init() {
 fmt.Println("init package rabbits")
}

1
2
3


init package collections
init package rabbits
init package main

Nhược điểm

Sau đây là một vài nhược điểm của việc dùng hàm init():

Làm chậm thời gian khởi động của ứng dụng.
Hàm init() sẽ được gọi ngay khi bạn import package bất kể có cần hay không.
Nếu hàm init() sửa giá trị của biến global, nó sẽ không được gọi khi chạy test.

Tài liệu tham khảo

Generics in Go

Fri, 24 Dec 2021 17:36:51 +0700

Go team released Go 1.18 Beta 1 in December 2021, introducing support for generic programming using type parameters, a much-anticipated feature.

Note: If you prefer, you can use the Go playground in “Go dev branch” mode to try new features with generics.

What is new in generics?

Type parameter lists look like ordinary parameter lists with square brackets. It is customary to start type parameters with upper-case letters to emphasize that they are types.

1

[P, Q constraint1, R constraint2]

Let’s take a look at the function min below.

1
2
3
4
5
6
7
8
9


func min(x, y int) int {
 if x < y {
 return x
 }
 return y
}

m := min(2, 3)
fmt.Println(m) // 2

If we want this function to work with other number types such as float64, we need to declare a new function to handle the new type. To solve that problem, we use generics. The type parameter T, declared in a type parameter list, takes the place of int.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


func min[T constraints.Ordered](x, y T) T {
 if x < y {
 return x
 }
 return y
}

m := min[int](2, 3)
n := min[float64](2, 3)
fmt.Println(m, n) // 2 2

Type parameter lists also have a type for each type parameter. This type defines a set of types. It is called the type constraint. In Go, type constraints must be interfaces.

Let’s take a look at the example below.

1

func min[T constraints.Ordered](x, y T) T

constraints.Ordered is a type constraint. Ordered defines the set of all integer, floating-point, and string types.

~T means the set of all types with the underlying type T.

Check this discussion for more information.

1
2
3
4
5
6


// Package constraints define a set of useful constraints to be used with type parameters.
package constraints

type Ordered interface {
 int | float | ~string
}

When declaring a variable without specifying an explicit type (either by using the := syntax or var = expression syntax), the variable’s type is inferred from the value on the right-hand side.

1
2


var i int
j := i // j is an int

You can call the min function without type inference. Sometimes, passing type arguments lead to more verbose code.

1
2
3
4
5
6


func min[T constraints.Ordered](x, y T) T

var a float64 = 1.1
var b float64 = 2.2
var m float64 = min(a, b) // not need to pass any type of argument here.
fmt.Println(m) // 1.1

References

Go common mistakes - Part 1

Thu, 23 Dec 2021 04:16:17 +0700

Albert Einstein had a quote

Anyone who has never made a mistake has never tried anything new.

But one shouldn’t repeat his mistakes. It is best to learn from them and capture them forever.

Here are the mistakes I have made when I started to learn Go.

1. Import for side effect

Issue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


package main

import (
 "encoding/base64"
 "fmt"
 "image" // missing import for package image/jpeg
 "log"
 "strings"
)

func main() {
 reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
 m, _, err := image.Decode(reader)
 if err != nil {
 log.Fatal(err)
 }
 fmt.Println(m)
}

const data = `
/9j/4AAQSkZJRgABAQIAHAAcAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdA
SFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2Nj
Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCABnAJYDASIAAhEBAxEB/8QA
HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh
MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW
V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG
x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF
BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV
YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE
hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq
8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDlwKMD0pwzSiuK57QzGDxS7D6in8Y5ximnAPUfSlcq4m3ilUYp
2OKXHvRcVxnTtS7c07HNFK4DQPakC4PNOA+tOx70XAjK/So5gBGP94fzqfvUVx/qxx/EP51UXqRP4WSE
cmgjilP3jSEZqS0IO/NGDnpUiocDg/McDjvV6HTPOdVWYgsM5KcfzzQ2JySM2jp6VYu7SWzmMUwG4cgj
kMPUVBjjtTGtRu0Zopw+lFFxhinrGzuqqMsxAA9yaXFSRv5cqSEcIwYj6GpuZ30O30fSLKzhUpbpNMv3
5XGTn29BV28jt7pPLuIVljPBBFVreYx+VbqAjycgt3x14zRcNOxGyVFHQkIc/wA61exyKLbuzjdZ046d
ftEuTEw3Rk9SPT8P8Kpbea3tchbyVae4JkjbbGpGdwOM89Af6ViFTWUtGdcXoM2+woK1JtpNtTcoZt+l
Jt7ZqTbRtouFyPFRXI/c9D94fzqzioLsfuD/ALw/nVReqIn8LJCOTSY+tSMOTmkIpXLRu+F0t5pJxPHG
wjjUAuBjJJz1+laD6Pai+WaK9SBX6puzn6ZP+NV/Dkdtc6ZNbyAFwxLAHDYPv6VoQ21nPNEEiQGEFRtk
Gf0NaWTOeW7Of8QwGG4MRZnEbYXPJwRnOR0zWNXW+KrqBLUWi5EjbWCgcAA9c/gRXKYqZaGlK/LqMH0F
FLtHvRSNiYD2pSDTgpp6p0ywUHoTULXYxcktzrdCf7Xo8LP/AKyEmMNjJ46dfbFWJ5TDGNwB9lFUvDV9
YrbfYGbyrjcWG88S57g+vtV26ZIvMlumKwwjLZ6V0WfU54yTvYwtbubea2WNWbzg4bYQeBgj8OtYeKhj
u4y2HQxqxOD1xzxmrWAQCCGB6EGsaikndmsJxeiYzBo280/Z7UbayuaXGY5oIp+2lx9KLjIsVDeD/Rj/
ALy/zq1t96r3y4tT/vL/ADq4P3kRP4WSleTSFKkkKoCW4GaqNcMxIjXj1pxjKT0FKrGC1Nrw3vGrKkYz
5kTAr6455/HH510UdwPtRgWCbzF5+YYUf4Vwun39xpmoR3qASMmQUJwGU9Rnt/8AWrpbrxhb8/ZdOmaQ
gAGZwFH5ZJrpVKVlY5ZYhN6kXiu2eO/ikZlIljAAB5yM549OawSOOlPuLqe+umuLqTfM4OSOAo7ADsKh
hl/cRsTuJHPv7mlKi3sVTxNtGP20VJhThgSQaK52mnZnUqsWrpkyeUrr5pABOAPU1AGaXUCWJISHGPfP
P8qL7BiKnsMg46H3qrbzupbj5mPTPTpXVSglG551SpzSsXJ4/MBUgYIxyKpySyGBYJriV1D7kRpCVH4V
bSeNJ4xchni3DeqnBI+td7F4b0mKIRjT45VbktJlzk455+n6VtYzv2PNwFZWBHBGKVJDGVC54/nXQeMN
NttLNkba1jgWVWDmM8bhg4/nzXLSSbXVj6fyNKUdNRp21RtIRJGrjuM0u3FQ2DbodvcEkfQmrW2vLqLl
k0ejCXNFMj2/jQV9qkxSYNRcsZiq2oI32N2CkhWXJxwOe9XMcVt6hoPn6dFaW0wgRpNzvKDlz6+/0rai
ryv2Jm9LHJai+ZRGCBjnr71ErdAxAY9B611t1Y2cunbbaOQ3FvKZI3UqGlZMbiWwfcfhV231iwvLSM3U
lt5Uq52TuZG+hGMA12xXJGxxzjzybOQtNOvb5j9ktZJhnBIHyg+5PFX38JayqK/2eLJIBUTgkDA9q7ex
itrSHFpGsUbndhRgc+g7VNIyfZJAoJZUbb3I46CtFJMylBo8sdWhmYMuCnylc9wef5VUT7+1chc5NS7h
sUZO5RtIPUH3pkBDOxxxmqM9TQtn+WilhHfHaik43KTG3Z4IyPyrNVjGCsZ+dmwv6V3cXhSG8sYpJLud
JJIwxChdoJGcYx/Wkg8DafA4knvLiQr/ALqj+VQpKw3FtnFFfvbiSMgZJ6/jXp2n3d9cQRBTFsKD96EP
oOxPU/8A68VVtbbRtMVntbePKDLTSHJH/Aj/AEqHTvE66rq72VugMMcbSGTnL4wMAfjT5n0HyW3L+s6b
baxaJBdzN+7bcrxkAhun0rz3VNCv7e7lgigknWI43xLu6jjIHTjtXqfkpPGVYsBkghTikgsYIN/lhgXb
cxLkknp/ShczQ7xtY8vtEmhkj8yGRBuCnehUcnHcVtmwfJ/fQ8e7f/E12txZW91C0U6b42xlST2OR/Ko
Bo1gM/uW55/1jf41nOipu7LhV5FZHIGzI6zwj/vr/Ck+yr3uYf8Ax7/CutbQdMb71tn/ALaN/jSf8I/p
X/PoP++2/wAan6rAr6wzkWt0II+1Rc/7Lf4Vd1eeCSKBbdZDdShYoiZNoyfY10P/AAj2lf8APmP++2/x
oPh/SjKspsozIuNrZORjp3qo0FHYPb3OZt7ae3SzjuItsiRSAgnccl/UA+3Q1yNjKLR4ZZYY5VD7tkv3
WwO/+e1evPp9nI257aJm6bioz1z1+tY+s6Hplnot9PbWMMcqwOFcLyOO1bJWMZSTOPHi+9w3mosrlyd2
9lCj02g9P/1e9a3hzxAbl2ikZRcdQueHHt7j864Y8Z4I4oRzG6urFWU5BHBB7HNJxTFGbR6he6Vpmtgm
eLy5zwZI/lb8fX8azIvBUUTHdfSFP4QsYB/HNZ+k+KEnRY75hHOvAk6K/v7H9K6yyvlnQBmDZ6GsnzR0
N0oy1RzOtaN/Y1tHNFO06u+zYy4I4Jzx9KKveJblXuordSGES5b6n/62PzorKVdp2LjQTVyWz8UWEWlq
jSgyxfJt6EgdDzWTdeLIZGO7zHI/hVajGmWWP+PWL8qwlAIURrhpMAHHJA71pRcZrToZzcoEuo6heakA
GHk245CZ6/X1qPTLq40q+W5t2QybSpDAkEEc55/zilk5k2r91eKhLDzWz2rpsczbbuemeD76fUNG865I
MiysmQMZAAwa3a5j4ftu0ByP+fh/5CulkLLG7INzhSVHqe1Fh3uOoqn9qQQxyhndmHIxwOmSR2xQ13KD
KoiBZOV9JBnt707MVy5RWdNdy7wRGf3bfMinnO1jg+vY03WXLaJO3mhQ20b0zwpYf0qlG7S7icrJs08U
VwumgC+YiQyeVtZH567hzj8aSL949oGhE/2v5pJCDkksQwBHC4/+vXQ8LZ2uYxxCavY7us/xCcaBfn0h
b+VP0bnSrb94ZMJgOecj1rl/GfidUE2k2gy5+SeQjgA/wj3rlas2jdao48qrjLAGkSKPk4Gc1WMj92I+
lIJnU8OfxPWo5inBokmtQTmM4OOh71b0q6vbFmWCbaxHyqQGAP0PT8KhSTzVyo5ocSKA5VfTOTmqsmRd
pl99XjPzThzK3zOeOSeveirNmkgg/fIpYsTkYORxRXmzlTjJqx6EVUcU7mhkKCzdAK59QI9zYxtG1fYU
UVtgtmY4nZEa8Ak9aqFv3rfSiiu1nMeifDv/AJF+T/r4f+QrqqKKQwzQenNFFMCOKFIgNuThdoJ5OPSk
ubeK6t3gnXdG4wwziiii/UTKMOg6dbzJLFE4dSCP3rEdeOM8805tDsGMvySgSsS6rM6gk9eAcUUVftZt
3uyVGNthuq3Eei6DK8H7sRR7YuMgHtXkc8rzTNLM26RyWY+p70UVnLY0iEsUipG7rhZBlDkc1HgYoorM
0HwyBXGeRjmrcUhMg2ghezd//rUUVcTKW5s2jZtY/QDaOKKKK8ip8bPRj8KP/9k=
`

1

image: unknown format

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


package main

import (
 "encoding/base64"
 "fmt"
 "image"
 "log"
 "strings"
 // Package image/jpeg is not used explicitly in the code below,
 // but is imported for its initialization side-effect, which allows
 // image.Decode to understand JPEG formatted images.
 _ "image/jpeg"
)

func main() {
 reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
 m, _, err := image.Decode(reader)
 if err != nil {
 log.Fatal(err)
 }
 fmt.Println(m)
}

const data = `
/9j/4AAQSkZJRgABAQIAHAAcAAD/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdA
SFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2Nj
Y2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wAARCABnAJYDASIAAhEBAxEB/8QA
HwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIh
MUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW
V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG
x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQF
BgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAV
YnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE
hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq
8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDlwKMD0pwzSiuK57QzGDxS7D6in8Y5ximnAPUfSlcq4m3ilUYp
2OKXHvRcVxnTtS7c07HNFK4DQPakC4PNOA+tOx70XAjK/So5gBGP94fzqfvUVx/qxx/EP51UXqRP4WSE
cmgjilP3jSEZqS0IO/NGDnpUiocDg/McDjvV6HTPOdVWYgsM5KcfzzQ2JySM2jp6VYu7SWzmMUwG4cgj
kMPUVBjjtTGtRu0Zopw+lFFxhinrGzuqqMsxAA9yaXFSRv5cqSEcIwYj6GpuZ30O30fSLKzhUpbpNMv3
5XGTn29BV28jt7pPLuIVljPBBFVreYx+VbqAjycgt3x14zRcNOxGyVFHQkIc/wA61exyKLbuzjdZ046d
ftEuTEw3Rk9SPT8P8Kpbea3tchbyVae4JkjbbGpGdwOM89Af6ViFTWUtGdcXoM2+woK1JtpNtTcoZt+l
Jt7ZqTbRtouFyPFRXI/c9D94fzqzioLsfuD/ALw/nVReqIn8LJCOTSY+tSMOTmkIpXLRu+F0t5pJxPHG
wjjUAuBjJJz1+laD6Pai+WaK9SBX6puzn6ZP+NV/Dkdtc6ZNbyAFwxLAHDYPv6VoQ21nPNEEiQGEFRtk
Gf0NaWTOeW7Of8QwGG4MRZnEbYXPJwRnOR0zWNXW+KrqBLUWi5EjbWCgcAA9c/gRXKYqZaGlK/LqMH0F
FLtHvRSNiYD2pSDTgpp6p0ywUHoTULXYxcktzrdCf7Xo8LP/AKyEmMNjJ46dfbFWJ5TDGNwB9lFUvDV9
YrbfYGbyrjcWG88S57g+vtV26ZIvMlumKwwjLZ6V0WfU54yTvYwtbubea2WNWbzg4bYQeBgj8OtYeKhj
u4y2HQxqxOD1xzxmrWAQCCGB6EGsaikndmsJxeiYzBo280/Z7UbayuaXGY5oIp+2lx9KLjIsVDeD/Rj/
ALy/zq1t96r3y4tT/vL/ADq4P3kRP4WSleTSFKkkKoCW4GaqNcMxIjXj1pxjKT0FKrGC1Nrw3vGrKkYz
5kTAr6455/HH510UdwPtRgWCbzF5+YYUf4Vwun39xpmoR3qASMmQUJwGU9Rnt/8AWrpbrxhb8/ZdOmaQ
gAGZwFH5ZJrpVKVlY5ZYhN6kXiu2eO/ikZlIljAAB5yM549OawSOOlPuLqe+umuLqTfM4OSOAo7ADsKh
hl/cRsTuJHPv7mlKi3sVTxNtGP20VJhThgSQaK52mnZnUqsWrpkyeUrr5pABOAPU1AGaXUCWJISHGPfP
P8qL7BiKnsMg46H3qrbzupbj5mPTPTpXVSglG551SpzSsXJ4/MBUgYIxyKpySyGBYJriV1D7kRpCVH4V
bSeNJ4xchni3DeqnBI+td7F4b0mKIRjT45VbktJlzk455+n6VtYzv2PNwFZWBHBGKVJDGVC54/nXQeMN
NttLNkba1jgWVWDmM8bhg4/nzXLSSbXVj6fyNKUdNRp21RtIRJGrjuM0u3FQ2DbodvcEkfQmrW2vLqLl
k0ejCXNFMj2/jQV9qkxSYNRcsZiq2oI32N2CkhWXJxwOe9XMcVt6hoPn6dFaW0wgRpNzvKDlz6+/0rai
ryv2Jm9LHJai+ZRGCBjnr71ErdAxAY9B611t1Y2cunbbaOQ3FvKZI3UqGlZMbiWwfcfhV231iwvLSM3U
lt5Uq52TuZG+hGMA12xXJGxxzjzybOQtNOvb5j9ktZJhnBIHyg+5PFX38JayqK/2eLJIBUTgkDA9q7ex
itrSHFpGsUbndhRgc+g7VNIyfZJAoJZUbb3I46CtFJMylBo8sdWhmYMuCnylc9wef5VUT7+1chc5NS7h
sUZO5RtIPUH3pkBDOxxxmqM9TQtn+WilhHfHaik43KTG3Z4IyPyrNVjGCsZ+dmwv6V3cXhSG8sYpJLud
JJIwxChdoJGcYx/Wkg8DafA4knvLiQr/ALqj+VQpKw3FtnFFfvbiSMgZJ6/jXp2n3d9cQRBTFsKD96EP
oOxPU/8A68VVtbbRtMVntbePKDLTSHJH/Aj/AEqHTvE66rq72VugMMcbSGTnL4wMAfjT5n0HyW3L+s6b
baxaJBdzN+7bcrxkAhun0rz3VNCv7e7lgigknWI43xLu6jjIHTjtXqfkpPGVYsBkghTikgsYIN/lhgXb
cxLkknp/ShczQ7xtY8vtEmhkj8yGRBuCnehUcnHcVtmwfJ/fQ8e7f/E12txZW91C0U6b42xlST2OR/Ko
Bo1gM/uW55/1jf41nOipu7LhV5FZHIGzI6zwj/vr/Ck+yr3uYf8Ax7/CutbQdMb71tn/ALaN/jSf8I/p
X/PoP++2/wAan6rAr6wzkWt0II+1Rc/7Lf4Vd1eeCSKBbdZDdShYoiZNoyfY10P/AAj2lf8APmP++2/x
oPh/SjKspsozIuNrZORjp3qo0FHYPb3OZt7ae3SzjuItsiRSAgnccl/UA+3Q1yNjKLR4ZZYY5VD7tkv3
WwO/+e1evPp9nI257aJm6bioz1z1+tY+s6Hplnot9PbWMMcqwOFcLyOO1bJWMZSTOPHi+9w3mosrlyd2
9lCj02g9P/1e9a3hzxAbl2ikZRcdQueHHt7j864Y8Z4I4oRzG6urFWU5BHBB7HNJxTFGbR6he6Vpmtgm
eLy5zwZI/lb8fX8azIvBUUTHdfSFP4QsYB/HNZ+k+KEnRY75hHOvAk6K/v7H9K6yyvlnQBmDZ6GsnzR0
N0oy1RzOtaN/Y1tHNFO06u+zYy4I4Jzx9KKveJblXuordSGES5b6n/62PzorKVdp2LjQTVyWz8UWEWlq
jSgyxfJt6EgdDzWTdeLIZGO7zHI/hVajGmWWP+PWL8qwlAIURrhpMAHHJA71pRcZrToZzcoEuo6heakA
GHk245CZ6/X1qPTLq40q+W5t2QybSpDAkEEc55/zilk5k2r91eKhLDzWz2rpsczbbuemeD76fUNG865I
MiysmQMZAAwa3a5j4ftu0ByP+fh/5CulkLLG7INzhSVHqe1Fh3uOoqn9qQQxyhndmHIxwOmSR2xQ13KD
KoiBZOV9JBnt707MVy5RWdNdy7wRGf3bfMinnO1jg+vY03WXLaJO3mhQ20b0zwpYf0qlG7S7icrJs08U
VwumgC+YiQyeVtZH567hzj8aSL949oGhE/2v5pJCDkksQwBHC4/+vXQ8LZ2uYxxCavY7us/xCcaBfn0h
b+VP0bnSrb94ZMJgOecj1rl/GfidUE2k2gy5+SeQjgA/wj3rlas2jdao48qrjLAGkSKPk4Gc1WMj92I+
lIJnU8OfxPWo5inBokmtQTmM4OOh71b0q6vbFmWCbaxHyqQGAP0PT8KhSTzVyo5ocSKA5VfTOTmqsmRd
pl99XjPzThzK3zOeOSeveirNmkgg/fIpYsTkYORxRXmzlTjJqx6EVUcU7mhkKCzdAK59QI9zYxtG1fYU
UVtgtmY4nZEa8Ak9aqFv3rfSiiu1nMeifDv/AJF+T/r4f+QrqqKKQwzQenNFFMCOKFIgNuThdoJ5OPSk
ubeK6t3gnXdG4wwziiii/UTKMOg6dbzJLFE4dSCP3rEdeOM8805tDsGMvySgSsS6rM6gk9eAcUUVftZt
3uyVGNthuq3Eei6DK8H7sRR7YuMgHtXkc8rzTNLM26RyWY+p70UVnLY0iEsUipG7rhZBlDkc1HgYoorM
0HwyBXGeRjmrcUhMg2ghezd//rUUVcTKW5s2jZtY/QDaOKKKK8ip8bPRj8KP/9k=
`

1

&{[44 44 45 46 46 47 48 48 42 42 42 42 42 42 42 42 42 42 42 43 45 49 52 53 46 46 46 4 ... 165 169] 160 80 YCbCrSubsampleRatio420 (0,0)-(150,103)}

2. Unexpected new-line

Issue

1
2
3
4
5
6
7
8


func main() {
 const fruits = []string{
 "cherry",
 "banana" // Missing a comma here `,`
 }

 fmt.Println(fruits)
}

1

./model.go:6:17: syntax error: unexpected newline, expecting comma or }

Solution

1
2
3
4
5
6
7
8


func main() {
 const fruits = []string{
 "cherry",
 "banana",
 }

 fmt.Println(fruits) // ["cherry", "banana"]
}

3. Unaltered strings

Issue: Strings are immutable in Go

1
2
3
4
5
6


func main() {
 fruit := "cherry"
 fruit[0] = "C"

 fmt.Println(fruit) // error here
}

1

./model.go:7:14: cannot assign to fruit[0] (strings are immutable)

Solution

1
2
3
4
5
6


func main() {
 fruit := []rune("cherry")
 fruit[0] = 'C'
 s := string(fruit)
 fmt.Println(s) // Cherry
}

Go interview questions and answers

Sun, 12 Dec 2021 01:36:22 +0700

1. Explain packages in Go.

Every Go program is made up of packages. The program starts running in package main. This program is using packages with import paths such as fmt.

1
2
3
4
5
6
7
8
9


package main

import (
 `fmt`
)

func main() {
 fmt.Println("Hello word!")
}

2. What is `GOPATH`?

The GOPATH is an environment variable that determines the location of the workspace. It is the only variable that you have to set when developing Go code.

3. How to use custom packages?

You have the folder structure and two files as below.

1
2
3
4
5
6


src/
 myproject/
 mylib/
 mylib.go
 ...
 main.go

mylib.go

1
2
3
4
5


package mylib

type SomeType struct {
 ...
}

main.go

1
2
3
4
5
6
7
8
9


package main

import (
 "mylib"
)

func main() {
 ...
}

If you want to use mylib in main.go, you could go like this:

Place the directory with library files under the directory of your project.
In the rest of your project, refer to the library using its path relative to the root of your workspace containing the project.

Now, in the top-level main.go, you could import “myproject/mylib” and it would work.

main.go

1
2
3
4
5
6
7
8
9


package main

import (
 "myproject/mylib" // WORK
)

func main() {
 ...
}

4. Explain what is goroutine and how to stop goroutine?

A goroutine is a function that is capable of running concurrently with other functions.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import (
 "fmt"
 "time"
)

func say(s string) {
 for i := 1; i <= 5; i++ {
 time.Sleep(100 * time.Millisecond)
 fmt.Println(s)
 }
}

func main() {
 go say("world")
 say("hello")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


$ go run main.go
world
hello
hello
world
world
hello
hello
world
world
hello

To stop goroutine, you pass the goroutine a signal channel, that signal channel is used to push a value into when you want the goroutine to stop. The goroutine polls that channel regularly as soon as it detects a signal, it quits.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import (
 "fmt"
 "time"
)

func say(s string, quit chan bool) {
 defer close(quit)

 for i := 1; i <= 5; i++ {
 fmt.Println(s, i)
 if i == 3 {
 quit <- true
 }
 }

 for {
 select {
 case <-quit:
 return
 default:
 // Do other stuff
 }
 }
}

func main() {
 // a channel to signal that it's stopped
 quit := make(chan bool)

 go say("Hello", quit)

 // Sleep the program to avoid go routine is forced to exit because `main()` exits
 time.Sleep(1000 * time.Millisecond)
}

1
2
3
4


$ go run main.go
Hello 1
Hello 2
Hello 3

Go Tools - Part 1

Thu, 02 Dec 2021 23:47:01 +0700

Overview

Go tools are the great features that exist alongside the language as part of the go command. Almost Go tools come together with Go installation, but there are some you might install depending on your needs.

Installation

The easiest way to install a Go tool is to run go get -u golang.org/x/tools/.... Another way to do it is to git clone the repository to $GOPATH/src/golang.org/x/tools.

There are some helpful flags:

-u forces the tool to sync with the latest version of the repo.

-d if you just want to clone a repo to your GOPATH and skip the building and installation phase.

Tools

`go vet`

The vet command will check your code for common errors. Let’s look at the types of errors vet can catch:

Bad parameters in Printf-style function calls
Method signature errors for common method definitions
Bad struct tags
Unkeyed composite literals

1
2
3
4
5
6
7
8


package main

import "fmt"

func main() {
 // Printf calls whose arguments do not align with the format string.
 fmt.Printf("The quick brown fox jumped over lazy dogs", 3.14)
}

1
2


$ go vet main.go
main.go:6: no formatting directive in Printf call

`go list`

It lists the packages named by the import paths, one per line.

`go env`

It prints Go environment information.

1
2
3
4
5


$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
...

If there are specific values that you’re interested in, you can pass them as arguments to go env.

1
2
3
4


$ go env GOPATH GOOS GOARCH
/home/nana/go
linux
amd64

`go fmt`

Gofmt is a tool that automatically formats Go source code.

To format your code, you can use the gofmt tool directly:

1

gofmt -w yourcode.go

Or you can use the “go fmt” command:

1

go fmt path/to/your/package

It also supports rewrite rules that you can use to help refactor your code.

1
2
3
4
5
6


var foo int

func bar() {
 foo = 1
 fmt.Println("foo")
}

1
2
3
4
5
6
7
8
9


$ gofmt -d -w -r 'foo -> Foo' .
-var foo int
+var Foo int

 func bar() {
- foo = 1
+ Foo = 1
 fmt.Println("foo")
 }

Packages in Go - Part 2

Wed, 01 Dec 2021 17:25:36 +0700

Imports

The import statement tells the compiler where to look on disk to find the package you want to import.

1

import "fmt"

To import more than one package, you need to wrap the import statements in an import block.

1
2
3
4


import (
 "fmt"
 "strings"
)

Packages are found on disk based on their relative path to the directories referenced by GOPATH. If the compiler cannot find the package you’ve referenced in your GOPATH, you’ll get an error when trying to run or build your program.

The Go tooling has built-in support for fetching source code from distributed version control systems (DVCS) such as sharing sites likes Github.

For example:

1

import "github.com/dgrijalva/jwt-go"

When an imported path contains a URL, the Go tooling can be used to fetch the package from the DVCS and place the code inside the GOPATH at the location that matches the URL.

Packages with the same name can be imported by using named imports.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package main

import (
 "fmt"
 myfmt "mylib/fmt"
)

func main() {
 fmt.Println("Standard library")
 myfmt.Println("My custom library")
}

The Go compiler will fail the build and output an error whenever you import a package that you don’t use.

Go doesn’t allow any unused variable. Any unused variable can be replaced with the _ (underscore character), known as the blank identifier. A blank import of a package is used when the imported package is not being used in the current program, but we need the init function in the Go source files belonging to that package can be called and initialization of variables in that package can be done properly.

As an example mysql package is used as blank import for its side-effect of registering the mysql driver as a database driver in the init() function of mysql package, without importing any other functions.

1

_ "github.com/go-sql-driver/mysql"

Init

Each package has the ability to provide as many init() functions. They are automatically executed before the main() function in the man package is called.

init() function is similar to the main() function. It doesn’t take any argument nor return anything. Go can support multiple init() functions within one file. They are called in their respective order of declaration within the file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import "fmt"

func init() {
 fmt.Println("init 1")
}

func init() {
 fmt.Println("init 2")
}

func main() {
 fmt.Println("main")
}

1
2
3
4


$ go run main.go
init 1
init 2
main

The init() functions are great for setting up packages, initializing variables, or performing any other bootstrapping you may need prior to the program running.

An example of this is database drivers. They register themselves with the SQL package when their init function is executed at startup because the SQL package can’t know about the drivers that exist when it’s compiled. Let’s look at an example of what an init function might do.

1
2
3
4
5
6
7
8
9


package postgres

import (
 "database/sql"
)

func init() {
 sql.Register("postgres", new(PostgresDriver))
}

This code lives inside your pretend database driver for the PostgreSQL database. When a program imports this package, the init function will be called, causing the database driver to be registered with Go’s sql package as an available driver.

Now we can tell the sql.Open method to use this driver.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


package main

import (
 "database/sql"
 _ "https://github.com/goinaction/code/chapter3/dbdriver/postgres"
)

func main() {
 sql.Open("postgres", "mydb")
}

References

Go in action

Packages in Go - Part 1

Tue, 30 Nov 2021 23:35:24 +0700

Packages

All Go programs are organized into groups of files called packages, so that the code has the ability to be included in other projects as smaller reusable pieces.

Let’s look at the packages that make up Go’s http functionality in the standard library which contains a series of related files with the .go extension.

1
2
3
4
5
6
7
8
9


net/http/
 cgi/
 cookiejar/
 testdata/
 fcgi/
 httptest/
 httputil/
 pprof/
 testdata/

Every Go source file belongs to a package. The package declaration must be the first line of code in your Go source file. All the functions, types, and variables defined in your Go source file become part of the declared package.

1

package <packagename>

The convention for naming your package is to use the name of the directory containing it.

When naming your packages and their directories, you should use short, concise, lowercase names, with no under_scores or mixedCaps. They are often simple nouns, such as:

time (provides functionality for measuring and displaying time)
list (implements a doubly-linked list)
http (provides HTTP client and server implementations)

Package names may be abbreviated when the abbreviation is familiar to the programmer. Widely-used packages often have compressed names:

strconv (string conversion)
syscall (system call)
fmt (formatted I/O)

Keep in mind that a unique name is not required because you import the package using its full path.

main package and main() function

Go programs start running in the main package. It is a special package that is intended to be compiled into a binary executable.

The main() function is a special function that is the entry point of an executable program. Let’s see an example of an executable program in Go.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Package declaration
package main

// Importing packages
import (
 "fmt"
)

func main() {
 fmt.Println("Hello, world!")
}

1

go run main.go

1
2


## Output
Hello, world!

golang on The Writer At Heart

Cool tricks with goroutine

Using runtime.Gosched() to force schedule Goroutines

Một vài lỗi tôi gặp phải với Go và Goland

How to fix IntelliJ cannot resolve symbol

A fatal error has been detected by the Java Runtime Environment

C compiler “gcc” not found: exec: “gcc”: executable file not found in $PATH

Where to learn Go?

Go tour websites

Effective Go

Go by example

200lab

Go101

GoExercises

Hàm init trong Go

Concepts

Requirements

Demo

Nhược điểm

Tài liệu tham khảo

Generics in Go

What is new in generics?

References

Go common mistakes - Part 1

1. Import for side effect

2. Unexpected new-line

3. Unaltered strings

Go interview questions and answers

1. Explain packages in Go.

2. What is GOPATH?

3. How to use custom packages?

4. Explain what is goroutine and how to stop goroutine?

Go Tools - Part 1

Overview

Installation

Tools

go vet

go list

go env

go fmt

Packages in Go - Part 2

Imports

Init

References

Packages in Go - Part 1

Packages

Using `runtime.Gosched()` to force schedule Goroutines

2. What is `GOPATH`?

`go vet`

`go list`

`go env`

`go fmt`