DEV Community: Adetola Esther Aderibigbe

Data Structures in Go[Maps]

Adetola Esther Aderibigbe — Fri, 06 Nov 2026 17:20:25 +0000

Introduction to Maps

A map is a built in Go data structure that stores information as key value pairs.

Unlike arrays and slices, where elements are accessed using their positions (indexes), values in a map are accessed using their keys.

Every entry in a Go map consists of two things:

Key: An identifier used to find an entry in the map.
Value: The information associated with that key.

For example, imagine storing information about a user. We could use the user's name and email as key value pairs.

user := map[string]string{
    "name":  "Adetola",
    "email": "adetola@yopmail.com",
}

syntax

The general syntax for declaring a map is:

map[keyType]valueType

In our example:

map[string]string

map tells Go that we are declaring a map.
The first string specifies the data type of the keys.
The second string specifies the data type of the values.

This means we have a map where both the keys and values are strings.

Can keys and values have different data types?

Yes. The key and value types do not have to be the same.

ages := map[string]int{
    "Adetola": 25,
    "Tobi":    30,
}

Here, the keys are strings, while the values are integers.

Other possible combinations include:

map[int]string
map[string]bool
map[string]float64

However, all keys in a particular map must have the same type, and all values must have the same type.

Key takeaway: A Go map stores data in key-value pairs. Unlike arrays and slices, we use keys rather than indexes to access its values. The key and value types can be different, but each must remain consistent throughout the map.

Declaring and Initialising Maps

There are several ways to create a map in Go.

1. Using a map literal

A map literal is useful when you already know the entries you want to store. The map is created and populated with values immediately.

userAges := map[string]int{
    "Ade":  25,
    "Tola": 30,
}

Here:

userAges is the variable name.
map[string]int declares a map with string keys and integer values.
"Ade" and "Tola" are the keys.
25 and 30 are their corresponding values.

A map literal allows us to create and populate a map in one step.

2. Using make()

The built-in make() function is used when you want to create an empty map and add entries later.

userAges := make(map[string]int)

This creates an initialized, empty map that is ready to receive entries.

userAges := make(map[string]int)

userAges["Ade"] = 25
userAges["Tola"] = 30

fmt.Println(userAges)

Output:

map[Ade:25 Tola:30]

You can also provide an optional initial capacity hint:

userAges := make(map[string]int, 10)

This tells Go that you expect the map to hold approximately 10 entries. It does not limit the map to 10 entries.

3. Declaring a map without initialising it

You can declare a map without initialising it.

var userAges map[string]int

This creates a nil map. A nil map can be read from, and its length can be checked, but you cannot add entries to it.

var userAges map[string]int

fmt.Println(userAges["Ade"]) // 0
fmt.Println(len(userAges))   // 0

However, attempting to add an entry causes a runtime panic.

var userAges map[string]int

userAges["Ade"] = 25 // Runtime panic

Why?

Because the map has been declared but not initialised. It does not have an underlying map structure ready to store entries. To add entries, initialise it first using either a map literal or make().

Key distinction: var userAges map[string]int creates a nil map, while make(map[string]int) creates an initialized, empty map.

Both initially have zero entries, but only the initialized map can accept new entries.

Adding and Updating Values in a Map

Go uses the same syntax to add a new entry and update an existing entry.

The general syntax is:

mapName[key] = value

1. Adding a new entry

When the key does not already exist, Go creates a new entry.

userAges := make(map[string]int)

userAges["Ade"] = 25
userAges["Tola"] = 30

fmt.Println(userAges)

Output:

map[Ade:25 Tola:30]

The first assignment creates an entry with the key "Ade" and value 25 and the second assignment creates another entry with the key "Tola" and value 30.

2. Updating an existing entry

When the key already exists, assigning a new value updates the existing entry.

userAges := map[string]int{
    "Ade":  25,
    "Tola": 30,
}

userAges["Ade"] = 26

fmt.Println(userAges)

Output:

map[Ade:26 Tola:30]

Notice that "Ade" originally had a value of 25. After the assignment, its value becomes 26.

Go does not create another "Ade" entry. It updates the existing one.

Key takeaway: The assignment syntax is the same for adding and updating. Go checks whether the key already exists and either creates a new entry or replaces the existing value.

Accessing Values in a Map

To retrieve a value from a map, you use its key. The syntax is:

mapName[key]

userAges := map[string]int{
    "Ade":  25,
    "Tola": 30,
}

fmt.Println(userAges["Ade"])

Output:

Go looks for the key "Ade" and returns the value associated with it.

What happens when a key does not exist?

If you try to access a key that does not exist, Go returns the zero value of the map's value type.

For example:

userAges := map[string]int{
    "Ade": 25,
}

fmt.Println(userAges["Tola"])

Output:

Because the value type is int, Go returns the integer zero.

Other examples:

Map type	Zero value for a missing key
`map[string]int`	`0`
`map[string]string`	`""`
`map[string]bool`	`false`
`map[string]float64`	`0.0`

However, this creates a problem like what if a key does not exist, but another key exists with an actual value of 0?, How do we distinguish between the two?

Go solves this using the comma-ok idiom.

Checking Whether a Key Exists (Comma-OK Idiom)

Go allows you to retrieve a value and check whether its key exists at the same time.

Example:

userAges := map[string]int{
    "Ade":  25,
    "Tola": 30,
}

age, exists := userAges["Ade"]

if exists {
    fmt.Println("Age:", age)
} else {
    fmt.Println("User not found")
}

Output:

Age: 25

Let's break this down:

age, exists := userAges["Ade"]

Go returns two values:

age: The value associated with the key.
exists: A boolean indicating whether the key exists in the map.

If the key exists, exists is true.

If the key does not exist, exists is false.

Let's look at another example:

age, exists := userAges["Femi"]

if exists {
    fmt.Println("Age:", age)
} else {
    fmt.Println("User not found")
}

Output:

User not found

Even though Go returns the zero value for a missing key, the exists variable tells us that the key was not found.

This is particularly useful when working with user records, configuration, permissions, and other data where knowing whether an entry exists matters.

It is called the comma-ok idiom because of the two-value assignment used to check the result.

Deleting Entries from a Map

Go has a built-in function called delete() for removing entries from a map.

Syntax:

delete(mapName, key)
userAges := map[string]int{
    "Ade":  25,
    "Tola": 30,
    "Femi": 28,
}

delete(userAges, "Tola")

fmt.Println(userAges)

Output:

map[Ade:25 Femi:28]

The delete() function removes the entry associated with the specified key.

A few things to remember:

Deleting an existing key removes its entry.
Deleting a key that does not exist does nothing.
delete() does not return a value.
Calling delete() on a nil map is safe and does nothing.

Getting the Number of Entries in a Map

You can use the built-in len() function to find out how many entries a map contains.

Example:

userAges := map[string]int{
    "Ade":  26,
    "Tola": 30,
    "Femi": 28,
}

fmt.Println(len(userAges))

Output:

The len() function returns the number of key-value pairs currently stored in the map.

Unlike an array, a map does not have a fixed number of entries. Its length changes as you add or delete entries.

For example:

userAges := make(map[string]int)

fmt.Println(len(userAges)) // 0

userAges["Ade"] = 26
userAges["Tola"] = 30

fmt.Println(len(userAges)) // 2

delete(userAges, "Ade")

fmt.Println(len(userAges)) // 1

Iterating Over a Map

Sometimes you don't want to retrieve just one value. You want to go through every entry in a map.

Go uses the range keyword to iterate over maps.

userAges := map[string]int{
    "Ade":  25,
    "Tola": 30,
    "Femi": 28,
}

for name, age := range userAges {
    fmt.Println(name, age)
}

Possible output:

Ade 25
Tola 30
Femi 28

The output order may be different when you run the program.

