DEV Community: Thành Đoàn Nhật

Golang Day 2: Arrays, Slices and Maps

Thành Đoàn Nhật — Mon, 08 Jun 2026 16:25:08 +0000

Today, I learned about various types of collections in Go, because processing collection of data is one of the most common tasks in programing, such as data from files, from response API or from anything.
Since this is my current understanding, so if I have any mistake or you have additional insights, please leave a comment, I would really appreciate it.

Arrays

Overall

Arrays form the base data structure for both slices and maps.
An array is a fix-length data type that contains a contiguous block of elements of the same type. This could be a built-in type such as integer and strings, or it can be a struct type. Because of this, the data of memory can stay in CPU caches longer, and we can retrieve data in array quickly. Since all elements in arrays have the same type and size, Go can calculate memory address of any elements directly from its index. This allow constant-time access (O(1)). #### Declaring and initializing
Array declare by specifying the type of data to be stored and total number of elements required, known as length of array.

// Declare integer array with length is 5
var arr [5]int

We can't modify both type of element which stored in array and length of array after declare, so if we want to store in longer array, we need to create new array with target length, and copy all elements from old array to it.
We can declare array by literal, and this is a idiomatic in Go.

// Declare an integer array of 5 elements
array := [5]int{1, 2, 3, 4, 5}
* Note: we cannot declare an array of type _int_ and initialize it with _string_ values, it raise error when editor time.
// Declare an integer array of 5 elements but not specific number elements, Go automatically get that info from list value initializing
array := [...]int{1, 2, 3, 4, 5}
// Declare an integer array of 5 elements, but we just define 2 first element, so rest of array will store zero value of array's type.
array := [5]int{1:1, 4:4}
In this case, array is [0, 1, 0, 0, 4]

Working with array

To access individual element by index, we use []. Ex: array[2]
We can have an array of pointers, we use * to access value that pointer points to.

// Declare an array of pointers
array := [5]*int{0: new(int), 1: new(int)} 
// Assign value to pointer at index 1
*array[1] = 10
// Because we don't initialize value for rest of array, it will be zero value of pointer - nil.
// fmt.Println(array) -> [<nil> 0x2a73258360d0 <nil> <nil> <nil> 0x2a73258360d8]

Array is a value in Go, so we can assign it to other arrays, but that arrays need to same element's type and same length, if not, this raise error compiler.
Similar, copy an pointer array will copy all pointer from source array, not copy value of pointers point to.
We can create nested array, array contains array, this allow us to can create multidimensional array. #### Passing array between functions
When we passing array between functions, it always passed by value. This mean we will copy all value of array, regardless entirely type of elements and size of array, for large arrays, it not effective for both memory and performance.
In case large arrays, we should pass pointer of array between function, because we just pass address of array, not entire array, but when do it, we also aware that when we modify value of element of array, outer function will impact. ## Slices #### Overral
Slices are built around the concept of dynamic arrays, that can be modify size quickly. Underlying in memory of slice is contiguous block, so it offer you all benefit of indexing, iteration and garbage collection.
Slices have three metadata field: pointer address (pointer to underlying memory) , length and capacity. #### Declare
We can declare a slice by make function, specific length and capacity of slice (if capacity not specific, it could be same with length)

slice := make([]string, 5) 
slice_specific_cap := make([]string, 5, 10)

An idiomatic way of creating a slice is to use a slice literal. It quite similar with array literal, except we don't put length of slice in [], the length and capacity are based on length of values that we initializing

 slice := []string{'a', 'b', 'c'}

We can specific index of initial value, similar array:

slice := []string{99: 'a'}

Note: when we put length in [], we create an array, if not, we create a slice
Create nil slice: var slice []int
Create zero slice: slice := make([]int, 0) or []int{} #### Working with slice
I think it similar in list in Python, about index, changing share memory,.. but I notice that create slice from source slice have something to be aware.
Create new slice for exists slice. Ex:

 sliceSrc := []int{0, 1, 2, 3, 4}
 sliceNew := slice_src[1:3] // [1, 2]

After that, length of sliceNew is 2, but capacity of it is 4.
We have notice: for slice[i:j] with an underlying array of capacity k
length: j - i (3 - 1 = 2)
capacity: k - i (5 - 1 = 4)
Because this behavior is just create new slice from an exists underlying array, slice_new have pointer points to element index 1 in sliceSrc. So, if we modify index 1 in sliceSrc, the value of pointer 0 of sliceNew pointing will be change, similar potential problem of copy array in Python

Growth of slice: one of the advantage of using a slice over an array is that we can growth the capacity of our slice as needed. We do this by using built-in function append.

slice := []int{1, 2, 3}
newSlice := append(slice, 4) ! [1, 2, 3, 4]

Notice that append a slice can change value of exists underlying array, because it is contiguous block in memory.
When base capacity doesn't enough for new value, Go automatically create new underlying array with exist value, and growth the capacity of new underlying array, based on current number( if number under 1000, it will be 2, and if number greater 1000, it will be 1.25 and this is just current rule)

Because of potential issue when append value to new slice, we can protect it by third index when assign new slice. newSlice := oldSlice[2:3:4] newLength: 3 - 2 = 1 newCapacity: 3 - 2 = 1 In this case, newSlice has newLength and newCapacity is 1, because of this, when we call append for newSlice to add new value, Go need to create new underlying array, and we will prevent any potential bug from sharing underlying array. Notice that we can't create new capacity large than capacity of exist slice, it will raise runtime error.
We can append multiple value to a slice with one call.

