Forem: Chathumi Kumarapeli

Go (12) - Mutexes & Generics

Chathumi Kumarapeli — Thu, 22 May 2025 01:39:05 +0000

Mutexes

Mutexes are also used to communicate between goroutines and to lock shared resources so that only one goroutine can access them at a time. This helps in avoiding the concurrent read/write problem.
Mutex (mux) stands for mutual exclusion because it blocks all the goroutines except one.

sync.Mutex

The standard Go library provides a built-in mutex as sync.Mutex, which comes with two methods:

.Lock()
.Unlock()

Only one thread can lock a mutex at once.

An example is given below.

func protected() {
     mux.Lock()
     defer mux.Unlock()
     // ... code here
}

The code block in the above function is protected since there is a mutex. We use the defer function on unlock, so we never miss unlocking the mutex. When a goroutine calls the above function, the function gets locked. So all other goroutines that call this function get blocked until the initial goroutine finishes executing the function.

Maps are not thread-safe. If there is a map used by multiple goroutines (writing to the map), then using a mutex is a must.

Read write mutex

Go's standard library provides another type of mutex: sync.RWMutex.
It has the following methods.

Lock()
Unlock()
RLock()
RUnlock()

Why is this needed? It is not safe to write to a map by multiple goroutines simultaneously. But it is safe to read from a map. When you use Lock(), no other goroutine is allowed to either read or write that resource. But when RLock() is used, multiple goroutines are allowed to read the resource. This increases the performance of the application.

RW mutexes allow infinite readers to read a shared resource but only one writer to update it.

Generics

Generics allow us to use variables to refer to specific types. It helps in reducing code duplication. Look at the function signature below.

func splitSlice[T any] (s []T) ([]T, []T) {}

In the above example, T is the type parameter, and we have mentioned that it can be on any type. This means the above function can slice int arrays, string arrays, etc. The splitSlice can be called like below.

s1, s2 := splitSlice([]int{5, 10, 15, 20, 25, 30})

As you can see, we have passed an integer slice to splitSlice(). So, it returns two integer slices.

Why Generics?

To reduce repetitive code
To use in libraries and packages

Constraints

Constraints are used when generic functions are used only for a subset of types. There, we define an interface on which the generic function should operate.

type stringer interface {
     String() string
}

func concat[T stringer] (vals []T) string {
     // inside this function, you can use
     // String() function in stringer interface
}

Parametric Constraints

Interface definitions that can be used as constraints can accept type parameters.

type store[P product] interface {
     Sell(P)
}

type product interface {
     Price() float64
     Name() string
}

Interface Type List

With generics, a new method of writing an interface was also introduced. With that, we can list a set of types to get a new interface or constraint.

type Ordered interface {
     ~int | ~int8 | ~int16 | ~int32 | ~int64 |
     ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
     ~float32 | ~float64 |
     ~string
}

As you can see, the above interface has no methods but types. But, all those mentioned types support <, <=, >, and >= operators.

You can create an interface using a type list when you know exactly which types satisfy your interface.

Naming generic types

Check out the function signature given below.

func sendRequest[T any](req T) error {}

Note that T is just a variable used as the type parameter. You can name it anything you want. But T is the common version.

Go (11) - Channels & Concurrency

Chathumi Kumarapeli — Tue, 20 May 2025 02:33:14 +0000

Concurrency VS Synchronization

Synchronous code

When code executes line by line in order, one thing at a time is called synchronous. It is simple, but sometimes might not be very efficient.

Concurrency

func main() {
    // block 1
    x := 10
    x++
    fmt.Printf("x = %d", x)

    // block 2
    y := 20
    y--
    fmt.Printf("y = %d", y)
}

Check the code blocks in the above example. As you can see, the code lines in block 1 should execute in order. The code lines in block 2 should also execute line by line. But blocks 1 and 2 have no dependency on each other. So, we can run them separately on two CPU cores. This is called running in Parallel. It increases efficiency.

In Golang, it is easy to write concurrent code.

Go routine

func main() {
    // some code
    go funcName()

    // rest of the code
}

In the above example, you can see go funcName(). It tells that the funcName() function runs in parallel with the rest of the code in the main function.
So all you need to do is use the go keyword to instruct it to run in concurrent mode. We have a special name here for concurrent functions: go routine. In the above example, funcName() is a go routine.

We can't expect return values from a go routine like we get from a regular function.