for name, age := range userAges {

for starts the loop.
range allows us to iterate over the map.
userAges is the map we want to iterate through.
name receives the key from each entry.
age receives the corresponding value.

For every entry in the map, Go assigns its key to name and its value to age.

The loop then executes the code inside its body.

fmt.Println(name, age)

This prints the key and its corresponding value.

Important: Map iteration order

Go does not guarantee the order in which map entries are returned during iteration. This means you should not rely on a map to preserve the order in which entries were inserted.
If you need a specific order, you must collect the keys and sort them before iterating.

Important Characteristics of Go Maps

A. Map keys must be comparable

Go requires map keys to be types that can be compared using the == operator.

Common valid key types include:

Strings
Integers
Floating-point numbers
Booleans
Pointers
Arrays whose element types are comparable
Structs whose fields are all comparable

Slices, maps, and functions cannot be used directly as map keys.

For example:

// Valid
ages := map[string]int{}

// Invalid
// users := map[[]int]string{}

Why? Because slices cannot be compared using == in Go.

This restriction exists because Go needs to be able to compare keys when storing and retrieving map entries.

B. Maps are reference like types

When you assign a map to another variable, Go does not create an independent copy of all its entries.

Both variables refer to the same underlying map data.

Example:

first := map[string]int{
    "Adetola": 25,
}

second := first

second["Adetola"] = 30

fmt.Println(first["Adetola"])  // 30
fmt.Println(second["Adetola"]) // 30

Notice that changing the value through second also affects what we see through first.

This is different from arrays, where assigning one array to another copies the entire array.

C. A map is not safe for concurrent writes by default

If multiple goroutines access a map concurrently and at least one of them writes to it, you need synchronization.

Ordinary Go maps are not automatically safe for concurrent writes.

We'll explore goroutines, concurrency, and synchronization later in your Go learning journey.

For now, remember that when multiple goroutines need to modify the same map, you must protect those operations appropriately.

Go Maps vs JavaScript Objects

Since you already know JavaScript, let's connect the concepts. In JavaScript, you might represent the same information using an object:

const userAges = {
    Adetola: 25,
    Tobi: 30,
};

console.log(userAges.Adetola);

In Go:

userAges := map[string]int{
    "Adetola": 25,
    "Tobi":    30,
}

fmt.Println(userAges["Adetola"])

They can serve similar purposes, but they are not exactly the same.

Feature	Go map	JavaScript object
Structure	Key-value pairs	Properties and values
Key types	One declared comparable type	Strings or symbols
Value types	One declared value type	Can hold different types
Access	`users["Adetola"]`	`users.Adetola`
Add/update	`users["name"] = value`	`users.name = value`
Delete	`delete(users, "name")`	`delete users.name`
Missing key	Returns zero value; comma-ok checks existence	Returns `undefined`
Iteration	`for range`	`for...in`, `Object.keys()`

JavaScript also has a built-in Map

JavaScript's Map object is another useful comparison to Go maps.

const ages = new Map();

ages.set("Adetola", 25);
ages.set("Tobi", 30);

console.log(ages.get("Adetola"));

JavaScript's Map supports keys of different types, while a Go map has one declared key type.

For example, JavaScript can do this:

const example = new Map();

example.set("name", "Adetola");
example.set(25, "age");
example.set(true, "active");

Go requires all keys in a particular map to have the same declared type.

Practical Example: User Lookup

Imagine you're building a backend service and need to look up a user's account balance using their user ID.

A map can help you associate each user ID with a corresponding balance.

balances := map[string]float64{
    "USER-001": 15000.50,
    "USER-002": 25000.00,
    "USER-003": 8000.75,
}

balance, exists := balances["USER-001"]

if exists {
    fmt.Println("Account balance:", balance)
} else {
    fmt.Println("Account not found")
}

Output:

Account balance: 15000.5

This is a practical use of maps: you have an identifier and need to retrieve its associated information.

Notice that:

The keys are strings because the user IDs are strings.
The values are float64 because the balances contain decimal values.
The comma-ok idiom checks whether the requested user ID exists.

This is a simplified example. In production financial systems, monetary values generally require more careful representation than ordinary floating-point numbers.

Lesson Takeaways

These are the points worth keeping in your study notes.

A map is a built-in Go data structure that stores data as key-value pairs.
A map is declared using map[keyType]valueType.
Keys and values can have different types, but each type must remain consistent within its map.
Map keys must be comparable. Slices, maps, and functions cannot be used directly as keys.
You can initialise a map using a map literal or make().
A nil map can be read from but cannot be used to add entries.
Use mapName[key] = value to add or update an entry.
Use mapName[key] to retrieve a value.
A missing key returns the zero value of the map's value type.
Use value, exists := mapName[key] to check whether a key exists. This is the comma-ok idiom.
Use delete(mapName, key) to remove an entry.
Use len(mapName) to get the number of entries.
Use for range to iterate over a map.
Map iteration order is not guaranteed.
Assigning a map to another variable does not create an independent copy; both variables refer to the same map data.
Ordinary Go maps are not safe for concurrent writes without synchronization.

map[string]int means string keys and integer values.
value, exists := myMap[key] lets you distinguish a missing key from a key containing a zero value.
Maps are useful when you need to retrieve information using an identifier rather than a numerical position.

Data Structures in Go[Arrays and Slices]

Adetola Esther Aderibigbe — Fri, 06 Nov 2026 15:46:15 +0000

Introduction: Why Do We Need Data Structures?

So far, we've covered the foundations of Go, including variables, data types, operators, conditional statements, loops, and functions.

These concepts give us the building blocks we need to write Go programs. However, as we begin building more practical applications, we'll encounter a new challenge such as working with large amounts of data.

Think about an application that manages users, processes transactions, stores product information, or tracks customer records.

We won't always be working with a single value at a time. We'll often need to store, organise, access, modify, and manipulate collections of related data. For example:

A banking application might need to store multiple customer account balances.
An e-commerce application might need to manage a collection of products. Storing each value in a separate variable would quickly become impractical and difficult to manage. This is where data structures come in.

Data structures are ways of organising and storing data in a program so that we can access, manage, and manipulate it efficiently.

Go provides several built-in data structures and mechanisms that help us work with collections of data.

In this module, we'll explore four important concepts:

Arrays and Slices: Used to store collections of values of the same type.
Maps: Used to store data as key-value pairs.
Structs: Used to group related values, potentially of different types, into a single custom data type.
Pointers: Used to store and work with the memory address of another value.

We'll begin with arrays, slices, and maps before moving on to structs and pointers.

Arrays and Slices in Go

In Go, arrays and slices are data structures that consist of an ordered sequence of elements. They are useful when we want to work with multiple related values, as they allow us to keep data that belongs together in a single variable and perform similar operations on multiple values at once.

Coming from a JavaScript background, I'd assume most of us are already familiar with arrays and how they work. However, Go approaches arrays and slices a little differently, so I'd still love to go over them again.

Although both are used to store multiple values of the same data type in a single variable, the major difference between them is their length.

An array has a fixed length, meaning the number of elements it can contain is determined when it is created and cannot be changed.

A slice, on the other hand, is flexible. Its length can change as we add or remove elements, making it more convenient when working with collections of data that may grow or shrink over time.

We'll explore both concepts, how to define and initialise them, how to access and manipulate their elements, and the differences between them.

Defining an Array

An array is a collection of elements of the same data type with a fixed length. The length is part of its type.

In Go, arrays are defined by specifying the size (length) of the array inside square brackets[], followed by the data type of its elements.

Syntax:

var numbers [3]int

var - Keyword used to declare a variable.
numbers - Variable name.
[3]- Length of the array (number of elements it can hold).
int - Data type of the elements stored in the array.

Important to note:

Once an array has been declared, its length cannot be changed. However, its elements can be modified, and we can also initialise an array with values.
it's important to understand that an array's length is part of its type. This is one of the major differences between arrays in Go and arrays in JavaScript.

var first [2]int
var second [3]int

Although both arrays contain integers, they have different types.

first has the type [2]int (an array of 2 integers).
second has the type [3]int (an array of 3 integers).

Because their lengths are different, their types are also different.

This means you cannot assign one array to the other or compare them directly as though they were the same type.

Important to note:

Array length is part of its type.
Arrays of different lengths are different types.
Arrays of the same type can be compared, provided their element type is comparable.

Declaring and Initialising Arrays

There are several ways to declare and initialise an array in Go.

1. Declaring an Array Without Specifying Initial Values

We can declare an array without providing any initial values.

var numbers [3]int

fmt.Println(numbers)

Output:

[0 0 0]

This creates an array with three integer elements and since we haven't provided any initial values, Go automatically initialises each element with the zero value of its respective data type.

For integers (int), the zero value is 0.

This behaviour also applies to other data types.

var names [3]string

fmt.Println(names)

Output:

[  ]

For strings, the zero value is an empty string (""). When printed as part of an array, the empty strings appear as blank spaces between the brackets.
This is an important characteristic of Go. When variables are declared without explicit initial values, Go automatically assigns them their respective zero values. Arrays follow this rule element by element.

2. Initialising an Array With Explicit Values

We can also provide initial values when declaring an array.

score := [3]int{85, 90, 95}

fmt.Println(score)

Output:

[85 90 95]

Here, we are declaring and initialising an array called score with three integer values. The values are assigned in order, starting from index 0.

Index	Value
0	85
1	90
2	95

The syntax consists of three main parts:

The array's length: [3]
The data type: int
The initial values: {85, 90, 95}

3. Specifying the Length but Providing Fewer Initial Values

Go also allows us to initialise an array with fewer values than its declared length.

numbers := [4]int{10, 20}

fmt.Println(numbers)

Output:

[10 20 0 0]

Here, we've declared an array called numbers with a length of four, but we've only provided two initial values. What happens?

The first element (index 0) receives 10.
The second element (index 1) receives 20.
The third element (index 2) receives the zero value, 0.
The fourth element (index 3) also receives the zero value, 0.

The remaining elements are automatically initialised with the zero value of their data type.Even though we provided only two initial values, the array still has a length of four which does not change because the length was already specified during declaration.

4. Allowing Go to Infer the Array Length

Go provides the ... notation for array literals when we want the compiler to determine the array's length automatically. Instead of manually specifying the number of elements, we allow Go to count the initial values and determine the length.

numbers := [...]int{10, 20, 30, 40}

fmt.Println(numbers)

Output:

[10 20 30 40]

Here, we've used ... instead of explicitly specifying the array's length.

Go counts the number of initial values and infers the array's type as [4]int.

It’s important to know that the ... notation does not mean that the array has a variable length, it simply tells the compiler to determine the array's length from the number of initial values provided. Once the array has been initialised, its length is fixed.

Go vs JavaScript: Array Initialisation

Coming from a JavaScript background, let's look at how array initialisation differs in both languages.

JavaScript:

const numbers = [10, 20];

numbers.push(30);

console.log(numbers);

Output:

[10, 20, 30]

In JavaScript, we can initialise an array with two elements and use the push() method to add another element.

The array grows from two elements to three.

Go:

numbers := [4]int{10, 20}
fmt.Println(numbers)

Output:

[10 20 0 0]

In Go, we've declared an array with a length of four, even though we've only provided two initial values.

The remaining two elements are automatically assigned their zero values.

The main difference is that Go arrays have a fixed length, whereas JavaScript arrays can grow or shrink as elements are added or removed.

To create a Go collection that can grow dynamically, we typically use slices, which we'll explore later.

Lesson Takeaway

The length of an array is part of its type in Go.
Go automatically assigns zero values to elements that aren't explicitly initialised.
You can initialise an array with fewer values than its declared length.
The ... notation allows Go to infer the array's length.
Array elements can be modified, but the array's length cannot be changed.

Finding the Length of an Array Using `len()`

Go provides a built-in function called len() that allows us to obtain the number of elements in an array or slice. This returns the total number of elements, not the highest index.

numbers := [3]int{20, 30, 40}

fmt.Println(len(numbers))

Although the array's highest index is 2, its length is 3 because it contains three elements.

Go vs JavaScript: Finding Array Length

In JavaScript, we use the .length property to determine the number of elements in an array.

JavaScript:

const numbers = [10, 20, 30, 40];

console.log(numbers.length);

Output:

Go:

numbers := [4]int{10, 20, 30, 40}

fmt.Println(len(numbers))

Output:

The difference is simply how both languages provide access to the length:

JavaScript uses the .length property.
Go uses the built-in len() function.

Why is `len()` important?

The len() function is frequently used when working with arrays and slices, particularly when iterating through their elements using loops. It allows us to determine the number of elements we need to work with without manually counting them.

Array Assignments in Go

One of the important differences between arrays in Go and JavaScript is how they behave when assigned to another variable.

In Go, arrays are value types. This means that when we assign an array to another variable, Go copies the entire array, including all its elements.The two variables now hold separate copies of the array meaning modifying one does not affect the other.

first := [3]int{10, 20, 30}

second := first

second[0] = 90

fmt.Println(first)
fmt.Println(second)

Output:

[10 20 30]
[90 20 30]

Let's break down what's happening:

We declare an array called first containing three integers.
We create another variable called second and assign first to it.
Go copies all the elements of first into second.
We modify the element at index 0 of second, changing its value from 10 to 90.
When we print both arrays, we see that first remains unchanged while second contains the modified value.

This happens because both variables hold separate copies of the array.

Go vs JavaScript: Array Assignment

JavaScript handles array assignment differently. In JavaScript, arrays are reference types. Assigning an array to another variable copies the reference to the same underlying array object, rather than creating an independent copy.

const first = [10, 20, 30];

const second = first;

second[0] = 90;

console.log(first);
console.log(second);

Output:

[90, 20, 30]
[90, 20, 30]

Notice that modifying second also affects first, This happens because both variables refer to the same array object in memory.

Go	JavaScript
Arrays are value types.	Arrays are reference types.
Assigning an array copies its elements.	Assigning an array copies its reference.
Each variable holds an independent array copy.	Both variables can refer to the same array object.
Modifying one copy does not affect the other.	Modifying the shared array affects both references.

This value-copying behaviour also applies when passing arrays to functions in Go. When an array is passed as an argument to a function, the function receives a copy of the array.

This means that even if the function modifies an element, the original array outside the function remains unchanged. We'll explore this behaviour further when we get into functions and pointers.

Why Are Arrays Less Common Than Slices in Go?

Although arrays are useful in Go, they are less commonly used than slices in everyday application development. The main reason is their fixed length.
In real-world applications, the amount of data we work with can change frequently. For example:

The number of users in an application can increase or decrease.
The number of products in an online store can change.
The number of transactions processed by a banking application can vary.
The number of records returned from an API can change depending on the request.

Arrays are not particularly convenient for these situations because their length cannot be changed after declaration. Slices, on the other hand, provide more flexibility because their length can grow or shrink as needed.

So When Should We Use Arrays?

Arrays are still useful, particularly when we know the exact number of elements we need and that number is not expected to change.

For example:

Storing the RGB values of a colour (three integers).
Representing a fixed number of coordinates.
Working with fixed-size cryptographic keys.
Storing a fixed set of measurements. Takeaway
Use arrays when a fixed size is an intentional requirement.
Use slices for most collections where the number of elements may grow, shrink, or change over time.

Slices in Go

Defining Slices

A slice is a flexible, dynamically sized sequence of elements that describes a section of an underlying array. We can also think of a slice as a dynamic array because, unlike arrays, its length can grow or shrink as needed.
However, it's important to understand that a slice itself is not an underlying array. A slice is a value that describes a portion of an array that it exposes.
A slice provides access to a section of an underlying array, and multiple slices can refer to the same underlying array, this means that different slices can share the same underlying data. Changes made through one slice can affect what another slice sees if they refer to the same elements.

Slice Syntax

collection[start:end]

collection: The array or slice we want to extract elements from.
start: The index where the slice begins. This index is inclusive.
end: The index where the slice stops. This index is exclusive. The start index is included in the resulting slice, while the end index is excluded.

numbers := [5]int{10, 20, 30, 40, 50}

Now, let's create a slice called middle from this array:

middle := numbers[1:4]

fmt.Println(middle)

Output:

[20 30 40]

Our original array contains five elements so when we write:

middle := numbers[1:4]

We're extracting a section of the original array, starting at index 1 and stopping before index 4.
This means:

Index 1 is included (value: 20).
Index 2 is included (value: 30).
Index 3 is included (value: 40).
Index 4 is excluded (value: 50).

The resulting slice contains [20 30 40].

Declaring and Initialising Slices

There are several ways to declare and initialise slices in Go. Let's explore them.

1. Declaring a Slice Without Initialising It:

We can declare a slice without providing any initial values.

var numbers []int

This declares a slice of integers but unlike arrays, there is no fixed length included in the declaration.
However, there is an important distinction between declaring a slice and allowing Go to infer the length of an array. Although the declarations might look similar, they behave differently.

A newly declared slice without an initial value is a nil slice. A nil slice has:

Length of 0.
Capacity of 0.
No underlying array currently associated with it. We can verify this using the len() and cap() functions.

var numbers []int

fmt.Println(numbers)
fmt.Println(len(numbers))
fmt.Println(cap(numbers))

Output:

[]
0
0

Even though the slice has no elements, we can still add elements to it using the append() function.

var numbers []int
numbers = append(numbers, 10, 20)
fmt.Println(numbers)

Output:

[10 20]

This works because append() returns a slice value containing the added elements, which we assign back to numbers. It’s also important to not that a nil slice is not the same as an array containing zero values.

var numbers [3]int

fmt.Println(numbers)

Output:

[0 0 0]

This array contains three elements, even though all three elements have the zero value of int. However:

var numbers []int

fmt.Println(numbers)

Output:

[]

This slice contains no elements. The difference is that an array has a fixed number of elements, while a nil slice has a length and capacity of zero.

2. Initialising a Slice Using a Slice Literal

Another way to create a slice is by using a slice literal. A slice literal looks similar to an array literal, except that we omit the length inside the square brackets.

numbers := []int{10, 20, 30}

fmt.Println(numbers)

Output:

[10 20 30]

This creates a slice containing three integers but lrt's notice the difference

// Array
numbers := [3]int{10, 20, 30}

// Slice
numbers := []int{10, 20, 30}

For an array, we specify the length inside the brackets while for a slice, we leave the brackets empty. The type of our slice is []int, not [3]int.
We can also initialise slices containing other data types.

String slice:

names := []string{"John", "Mary", "Peter"}

Boolean slice:

status := []bool{true, false, true}

Floating-point slice:

prices := []float64{10.5, 20.5, 30.5}

Just like arrays, all elements in a slice must have the same data type.

3. Creating a Slice Using `make()`

Go provides a built-in function called make() that allows us to create and initialise slices with a specified length and optional capacity.
syntax:

make([]T, length)

Where:

make: The built-in function used to create the slice.
[]T: Specifies the slice's data type.
length: Specifies the initial number of elements in the slice.

numbers := make([]int, 3)

fmt.Println(numbers)

Output:

[0 0 0]

This creates a slice of integers with a length of three with all three elements initially assigned the zero value of int, which is 0. We can then assign values to individual elements using their indices.

numbers := make([]int, 3)
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30

fmt.Println(numbers)

Output:

[10 20 30]

The make() function is useful when we know how many elements we want to work with from the beginning, but we don't necessarily have their actual values yet.

4. Creating a Slice With a Specified Capacity

We can also provide a capacity when creating a slice using make().

syntax:

make([]T, length, capacity)

[]T: Specifies the slice's data type.
length: Specifies the number of elements the slice currently contains.
capacity: Specifies the maximum number of elements the slice can hold before needing a larger underlying array.

numbers := make([]int, 3, 5)
fmt.Println(numbers)
fmt.Println(len(numbers))
fmt.Println(cap(numbers))

Output:

[0 0 0]
3
5

This creates a slice of integers with Length: 3, Capacity: 5, with the slice currently containing three elements, all initialised to zero. However, its underlying array has room for five elements.

Understanding Length vs Capacity

This is an important distinction when working with slices.

Length (len) refers to the number of elements currently contained in the slice.

Capacity (cap) refers to the number of elements between the beginning of the slice and the end of its underlying array.

numbers := make([]int, 3, 4)

The slice has three elements, but its capacity is four, it's important to note that capacity does not mean the slice already contains five elements, It currently contains only three elements.
To access an element directly using its index, that index must be within the slice's current length, not merely within its capacity.

numbers[3] = 40

This would cause an index out of range panic because the slice's current length is three, and its valid indices are 0, 1, and 2. To add a fourth element, we use `append()

`go
numbers := make([]int, 3, 4)

numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers = append(numbers, 40)
fmt.Println(numbers)
fmt.Println(len(numbers))
fmt.Println(cap(numbers))
`

Output:

`plaintext
[10 20 30 40]
4
4

`
Notice what happened, Initially the slice had a length of 3 and capacity of 5.

We used append() to add another element.
The length increased from 3 to 4.
The capacity remained 5 with enough room to still grow.

This is how we can add elements to a slice without directly accessing an index outside its current length.

Shared Underlying Arrays

When you create a slice from an array, the slice does not create an independent copy of the selected elements. Instead, it refers to the relevant portion of the original array. Let's look at an example:
`go
numbers := [5]int{10, 20, 30, 40, 50}

middle := numbers[1:4]

fmt.Println(numbers) // [10 20 30 40 50]
fmt.Println(middle) // [20 30 40]
`

The original array still contains all five elements:

Index	0	1	2	3	4
Value	10	20	30	40	50

The slice middle starts at index 1 and ends before index 4. Therefore, it contains the values at indexes 1, 2 and 3: 20, 30, 40.
What happens when we modify the slice?
We can modify an element through the slice:

`go
middle[0] = 99

fmt.Println(numbers) // [10 99 30 40 50]
fmt.Println(middle) // [99 30 40]
`

Notice that changing middle[0] also changes numbers[1].

This happens because middle[0] refers to the same underlying array element as numbers[1]. The slice is not an independent copy.

Multiple Slices Can Share One Underlying Array

More than one slice can refer to different portions of the same underlying array. If those portions overlap, changes made through one slice can be visible through the other.

`go
numbers := [5]int{10, 20, 30, 40, 50}

first := numbers[0:3]
second := numbers[2:5]

fmt.Println(first) // [10 20 30]
fmt.Println(second) // [30 40 50]
`

Both slices include the element at index 2, which has the value 30, Let's modify the elements through the slices:

`go
first[1] = 28
first[2] = 29
second[2] = 45

fmt.Println(numbers) // [10 28 29 40 45]
fmt.Println(first) // [10 28 29]
fmt.Println(second) // [29 40 45]
`

first[1] = 28 changed numbers[1].
first[2] = 29 changed numbers[2], which is also visible through second[0].
second[2] = 45 changed numbers[4].

Even though first and second are distinct slice values, they share the same underlying array. It’s important to note that When multiple slices share an underlying array, modifying an element through one slice can affect the other slices if they refer to that same element.

You can read more about this in the official Go blog article,

Slice Length and Capacity

Every slice has two important properties:

Length (`len`): The length is the number of elements currently accessible through a slice. You can get it using Go's built-in `len()` function.

Capacity (`cap`): The capacity is the number of elements from the slice's starting position to the end of its underlying array. You can get it using Go's built-in `cap()` function.

Capacity is always greater than or equal to length.

The difference is:

len() tells you how many elements are currently part of the slice.
cap() tells you how much space is available in the underlying array from the slice's starting position.

go numbers := make([]int, 2, 5) fmt.Println(numbers) // [0 0] fmt.Println(len(numbers)) // 2 fmt.Println(cap(numbers)) // 5

[]int means we are creating a slice of integers.
2 is the length.
5 is the capacity.

The slice currently has two elements, both initialised to their zero value (0) and although its capacity is five, only two elements are currently accessible through the slice. We can still assign values to the existing elements

`go
numbers[0] = 10
numbers[1] = 20

fmt.Println(numbers) // [10 20]
`

Both assignments are valid because indexes 0 and 1 are within the current length of the slice.
However, this would cause a runtime panic:

javascript numbers[2] = 30

Why?
Because the slice's length is currently 2, meaning its valid indexes are 0 and 1 and even though the capacity is 5, index 2 is not yet part of the slice's accessible elements.

Capacity does not give you permission to access elements beyond the current length.

To make the slice longer, we need to use append().

go numbers = append(numbers, 30) fmt.Println(numbers) // [10 20 30] fmt.Println(len(numbers)) // 3 fmt.Println(cap(numbers)) // 5

The append() function adds an element to the slice and returns the updated slice. We assign the result back to numbers.

The length increases from 2 to 3, while the capacity remains 5 because there is still room in the underlying array.

Lesson Takeaway

len() tells you how many elements you can access in the slice right now.
cap() tells you how much room is available from the slice's starting position to the end of its underlying array.
You cannot access elements using an index beyond the current length, even if the capacity allows room for more elements.
Use append() to grow a slice.

Adding Elements to Slices with `append()`

We've already seen that slices can grow beyond their initial length. Go provides a built-in function called append() to add elements to a slice.

The append() function:

Adds one or more elements to an existing slice.
Returns a new slice value representing the result.
Does not necessarily create a new underlying array.

1. Appending a Single Element

Syntax:

go slice = append(slice, value)
Let's look at an example:

`go
numbers := []int{10, 20, 30}

numbers = append(numbers, 40)

fmt.Println(numbers) // [10 20 30 40]
`

Here is what happens:

We create a slice called numbers containing 10, 20, 30.
We call append(numbers, 40) to add 40.
append() returns the resulting slice.
We assign the returned slice back to numbers.

Why do we assign the result back?
Because append() returns a slice value. It does not simply modify the existing slice variable in place. This is why we write:

go numbers = append(numbers, 40)
Rather than just:

python append(numbers, 40)

2. Appending Multiple Elements

You can append more than one element in a single operation.

`go
numbers := []int{10, 20}

numbers = append(numbers, 30, 40, 50)

fmt.Println(numbers) // [10 20 30 40 50]
`

Here, we added three elements (30, 40 and 50) in one append() operation.

3. Appending One Slice to Another

You can also append the elements of one slice to another.

To do this, Go uses the ... operator.

Example:

`go
first := []int{10, 20, 30}
second := []int{40, 50}

first = append(first, second...)

fmt.Println(first) // [10 20 30 40 50]
`

The ... operator expands the elements of second so that they can be passed as individual arguments to append().

Without ..., Go would try to append the entire second slice as one element, which would cause a type error because first is a slice of integers, not a slice of slices.

4. Does append() Always Create a New Underlying Array?

No, This is an important part of understanding how slices work, Let’s remember every slice has a length and a capacity. So when you append elements, Go checks whether the underlying array has enough remaining capacity.
There are two possible scenarios:

Scenario A: There is sufficient capacity

If the underlying array has enough capacity, Go reuses the existing array.

`go
numbers := make([]int, 2, 5)
numbers[0] = 10
numbers[1] = 20

numbers = append(numbers, 30)

fmt.Println(numbers) // [10 20 30]
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // 5
`
Initially:

Length = 2
Capacity = 5 After appending 30:
Length = 3
Capacity = 5

Since the underlying array has enough capacity, Go can reuse it without allocating a new one.

Scenario B: There is insufficient capacity

If the underlying array does not have enough capacity, Go allocates a new underlying array with sufficient capacity and copies the existing elements into it.

`go
numbers := make([]int, 2, 2)

numbers[0] = 10
numbers[1] = 20

numbers = append(numbers, 30)

fmt.Println(numbers) // [10 20 30]
fmt.Println(len(numbers)) // 3
fmt.Println(cap(numbers)) // At least 3
`

Initially:

Length = 2
Capacity = 2

When we append 30, the slice needs to grow beyond its available capacity, Go therefore allocates a new underlying array, copies the existing elements into it and adds the new element. The resulting slice now refers to the new underlying array.

Important: Go determines the new capacity internally. You should not assume that it will always double the previous capacity or grow by a particular amount.

Go vs JavaScript: append() and push()

Coming from JavaScript, you can think of Go's append() as having a similar purpose to JavaScript's .push().

Both are used to add elements to collections.

JavaScript:

`javascript
const numbers = [10, 20, 30];

numbers.push(40);

console.log(numbers); // [10, 20, 30, 40]
`

Go:

`go
numbers := []int{10, 20, 30}

numbers = append(numbers, 40)

fmt.Println(numbers) // [10 20 30 40]
`

However, there is an important difference:

JavaScript	Go
Uses `.push()`	Uses `append()`
`.push()` modifies the existing array	`append()` returns a slice value
No need to assign the result back when using `.push()`	You should assign the result back when using `append()`
JavaScript arrays grow dynamically	Go slices grow dynamically, but their underlying arrays have a capacity

Lesson takeaway:
append() adds elements to a slice and returns the resulting slice. Depending on the available capacity, Go may reuse the existing underlying array or allocate a new one.

Slicing an Array or Another Slice

We've already seen how to create a slice from an array. We can also use slicing expressions to select different portions of an array or an existing slice. Let's start with an example:

`go
numbers := []int{10, 20, 30, 40, 50}

parts := numbers[1:4]

fmt.Println(parts) // [20 30 40]
`

The expression numbers[1:4] means:

Start at index 1 (inclusive).
Stop before index 4 (exclusive), therefore the resulting slice contains 20, 30, 40.

1. Omitting the Start Index

You can omit the start index to select elements from the beginning of the slice.

`go
numbers := []int{10, 20, 30, 40, 50}

parts := numbers[:3]

fmt.Println(parts) // [10 20 30]
`
This is the same as writing:

go parts := numbers[0:3]

When the start index is omitted, Go uses 0 by default.

2. Omitting the End Index

You can also omit the end index to select elements from a particular position through to the end of the slice.

`go
numbers := []int{10, 20, 30, 40, 50}

parts := numbers[2:]

fmt.Println(parts) // [30 40 50]
`

This is equivalent to:

go parts := numbers[2:len(numbers)]

When the end index is omitted, Go uses the length of the slice.

3. Omitting Both Indexes

You can omit both indexes:

`go
numbers := []int{10, 20, 30, 40, 50}

parts := numbers[:]

fmt.Println(parts) // [10 20 30 40 50]
`

This creates another slice describing the same elements as the original slice. It does not create an independent copy. Both slices refer to the same underlying array.

4. Creating a Slice from Another Slice

You can also create a new slice from an existing slice.

`go
numbers := []int{10, 20, 30, 40, 50}

first := numbers[1:5]
second := first[1:3]

fmt.Println(first) // [20 30 40 50]
fmt.Println(second) // [30 40]
`

Let's understand what happens here.

First:

plaintext first := numbers[1:5]

This creates a slice containing the elements from index 1 up to, but not including, index 5 of numbers.

The result is:

[20 30 40 50]

go second := first[1:3]

This creates another slice from first.

An important detail is that the indexes in this second slicing expression are relative to first, not the original numbers slice.

Therefore:

first[1] is 30.
first[2] is 40.

The resulting second slice is [30 40].

Both slices still refer to portions of the same underlying array.

5. Valid Slice Indexes

When using a two-index slice expression, the indexes must satisfy certain rules:

The start index must not be negative.
The end index must not exceed the length of the collection.
The start index must not be greater than the end index.

For example:

`go
numbers := []int{10, 20, 30, 40, 50}

parts := numbers[1:4] // Valid
`
But these would cause runtime panics:

python numbers[-1:3] // Negative start index numbers[1:6] // End index exceeds length numbers[4:2] // Start index is greater than end index

Remember that the end index is exclusive.

Removing Elements from a Slice

Go does not have a built-in remove() function for slices.

However, a common technique is to combine slicing and append() to remove an element.

Let's say we have this slice:

go numbers := []int{10, 20, 30, 40, 50}

We want to remove the element at index 2, which is 30.

We can do this:

`go
i := 2

numbers = append(numbers[:i], numbers[i+1:]...)

fmt.Println(numbers) // [10 20 40 50]
`

Let's break down what happens.
Step 1: Declare the index to remove

plaintext i := 2

We declare i and assign it the value 2.

This is the index of the element we want to remove.

Step 2: Select the elements before the index

python numbers[:i]
Since i is 2, this becomes:

python numbers[:2]
It selects the elements from the beginning up to, but not including, index 2.

The result is:

[10 20]

Notice that the element at index 2 (30) is excluded.

Step 3: Select the elements after the index

python numbers[i+1:]

Since i is 2, this becomes:

python numbers[3:]

It selects the elements starting from index 3 through to the end.

The result is:

[40 50]

Step 4: Combine both portions using append()

go numbers = append(numbers[:i], numbers[i+1:]...)

This is where everything comes together.

numbers[:i] gives us the elements before the element we want to remove: [10 20].
numbers[i+1:] gives us the elements after the element we want to remove: [40 50].
... expands the second slice into individual elements.
append() adds those elements to the first portion.
We assign the resulting slice back to numbers.

The final result is:

[10 20 40 50]

The element 30 is no longer part of the resulting slice.

What Does the `...` Operator Do Here?

Remember that append() can accept multiple individual values:

go numbers = append(numbers, 40, 50)

But when we want to append the elements of another slice, we use ...:

go numbers = append(numbers, anotherSlice...)

The ... operator expands the slice into individual arguments.

Without it, Go would attempt to append the entire slice as a single value, which would cause a type error when working with a []int.

JavaScript vs Go: Removing Elements

In JavaScript, you can use the .splice() method to remove elements from an array.

JavaScript:

`javascript
const numbers = [10, 20, 30, 40, 50];

numbers.splice(2, 1);

console.log(numbers); // [10, 20, 40, 50]
`

The .splice() method takes:

The index where removal should begin.
The number of elements to remove.

In Go, we use slicing and append():

Go:

`go
numbers := []int{10, 20, 30, 40, 50}

i := 2
numbers = append(numbers[:i], numbers[i+1:]...)

fmt.Println(numbers) // [10 20 40 50]
`

The difference is that JavaScript provides .splice() as a built-in array method, while Go's approach is more explicit.

In Go, we describe the elements before and after the position we want to remove, then combine them using append().

Lesson takeaway:
Slicing allows you to select portions of arrays and slices. By combining slicing with append(), you can also remove elements from a slice.

Copying Slices

Before we discuss copying slices, let's revisit something we've already learnt. When you create a slice from an array, the slice provides a view into the array's data. Similarly, assigning one slice variable to another does not copy the underlying elements. It copies the slice value (descriptor).

`go
first := []int{10, 20, 30}

second := first

second[0] = 99

fmt.Println(first) // [99 20 30]
fmt.Println(second) // [99 20 30]
`

Why does this happen?

When we write:

pascal second := first
Go copies the slice descriptor, not the underlying elements, Meaning both first and second still refer to the same underlying array.

Therefore, modifying an element through second also affects what we see through first.

Using copy() to Create Independent Slices

If we want two slices whose elements can be modified independently, we can use Go's built-in copy() function.

The copy() function copies elements from a source slice into a destination slice.

However, the destination must have sufficient length if we want to copy all the source elements.

Example:

`go
first := []int{10, 20, 30}

second := make([]int, len(first))

copy(second, first)

second[0] = 99

fmt.Println(first) // [10 20 30]
fmt.Println(second) // [99 20 30]
`

Let's understand what happens:

Step 1: Create the original slice

go first := []int{10, 20, 30}
This creates our source slice.

Step 2: Create a destination slice

go second := make([]int, len(first))

We create another slice with the same length as first.

Since first has three elements, second also has a length of three.

At this point, second contains three zero values:

[0 0 0]

Step 3: Copy the elements

plaintext copy(second, first)

This copies the elements from first into second.

Now both slices contain:

[10 20 30]

However, they have separate underlying arrays.

Step 4: Modify the destination

python second[0] = 99

This changes only the first element of second.

When we print both slices:

go fmt.Println(first) // [10 20 30] fmt.Println(second) // [99 20 30]

The original slice remains unchanged because second has its own underlying array.

How Many Elements Does copy() Copy?

The number of elements copied depends on the lengths of the source and destination slices.

The copy() function copies the minimum of the two lengths.

In other words:

Number of elements copied = min(len(destination), len(source))

`go
source := []int{10, 20, 30, 40}

destination := make([]int, 2)

n := copy(destination, source)

fmt.Println(destination) // [10 20]
fmt.Println(n) // 2
`

Here:

The source has a length of 4.
The destination has a length of 2.
Only two elements are copied.
copy() returns 2, representing the number of elements copied.

The remaining source elements (30 and 40) are not copied because the destination only has room for two elements within its current length. copy() does not automatically grow the destination slice. Its length determines how many elements can be copied into it.

Lesson Takeaway

Assigning one slice to another copies the slice descriptor, not the underlying elements.
Two slices assigned this way can share the same underlying array.
Use copy() when you need independent element storage.
The number of elements copied is the smaller of the source and destination lengths.
copy() returns the number of elements successfully copied.

Nil Slices vs Empty Slices

In Go, a nil slice and an empty slice can look similar when printed, but they are not the same. Let's look at both declarations.

1. Declaring a Nil Slice

`go
var first []int

fmt.Println(first) // []
fmt.Println(len(first)) // 0
fmt.Println(cap(first)) // 0
fmt.Println(first == nil) // true
`

When we declare a slice using var without initialising it, Go creates a nil slice.

A nil slice:

Has a length of zero.
Has a capacity of zero.
Does not currently reference an underlying array.
Is equal to nil.

2. Declaring an Empty Slice

`go
second := []int{}

fmt.Println(second) // []
fmt.Println(len(second)) // 0
fmt.Println(cap(second)) // 0
fmt.Println(second == nil) // false
`

Here, we use an empty slice literal.

Although the slice contains no elements, it is initialised and is not nil.

An empty slice:

Has a length of zero.
Has a capacity of zero.
Is not equal to nil.

3. Comparing Nil and Empty Slices

Let's put both declarations together:

`go
var first []int

second := []int{}

fmt.Println(first) // []
fmt.Println(second) // []

fmt.Println(first == nil) // true
fmt.Println(second == nil) // false
`

Both slices print as [], and both have a length of zero.

However, the difference is that the first is nil, while the second is an initialised empty slice.

4. Can You Append to Both?

Yes!

Both nil slices and empty slices can be used with append().

Example:

`go
var first []int
second := []int{}

first = append(first, 10)
second = append(second, 20)

fmt.Println(first) // [10]
fmt.Println(second) // [20]
`

Go automatically handles the underlying storage when elements are appended.

Why Does the Difference Matter?

The distinction between nil and empty slices can matter in a few situations:

Checking whether a slice has been initialised

You can compare a slice to nil to determine whether it is nil.

Returning data from functions

A function might return a nil slice when there is no result, while another might return an initialised empty slice. These are different values even though both contain zero elements.

Encoding data into formats such as JSON

The distinction can affect the output.

For example:

`go
var first []int
second := []int{}

firstJSON, _ := json.Marshal(first)
secondJSON, _ := json.Marshal(second)

fmt.Println(string(firstJSON)) // null
fmt.Println(string(secondJSON)) // []
`

A nil slice is encoded as null, while an empty slice is encoded as an empty array ([]). This can matter when building APIs because clients may treat null and [] differently.

Can You Compare Slices Directly?

Go does not allow you to compare two slices directly using == to check whether their elements are equal.

For example:

`go
first := []int{10, 20, 30}
second := []int{10, 20, 30}

// fmt.Println(first == second) // Compile-time error
`

You can, however, compare a slice to nil:

go fmt.Println(first == nil) // false

If you need to check whether two slices contain the same elements, you need to compare their elements or use an appropriate equality function.

General Lesson Takeaway: Arrays and Slices

Arrays and slices are both used to store collections of elements of the same data type in Go. However, they behave differently.

Arrays

Arrays have a fixed length.
Their length is part of their type.
Arrays store elements of the same data type.
Arrays are value types, meaning assigning an array to another variable copies its elements.
Their elements can be accessed and modified using indexes.
Use arrays when you need a collection with a fixed, known size.

Slices

Slices are flexible and can grow or shrink.
Slices are built on top of underlying arrays.
Multiple slices can share the same underlying array.
Assigning one slice to another copies the slice descriptor, not the underlying elements.
Use append() to add elements.
Use copy() when you need to copy elements into independent storage.
Use slicing expressions to select portions of arrays and slices.
Use len() to get the current number of elements.
Use cap() to get the available capacity.
A nil slice and an empty slice both have a length of zero, but they are not the same.

Important Go Functions and Operations

Function / Operation	Purpose
`len()`	Returns the number of elements in an array or slice.
`cap()`	Returns the capacity of a slice or array.
`append()`	Adds elements to a slice and returns the resulting slice.
`copy()`	Copies elements from one slice into another.
`make()`	Creates and initialises a slice with a specified length and optional capacity.
`numbers[start:end]`	Creates a slice from a selected range of elements.

Arrays vs Slices: Quick Comparison

Feature	Arrays	Slices
Size	Fixed	Flexible
Length	Part of the type	Can change
Assignment	Copies elements	Copies slice descriptor
Underlying array	The array itself	Refers to an underlying array
Adding elements	Cannot grow	Uses `append()`
Length and capacity	`len()`	`len()` and `cap()`
Common use	Fixed-size collections	Everyday collections and application data

Think of an array as a fixed size container, A slice is a flexible view into an underlying array. You can create slices from arrays or other slices, append elements, copy elements into independent storage, and select different portions using slicing expressions.

GO: Introduction and core syntax

Adetola Esther Aderibigbe — Thu, 22 Oct 2026 03:30:51 +0000

Go (Golang) is Google's statically typed, compiled, cross-platform, open-source programming language that combines efficiency with ease of use. Its features include built-in concurrency via goroutines and channels. It has simple syntax, fast compilation, and a comprehensive standard library. It's popular for microservices, web servers, and cloud-native development.

Installation guide: Getting Started with Go — Install Go

Module One: Go Core Syntax

Package declaration and Imports
Variables and Types
Control Flow and Loops: for loops, range loops, and switch statements

Package declaration and Imports

A Go program is made of packages. Packages in Go are directories containing source files that work together to organize and reuse code. Every Go file belongs to a package, and that package is declared at the top of the file. A package like fmt (for formatted I/O) is one you bring in with an import.

A package can also be defined as a group of files that share one package name, usually in one folder. Every Go file starts with a package line that names it. A Go program starts in a package called main, and its function main is where the program starts running.

A package works like a folder of recipes in a cookbook section. Every recipe card in the folder says which section it belongs to. The section that starts the meal is the one the cook opens first.

// package line
package main
// import line
import "fmt"
func main() {
    fmt.Println("Hello, World!")
}

Expected output: Hello, World!

package main tells Go which package the file belongs to. The main package is special because it's the entry package for a program intended to run as an executable.

import "fmt" makes Go's standard library fmt package available to the file. It is used for formatted input and output, including printing text to the terminal.

func main() declares a function named main. When you run an executable program, execution begins in the main function.

fmt.Println("Hello, World!") calls the Println function from fmt to print text, followed by a new line. The dot accesses an exported name from a package, and the parentheses contain the arguments you're passing to the function.

How to Use Code That Belongs to Another Package (Import Another Package)

Our file often needs code from another package, which is listed in the import line. The import statement makes a standard library package available to the file. After importing, you call its functions using the package name, a dot, and the function name, such as fmt.Println. fmt is the package, and Println is the function inside it.

package main

// Makes the standard library package available to the file.
import "fmt"

// Declares the function where execution begins.
func main() {
    // Creates a variable named name as a string using the short variable declaration.
    name := "Ada"

    // Calls fmt.Println, which lives in the fmt package.
    fmt.Println("Hello", name)
}

Expected output:

Hello Ada

Naming Conventions in Go

As an example, we have fmt.Println("Train Name"). Under fmt, we have the package name, and under Println, we have the function name.

Note: Println starts with a capital letter. In Go, names beginning with a capital letter are exported and can be accessed from another package, while names beginning with a lowercase letter are unexported and can only be accessed within their own package. Go decides what other packages can use based on the first letter of a name.

Unused Imports and Compiler Errors

Go checks imports strictly. If a file imports a package and doesn't use it, the compiler stops with an error. If the file uses a package without importing it, the compiler also stops. The import block is an honest list that shows what a file depends on, and every imported package must be used.

Never use a package you haven't imported yet. Check whether an imported package is needed before importing it. You don't need to use every function inside an imported package, just one.

Incorrect:

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "ada"
}