append(slice, 2, 3, 4) or append(slice, sliceOther...)

Iterate slice: for index, value := range slices. Range will return two value, index and value of this index. Value return is copy of the value, not referrence.
We also iterate a slice by for index, similar other language:

for index:=0; index < len(slice); index++

Passing slice between functions

When we pass slice between functions, it requires nothing more than passing the slice by value because we just copy the slice pass to function, not contains underlying array, and because of this, need to be careful when change value of underlying array.

Maps

Overall

A maps is a data structure similar dict in Python, store collection of data by key/value pairs. A maps is unorder, although we store in same order, the order of pair when we iterate always different. Maps use hash tables internal. A hash table of key helps determine where key/value pairs stored and located efficiently. Because of this, key of maps require hashable, that mean it always return same value when hash every time (int, string, .. not slices, maps and function) #### Declare
We can use map function or literal maps

 // Declare use map function
maps := make(map[string]int) # map with string key and int value
// Declare use maps literal
dict := map[string]int{"a": 1, "b": 2}

Working with maps

A nil map can't use to store key/value pairs, but zero map can use.
Get value of key in maps can return two value: value and flag exists key. When key exists, it return value and True, but when key not exists, value return zero values of map value and False for flag exists key.

value, exists := maps["key"]

We can assign a key/value pair to maps by : maps[key] = value
We can remove a key/value pair in maps by: delete(maps, key), and if key is not exists, it will not raise any error.
Iterate maps return key and value for each pair

 for key, value := range maps

Passing maps between functions

Maps are pass by value. However, the copied hash value still refers to underlying hash table, so modify maps in function also make caller maps.

So this is some main point I learn about arrays, slices and maps in Go. I feel they quite similar concept in Python, but have some new concepts about capacity of underlying arrays.
Thank you for take time to read my blog. Good luck for your journey!

Golang Day 1: Introduce

Thành Đoàn Nhật — Sun, 07 Jun 2026 05:13:56 +0000

Today, I started learning Go(Golang), and I want to note down some key concepts that I think are important to understand and remember.
Since this is based on my current understanding, there may be mistakes. If you notice any, please leave a comment, I would really appreciate your feedback.

When I was looking at backend developer job postings, I noticed that Go is frequently listed as a required or preferred programming language. This is true for both startups or well-established technology companies. That led me to a question: Why do so many developers choose Go for new projects?
After researching various resources and books, I found that Go has become increasingly popular because it addresses modern software development challenges.
When choosing a programming language for new project, there are usually trade-offs between development speed (such as Python), execution performance (such as C or C++) and team familiarity.
Go sits somewhere in the middle of these competing priorities by offering both rapid development and strong performance.

Here are some features that I believe contribute to Go's growth in the software industry.

Concise syntax: Go has simple and concise syntax with relatively few keywords to learn. Because of this, new developers can become productive quickly and focus more in solving problems rather than learning complex language features.
Fast compilation: Go's compiler is known for its speed. Instead of waiting a long time for a project compile, especially in large codebases, developers can build and test their applications quickly. This helps improve productivity and shortens the development feedback loop.
Efficient Resource Utilization: Go can efficiently utilize modern hardware resources because it has built-in support for concurrency. Go provides gorountines, which are lightweight thread managed by the Go runtime. Goroutines requires significantly less memory than operating system threads, and it easy to create and manage. Go also provides channels, which allow goroutines to communicate safely. Channels helps reduce the complexity of sharing data between concurrent tasks and can prevent some common synchronization issues.
Garbage Collection: Go includes a garbage collector, which automatically manages memory allocation and deallocation. This significantly reduces the risk of memory-related problems and allows developers to focus more on business logics. Although garbage collection introduces some runtime overhead, it is often acceptable trade-off for improved productivity and reliability. I once experienced application crashes in C++ due to management memory mistakes, so I personally find this trade-off worthwhile.

There are some of the main reasons I found while researching why Go has become popular in software industry. It combines ease of development, good performance and strong support for concurrent programing, making it a compelling choice for many backend systems or cloud-native applications.
If I have misunderstood anything or you have additional insights, please leave a comment. I would greatly appreciate for your feedback.
Thank you for taking the time to read my blog, and good luck on your learning journey!

First blog: My journey was started

Thành Đoàn Nhật — Fri, 05 Jun 2026 07:47:24 +0000

Hello everyone, my name is Ethan and I from Vietnam. I am a Backend Engineer with over 5 years of experience, mainly developing with Python and hand-on Golang in about 1 year. I focus on developing and building scalable and distributed system using FastAPI, Flask and Sanic. I worked with event-drivent architecure using Kafka and Pulsar to handle message queue. I know use Redis, PostgreSQL, MySQL, MongoDB,… I am interested with AI-power or Intelligence System, so I have skills about AI, Machine Learning (I am actually train model myself) and have knowledge of AI, include embedding, training, score, evaluation,…

Recently, I am looking for a new opportunity for Backend or AI Engineer in Ho Chi Minh City but that have some difficulties. I see that the IT market is highly competitive, thanks for the rapid growth of AI technologies, and impact from downly economic in the world. So I build that blog to improve my skills include technical skills (I think i will learn Golang seriously) and English skills (I really want to work in international environment to explore my mind, not just my eye).

Because my english is weak, I very appreciate with people help me to fix and improve it, although i know that my words are terrible, sometime not right meaning, but I think that the best way to improve these skill is practice and practice.

Thanks for you to read my first blog, good luck to you!

*** If you have any questions about me or my beautiful country - Vietnam, you can contact me by email: dnthanh0207@gmail.com