Now, you might wonder what the use of these go routines is if they can't even return a value. That is why we have channels.

Channels

Channels are used to communicate between goroutines. They are a type-safe and thread-safe queue.
One or more goroutines can put data into a channel, and one or more other goroutines read that data from the channel.

Syntax to make a channel,

ch := make(chan int)

Above, initialize a channel of type int.

You can put data into channels using the syntax below.

ch <- 10

The <- is called the channel operator. The arrowhead shows the data flow direction.

Use the below syntax to receive data from a channel.

val := <- ch

It removes the value from the channel and saves it to the val variable.

Both sending and receiving data operations are blocking operations. If a value is sent to a channel but there is no other goroutine to receive the data, the code will stop and wait. The same happens during the reading. When a goroutine is expecting data from a channel, but no one is writing data to it, then the code is blocked there.

A token is a unary value. Most of the time, empty structs are used as tokens. What is passed through the channel is not a concern in this scenario. <-ch syntax is used to block and wait until something is sent to a channel.

Buffered Channels

When making a channel, we can make it buffered by providing a buffer length as the second argument.

ch := make(chan int, 100)

When the buffer is full, sending to the channel gets blocked. Likewise, when the buffer is empty, the receiving from the channel is blocked.

Closing channels

Channels should always be closed from the sending side. It says that this channel is closed, there's nothing more to read from it. The syntax is given below.

ch := make(chan int)
// code lines ...
close(ch)

Therefore, on the reading side, we have to check whether a channel is closed.

v, ok := <-ch

In the above example, the ok is a boolean variable. Its value is true if the channel is open. Else, ok is false.

If you send a value to a closed channel, that go routine will panic.

Closing a channel is not necessary. Unused open channels are garbage collected.

Range

The range can be used on channels as well. The example below receives values over the channel until it is closed. When the channel is closed, the loop exists.

    for item := range ch {
        // item is the next value received from the ch
    }

Select

When there is a single goroutine listening to multiple channels, we might need to process data in order per channel. In this case, we can use the select statement to switch between channels.

select {
    case i, ok := <- chInst:
        if !ok {
            return
        }
        fmt.Print(i)
    case s, ok := chString:
        if !ok {
            return
        }
        fmt.Print(i)
}

Read-only channels

When you want to make a channel read-only, you should cast it from chan to <-chan type.

func readCh(ch <-chan int) {
    // ch is a read-only channel in this function
}

Write-only channels

To make a channel write-only, you should cast it from chan to chan<- type.

func readCh(ch chan<- int) {
    // ch is a write-only channel in this function
}

Read-only and write-only channels concept is useful in identifying which functions use the channel for reading and which use it for writing.

Few points to remember:

A send to a nil channel blocks the code forever
A receive from a nil channel blocks forever
A send to a closed channel panics
A receive from a closed channel returns the zero value

Go - (10) Packages & Modules

Chathumi Kumarapeli — Thu, 15 May 2025 01:34:33 +0000

Packages

Main package

If you see package main at the top of a go file, you have been writing your code within the main package. It has the entry point to the main function. The main package runs as a standalone programme. So, the executable code should be written within the main package.

All other packages (any package whose name is not main) are library packages. You can use (import) those libraries in your code. Library packages export named functions that other libraries can use.

package main

// imports from the standard library
import (
    "fmt"
)

func blah() {
    fmt.Println("=====> Hello there!")
}

Libraries

You can import standard libraries by their name. Like we have done to "fmt". But the import statement is different if you have published your library and want to use it in another code. There, you should give the path to your remote repository of that library.

// myrepo is the custom library
import (
    "github.com/myusername/myrepo"
)

Package name is the same as the last element of its import path. It is not a rule but a best practice.

In Go, if all of the code exists in the same directory, it's part of the same package. Because in Go, we don't export or import code in the files of the same directory (package). So, you want to import code only if they are in a different directory/package. Directory and package are the same in Go, because you can have multiple packages in the same directory.

Modules

A module is a collection of packages that are released together.

A Go repository usually has only one module. It is located at the root of the repository.

The module of a repo is declared by the go.mod file, which is at the root. It contains,

module path
Go version
external package dependencies (optional)

In Go, a module is given by its remote repository path where the module is hosted. It tells Go where it can download the module from.

An import path is the combination of the module path and package subdirectory.

Packages in the standard library do NOT have a module path prefix.