Go complains about fmt and strings being imported and not used. It also complains that name is declared and not used, because Go is just as strict about unused variables.

Correct:

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "ada"
    fmt.Println(strings.ToUpper(name))
}

Go vs. JavaScript

JavaScript	Go
`const name = "Ada";`	`name := "Ada"`
`console.log("Hello", name);`	`fmt.Println("Hello", name)`

Lesson Takeaway

Every Go file starts with a package line, and package main with the main function is where a program starts.
An import statement brings in another package, and you can call its functions using the package name.
A name starting with a capital letter is exported and can be used from other packages, while a lowercase name remains unexported.
Go returns a compiler error for unused imports.

Variables and Types

A variable is a named storage location in memory used to hold a value of a specific type. It is a named box that holds a value.

In Go, variables are statically typed, meaning their type is known at compile time and cannot change.

Variables are declared using the var keyword, followed by the name, the type, and an optional value. The type says what kind of value the box can hold, and Go checks this. Any value written with the wrong type will be rejected by Go.

Kitchen analogy: There is a labelled jar in the kitchen. The label is the name, the jar's size and purpose are the type, while the contents are the value.

var itemCount int = 3

var — keyword
itemCount — name
int — type
3 — value

Go also infers the type from the value. If you provide a value, you can leave out the type. In that case, 3 becomes an integer (int), 2.5 becomes a float64, "C" becomes a string, and true or false becomes a boolean.