$GOPATH is an environment variable whose value is set by default in a location on your machine. Usually, it is ~/go. But since we are working with Go modules, we can avoid putting our code into the $GOPATH/src directory.

Go includes a remote URL in module paths to simplify remote downloading of packages.

There are two ways to run a Go programme.

go run main.go: This is suitable for a very small code. It simply runs the code. Go run can accept package names and file names are arguments.
go build: This produces a production executable. It gives a compiled binary that can run anywhere.

If you execute go install inside your repository, Go installs your application globally on your machine. Now, you can run your binary by simply giving its name from anywhere on your machine.

Initialize a module

Create a directory named mymodule and cd into it. Then run below:

remote: something like github.com
username: Github namespace

go mod init <remote>/<username>/mymodule

It creates a new go.mod file.
Then you can start writing your code inside it with a new package mymodule. This can be imported into other packages of your main project. But for that, make sure you start the names of your functions in Capital letters. Lowercase names are not exportable in Go.

Running go build on a library package compiles it and silently saves it to the local build cache.

Go - (9) Pointers

Chathumi Kumarapeli — Sun, 27 Apr 2025 05:43:00 +0000

Pointers

Here we talk about the usage of Pointers in Golang. We don't discuss pointer theories.

A pointer stores the memory address of another variable.

x := 5 // value of x is 5
y := x // value of y is 5
z := &x // value of z is the memory address of x

*z = 6 // value of x is updated to 6
fmt.Println(*z) // prints 6

* is called the dereference operator

Syntax to define a pointer: var p *int // p is an integer type pointer

The & operator generates a pointer to its operand.

greeting := "yellow"
ptr := &greeting // a pointer to greeting variable

Why use Pointers

To pass the value by reference
Increase the performance and memory efficiency.

func replaceMsg(msg *string) {
    val := *msg
    val = strings.ReplaceAll(val, "Hi", "Hello")
    *msg = val
}
func main() {
    m := "Hi, Bella. Hi, Edward. Hope you're doing well!"
    replaceMsg(&m)
    fmt.Println(m)
}

Let's go through the above function code lines.

The val := *msg dereferences the pointer msg to get its actual string value. Then it is assigned to the val variable.
val = strings.ReplaceAll(val, "Hi", "Hello"): replaces all occurrences of "Hi" with "Hello" in val
*msg = val: writes the modified string to the memory location msg points to.

Nil Pointers

If a pointer points to nothing, the code panics. Therefore, you should always check whether a pointer is nil before you move further in your code.

The updated replaceMsg() with the safety check for a nil pointer is given below.

func replaceMsg(msg *string) {
    if msg == nil { // nil pointer check
        return
    }
    val := *msg
    val = strings.ReplaceAll(val, "Hi", "Hello")
    *msg = val
}

Pointer receivers

Methods can take pointers as the receiver type. Those methods can directly modify the values the pointer points to.

type car struct {
    color string
}

func (c *car) setColor(color string) {
   c.color = color 
}
func main() {
    c := car {
        color: "green"
    }
    c.setColor("purple")
    fmt.Println(c.color) // prints "purple"
}

Go - (8) Advanced Functions

Chathumi Kumarapeli — Sun, 27 Apr 2025 03:24:31 +0000

Higher Order Functions (HOF)

We can pass functions as data to another function.

A function that takes in another function as a parameter or returns another function is called a Higher-order function.

func aggregate(a, b, c int, arithmetic func(int, int) int) int {
    return arithmetic(arithmetic(a, b), c)
}

The aggregate () function takes four parameters. As you can see, the last one is another function. And the aggregate () function calls the passed-in function twice and returns an int.

First Class Function (FCF)

A function that is treated like another variable.

HOFs and FCFs are usually used as,

HTTP API handlers
pub/sub handlers
onclick handlers

Currying

Writing a function that takes function/s as parameters and returns a new function.
It is not very commonly used in programming.

// Takes two integers and returns their product
func multiply(x, y int) int {
    return x * y
}

func doMath(mathFunc func(int, int) int) func (int) int {
    return func(x int) int {
        return mathFunc(x, x)
    }
}

func main() {
    squareFunc := doMath(multiply) // Pass the multiply function to doMath
    fmt.Print(squareFunc(5))
}

In the above example, square(5) internally does doMath(multiply(5, 5)). So the final answer is 25. Here we have wrapped multiply inside a new function that always multiplies a number by itself.

Defer

A keyword unique to Go.
Allow a function to execute automatically right before its enclosing function returns.

Why is this defer() required? Check the example below. The copyFile function has several return statements. When you open a file, you should close it once its usage is done. But you have done it before every return statement. This is tedious. So instead, you can use a defer.

func copyFile(desination, source string) (written int64, err error) {
    src, err := os.Open(source) // open file
    if err != nil { return }

    defer src.Close()

    dest, err := os.Create(desination) // create file
    if err != nil { return }

    defer dest.Close()

    return io.Copy(dest, src) // copy source file content to dest file
}

Closures

Functions that reference variables that are outside their function bodies.
They may also access and assign to the referenced variables.

// closure function
func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c := counter()

    fmt.Println(c()) // 1
    fmt.Println(c()) // 2
    fmt.Println(c()) // 3

    d := counter()   // new counter
    fmt.Println(d()) // 1
}

In the above example, the count variable in counter() is outside of the function body of its return function. But whenever you call c (in the main function) again and again, the reference to the count is increased.

Anonymous functions

Functions with no names
used in closures or when you return a function as a return value.

Check the example below.

func main() {
    // Anonymous function assigned to a variable
    greet := func(name string) string {
        return "Hello, " + name
    }

    // Call the anonymous function
    message := greet("Edward Cullen")
    fmt.Println(message)
}

The above example will print Hello, Edward Cullen

Go - (7) Maps

Chathumi Kumarapeli — Sun, 27 Apr 2025 01:47:06 +0000

Maps

A collection of key-value pairs

You can initialize maps like below.

    students := make(map[string]int)
    students["SE"] = 100
    students["BA"] = 73
    students["DA"] = 49

    ages := map[string]int {
        "Bella": 17,
        "Edward": 18,
    }

To get the number of key-value pairs in the map, use the len () function.

Searching for a value in a map using its key is much faster than searching a slice. You should search the index by index in a slice until you find the value.

Syntaxes of Maps

insert a value: mapName[key] = value
get a value: value = mapName[key]
delete a value: delete(mapName, key)
check if a key exists: value =, ok := mapName[key]

Any type can be used as map values, but not as map keys. Keys should be comparable types (numeric, string, bool, channel, pointer, and interface). So, types like slice or array cannot be used as map keys.

If you try to access a nil map, the code panics.
If you try to access a value where the key doesn't exist, the code returns the zero value.
You can't have duplicate keys. A key can have a maximum of one value assigned to it.
If you pass a map to a function and update its elements inside the function, the content of the original map is changed.

Go - (6) Arrays and Slices

Chathumi Kumarapeli — Sat, 26 Apr 2025 12:17:41 +0000

Arrays

In Go, arrays have a fixed size.

var marks [10]int // an array of 10 integers

Assigning values to an array looks like this.

names := [3]string{
    "Edward",
    "Bella",
    "Jcob",
}

In Go, if you assign an array to another array, it copies all the elements of the first array. Also, when you pass an array to a function, it gets a copy of the array.

But what if you want to allocate size dynamically?

Slice

Built on top of arrays.
Holds a reference to the underlying array.
Dynamically-sized
In Go, we work with slices 90% of the time.

Unlike assigning an array to another array, when you assign a slice to another slice, both points to the same array. This gives pointer-like behaviour.

sliceA := make([]int, 4, 8)
sliceFixed := make([]string, 5)
sliceLiteral := []string{"hello", "hi", "thanks"}

Capacity of a slice is the maximum length it can take. If the data exceeded the capacity, the slice is reallocated. You can get the capacity of a slice using the cap() function.

Length is the current length (number of elements) a slice has. You can get the length of a slice using the len() function.

In the above example, sliceA is an int slice, which is 4 in length but has a capacity of 8. Both the length and capacity of the sliceFixed size are 5. Also, if you print the length of sliceLiteral, it will give 3.

Variadic functions

A function that can take an arbitrary number of final arguments.

Check the example below. The printNames() function takes the names argument, which is a slice. You can see it in the main function where we call the printNames(). Note that we can pass a slice any number of string elements.

func printNames(names ...string) {
    // names is a slice
    for i := 0; i < len(names); i++ {
        fmt.Println(names[i])
    }
}

func main() {
    users := []string{"edward", "jcob", "bella"}
    printNames(users...)
}