The short assignment operator (:=) is used to declare a variable in Go, with the type usually inferred from the assigned value. It can only be used inside a function. Variables declared outside a function must use the var keyword.

Use var when you want to specify a type that cannot be inferred from the value, or when you want a zero value, which is the default value Go assigns to a variable when no value is provided. Inside a function, the short assignment operator (:=) is the usual choice for declaring a new variable.

Go vs. JavaScript

JavaScript	Go
`let item = 3;`	`itemCount := 3`

Type Inference in Go

Type inference is Go working out a variable's type from the value you give it. Go determines a variable's type from the initial value you assign to it. You don't write the type; Go infers it from the value, and the variable has a fixed type. So, the variable can't later hold a different kind of value. For example, if name is declared as a string using the short assignment operator (:=), assigning 5 to name later would be incorrect because name has already been defined as a string.

Kitchen analogy: A shelf is labelled by the first item placed on it. If the first item placed on a shelf is a book, then it can't also be used to store a banana.

// Type Inference in Go
package main

import "fmt"

func main() {
    // var declares itemCount with the type int and the value 3.
    var itemCount int = 3

    // price := 29.5 declares a new variable. Go infers float64 from 29.5.
    price := 29.5

    // name := "tea" declares a string. The := creates a new name here.
    name := "tea"

    // A plain = assigns to an existing variable. It does not declare a new one, so no := is needed.
    itemCount = itemCount + 6

    // Prints the three values in order: name, itemCount, and price.
    fmt.Println(name, itemCount, price)
}

Expected output:

tea 9 29.5

How does this compare to TypeScript?

If you're coming from TypeScript, this will feel familiar:

let name = "tea";
name = "coffee"; // Valid
name = 5;        // Type error

TypeScript infers that name is a string, much like Go does. The difference is that TypeScript's types disappear once it's compiled to JavaScript, while Go's types are part of the compiled program. Both languages help catch certain mistakes before your program runs. Here's the same thing in Go:

name := "tea"
name = "coffee" // Valid
name = 5        // Compile error

Go Variable Naming Rules

Go variable names can be short, like x and y, or descriptive, like age and price. They must start with a letter or underscore, cannot start with a digit, and can contain only letters, digits, and underscores. Variable names are case-sensitive, cannot contain spaces or be Go keywords, and have no length limit. Multi-word variable names can use camel case (myVariableName), Pascal case (MyVariableName), or snake case (my_variable_name).

Lesson Takeaway

The var keyword is used to declare a variable in Go.
The short variable declaration operator (:=) declares a variable with its type inferred from the assigned value.
The short variable declaration operator (:=) can only be used inside a function.

Control Flow and Loops

A quick note before we start: the snippets in this section leave out package main and import "fmt" to keep things short. If you want to run one, add those two lines at the top of the file.

for Loops

Many languages have a separate keyword for each loop type, but Go doesn't. It has only for, and what follows it decides the loop shape. The header sits between for and the opening brace, and the body is the code that repeats.

Kitchen analogy: A kitchen timer can count down a set number of minutes. When it reaches zero, it stops and is ready to be turned off. One tool, 3 uses.

func main() {
    // i := 1 happens once, before any check.
    // i <= 3 is checked before every pass, and the body only runs while it's true.
    // i++ adds 1 after each pass.
    for i := 1; i <= 3; i++ {
        fmt.Println(i)
    }
}

Expected output:

1
2
3

for — keyword
i := 1 — initialises i to 1
i <= 3 — condition
i++ — increments i by one
fmt.Println(i) — body, the code that repeats

A typical for loop has three parts, separated by semicolons.

Initial statement: It runs once before the loop starts and usually creates a counter.

i := 1;

Condition statement: It is checked before each pass through the loop.

i <= 3;

Post statement: It runs after each pass and usually changes the counter.

i++

So, i := 1 starts the counter at one, the loop runs while i is less than or equal to three, and i++ adds one after each pass.

Types of For Loops in Go

There are three major types of loops in Go:

Classic loop
Condition only loop
Infinite loop

1. Classic Loop

We use a classic loop when we want to repeat something a known number of times or track a counter.

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

A classic loop has three parts: the initial statement, condition statement, and post statement. It runs five times in this example, printing 0 to 4.

2. Condition Only Loop

This works like a while loop in JavaScript or TypeScript.

count := 0
for count < 5 {
    fmt.Println(count)
    count++
}

Note: There's no semicolon in the loop header. It has only a condition and runs while the condition is true.

3. Infinite Loop

You use an infinite loop when you omit the condition. The loop continues indefinitely unless something inside stops it, usually with the keyword break or return.

for {
    fmt.Println("Still running")
    break
}

Note: break stops the loop after the first print. An infinite loop has no condition and runs indefinitely until it is stopped.

Go vs. JavaScript/TypeScript

Purpose	Go	JavaScript
Counter loop	`for i := 0; i < 3; i++ { }`	`for (let i = 0; i < 3; i++) { }`
Condition loop	`for count < 3 { }`	`while (count < 3) { }`
Infinite loop	`for { }`	`while (true) { }`

Main difference: Go does not have a separate while keyword. It uses for for all loop types, and what follows for determines how the loop behaves.

Range Loop

Writing i := 0; i < 5; i++ can honestly be a bit long sometimes. So Go gives us a shorter way to write it using range.

for i := range 5 {
    fmt.Println(i)
}

This gives i values from 0 to 4, printing each value on a new line.

Expected output:

Note: range 5 iterates five times, producing values from 0 up to, but not including, 5. Ranging over a number like this needs Go 1.22 or newer, so if it doesn't compile, run go version to check what you have installed.

In a loop, continue skips the rest of the current iteration and moves to the next one, while break stops the whole loop.

func main() {
    for i := range 5 {
        if i == 2 {
            continue
        }

        fmt.Println(i)
    }
}

Expected output:

Lesson Takeaway

Go has only one looping keyword, for.
A classic loop has three parts, separated by semicolons: an initialisation statement that starts the counter, a condition statement that is checked before every pass, and a post statement that runs after every pass.
A condition-only loop runs as long as the condition is true.
An infinite loop runs indefinitely unless it is stopped using break or return.
A range loop provides a shorter way to iterate over values, such as for i := range 5, which produces values from 0 to 4.
continue skips the rest of the current iteration and moves to the next one, while break stops the loop.

Route Logic Using Typed Switch Statements

In JavaScript or TypeScript, there is a switch statement or an if-else statement. Go has both too. A switch statement in Go selects and executes one block of code from multiple possibilities based on the value or type of an expression. A switch statement provides a cleaner alternative to multiple if statements. It also supports both value-based and type-based branching.

How does it work?

A switch statement tells Go which values to examine. Then, each case defines a possible value. Go runs the code under the matching case. If no case matches, it runs default.

package main

import "fmt"