Instead of a for loop, you can use range to print elements of a slice.

func printSweets() {
    sweets := []string{"cake", "chocolate", "toffee", "macrons"}
    for _, s := range sweets {
        fmt.Println(s)
    }
}

Go - (5) Errors & Loops

Chathumi Kumarapeli — Thu, 24 Apr 2025 02:10:59 +0000

Error Handling

Languages like JS use try catch blocks for error handling.
But in Go, it is a bit different.

Check the example below.

func getUser() (string, error) {
// ... some code here
    return username, err
}

func main() error {
    name, err := getUser()
    if err != nil {
// if err is not nil, return the error
        return err
    }
// if no errors, print the username
    fmt.Printf("User name: %s", name)
}

Error handling in Go is more convenient because it doesn't need nested error handling like in try-catch blocks.
Also, we can see which functions return error by looking at the function signature.
Go has a package named errors. It has methods like New() to initialize errors.

import (
    "errors"
)

func getUser() (string, error) {
// ... some code here
    return username, errors.New("couldn't get the username") // a new err is returned
}

Loops

The syntax of Go loops is very similar to loops in JS. The only difference is that we don't use parentheses.

An example of a traditional for loop is given below.

for i := 0; 0 < 10; i++ {
    fmt.Print(i)
}

I Go loops, the condition in the loop is optional. If you check the example below, it goes out of the loop considering the conditional block.

totalCost := 0.0
threshold := 5.0
for i := 0; ; i++ {
    totalCost += 1.0 + (0.01 * float64(i))
    if totalCost > threshold {
        return i
    }
}

Go - (4) Interfaces

Chathumi Kumarapeli — Tue, 15 Apr 2025 13:23:24 +0000

Introduction

Interfaces are a collection of method signatures.

type shape interface {
    area() int
    perimeter() int
}

In the above example, shape is anything that can be used to calculate its area and parameter. If you check the example below, you can see that rectangle implements both the area() and perimeter() methods. So, it means rectangle implements the shape interface.

type rectangle struct {
    length int
    width  int
}

func (r rectangle) area() int {
    return r.length * r.width
}

func (r rectangle) perimeter() int {
    return (r.length + r.width) * 2
}

Multiple types can implement the same interface. If there is another struct named circle with area() and perimeter() methods, then it also implements the shape interface.
Likewise, a single type can implement multiple interfaces as well. For example, an empty interface like interface {} is always implemented by every type.
In Go, interfaces are implemented implicitly. If you check the above function, you can see that we have never explicitly mentioned that the rectangle struct is implemented by shape (like we do in Java).

Named argument interfaces

You can also use named arguments and return data in interface methods. If you check the below function, it is not that clear what are the arguments passing to the Copy() method. You only know that they should be strings.

type Copier interface {
    Copy(string, string) int
}

Therefore, to give more readable interface methods, you can define the interface like below.

type Copier interface {
    Copy(sourceFile string, destFile string) (copiedBytes int)
}

Type assertion

Assume you have several types implemented by the shape interface. But you need to write a function to take the area of a rectangle. In such a case, you should use type assertion.

func getArea(s shape) int {
    r, ok := s.(rectangle)
    if ok {
        return r.length * r.width
    }
    return 0
}

Here, you pass a shape and check whether it's a rectangle. If it is, the value of ok would be true. And r would get a rectangle struct.

Type Switch

Instead of type assertion, you can also use switch cases.

func printNumericValue(num interface{}) {
    switch v := num.(type) {
    case int:
        fmt.Printf("%d", v)
    case string:
        fmt.Printf("%s", v)
    default:
        fmt.Printf("%T", v)
    }
}

Clean Interfaces

Keep interfaces as simple as you can.
Don't make the interface aware of the underlying types (ex: shape interface should not have methods like isCircle()).

Interfaces are not classes. They are much simpler. They don't have constructors or deconstructors to create/destroy data. There is no hierarchy of passing behavior (parent-to-child behavior).

Go - (3) Structs

Chathumi Kumarapeli — Mon, 14 Apr 2025 12:53:55 +0000

Structs

The data types created by the programmer.
A collection of key-value pairs.
All the keys in a struct don't need to be in the same data type.

type Employee struct {
    Name string
    Age  int
    Job  string
}

Data types of keys can also be structs (not primitive datatypes). As you can see in the below example the DepartmentHead is of type Employee.