func main() {
    day := "Monday"

    switch day {
    case "Monday":
        fmt.Println("Start of the week")
    case "Friday":
        fmt.Println("Almost the weekend")
    default:
        fmt.Println("Another day")
    }
}

Expected output:

Start of the week

Go supports two types of switch statements

Expression switch
Type switch

1. An Expression Switch

An expression switch evaluates an expression and executes the matching case block. This is useful when you have several possible options.

// Expression switch: evaluate the value, find a match,
// execute the matching case, and exit the switch.

func main() {
    route := "/profile"

    switch route {
    case "/":
        fmt.Println("Home page")
    case "/dashboard":
        fmt.Println("Dashboard page")
    case "/profile":
        fmt.Println("Profile page")
    default:
        fmt.Println("Page not found")
    }
}

An expression switch can also check more than one value in a single case. Just separate the values with a comma.

func main() {
    age := 25

    switch age {
    case 18:
        fmt.Println("Finally an adult")
    case 25, 30: // two values, one case
        fmt.Println("How's life?")
    case 35:
        fmt.Println("Oldie")
    default:
        fmt.Println("Another age")
    }
}

Expected output:

How's life?

The value in the switch and the values in the case expressions must be comparable under Go's type rules. E.g., an integer variable cannot be compared directly against a string.

func main() {
    age := 25

    switch age {
    case "25": // Error: cannot compare int with string
        fmt.Println("Twenty-five")
    }
}

This code produces a compile-time error because age is an integer (int), while "25" is a string. Go does not allow these incompatible types to be compared directly in a switch statement. The fix is to make both sides the same type, like case 25:.

Go also allows you to omit the value after switch. Each case can then contain a Boolean condition.

func main() {
    score := 75

    switch {
    case score >= 80:
        fmt.Println("Excellent")
    case score >= 60:
        fmt.Println("Passed")
    default:
        fmt.Println("Try again")
    }
}

Go evaluates the cases from top to bottom and executes the first case whose condition is true.

2. Type Switch

A switch checks the value, while a type switch checks what type a value is. This is useful when a variable has an interface type, such as any, and the value inside can be any data type. In Go, any is an alias for the empty interface, and it can hold a value of any type.

func main() {
    var value any = true

    switch v := value.(type) {
    case string:
        fmt.Println("This is a string:", v)
    case int:
        fmt.Println("This is an integer:", v)
    case bool:
        fmt.Println("This is a Boolean:", v)
    default:
        fmt.Println("Unknown type")
    }
}

value — a variable of type any.
.(type) — the syntax used to inspect the value's type in a type switch.
v — a variable declared in the switch that refers to the value inside each case, with its specific type.
case string — when the value is a string, v is a string.
case int — when the value is an integer, v is an integer.

Expression Switch vs. Type Switch

Feature	Expression switch	Type switch
What it checks	A value or Boolean condition	The type of a value
Typical use	Routes, selectors, and codes	Values whose types may differ
Example	`switch route`	`switch v := value.(type)`
Cases	Values or Boolean conditions	Types such as string, int, etc.
Matching	Executes the matching case	Executes the case matching the value's type
Type handling	Cases must be compatible with the switch expression's type	Go identifies the value's type in each case

Go vs. JavaScript

Feature	Go	JavaScript
Syntax	`switch expression { }`	`switch (expression) { }`
Case behaviour	Exits the switch automatically after a matching case (use `fallthrough` if you want it to continue)	Requires `break` to prevent fall-through

Lesson Takeaway

Use an expression switch when one value can have several possible outcomes.
Use a type switch when you need to identify a value's type.
Use case to define options and default to handle anything unmatched.

Final Practice Exercise

Create a small program that combines what you've learned.

Your program should:

Declare a variable called status and assign it "pending".
Use an expression switch to print a message for "pending", "approved", or "rejected".
Print "Unknown status" for any other value.
Use a for loop with range 5 to print the numbers zero through four, but skip the number two using continue.

Next Module: Data Structures

A Beginner’s Guide to ThreeJs

Adetola Esther Aderibigbe — Fri, 13 Feb 2026 11:10:13 +0000

Sometime ago,I was told me that no matter what you’re learning in tech whether it’s a new method, a new language, a new framework, or a new tool you can always approach it by asking three questions: What does it take? What does it return? And what does it do?

Unfortunately, with Three.js, this is the first time that approach has completely failed me, After three trails however, I'm writing this as an intro to threejs for those that are struggling with it just like me.

What is ThreeJs

Three.js is a high-level JavaScript library for creating 3D graphics in web browsers. It simply simplifies 3D creation and animation without any WebGL code knowledge.

To render 3D graphics in a browser, we need the help of the GPU(Graphic processing unit)the part of your computer that’s really good at drawing graphics.
WebGL is the tool that lets JavaScript talk to the GPU. It acts like a translator, helping the browser tell the GPU what to render on the screen.
Threejs is built on top of webgl, it abstracts the complicated webGL language into an easy to use javascript Api so we reallyy don't have to bother again that.
To understand or use Three.js, it’s important to know that everything is built around three core objects. These three objects form the foundation of the Three.js workflow:
1. Scene
2. Camera
3. Renderer
In this tutorial, we’ll explore these three core concepts while building something small along the way. This hands on approach will help make each concept easier to understand as we go but before we begin, the first step is installation by running this in our terminal

# three.js
npm install --save three

# vite
npm install --save-dev vite

1.Scene

A scene in Three.js can be thought of as the world where everything exists. It contains everything you want to see(objects, lights, and anything else that should appear on the screen).
A good way to think about a scene is like a movie set. The set holds all the props, actors, and lights. Without the set, there’s nothing to film.
In the same way, before we can display anything with Three.js, we must first create a scene. Every visible object in Three.js lives inside a scene

import * as THREE from 'three';

const scene = new THREE.Scene();

That’s it.
At this point, we've created an empty world. Nothing will show on the screen yet because the scene has no objects,no camera and nothing is being rendered So we need the camera.

2.Camera

The camera is the viewer's eye. It is used to look at everything inside the scene. on our movie set, the camera is literally the cameraman. And there are multiple camera types. Three.js provides several types of cameras, including:
• PerspectiveCamera
• OrthographicCamera
• CubeCamera
• ArrayCamera
• StereoCamera

However, the most common is the PerspectiveCamera which is designed to mimic how the human eye sees the world, where objects farther away appear smaller and objects closer appear larger.

import * as THREE from 'three';

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera( 75, window.innerWidth / window.innerHeight, 0.1, 1000 );

a PerspectiveCamera takes 3 arguments, each controlling how the scene is viewed.

Field of View (FOV)
This controls how wide the camera can see.It is measured in degrees and usually represents the vertical viewing angle.
A larger value means you see more of the scene, while a smaller value zooms in closer.(ours is 75)
Aspect Ratio
This is the shape of the camera’s view and is usually based on the browser window.
It is calculated by dividing the window’s width by its height:

window.innerWidth / window.innerHeight

The last two are
a. Near Clipping Plane
This defines how close an object can be to the camera before it is no longer visible.

b. Far Clipping Plane
This defines how far an object can be from the camera before it disappears.

Together, the near and far values create the view frustum, which determines what the camera can and cannot see.

For example, using 0.1 and 1000 means everything is seen frim the camera lens.

3. Renderer

The renderer is what actually draws everything on the screen. You can think of it like a painter, it takes all the objects in the scene, looks through the camera, and paints the final image onto your browser. In Three.js, the most commonly used renderer is the WebGLRenderer. When creating it, you need to tell it where to display the scene in the browser. Usually, this is done by attaching it to a DOM element, like the or a specific

import * as THREE from 'three';

// Create the renderer
const renderer = new THREE.WebGLRenderer();

// Set the size of the renderer (usually the window size)
renderer.setSize(window.innerWidth, window.innerHeight);

// Add the renderer to the HTML document
document.body.appendChild(renderer.domElement);

Now that we have a scene, a camera, and a renderer, let’s add a 3D object. In Three.js, creating an object happens in three main steps

1. Create the geometry

The geometry defines the shape of our object. It’s basically the XYZ points that make up the object in 3D space.

Three.js has a bunch of built-in geometries, like cubes, spheres, cones, and planes that can be seen in the docs. For this tutorial, we’ll use a sphere:

const geometry = new THREE.SphereGeometry(15, 32, 16);

15 is the radius of the sphere

32 is the number of horizontal segments

16 is the number of vertical segments

This gives us a smooth-looking sphere.

2. Create the material

The material defines how the geometry looks. we can think of it as the wrapping paper for your 3D shape.

Three.js has many materials that can aslo been seen in their docs. Some respond to light (like MeshStandardMaterial), while others don’t. For simplicity, we’ll use MeshBasicMaterial, which does not rely on lights:

const material = new THREE.MeshBasicMaterial({
  color: 0xf9a8d4,
  wireframe: true,
});

color: sets the color of the sphere

wireframe: true makes the sphere display as a wireframe, so you can see its structure

3.Creating a mesh
A mesh is created by combining geometry and material. The mesh is the actual object that can be added to the scene.

const sphere = new THREE.Mesh(geometry, material);
sphere.position.set(8, -30, 0)
scene.add(sphere);

Now the sphere exists in the scene, ready to be rendered.

Animate the sphere

We can make the sphere spin to make the scene more dynamic:

const animate = () => {
requestAnimationFrame(animate);

sphere.rotation.x += 0.01;
sphere.rotation.y += 0.005;
sphere.rotation.z += 0.01;

renderer.render(scene, camera);

};

animate();

At this point, you have a 3D animated sphere rotating on your screen! Of course, there’s much more to Three.js than just this. It’s used in interactive websites, games, simulations, and a whole lot more but if you’ve struggled with Three.js like I have, congratulations, you’ve just created your first 3D object. From here, you can, Add lights to your scene, Experiment with materials, colors, and geometries and Play around with what you’ve built and see how changes affect your scene.

Also, check out the examples in the official Three.js documentation they’re a great source of inspiration and learning and maybe once I’ve mastered Three.js, I’ll come back with a more detailed tutorialand this time, we might build something even more exciting.

Some cool Web APIs

Adetola Esther Aderibigbe — Tue, 28 Oct 2025 07:48:34 +0000

Last week, I decided to switch up how I learn. Instead of just reading tutorials and documentation, I tried something simple, asking three core questions about every new concept I came across, a technique recommended by my mentor.

Those three questions were:

What does it do? (What’s its purpose or behavior?)
What does it take? (What inputs, dependencies, or setup does it require?)
What does it return? (What’s the output or result you can expect?)

This technique forces clarity and Using this approach, here’s what I explored last week.

1. Interception Observer

What does it do?

interception Observer is used to detect interaction between the target element and its ancestor element. It is used to detect if some elements are visible at viewports or not.
It provides an efficient way to track visibility changes without constantly listening to scroll or resize events.

What does it take?

An Intersection Observer takes two main inputs:

1) A callback function
This function is triggered whenever the visibility of the observed element changes. It receives a list of IntersectionObserverEntry objects, which contain information about each observed target.
If an entry’s isIntersecting property is true, it means the target element is visible within the viewport or within the specified root element.

2) An options object
This object can include the following properties:
a) root: Defines the element that is used as the viewport for checking the visibility of the target. It must be an ancestor of the target element. If not specified, the browser’s viewport is used by default.
b) threshold (sometimes misheard or mistyped as choiceOde): Can be a single number or an array of numbers between 0 and 1. It specifies how much of the target element must be visible before the callback is triggered.
Example: 0.5 means the callback fires when half of the element is visible; 1 means the callback fires only when the entire element is visible. The default value is 0.
c) rootMargin: Works similarly to CSS margins. It accepts one to four values (margin-top, margin-right, margin-bottom, margin-left) and can be used to expand or shrink the root’s bounding box. For example, "0px 0px -50px 0px" can trigger earlier or later than the actual visibility point.

What does it return?

It returns an observer object that provides methods such as .observe() and .unobserve(), allowing you to start or stop observing specific target elements for visibility changes.

When to use Intersection Observer

Intersection Observers are useful in many real world web interactions, including:

Lazy loading images – Only load images when they’re about to appear on the screen.
Detecting visibility – Check whether a specific element is within the viewport.
Autoplay or pause media – Automatically play a video when visible and pause when it scrolls out of view.
Infinite scrolling – Load more content when the user reaches the end of a page or list.

2.createElement()

What does it do?

In an HTML document, the document.createElement() method is used to dynamically create new HTML elements using JavaScript. Instead of hardcoding everything inside your HTML file, this method lets you generate elements on the fly and attach them to the DOM. JavaScript dynamically builds and updates the interface by creating, modifying, and removing elements without reloading the page.
This makes the web app more efficient and interactive, as it allows constructing UI components directly with JavaScript rather than writing repetitive static HTML.

What does it take?

The createElement() method takes one argument, a string representing the tag name of the element you want to create.
For example:

const button = document.createElement('button');

Here, a element is created in memory but not yet added to the page.

What does it return?

the new element.

3.Canva API

The Canvas API provides a means for drawing graphics via JavaScript and the HTML <canvas> element. Among other things, it can be used for animation, game graphics, data visualization, photo manipulation, and real-time video processing.

The Canvas API largely focuses on 2D graphics allowing developers to create visual elements dynamically including animations, charts, game graphics, image effects, and even real-time video processing.

What does it take?

To use the Canvas API, you typically need:
a) An HTML element: This defines the drawing area in your document. For example:

<canvas id="myCanvas" width="400" height="400"></canvas>

b) A rendering context
In JavaScript, you access the drawing functions by retrieving the context

const canvas = document.getElementById('myCanvas'); const ctx = canvas.getContext('2d');

The getContext('2d') method gives you the 2D drawing context, which contains all the methods needed to draw shapes, text, images, and more.

c) Drawing instructions
Once you have the context, you can call methods like:

ctx.fillRect(x, y, width, height) – Draws a filled rectangle.
ctx.beginPath() and ctx.lineTo() – Used to create complex paths and shapes.
ctx.drawImage() – Renders images or videos onto the canvas.

What does it return?

Channel Messaging API

What does it do?

The Channel Messaging API allows two separate scripts running in different browsing contexts (such as two iframes or an iframe and its parent document) to communicate directly with each other.
It creates a two-way communication channel, where each side can send and receive messages asynchronously through dedicated message ports.
This makes it useful for scenarios where web components, embedded widgets, or isolated scripts need to share data safely and efficiently without relying on global variables or storage.

What does it take?

A message channel is created using the MessageChannel() constructor. Once created, the two ends of the channel can be accessed through: MessageChannel.port1 and MessageChannel.port2

The context that creates the channel uses port1, while the second context (such as an iframe) uses port2.

You can send messages through port2.postMessage() and transfer the port itself to another browsing context using window.postMessage() along with two arguments(the message to send, the object to transfer ownership of)
The receiving context listens for messages using onmessage, and grabs the message content from event's data.
To reply, it can use its own MessagePort.postMessage() method.
When communication is no longer needed, MessagePort.close() can be called to close the connection on both ends.

What does it return?

a communication bridge

Geolocation API

What does it do?

The Geolocation API allows users to share their physical location with web applications if they choose to.
For privacy and security reasons, the browser always asks for the user’s permission before sharing any location data. Once granted, the API enables a web app to access the device’s geographic position, using the best available method (such as GPS, Wi-Fi, or network information).

For browser extensions, any feature that accesses geolocation data must explicitly declare the "geolocation" permission in the manifest file.

What does it take?

The Geolocation API takes:

1 User permission
The browser automatically prompts the user to grant or deny location access before the API can return any data.
2 Callback functions
The API works asynchronously and requires callback functions to handle success or error responses.

The Geolocation API is accessed via a call to navigator.geolocation; this will cause the user's browser to ask them for permission to access their location data. If they accept, then the browser will use the best available functionality on the device to access this information. Developer can now access this location information in a couple of different ways:

a) Geolocation.getCurrentPosition(): Retrieves the device's current location.
b) Geolocation.watchPosition(): Registers a handler function that will be called automatically each time the position of the device changes, returning the updated location.

Each of these methods can take up to three arguments:
1 A success callback (required) executed when location retrieval succeeds. It receives a GeolocationPosition object containing data such as latitude, longitude, and accuracy.
2 An error callback (optional) executed if retrieval fails. It receives a GeolocationPositionError object explaining what went wrong (e.g., permission denied, timeout, or unavailable data).
3 An options object (optional) that allows developers to configure retrieval settings such as accuracy, timeout, and caching behavior.

navigator.geolocation.getCurrentPosition(
  (position) => {
    console.log(position.coords.latitude, position.coords.longitude);
  },
  (error) => {
    console.error(error);
  },
  { enableHighAccuracy: true, timeout: 5000 }
);

What does it return?

The Geolocation API returns a Geolocation object, which provides access to the methods and properties needed to retrieve and monitor location data.
When successfully executed, it provides a GeolocationPosition object containing detailed information such as:

coords.latitude
coords.longitude
coords.accuracy
timestamp

When to use Geolocation API

Geolocation API can be useful when building

Weather apps
Maps and navigation
Ride-hailing or delivery apps
Logistics and fleet management
Fitness and outdoor activity apps

Storage API

What does it do?

The Storage API provides a way for web applications to store data locally on a user’s device directly in the browser so that information can persist between sessions without needing a server connection.
It allows developers to save key value data, user preferences, and small amounts of application state, making websites faster and more interactive even when offline.
There are two main parts of the Storage API:

localStorage – Stores data permanently (until explicitly cleared by the user or the site).
sessionStorage – Stores data temporarily for a single session (it’s cleared once the browser tab is closed).

What does it take?

The Storage API takes: A key and a value. Data is stored in key value pairs, where both are strings.

localStorage.setItem('username', 'Adetola');
Here, 'username' is the key, and 'Adetola' is the value being stored.

A key (for retrieval or removal) –
To read stored data:
const name = localStorage.getItem('username');
To remove data:
localStorage.removeItem('username');
Or to clear everything at once:

localStorage.clear();

What does it return?

The Storage API itself returns a Storage object, which provides methods (setItem(), getItem(), removeItem(), clear()) for interacting with stored data.

When data is retrieved using getItem(), it returns the string value associated with the specified key. If the key doesn’t exist, it returns null.

References

SEO and Next.js: How to Implement and Optimize for Better Results

Adetola Esther Aderibigbe — Tue, 28 Oct 2025 06:29:28 +0000

What is SEO?

SEO stands for Search Engine Optimization. It is the process of making a website more visible in search results to increase both the quality and quantity of traffic. Unlike paid ads, SEO focuses on organic traffic, making websites easier for users to find naturally through search engines like Google and Bing.

Why is SEO Important?

Organic search dominates traffic: Around 50% of website traffic comes from search engines. Unlike paid advertising which may be shown to people who aren’t actively looking. organic search happens when a user types a specific query. By ranking for those keywords, your website positions itself as the solution to their problem, leading to higher quality leads and better conversion rates. 2.Search is a daily habit: Over 8.5 billion searches happen on Google every day. Search is deeply integrated into people’s lives. Businesses without a strong organic presence risk being invisible to their audience. Since most searches now happen on mobile, Google prioritizes mobile-friendly websites. This means businesses need fast, responsive, user-friendly websites to perform well in search rankings and build a strong brand perception.
It’s sustainable: Unlike paid ads that stop driving traffic once the campaign ends, SEO continues to work long term, making it a more sustainable strategy.
It builds trust: Ranking high on Google is a signal of credibility. Users tend to trust organic results more than ads, so appearing at the top transfers that trust to your brand.
It outperforms paid ads in the long run While ads can provide a short-term boost, SEO offers long-term visibility and trust that ads cannot match.

Implementing SEO in Next.js

Metadata Management The easiest way to start with SEO is by managing your Html metadata using the next/head document. Metadata is like your page title and description, is crucial for SEO. It's the first thing search engines see and what appears in search results. Next.js provides a straightforward way to handle this using the metadata object or the generateMetadata function (for App Router) or the next/head component (for Pages Router).

Static Metadata: For pages with content that doesn't change, you can define a static metadata object. This is ideal for things like your homepage, "about us" page, or a static landing page.

 import type { Metadata } from 'next'

 export const metadata: Metadata = {
   title: 'My Awesome Website',
   description: 'The best website for all your needs.',
 }

 export default function Page() {
   //...

Dynamic Metadata: For dynamic pages, like blog posts or product pages, you'll need to generate metadata based on the content. The generateMetadata function allows you to fetch data and use it to create unique titles and descriptions for each page.

import type { Metadata, ResolvingMetadata } from 'next'

type Props = {
  params: { slug: string }
}

export async function generateMetadata(
  { params }: Props,
  parent: ResolvingMetadata
): Promise<Metadata> {
  // Fetch data for the specific blog post
  const post = await fetch(`https://.../posts/${params.slug}`).then((res) => res.json())

  return {
    title: post.title,
    description: post.description,
  }
}

export default function Page({ params }: Props) {
  //...
}

Optimizing SEO in Next.js

SEO in Next.js goes beyond metadata—it’s about leveraging the framework’s built-in features for speed, crawlability, and user experience.

Rendering Strategies Choosing the right rendering method is crucial for SEO:
Static Site Generation (SSG): Pages are pre-rendered at build time into static HTML. This makes them fast-loading and ideal for content that doesn’t change often (e.g., landing pages).
Server-Side Rendering (SSR): Pages are rendered on the server for each request. This is best for highly dynamic, user-specific content, like a product inventory or a profile page. The advantage is that crawlers still see the complete HTML.
Incremental Static Regeneration (ISR): A hybrid approach that combines SSG and SSR. Pages are generated statically but can be updated at intervals or when data changes. This offers both speed and freshness.
Image and Font Optimization Page speed is a major SEO factor, and Next.js helps here:
Automatic image optimization (resizing images based on device and lazy-loading them only when they appear in view).
Built-in font optimization, reducing load time and improving Core Web Vitals.

Server-Side Rendering (SSR)

The delivery of content from a server to a user’s browser is a foundational challenge in web development. The architectural approach chosen directly shapes performance, user experience, and business outcomes.
For a while now, the debate has centered on two core strategies: Server-Side Rendering (SSR) and Client-Side Rendering (CSR).

SSR generates a complete HTML page on the server and delivers it ready for immediate display in the browser.
CSR, by contrast, sends a minimal HTML shell and relies on JavaScript in the browser to construct the page. At their core, these strategies represent a fundamental trade-off: should the computational workload be centralized on the server or distributed across user devices? In this section, we’ll focus on SSR.

What is SSR?

Server-Side Rendering (SSR) is a technique where a web page’s HTML is generated on the server in response to a user’s request.
When a user navigates to a URL:

The server processes the request.
It fetches any required data.
It generates a complete HTML document.
That document is sent to the browser, which can immediately display the content. This is different from CSR, where the server sends a lightweight HTML shell and relies on JavaScript running in the browser to fetch data, construct the DOM, and render the final page.

Why Do You Need SSR?

SSR solves several common challenges in modern web development:

Faster First Paint / Initial Load Since the browser receives a fully rendered page, users can see meaningful content almost immediately.
Improved SEO Search engine crawlers can index SSR pages more effectively because the content is present in the initial HTML, not hidden behind JavaScript execution.
Consistent User Experience Across Devices SSR reduces reliance on client-side processing power. This makes it ideal for users on older devices or slower networks, where heavy JavaScript rendering would otherwise cause delays.

When to Use SSR

Content-heavy sites that need SEO (e.g., blogs, e-commerce stores, news sites).
Applications targeting a global audience where device performance and network speed vary.
Pages requiring fast initial load times to reduce bounce rates.

When Not to Use SSR

Highly interactive, dynamic applications (e.g., dashboards, single-page apps) where most of the content changes after the page loads.
Applications with real-time updates (e.g., stock tickers, chat apps) that rely heavily on client-side rendering anyway.
Projects with limited server resources, since SSR increases server workload.

Pros of SSR

Faster initial page load and first contentful paint
Better SEO since crawlers see pre-rendered HTML
Consistent experience across devices
Good for static or semi-static content with high visibility needs

Cons of SSR

Heavier load on the server, which can affect scalability 
Slower page transitions (compared to CSR) since each navigation triggers a new server request 
Increased complexity when integrating with client-side interactivity Caching and performance optimization can be more challenging

Accessibility.

Adetola Esther Aderibigbe — Mon, 28 Jul 2025 09:22:59 +0000

What is accessibility?

Accessibility is the practice of making your app or website accessible to everyone regardless of their ability or disability. It is often referred to as A11y(as in, 'a', then 11 characters, and then 'y'). It can be seen as treating everyone the same, and giving them equal opportunities, no matter what their ability or circumstances.

What type of disabilities are we looking at?

1) People with visual impairments
This includes:

Blindness
Low vision
Color blindness

Many visually impaired users rely on screen readers, which convert digital text into speech, or screen magnifiers. Designers and developers should ensure that all visual elements are also accessible through text, proper HTML semantics, and ARIA labels.

2) people with hearing impairments
This includes individuals with hearing loss ranging from mild to profound
To make content accessible to them,

Videos should be captioned
Audio should come with transcripts
Textual alternatives should be provided for sound-based interactions

3) people with mobility impairments
This includes:

Paralysis or loss of limb function
Neurological disorders affecting control
Age-related movement limitations Such users may not use a mouse. They might navigate entirely with a keyboard, voice control, or adaptive switches. Therefore, all functionality should be operable using a keyboard alone. The Web Content Accessibility Guidelines (WCAG) were developed by the World Wide Web Consortium (W3C) to standardize accessibility. These guidelines are organized around four core principles, known by the acronym POUR.

1. Perceivable

Users must be able to perceive the content, regardless of how they interact with it.
Best practices:

Provide text alternatives (alt) for images
Use captions and transcripts for media
Ensure sufficient color contrast
Structure content with proper headings

2. Operable

Users must be able to interact with and control the interface.
Best practices:

All functionality should be accessible via keyboard
Allow users to pause or disable animations
Avoid flashing content that could trigger seizures
Provide clear navigation and focus indicators

3. Understandable

Content and operation should be easy to comprehend.
Best practices:

Use plain, simple language
Make navigation consistent across pages
Label all forms clearly
Identify input errors and offer suggestions

4. Robust

Content must be usable with a wide range of technologies, including assistive tools.

Best practices:

Use semantic HTML elements <button> <nav> <header> etc.
Add ARIA roles and states where necessary
Ensure compatibility with screen readers and assistive browsers

How to Implement Accessibility in Your Projects

Accessibility is the right thing to do as building accessible sites benefits everyone. A common accessibility myth is that accessibility is an expensive "added extra" to implement on a project.These are some practical suggestions you can take to make your website or app more accessible

1. Start with Semantic HTML

Use the correct HTML elements for structure and meaning.
For example:
Use <button> for buttons, not <div>
Use <label> elements properly linked to form inputs

2. Caption and Transcribe All Media

Don’t rely on auto-generated captions. Always provide human-reviewed captions and transcripts for audio or video content.

3.Navigation

Presenting menus as structured lists gives assistive technologies the context they need to help users navigate. It also improves responsiveness on various devices and screen sizes.
Practice includes:

Placing your menu in a consistent location across all pages
Use HTML or ARIA to highlight the active/selected item
Label menus clearly for easy understanding

4. Order and Grouping

Grouping related items enhances navigation and helps screen readers communicate structure and progress clearly.
Practice includes:

Use unordered lists <ul>for menus or items where order doesn’t matter
Use ordered lists <ol> where sequence is important (e.g. steps in a process
Make sure only <li> elements are children of your lists

5. Color Contrast

Color contrast ensures that text and interactive elements are legible, even for users with low vision or color blindness. Text and background contrast should be at least 4.5:1 and Essential UI icons should have a contrast ratio of at least 3:1

Git as an onion

Adetola Esther Aderibigbe — Mon, 16 Jun 2025 10:16:10 +0000

Git is an open-source version control system that allows developers to track and manage their codebase. It allows several developers to be able to work on one particular project simultaneously without interfering with each other's work. We'll be looking at Git as an onion in which we unfold each layer one by one until we get to the core which is understanding what Git really is.

Benefits of Git

Git helps in tracking changes, making it possible to reverse back to the previous stage in case something goes wrong.
Git allows for multiple people to be able to work on one single project at once.
Git acts as storage, allowing people to share their work. Git heavily relies on the branching system.

Branching
One of the layers of our onion is Branching.
Branching traditionally means diverging from the main development line. It is copying a copy of what already exists.
A branch can also be called a pointer to a commit. The default branch is always the main branch in which other branches are then created from. Branches are mainly created for features, bugs, fixes, experiments, and so on.

Branching Strategy
Branching Strategy is basically defining a set of rules to define how to work with branch. It is creating a structured workflow.

Types of Workflow

Centralized Workflow
In a centralized workflow, work is done usually in the main branch, and it is the most common branch among developers working on personal projects. This is actually not often advised as it is hard to keep track of changes.
Gitflow Workflow
Gitflow Workflow, unlike centralize workflow, this involves a number of branches. There is usually the main branch, which is the stable branch and then the development branch where all the changes happen. We also have a feature branch, which is created solely for development of a particular feature, a release branch for a release, hotfix branch to fix codes already in production, and so on.
Forking Workflow
A fork is a copy of a repo a developer has worked on. A developer can make a copy of a repo(fork a repo)and then make their own changes and then push to their account without affecting the original repo. This workflow is usually used in open source projects.
GitHub Workflow
GitHub Workflow compare to other workflows is lightweight and favoured by GitHub. This workflow is also created around branches and revolves around pull requests. The GitHub Workflow is the workflow in which we will be discussing more in depth in this article.

GitHub workflow heavily operates on a pull request system. Once changes are made in a development branch, the changes are then pushed to the main branch and then this is done by creating a pull request. What the pull request does is it announces a push to a branch, allowing other collaborators to discuss, reveal changes, or even add more commits to the pull request.

Pull Requests
A pull request is another layer of the onion. A pull request improves code quality, as it allows a review system which ensures only quality codes are pushed to production. It also allows transparency to know what changes are made and then who made them. It also allows control which makes sure that only what we want to be pushed to production are pushed. And lastly, pull request also encourages collaborations as it allows developers to review each other's codes, approve and leave comments if there is need to.

A pull request is created using the Git push command
After a pull request has been approved, it is merged into the destination branch.

Merging
After a Pull request has been reviewed and found satisfactory by the reviewer, it is then Merge into the new branch, fully allowing changes made in the feature branch to be visible also in the destination branch.

Type of merge

Merge commit
The default type of merge on GitHub is the merge commit. With this, a new branch is created that brings changes made in the feature branch. This contains histories of both branches.
Squash and merge
Changes made in the feature branch are squashed into a single commit before merging into the destination branch.
Rebase and merge
Using this approach, the commits from the feature branch are placed on the destination branch, and then a merge is executed. The history of the destination branch is rewritten with the new commits.

Merging vs Rebasing
Git Rebase solves the same problem as Git merge. They were both designed to integrate changes from one branch to another. This is however just done in different ways. Git Merge combines histories and creates a merge commit, while Rebase moves your commit on top of another branch, completely rewriting the history. Git Merge preserves exact commit history, while Git Rebase creates a linear and cleaner history.

When to Merge?

When collaborating with other developers on shared branch
To preserve historical paths development took, what branches were combined and so on

When to Rebase?

When working on a solo project
To avoid unnecessary merge conflicts

Merge conflicts
A Merge Conflict occurs when changes are made on the same line of code by different developers. A Merge Conflict can also happen if the file with the changes made in has been deleted. A Merge Conflict has to be resolved before a Merge can happen.

Pull requests go through several states. The first one is the open state which indicates the PR is active and under construction ready to be merged. The second stage is the approved stage after which one or more reviewers have gone through the code and are satisfied with the states. This indicates that the PR is ready to be merged. Change Requested states. This indicates that a reviewer requested that changes be made in a particular file before the PR can be merged. Closed PR. A PR that is closed has been merged.

Git Cherry Picking
Git cherry Picking is an advance merging method. Gits Cherry Picking copies specific commits to another branch. It moves specific commits from one branch and then just that commit is moved into another branch. It creates duplicate commits in each branches, which can also cause confusion.

It is an advanced Gits feature and shouldn't replace a commit.Cherry‑pick does not move the commit. It creates a copy of the commit, but with a new parent in the branch that you're cherry‑picking into. The original commit stays the same.

When to cherrypick?

bug fix that applies to multiple versions of a product
Merge changes from a branch into another without merging the entire branch.

Git Blame
Git Blame is one of the many layers of the onion. It shows the last changes made in the file, when it was made and who made them

When to use Gif Blame

When debugging, it can be used to trace who walked on the path.
To preserve history.
For accountability.

Understanding Git is like peeling an onion layer by layer Before you get to the core, which is understanding how Git works, we have to peel through each layers, one after the other. Pool request, branching, etc. There are several other layers that are also not discussed in this article.

DEV Community: Adetola Esther Aderibigbe

Data Structures in Go[Maps]

Introduction to Maps

syntax

Can keys and values have different data types?

Declaring and Initialising Maps

1. Using a map literal

2. Using make()

3. Declaring a map without initialising it

Adding and Updating Values in a Map

1. Adding a new entry

2. Updating an existing entry

Accessing Values in a Map

What happens when a key does not exist?

Checking Whether a Key Exists (Comma-OK Idiom)

Deleting Entries from a Map

Getting the Number of Entries in a Map

Iterating Over a Map

Important: Map iteration order

Important Characteristics of Go Maps

A. Map keys must be comparable

B. Maps are reference like types

C. A map is not safe for concurrent writes by default

Go Maps vs JavaScript Objects

JavaScript also has a built-in Map

Practical Example: User Lookup

Lesson Takeaways

Data Structures in Go[Arrays and Slices]

Introduction: Why Do We Need Data Structures?

Arrays and Slices in Go

Defining an Array

Declaring and Initialising Arrays

1. Declaring an Array Without Specifying Initial Values

Output:

2. Initialising an Array With Explicit Values

3. Specifying the Length but Providing Fewer Initial Values

4. Allowing Go to Infer the Array Length

Go vs JavaScript: Array Initialisation

Lesson Takeaway

Finding the Length of an Array Using len()

Go vs JavaScript: Finding Array Length

Why is len() important?

Array Assignments in Go

Go vs JavaScript: Array Assignment

Why Are Arrays Less Common Than Slices in Go?

So When Should We Use Arrays?

Slices in Go

Defining Slices

Slice Syntax

Declaring and Initialising Slices

1. Declaring a Slice Without Initialising It:

2. Initialising a Slice Using a Slice Literal

3. Creating a Slice Using make()

4. Creating a Slice With a Specified Capacity

Understanding Length vs Capacity

Shared Underlying Arrays

Multiple Slices Can Share One Underlying Array

Slice Length and Capacity

Length (len): The length is the number of elements currently accessible through a slice. You can get it using Go's built-in len() function.

Capacity (cap): The capacity is the number of elements from the slice's starting position to the end of its underlying array. You can get it using Go's built-in cap() function.

Lesson Takeaway

Adding Elements to Slices with append()

1. Appending a Single Element

2. Appending Multiple Elements

3. Appending One Slice to Another

4. Does append() Always Create a New Underlying Array?

Go vs JavaScript: append() and push()

Slicing an Array or Another Slice

1. Omitting the Start Index

2. Omitting the End Index

3. Omitting Both Indexes

4. Creating a Slice from Another Slice

5. Valid Slice Indexes

Removing Elements from a Slice

What Does the ... Operator Do Here?

JavaScript vs Go: Removing Elements

Copying Slices

Using copy() to Create Independent Slices

How Many Elements Does copy() Copy?

Lesson Takeaway

Finding the Length of an Array Using `len()`

Why is `len()` important?

3. Creating a Slice Using `make()`

Length (`len`): The length is the number of elements currently accessible through a slice. You can get it using Go's built-in `len()` function.

Capacity (`cap`): The capacity is the number of elements from the slice's starting position to the end of its underlying array. You can get it using Go's built-in `cap()` function.

Adding Elements to Slices with `append()`

What Does the `...` Operator Do Here?