type Department struct {
    DepartmentName     string
    DepartmentLocation string
    DepartmentHead     Employee
}

Struct usage

The syntax of struct initialization is given below.

deptHead := Employee{}

You can access the keys of a struct by using the dot operator. It is also used to assign values to the keys.

deptHead.Name = "Edward Cullen"
deptHead.Age = 17
deptHead.Job = "Department Head"

Anonymous structs

In Go, we can define structs without giving them a name. It is used only when you do not need several instances of a struct. An example is given below.

user := struct {
    name string
    age int
    job string
} {
    name: "Bella",
    age: 11,
    job: "Writer",
}

Also, note that using unnamed structs is not that much common.

Nested structs

We can have structs inside a struct. And the inserted struct can be anonymous.

type Department struct {
    DepartmentName     string
    DepartmentLocation string
    DepartmentHead     struct {
        Name string
        Age  int
        Job  string
    }
}

For clean code use named structs whenever possible.

Embedded structs

Embedded structs are different from nested structs. Here, you don't use a key-value pair inside the main struct. Look at the given example.

type deptHead struct {
    Name string
    Age  int
    Job  string
}

type Department struct {
    DepartmentName     string
    DepartmentLocation string
    deptHead
}

The struct deptHead is directly embedded in the Department struct without any key (field). Therefore, Department inherits all the features of deptHead directly. So, you can access Name directly from a Department instance (Department.Name).

Even though I have used the word inheritance above, please note that Golang is NOT an object-oriented language. It doesn't suppose classes or inheritance.

The fields of an embedded struct are accessed at the top level unlike in nested structs.

dept := Department{
    DepartmentName:     "wearwolf",
    DepartmentLocation: "seattle",
    deptHead: deptHead{
        Name: "Jcob",
        Age:  16,
        Job:  "Department head",
    },
}
fmt.Printf("Department head is %s", dept.Name)

If you check the print statement in the above example, we have accessed the name of the department head directly. We can use dept.Name instead of dept.deptHead.Name when using embedded structs.

Struct Methods

We can define methods (functions) on structs. You can initialize a struct and then use dot operator to access its methods. Check out the example below.

type rectangle struct {
    lenght int
    width  int
}

func (r rectangle) getArea() int {
    return r.lenght * r.width
}

func main() {
    r := rectangle {
        lenght: 10,
        width: 5,
    }
    area := r.getArea() // calling method using dot operator
    fmt.Printf("Area of r: %d", area)
}

Go - (2) Functions

Chathumi Kumarapeli — Mon, 14 Apr 2025 06:21:14 +0000

Functions

Syntax of function signature

func funcName(arg1 dataType, arg2 dataType) returnType

In a case where there are more than one return type:

func funcName(arg1 dataType, arg2 dataType) (returnType1, returnType2)

Example function:

func add(a int, b int) int {
    return a + b
}

Since all the arguments in add function are in the same data type int, we can also write the function as below. As you can see we have given the data type of the arguments only once.

func add(a, b int) int {
    return a + b
}

Return value

Functions in Go can return,

No value
Single value
Multiple values An example per each type of the above functions is given below.

func printDiscount(price float32) {
    // returns no value
    fmt.Printf("Discounted value: .2%f", price*0.8)
}

func increment(x int) int {
    // returns a single value of type int
    x++
    return x
}

func getPass(marks int) (string, string) {
    // returns multiple values with type string
    // also note that the return values can be of different data types
    status := "Fail"
    level := "F"
    if marks >= 75 {
        status = "Pass"
        level = "A"
    } else if marks >= 55 {
        status = "Pass"
        level = "B"
    }

    return status, level
}

Go doesn't allow you to have unused variables. So, it has a way to ignore return values. Assume there is a function that returns two values, but you only want the first value it returns.

func getCoordinates() (int, int) {
    x := 3
    y := 4
    return x, y
}

If you only want x coordinate from the above function, use the below syntax.

x, _ := getCoordinates()

The _ tells the Go to ignore the second return value.

In Go, we can also name return values. In a scenario like that, the function execution is a bit different. Check out the function given below.

func getCoords() (x, y int) {
    // ... some code here
    return
}

As you can see we have named two return values as x and y, and given them the type int. With that, they get initialized with the value 0. As you can see we have simply used return. There the function returns x and y in order. You need not to explicitly say return x, y.

So when to use named return values? Think you have a function where you need to return the height, width, and length of an object. In such a case it may look more readable to state (height, width, length int) instead of (int, int, int).

Guard Clause

Guard clauses mean early returns. Check the func getPass(marks int) (string, string) that I have written above. There we have a single reutrn right before the end of the function. But we can have early returns per each condition, which is ideal. It provides a linear approach to logic trees.

func getPass(marks int) (string, string) {
    if marks >= 75 {
        return "Pass", "A"
    } else if marks >= 55 {
        return "Pass", "B"
    } 
    return "Fail", "F"
}

Pass by value

In Go, variables are passed by value, not by reference.

func main() {
    x := 10
    increment(x)
    fmt.Printf("incremented value: %d", x)
}

func increment(x int) {
    x++
}

In the above code, the main function gives "incremented value: 10".
So why is it not incremented even though we have called increment() function? That is because we are not returning the incremented value and assigning it to x. In the above code, a new memory address is used in increment(). The correct way is given below.

func main() {
    x := 10
    x = increment(x)
    fmt.Printf("incremented value: %d", x)
}

func increment(x int) int {
     x++
     return x
}

Go - (1) Intro

Chathumi Kumarapeli — Sat, 12 Apr 2025 12:26:54 +0000

A bit about Go

Any interpreted language is slower than Go because it is compiled.
High execution and compilation speed.
Go is faster than interpreted or VM-powered languages like Python, JS, PHP, Ruby, and Java
Go is slower in execution speed than compiled languages like C, C++, and Rust.
Go is slower in the above case because of its automated memory management (Go runtime).

Compilation: converting human readable code into machine readable code (to binary).

Go does compile work upfront. When you write a Go file and build it, it generates an executable that can be directly run on a machine. But an interpreted language converts the code as we run it.
Go is a static-typed language. If you initially set a variable as a string, you can't later change it to another data type.
Go has automated memory management. When Go code is compiled, you get one binary (an executable program) with a runtime in it. That runtime is used for garbage collection and automated memory management.
Memory efficient languages: Java <<< Go < Rust
One of the purposes of Go runtime is to clean up unused memory.

Numerics in Go

Numbers fall into four categories when it comes to

integers: whole numbers
unsigned integers (units): positive numbers
floats
complex numbers: imaginary numbers

The size of the numbers should also be considered. For example,e uint16 is twice the size of uint8. So you should use the data type that matches your requirement. For example, 255 is the largest number you can store in a uint8.

There is another data type named byte which is usually used in scenarios like marshaling a JSON object. It is also an alias for ùint8` because a byte is just 8 binary digits.
rune is an alias for int32

Declaring variables

Golang has := operator which is used for variable initialization
Ex: name := "". Here, there is no need to specify the datatype of name because Go identifies it as a string.

If you want to print the type of a variable instead of its value use %T.

Ex: fmt.Printf("The type of name variable is %T\n", name)

You can also declare multiple variables in the same line.

Ex: name, age := "Edward", 17

Number conversions

We can also convert numbers between different number types. Ex:

numInInt := 88 numInFloat := float64(numInInt)

But converting it the other way (float to int) is tricky. Because if the number is 88.8, we will lose 0.8 when converted to int.

The size of a type (ex: int64) is indicated in bits.

In JS const means you can't reassign to a variable. But you can compute the variable value at runtime. In Go, constants must be known at compile time (before running the program). Ex:

const Greeting = "Hello World!" // ✅ correct const RandomNumber = rand.Intn(10) // ❌ Compile-time error because of rand.Intn(10) is only known at run time

Formatting strings

Formatting strings in Go is a bit unfriendly. We use the fmt package for that which includes functions like Printf (print a formatted string directly to standard out) and Sprintf (returns formatted string as a value). Below are several formatting verbs in Go.

%s: for string
%d: for int in decimal
%f: for decimal (ex: 8.254)
%t: for bool
%v: the default formatted

Ex: fmt.Printf("It costs %.2f", 34.746) gives "It costs 34.75".

Conditionals in Go

The syntax is given below, the execution is pretty much the same as in other languages.

if marks >= 75 { fmt.Println("You got an A") } else if marks >= 45 { fmt.Println("You got an Pass") } else { fmt.Println("You failed.") }

One of the cleaning code hacks in Go, when a variable is only used for a conditional check is given below.

if err := getUsername(); err != nil { return fmt.Errorf("err", err) }