Golang is statically typed compiled language. So it can be compared with languages such as C++. Now, C++ has arrays however those were not with dynamic length. However we also have collections using which can make dynamic arrays.

Similarly, in Golang, an array has a static length.

var myArr = [3]int{1, 2, 3}

In the above example, we have created an array with 3 elements. The basic syntax of creating an array is:

[length]datatype{element1, element2, element3...}

You can define arrays in following ways

var myArr = [4]int{1, 2, 3, 4}                //fixed length
var myArr2 = [...]int{1, 2, 3, 4, 5}          //fixed length but dynamic length calculation
var myArr2 = [8]int{1, 2, 3, 4}               //next 4 values will be zero
var myArr2 = [5]string{"I", "am", "awesome"}  //next 2 values will be empty strings ""
var myArr2 = [2]int{1, 2, 3, 4}               //this will cause an error

Let’s create one more array

var myArr = [8]int{1, 2, 3, 4}

In the above example, we have created an array of length 8 however we have added only 4 elements in it. The other 4 elements in this case will be zero because the type is int. For strings, the zero value is ““. For pointers the zero value is nil.

We can index those elements and change the values. Accessing values is similar to other programming languages, using indexes. Arrays are 0-indexed.

myArr[4] = 5
myArr[5] = 6
myArr[6] = 7
myArr[7] = 8

Slices in simple words are dynamic arrays. Slices provide you with modularity over arrays. Creating a slice is similar to creating an array. You just don't provide the length of the array.

var myArr []int = []int{1, 2, 3}
myArr2 := []int{1, 2, 3, 4, 5}
fmt.Println(myArr)
fmt.Println(len(myArr2))
fmt.Println(cap(myArr2))

In the above example, you can see the cap function which returns the capacity that the slice can hold currently as per the memory alloted to it. This as well is dynamic and grows with the length of the array.

To append values to a slice, you can use the append function as follows:

arr := []int(1, 2, 3, 4)
arr = append(arr, 5)

Below are some more examples

arr := []int{1, 2, 3, 4}
fmt.Println(arr, len(arr), cap(arr))
arr = append(arr, 5)
fmt.Println(arr, len(arr), cap(arr))
arr2 := []int{1, 2, 3}
fmt.Println(arr2, len(arr2), cap(arr2))
arr2 = append(arr2, 4) // Capacity changes to 6 (2x)
// arr2 = append(arr2, 4, 5)             // Capacity changes to 6 (2x)
// arr2 = append(arr2, 4, 5, 6)          // Capacity changes to 6 (2x)
// arr2 = append(arr2, 4, 5, 6, 7)       // Capacity changes to 8 (2x + 2)
// arr2 = append(arr2, 4, 5, 6, 7, 8, 9) // Capacity changes to 8 (2x + 2 + 2)
fmt.Println(arr2, len(arr2), cap(arr2))
fmt.Println(arr2, len(arr2), cap(arr2))

In the above examples, I noticed one thing. When you append to an array for which the length and capacity are equal, it doubles the capacity of the array.

When the elements that are being added are more than the current length of the array and the length and capacity are equal, the capacity is incremented in a different way.

If the length and capacity of array is 3, and you are adding 6 elements, so the final length of array will be 9.

But capacity will be incremented as follows:

1. First it will double the capacity. so 3 becomes 6.

2. Can 9 elements fit in the capacity of 6, no... Hence now the capacity is further increased by 2 so the new capacity becomes 8.

3. Can 9 elements fit in the capacity of 8, no... hence now the capacity is further increased by 2 so the new capacity becomes 10.

4. Can 9 elements fit in the capacity of 10, yes. So this is the final capacity.

I observed that capacity first increases by 2 x original capacity and then is incremented by 2.

But once the append operation is done, and the length has gone from 3 to 9 and the capacity has become 10, if you now append again but just one value, then the capacity remains 10 and length becomes 10.

However instead of one value, if you increment 2 values, the length becomes 11, which cannot fit in the capacity of 10. So now the capacity is first doubled again from 10 to 20.

So the new length will be 11 and the new capacity will be 20.

Adding Slice to Slice

arr2 = append(arr2, arr...) //adding slice to another slice
fmt.Println(arr2, len(arr2), cap(arr2))

The above example shows how you can add a slice to a slice using the ... operator.

Slicing a Slice

arr3 := arr2[5:7]
// arr3 := arr2[:7] // will slice from start upto 7
// arr3 := arr2[5:] // will slice from 5 till end
// arr3 := arr2[:] // will slice from start to end
fmt.Println(arr, arr2, arr3)
arr3[1] = 25 //Updates original array (arr2) as well but (arr) won't change
fmt.Println(arr, arr2, arr3)

In the above example, we created a shorter version of the slice from index 5 to 7(not inclusive of 7). However the arr3 elements have the same reference as of arr2 and hence when you make any change in arr3, arr2 gets affected.

arr3 = append(arr3, 82, 83, 84)
fmt.Println(arr, arr2, arr3)

If you further append into arr3 like above, the effect will be as follows

1. The length of arr2 is 9 while arr3 is indexed from 5th upto 7th index of arr2. The length of the arr3 is 2 but the capacity is 7 because you sliced upto 7 even though you took only 2 elements. The memory referencing will be as follows

mem  0  1  2  3  4  5  6  7  8  9  10
arr2 1  2  3  4  1  2  25 4  5
arr3                2  25 -  -  -  -  -

2. In the above example, the - represents memory reserved for arr3 elements. So you can notice that the memory reservation also starts from the 5th index of arr2. So basically for arr3, the index 7 and 8 of arr2 are actually reserved for arr3 but empty in arr3's perspective. But for arr2, those actually hold values.

3. When you append 3 elements 82, 83 and 84... 82 and 83 take the 7th and 8th index of arr2 so the 7th and 8th index of arr2 are updated as well

4. Now arr3 has memory reserved beyond the memory of arr2. So 84 takes next position to 83. But since arr2 does not have that memory reserved for itself, 84 does not reflect in arr2.

So the initial and final state of arr2 and arr3 will be:

initial
arr2 = [1, 2, 3, 4, 1, 2, 25, 4, 5]
arr3 = [2, 25]

Final
arr2 = [1, 2, 3, 4, 1, 2, 25, 82, 83]
arr3 = [2, 25, 82, 83, 84]

Copying a slice

If you wish that the above should not happen, then you can copy slices with their memory addresses as well using the copy function.

myarr1 := []int{1, 2, 3, 4, 5, 6, 7, 8}
myarr2 := myarr1[5:7]
var myarr2Copy = make([]int, len(myarr2))
copy(myarr2Copy, myarr2)

Here we used 2 functions, make and copy. We will discuss more about make later. But for now, make is a way to declare variables as well as allows to declare the length and capacity as well.

We declared a myarr2Copy variable which has same length as of myarr2. Then we used the copy function to copy values from myarr2 to myarr2Copy. Since we have already declared the myarr2Copy variable, it's address will be different as of myarr2 or myarr1.

So now if you append to myarr2Copy

fmt.Println(myarr2Copy, myarr2, myarr1)
myarr2Copy = append(myarr2Copy, 9, 10, 11)
fmt.Println(myarr2Copy, myarr2, myarr1)

This should not update myarr2 or myarr1 and only myarr2Copy will be appended.

Make Function

Make function let's you declare variables just like var. There are some differences though. Make function has 3 parameters

make(type, length, capacity)

The type is the data type to be declared, the length and capacity can be passed in case of slices while for other types, length and capacity is not needed.

Make does not work for primitive types like bool, int and string, but works for slices, struct and map.

var x []int
x[0] = 10 //this will cause an error

x := make([]int, 4)
x[0] = 10 //this will work

In the above example, we declared x as []int however with var, we cannot provide the length of the slice. And hence the length of slice will remain zero. So in that case if you index the 0th index that will cause an error.

However, if you see the make example, we are passing 4 as the length. So x will be a slice with initial length of 4. So it will be safe to access the 0th index.

There is an additional way to decalare variables. Look at the below example

x := new(int) // intialized as 0
fmt.Println(*x)
y := new(string) // initialized as ""
fmt.Println(*y)
z := new([4]int) // initialized as [0,0,0,0]
fmt.Println(*z)

We can use the new keyword for allocating memory as per data type. However the variables will be pointer variables. We will discuss about pointers later.

If you find any question difficult, Go Tour(https://go.dev/tour/welcome/1) is your best help. It will take atmost two days to cover all the slides.

After solving all, you will realize Golang has its own quirks, just like Javascript.

For answers, checkout: https://github.com/SankalpSTG/go-guide/blob/main/interview-questions/output-based/answers/README.md

Q1. What will be the output for the following code

package main

import "fmt"

func main() {
    funcs := []func(){}
    for i := 0; i < 3; i++ {
        funcs = append(funcs, func() { fmt.Println(i) })
    }
    for _, f := range funcs {
        f()
    }
}

Q2. What will be the output for the following code

package main

import "fmt"

func main() {
    s := []int{1, 2, 3}
    t := s[:2]
    t = append(t, 99)
    fmt.Println("s:", s)
    fmt.Println("t:", t)
}

Q3. What will be the output for the following code

package main

import "fmt"

func f() (x int) {
    defer func() {
        x++
    }()
    return 1
}

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

Q4. What will be the output for the following code

package main

import "fmt"

type T struct{}

func (t *T) String() string {
    return "I'm T"
}

func main() {
    var t *T = nil
    var i fmt.Stringer = t
    fmt.Println(i == nil)
    fmt.Println(i)
}

Q5. What will be the output for the following code

package main

import "fmt"

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        ch1 <- 1
    }()

    select {
    case x := <-ch1:
        fmt.Println("Received", x)
    case y := <-ch2:
        fmt.Println("Received", y)
    }
}

Q6. What will be the output for the following code

package main

import "fmt"

func main() {
    x := 5
    {
        x := x
        fmt.Println(x)
    }
}

Q7. What will be the output for the following code

package main

import "fmt"

func main() {
    defer fmt.Println("deferred")
    panic("something went wrong")
    fmt.Println("after panic")
}

Q8. What will be the output for the following code

package main

import "fmt"

func main() {
    s := []int{1, 2, 3}
    t := s
    s = append(s[:1], s[2:]...)
    fmt.Println("s:", s)
    fmt.Println("t:", t)
}

Q9. What will be the output for the following code

package main

import "fmt"

type MyStruct struct{}

func (m *MyStruct) Error() string {
    return "error from MyStruct"
}

func main() {
    var m *MyStruct = nil
    var err error = m
    fmt.Println(err == nil)
    fmt.Println(err)
}

Q10. What will be the output for the following code

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int)

    select {
    case v := <-ch:
        fmt.Println("Received", v)
    default:
        fmt.Println("No value received")
    }

    time.Sleep(time.Second)
}

Q11. What will be the output for the following code

package main

import "fmt"

func main() {
    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }

    for k, v := range m {
        fmt.Println(k, v)
    }
}

Q12. What will be the output for the following code

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3}
    var ptrs []*int

    for _, n := range nums {
        ptrs = append(ptrs, &n)
    }

    for _, p := range ptrs {
        fmt.Println(*p)
    }
}

Q13. What will be the output for the following code

package main

import "fmt"

func main() {
    s := "hello"
    b := []byte(s)
    b[0] = 'H'
    fmt.Println(s)
    fmt.Println(string(b))
}

Q14. What will be the output for the following code

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 3; i++ {
        go func() {
            fmt.Println(i)
        }()
    }
    time.Sleep(time.Second)
}

Q15. What will be the output for the following code

package main

import "fmt"

func main() {
    var i interface{} = 10
    s := i.(string)
    fmt.Println(s)
}

Q16. What will be the output for the following code

package main

import "fmt"

func main() {
    m := map[string]int{"a": 1, "b": 2}
    var ptrs []*int

    for _, v := range m {
        ptrs = append(ptrs, &v)
    }

    for _, p := range ptrs {
        fmt.Println(*p)
    }
}

Q17. What will be the output for the following code

package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a[:2]
    c := a[2:]
    b = append(b, 99)
    fmt.Println("a:", a)
    fmt.Println("b:", b)
    fmt.Println("c:", c)
}

Q18. What will be the output for the following code

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        } else {
            fmt.Println("No panic occurred")
        }
    }()
    fmt.Println("Doing fine")
}

Q19. What will be the output for the following code

package main

import "fmt"

func main() {
    const x = 10
    {
        var x = 20
        fmt.Println(x)
    }
    fmt.Println(x)
}

Q20. What will be the output for the following code

package main

import "fmt"

type Person struct {
    name string
}

func main() {
    p1 := Person{name: "Alice"}
    p2 := p1
    p2.name = "Bob"

    fmt.Println(p1.name)
    fmt.Println(p2.name)
}

Q21. What will be the output for the following code

package main

import "fmt"

func main() {
    var a []int
    b := []int{}

    fmt.Println(a == nil)
    fmt.Println(b == nil)
}

Q22. What will be the output for the following code

package main

import "fmt"

func main() {
    for i := 0; i < 3; fmt.Println(i) {
        i++
    }
}

Q23. What will be the output for the following code

package main

import "fmt"

func modifyArr(a [3]int) {
    a[0] = 100
}

func modifySlice(s []int) {
    s[0] = 100
}

func main() {
    arr := [3]int{1, 2, 3}
    slice := []int{1, 2, 3}

    modifyArr(arr)
    modifySlice(slice)

    fmt.Println(arr)
    fmt.Println(slice)
}

Q24. What will be the output for the following code

package main

import "fmt"

func main() {
    res := make([][]int, 0)
    row := []int{}

    for i := 0; i < 3; i++ {
        row = append(row, i)
        res = append(res, row)
    }

    fmt.Println(res)
}

Q25. What will be the output for the following code

package main

import "fmt"

func main() {
    x := 2
    switch x {
    case 1:
        fmt.Println("One")
        fallthrough
    case 2:
        fmt.Println("Two")
        fallthrough
    case 3:
        fmt.Println("Three")
    default:
        fmt.Println("Default")
    }
}

Q26. What will be the output for the following code

package main

import "fmt"

func main() {
    var nums []int

    for _, v := range nums {
        fmt.Println(v)
    }

    fmt.Println("done")
}

Q27. What will be the output for the following code

package main

import "fmt"

func main() {
    ch := make(chan int)
    ch <- 10
    fmt.Println("done")
}

Q28. What will be the output for the following code

package main

import "fmt"

func main() {
    s := make([]int, 0, 2)
    capBefore := cap(s)

    s = append(s, 1)
    s = append(s, 2)
    capAfter := cap(s)

    s = append(s, 3)
    capFinal := cap(s)

    fmt.Println(capBefore, capAfter, capFinal)
}

Q29. What will be the output for the following code

package main

import "fmt"

func main() {
    var i interface{} = nil
    fmt.Println(i == nil)

    var p *int = nil
    i = p
    fmt.Println(i == nil)
}

Q30. What will be the output for the following code

package main

import "fmt"

type A struct{}

func (a A) Foo() {
    fmt.Println("A Foo")
}

type B struct {
    A
}

func main() {
    b := B{}
    b.Foo()
}

Q31. What will be the output for the following code

package main

import "fmt"

func main() {
    var s1 []int
    s2 := []int{}

    fmt.Println(len(s1), cap(s1), s1 == nil)
    fmt.Println(len(s2), cap(s2), s2 == nil)
}

Q32. What will be the output for the following code

package main

import "fmt"

func main() {
    x := 5
    defer fmt.Println(x)
    x = 10
}

Q33. What will be the output for the following code

package main

import "fmt"

func main() {
    var m1 map[string]int
    m2 := make(map[string]int)

    fmt.Println(m1 == nil)
    fmt.Println(m2 == nil)

    m2["key"] = 1
    // m1["key"] = 1  // Uncommenting this will cause what?
}

Q34. What will be the output for the following code

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    s1 := s[:3]
    s2 := s[3:]

    s1 = append(s1, 10)
    s2[0] = 20

    fmt.Println(s)
    fmt.Println(s1)
    fmt.Println(s2)
}

Q35. What will be the output for the following code

package main

import "fmt"

func main() {
    var i interface{} = (*int)(nil)

    v, ok := i.(*int)
    fmt.Println(v, ok)
}

Q36. What will be the output for the following code

package main

import "fmt"

func main() {
    m := map[int]string{
        1: "one",
        2: "two",
        3: "three",
    }

    for k := range m {
        fmt.Print(k, " ")
    }
}

Q37. What will be the output for the following code

package main

import "fmt"

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
    close(ch)

    for v := range ch {
        fmt.Print(v, " ")
    }
}

Q38. What will be the output for the following code

package main

import (
    "encoding/json"
    "fmt"
)

type Base struct {
    ID int `json:"id"`
}

type User struct {
    Base
    Name string `json:"name"`
}

func main() {
    data := []byte(`{"id":10, "name":"Alice"}`)
    var u User
    json.Unmarshal(data, &u)
    fmt.Println(u.ID, u.Name)
}

Q39. What will be the output for the following code

package main

import "fmt"

const (
    a = iota
    b
    c = 5
    d
    e = iota
)

func main() {
    fmt.Println(a, b, c, d, e)
}

Q40. What will be the output for the following code

package main

import "fmt"

func main() {
    var err error
    fmt.Println(err == nil)

    err = (*struct{})(nil)
    fmt.Println(err == nil)
}

Q41. What will be the output for the following code

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    s1 := s[:3]
    s2 := s1[:4]

    fmt.Println(s2)
}

Command Query Responsibility Segregation (CQRS) in simple terms is a design pattern in which you separate write commands (Create, Update, Delete) and read queries (Get) into different models.

What is the advantage of implementing CQRS?

CQRS help scale read and write operations independently.

CQRS allows read queries to be denormalized, that means read will be faster, while commands can adhere business logic strictly. In short, CQRS can help you with building read heavy systems.

Nest.js supports implementation of CQRS, you can read here: https://docs.nestjs.com/recipes/cqrs

Nest.js will only help you with implementing CQRS on a structural level. In real world implementation for large scale, you will be creating different microservices for read and write. Everytime writes happen, the read service has to be notified about changes in the data.

CQRS adds complexity and might feel unnecessary in situations. There are better patterns with Caching that you can implement over or with CQRS and that will be totally fine.

CQRS is something that you can do with monoliths and later break it apart into different microservices. And hence it perfectly makes sense.

Read this if you want to know more about CQRS and it's implementation in Go: https://threedots.tech/post/basic-cqrs-in-go/

When you want to upload a file to some object storage service like AWS S3 or GCS, there are two ways you can upload files

1. Through backend, using AWS / GCP standard libraries.

2. Through presigned urls

Why would you do presigned urls?

Servers often have limits on how much data can you upload at a time. Google Cloud run has a limit of 32MB, but if you use Compute Engine, it has no limits. Similarly AWS EC2 and ECS does not have limits but AWS Lambda has a limit of 10MB. So mostly serverless platforms have a limit not defined by you.

But in any case, uploading through backend won't be a good choice because you are unnecessarily eating up the bandwidth while uploading the file. This works for 10-20 files but if you have 1000 files of 100MB each, you can imagine what would happen.

How do we use presigned urls?

We request our server, that we want to upload a file, we provide the type of file and where we want to upload this file. The server should then request AWS S3 / GCS (or whatever service you are using) to create a presigned url. We can set the validity of this url.

Then we send this URL to the client. The client can then securely send the file on this URL.

There are practical limits for file size for presigned urls (5GB per file) but a good practice is, let's say if you have a file of 1GB, you break it into chunks of 10MB. You will have 100 chunks. Now you request for a presigned url for each chunk and then upload that chunk.

Once uploaded, you can combine all chunks on the S3 to make the file again. This is a common practice and this enables you to pause and resume your uploads as well.

AWS S3 allows 10,000 chunks per file and each chunk should be of size more than 5MB. These are some restrictions that AWS applies. This way, you can upload files of up to 5TB on AWS.

func (m *S3Service) getPresignedUrl(bucket constant.Bucket, key string) (string, error) {
    presignClient := s3.NewPresignClient(m.s3Client)
    url, err := presignClient.PresignPutObject(context.TODO(), &s3.PutObjectInput{
        Bucket: aws.String(string(bucket)),
        Key:    aws.String(key),
    }, s3.WithPresignExpires(15*time.Minute))
    if err != nil {
        return "", err
    }
    return url.URL, nil
}

The above is a go snippet to generate a presigned url. A presigned url might look like below

https://some-bucket.s3.region.amazonaws.com/some-prefix/some-key?X-Amz-Algorithm=AWS4-HMAC-SHA256
&X-Amz-Credential=some-credentials&X-Amz-Date=20250523T101848Z&X-Amz-Expires=900
&X-Amz-SignedHeaders=host&x-id=PutObject&X-Amz-Signature=some-signature

There are some headers like

1. X-Amz-Algorithm

2. X-Amz-Credential

3. X-Amz-Date

4. X-Amz-Expires

5. X-Amz-SignedHeaders

6. x-id

7. X-Amz-Signature

Now, using this, anyone can make a PUT request and upload a file to S3.

For multipart uploads, we will talk this in some other post.

Thanks.

When working with Golang, you will read one word; "idiomatic" alot on all the forums and in the community discussions.

But what does idiomatic actually mean?

Idiomatic, this word is only and only associated to Golang. Generally idiomatic in programming means writing code that follows the conventions, style, and best practices of the language you're using.

We use idiomatic a lot while talking about Go, because Golang's way of doing things is a bit different as compared to other general purpose languages. And hence many a times when you try to do something in Golang, the way you did the same in an OOPP environment like Java and C++, you might break patterns or you might not follow the idiomatic way of doing things in Go.

In Go, idiomatic code usually means:

1. Keeping things simple and readable

2. Using structs and interfaces effectively

3. Avoiding unnecessary abstraction

4. Keeping functions small and doing one thing

5. Reusing instead of re-initializing

The problem is, this is so vague, the Go community does suffer problem where someone might say something is idiomatic while the others saying it is not.

But Golang is evolving just like any other language and new features (for e.g. generics) are allowing you to decide what you can do and what you "should not" do. It is not "can not" and it is always "should not" while the community forces "must not".

At the end, if your Go code doesn't look simple, if your code does magic at runtime (hidden dependency injection), if your code enforces a lot of rules, maybe you are over engineering. Go likes to be simple (while it's verbosity doesn't look simple) and Go asks you to write small functions, simple & efficient code.

Go has 3 basic types

1. bool

2. Numeric

3. string

Bool

To declare a variable and then initalize it, you can do it following way:

var myVar bool                     //type declaration
myVar = false                     //value initialization
var myVar2 bool = false //type declaration and initialization

There is a special short cut operator to declare and define variables in Go:

myVar := false

In the above code, using the := operator, we can directly declare and assign the variable a value. The type is automatically inferred from the value.

Integers

There are two types of integers

1. Signed integers

2. Unsigned integers

Signed integers are declared with the int prefixed keywords

var x int = 200
var y int8 = -100

There are five types of int:

1. int -> 32 bits for 32 bit systems and 64 bits for 64 bit systems.

2. int8 -> 8 bit integer storing from -128 to 127

3. int16 -> 16 bit integer storing from -32768 to 32767

4. int32 -> 32 bit integer storing from +/- 2^31

5. int64 -> 64 bit integer storing from +/- 2^63

You can use these keywords to define integers.

Unsigned integers can be defined using uint prefixed key

var x uint = 1200
var x uint16 = 2456

Similar to int, you have five types of uint

1. int -> 32 bits for 32 bit systems and 64 bits for 64 bit systems.

2. int8 -> 8 bit storing positive values from 0 to 2^8

3. int16 -> 16 bit storing positive values from 0 to 2^16

4. int32 -> 32 bit storing positive values from 0 to 2^32

5. int64 -> 64 bit storing positive values from 0 to 2^64

There are two aliases for uint8 and int32

1. btye -> alias for uint8

2. rune -> alias for int32

var m rune = -42
var n byte = 37
fmt.Println(reflect.TypeOf(m), reflect.TypeOf(n))

m will be int32 whereas n will be uint8

Float

There are two types of floats

1. float32 -> 32 bit float storing from -3.4e+38 to 3.4e+38

2. float64 -> 64 bit float storing from -1.7e+308 to 1.7e+308

The default type is float64 in case you use := for defining a variable.

x := 3.44                //float64
var y float32 = 3e+38
var y float64 = 17.323

String

Strings can be defined using the string keyword

var x string = "Hello, World!"
y := "My name is awesome!"

Complex

Go also supports complex numbers as follows

a := complex(1.2, 3.4)
var b complex128 := complex(1.2, 3.4)
c := 8 + 7i

Complex numbers is the same mathematical concept where you had a real and an imaginary number. Both the real and imaginary part are floats either float32 or float64.

Complex numbers can be either 128bit or 64bit

1. complex128 -> 64bit f real + 64bit imaginary

2. complex64 -> 32bit real + 32bit imaginary

Zero Values

Following are the zero values, which are given when variables are declared without initializing

1. 0 for numeric types

2. false for boolean type

3. "" for strings

Null

In Golang, null is replaced with nil. We will talk more about nil when discussing pointers and interfaces.

𝐎𝐩𝐭𝐢𝐦𝐢𝐬𝐭𝐢𝐜 𝐋𝐨𝐜𝐤𝐢𝐧𝐠:

𝐀𝐬𝐬𝐮𝐦𝐩𝐭𝐢𝐨𝐧: Conflicts are rare.

𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Let everyone access the data, but verify before committing changes.

𝐇𝐨𝐰 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬:

- A version field (e.g., version or updatedAt) is stored with the record.

- Before updating, the application checks whether the version matches.

- If not, the operation fails and must be retried.

For e.g. in SQL:

UPDATE orders SET status = 'shipped', version = version + 1 WHERE id = 101 AND version = 2;

Mongodb Example:

db.items.updateOne(
 { id: itemId, version: 3 },
 { $set: { name: "New Name" }, $inc: { version: 1 } }
)

If version has changed, the update fails indicating someone else modified it.

𝐓𝐡𝐢𝐬 𝐢𝐬 𝐔𝐬𝐞𝐝 𝐢𝐧:

- High-read, low-write systems

- APIs with stateless communication

- Systems needing scalability over strict locking

𝐏𝐞𝐬𝐬𝐢𝐦𝐢𝐬𝐭𝐢𝐜 𝐋𝐨𝐜𝐤𝐢𝐧𝐠

𝐀𝐬𝐬𝐮𝐦𝐩𝐭𝐢𝐨𝐧: Conflicts are likely.

𝐇𝐨𝐰 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬:

- Lock the data to prevent others from modifying it until the lock is released.

- Other operations must wait or fail.

For e.g. in SQL

SELECT * FROM orders WHERE id = 101 FOR UPDATE;

MongoDB does not natively supports Pessimistic Locking but this can still be implemented with adding an additional lock field:

db.items.updateOne(
 { id: itemId, locked: false },
 { $set: { locked: true } }
)

Pessimistic Locks are needed in high concurrency systems such as BookMyShow or District where multiple people might attempt to book the same seat or spot.

var <variable-name> <data-type> = <value>

For e.g.

package main

func main(){
    var x int = 40
}

There is also a shortcut of defining variables

package main

func main(){
    x := 10
}

In the above case, we have used the := operator which is the shortcut method to declare variables. You don’t need to write var neither do you need to write the type. The type is inferred from the value. Basically whatever value is, the type is assigned accordingly.

package main

import (
    "reflect"
    "fmt"
)

func main(){
    x := 10
    y := "I am a string"
    fmt.Println(reflect.TypeOf(x), reflect.TypeOf(y))
}

In the above example, we have imported the reflect package which is a standard built-in package for go. Using reflect, we can determine the type of x and y. You will notice x will be int and y will be string.

Defining Variables in Bulk

package main
import "fmt"
func main(){
    var (    
        c = 10
        d = 20
        e = 30
    )
    fmt.Println(c, d, e)
    var (
        f int
        g int
        h int
    )
    fmt.Println(f, g, h)
    var i, j, k int
    i = 1
    j = 2
    k = 3
    fmt.Println(i, j, k)
    var l, m, n int = 4, 5, 6
    fmt.Println(l, m, n)
    o, p, q := 1, 2, 3
    fmt.Println(o, p, q)
}

In the above example, we are declaring and initializing variable c, d, e at once. We are declaring f, g, h and initializing them later. Similarly we are declaring i, j, k once with combining their types, basically all three will have same int type. Then we are declaring and initializing l, m, n at once. At the end, we are using shortcut method to declare o, p, q. These are different ways to define variables.

Constants

Go supports constants

const x int = 5

Constants cannot be defined using := and they need const keyword.

Once you have installed Go, to check if go has been correctly installed, you can open a terminal and write below comand.

go version

This should show you current version of Go.

Next. Create a folder for your project and inside that folder, open terminal and type

go mod init <project-name>

this will create a go.mod file which will have a list of all your dependencies for the project. You can think of this as the package.json in Javascript / Typescript projects.

Create a new file with name main.go, inside that file, write the below code

package main

import "fmt"

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

Save the file, and run below command

go run main.go

OR

go run .

This should run your project and print “Hello, World!“

Let’s talk about each component of this file

The first line package main, tells that this file belongs to package main. Consider package as a grouping method to group multiple types, entities under one name.

The second line is import fmt which is basically an import statement. We are importing the fmt package in our file. This fmt packages allows us to do many things, one of them is printing on the console.

In next set of lines, we have declared a function main, which acts as an entry point for the application. If you change the function name with something else, you won’t be able to run the application.

Functions in Golang are declared using func. In the function we are calling the Println function from the fmt package that we imported above the main function. We are passing “Hello, World!“ to the print function. This string is then printed on the console.

Go was created in 2007 at Google for following reasons

1. Slow Compilation: C++ and Java code at Google was too slow to compile. They needed something that could compile quickly

2. Complexity: Existing languages had grown to become too complex. They needed something that’s simple.

3. Concurrency: Languages such as C++ and Java made concurrency hard to manage.

Go brought some advantages as well

1. Tooling: Go has great tooling support (fmt, go test, go doc)

2. Garbage Collection: Go’s GC makes memory management simplified.

3. Goroutines: Light weight threads with multiplexing.

So did Google replace all its code with Golang?

The answer is NO!

Many of the languages (specifically Java) that were complex and that didn’t supported features such as concurrency, now they do, and they have pretty much simplified things.

So why Go?

Because Go is still different. Go needs minimal setup over general purpose languages like Java. Go is still fast to compile, faster to execute and fast to ship.

If you compare Go with scripting languages like Python and Javascript / Typescript, these scripting languages did offer rapid prototyping since the beginning. Go still has advantage over them because of concurrency.

If you compare Go with C++, the basic reason of using C++ was speed. However Golang is able to deliver the speeds relative to C++ with additional features and a different programming paradigm.

So Go is best of both worlds and hence you should be using Go.

Today, Javascript tops the charts because of it being heavily used by browsers and in web development. Java dominates the MNCs and legacy setups. Python dominates the AI space as well as backend. Go is slowly catching up being relatively new.

Go sits right between Java, Python, Javascript and C++. Go is a multi-paradigm (Imperative, Concurrent, Procedural) programming language.

Composition is a core philosophy of Go. Composition is basically building complex behavior by combining simpler types or functions. Composition is an alternative to Inheritance where you would combine multiple classes to create a complex behavior.

Go suggest instead of creating hierarchies of classes, just compose small reusable pieces of code.

type Animal struct {
    Name string
}

func (a Animal) Speak() {
    fmt.Println(a.Name, "makes a sound")
}

type Dog struct {
    Animal // embedded
    Breed  string
}

In next topics, we will cover how we can use Golang to create highly scalable applications.

A thread referred as the smallest unit of execution within a process, is managed by the OS Kernel. Each Thread has its own stack i.e. its own reserved memory for its state. Depending on the Operating System, the thread stack size can vary but typically falls between 1MB and 8MB.

Light Weight Threads often referred as User Level Threads were first conceptualized and developed in 1960s and 1970s. These are managed by a user-space library rather than the OS Kernel. The kernel isn't aware of the Light Weight Threads being created.

In context of Operating Systems, Light Weight Threads can have a different meaning. We are defining LWT in context of Programming Languages.

Light Weight Threads run above the OS Threads and their call stack is in most cases smaller than OS Threads.

Creating Light Weight Threads is also cheap and fast for following reasons:

1. When OS creates threads, it also has to do some extra work like managing the state of the thread. Light Weight Threads are switched at user level so there is less operational overhead.

2. Light Weight Threads also typically have smaller stack size.

3. Multiple Light Weight Threads can use a single OS Level Thread. This is called as multiplexing.

4. Light Weight Threads enable concurrent execution of multiple tasks independently but without the overhead of OS thread management.

Programming languages such as Go use light weight threads for Goroutines. Go also uses multiplexing allowing multiple Goroutines to use a single OS Thread. For e.g. in I/O-Bound operations, you can maybe run 1000+ Goroutines on a single thread while for CPU Heavy operations, the ratio of multiplexing will be lesser.

Depending on the Go Runtime version, Goroutines typically have an initial stack of 2kb which grows dynamically. Goroutines are handled & scheduled by the Go Runtime Scheduler.

Java introduced virtual threads, which were lightweight threads managed by the JVM. This was introduced through Project Loom (Java 19+ Preview / Java 21+ Stable). These as well are multiplexed by the JVM, running on a small pool of carrier OS Threads.

Other modern languages like Kotlin, Rust (async), and Erlang also use similar lightweight threading/concurrency models.

This is a tutorial for git commands. This should give you a basic idea of each git command specifically for interview preparation.

This tutorial assumes that you already have git installed and configured.

Basics

Create an empty folder and open terminal in that folder and type

git init

The above line will initialize your git repository.

Then create a file README.md and write something inside that file. You can also do this via terminal itself.

echo "# Git Practice Repo"

then in the terminal, write

git add READMD.md

then write

git commit -m "My first commit"

After this, you will have to go to github.com, create an empty repo and copy the https link with you.

In terminal, write

git remote add origin <your-repo-url>

Now rename your branch to "main"

git branch -M main

Now you will be pushing your file to github using below command

git push -u origin main

Now add some more changes to the READMD file, and commit

git commit -am "Updated READMD.md file"

Now push

git push

Now, go to github.com and edit your READMD.md and make some changes. Then come back to terminal, and type

git pull

This should pull the changes you made directly in github wehsite.

Resetting Unstaged Commits

If you are working on this file and you haven't made any commits but you wish to restore this file back to as it was, you can use the following command.

git checkout -- README.md

Try making some changes but do not commit. And then run the above command. The file will reset to it's original state.

Now try to do some unnecessary changes and push the file again.

Reverting Pushed Commits

Previously we tried resetting the file locally. Now we will revert the commit itself. After pushing the file, use the following command

git revert HEAD

This should revert the commit and your changes are gone. This will keep the history clean as well.

Now to revert but keep your changes staged you can use the soft reset command

git reset --soft HEAD~1

This should reset your last commit but keep the changes staged (git add stages the changes)

To revert the changes as well as unstage them use the mixed flag instead of soft

git reset --mixed HEAD~1

To revert the changes as well as delete them entirely, use the hard flag instead of mixed

git reset --hard HEAD~1

Now let's create a branch. To create a branch, use the checkout command.

git checkout -b feature/readme

feature/readme is your branch name

Now make some changes and commit

git commit -am "Updated feature/readme"

Now go to main branch

git checkout main

Now merge feature/readme into main using following command

git merge feature/readme

Once done, basically you have merged your branch locally. Now you can do git push to push the changes

git push

Then let's delete the branch

git branch -d feature/readme

This will delete the branch.

Stashing

Now make some changes in your readme file and then we will stash it using below command

git stash

Stashing saves your changes without commiting them. You can restore it later. You use this command if you wish to switch between branches without commiting or any other case.

Now to restore the stash, use the below command

git stash pop

This should restore your changes and then you can push those.

Logging

Now, in the terminal type

git log

This should show you a log of commits that happened on your branch. to see more you can press the down arrow which will let you scroll down. To exit, press the q key.

To see the logs in a better way, you can add flags like following

git log --oneline --graph --all

The oneline flag will show you each commit with message in one line. The graph flag creates a graph of branches to the left. The all flag should show all commits.

Now, make some changes in the README.md file and then use following command:

git diff

This command will show current changes that aren't yet committed.

Now, make some changes in the README.md file and then check the status of the commits using following command

git status

This will show you the changes that are staged or not staged, committed or uncommitted, everything.

Now let's talk about rebasing.

Imagine you are working on branch1. someone merged some changes in main branch. You need those changes in branch1. So you merge main into branch1.

Now, if this happens multiple times, you will have multiple merges in your branch1.

If you finally merge branch1 into main, the main branch history will show multiple merges from main to branch1.

The above looks messier and harder to read.

For a cleaner approach, instead we can rebase. Rebasing in simpler words is instead of merging you simply copy main branch history into branch1 history and place branch1 history above the main copied history.

The above is much cleaner to read.

Let's mimic this.

Merge Flow

in your main branch, create a file main.txt, write something in it, and then save it and commit main branch with message

git commit -am "Main Commit 1"

Now create another branch

git checkout -b branch1

Create a file branch1.txt, write this in it:

Branch Commit 1

And then save it and commit branch1 with message

git commit -am "Branch Commit 1"

Then go to main branch

git checkout main

Make some changes in text1.txt and commit

git commit -am "Main Commit 2"

Now go back to branch1

git checkout branch1

To merge main -> branch1, we will write

git merge main

Then we will make some changes in branch1.txt, and then commit

git commit -am "Branch Commit 2"

Then go to main branch

git checkout main

Make some changes in text1.txt and commit

git commit -am "Main Commit 3"

Now go back to branch1

git checkout branch1

To merge main -> branch1, we will write

git merge main

Then we will make some changes in branch1.txt, and then commit

git commit -am "Branch Commit 3"

Now go to main branch and merge branch1 into main

git merge branch1

Now if you try to log the main commits using following command

git log --oneline --graph

Observe the graph and the commits, this will look a bit messy.

Rebase Flow

in your main branch, create a file main.txt, write something in it, and then save it and commit main branch with message

git commit -am "Main Commit 1"

Now create another branch

git checkout -b branch1

Create a file branch1.txt, write this in it:

Branch Commit 1

And then save it and commit branch1 with message

git commit -am "Branch Commit 1"

Then go to main branch

git checkout main

Make some changes in text1.txt and commit

git commit -am "Main Commit 2"

Now go back to branch1

git checkout branch1

To rebase main -> branch1, we will write

git rebase main

Then we will make some changes in branch1.txt, and then commit

git commit -am "Branch Commit 2"

Then go to main branch

git checkout main

Make some changes in text1.txt and commit

git commit -am "Main Commit 3"

Now go back to branch1

git checkout branch1

To rebase main -> branch1, we will write

git rebase main

Then we will make some changes in branch1.txt, and then commit

git commit -am "Branch Commit 3"

Now go to main branch and merge branch1 into main

git merge branch1

Now if you try to log the main commits using following command

git log --oneline --graph

Observe the graph and the commits, those will look cleaner than the merge.

For interactive rebasing

you can use an extra flag -i like below

git rebase main -i

This will open up an editor with instructions allowing you to make changes allowing you to squash or pick commits. Squashing is combining multiple commits into one.

Alias

You can create alias for commands to make them shorter

git config --global alias.st status

So next time, you will be calling status command using

git st

That's all.

I went to specific language / framework websites from where they could be installed. Then I copied the root url and pasted it into look up websites (this one: ) and hit lookup. Following were the results for each of them.

Node.js: 4lac+ visitors
Python: 1.3million+ visitors
Java: 4.7million+ visitors
Go: 4,000+ visitors
Rust: 67,000+ visitors

Golang and Rust were a surprise. Now I went to Naukri.com and searched the above languages into jobs.

Node.js: 1lac+ jobs
Python: 50,000+ jobs
Go: 1lac+ jobs
Java: 6,000+ jobs
Rust: 1lac+ jobs

Java was a shock, python as well. Then I searched Django and Flask instead of python and Springboot and Hibernate instead of Java. For both the cases, I got 1lac+ jobs this time.

So Naukri search results didn’t made sense.

Then I went to indeed. Following were the results

Node.js: 7,000+ jobs
Python: 29,000+ jobs
Go: 800+ jobs
Java: 25,000+ jobs
Rust: 200+ jobs

This time the numbers were different.

While just 2 job sites won’t tell the actual statistics, the number of visitors on each of the language’s official website can tell that how many new users are downloading that specific language.

If we see Golang, it has highest number of jobs per number of visitors, then follows Python, then Node.js, then Rust, and at the end, there is Java. That’s what this experiment concludes.

If you see more jobs for a particular language, that doesn’t mean you should learn that language. You should also be looking at how many people are learning that language. If those as well are more, then learning that language makes less sense as you will have more competition.

But if a language or a framework has less jobs but even less developers, then it should be easier to get a job for that language.

For more accurate stats regarding languages, also checkout stack overflow survey: https://survey.stackoverflow.co/2024/technology

That’s it for now…

1. For some there is an apply free delivery button which is by default checked out even if you pay premium

2. Some send stale food. Some send bad quality of products and then they refuse to refund.

PG Apps ask you for deposit and never refund.

Hotel Booking Apps confirm your stay a week back and when you reach your hotel, you are either forced to pay more at reception, or you have to look for other options, with trolly bags in your hand in a unknown city.

Cab Drivers use Ride Apps to accept booking but then they will call you and ask for higher price,

Online Packers and Movers provide you with insurance for products for high premium but you are never able to claim that.

Broadband services take weeks to send someone to fix connectivity issues.

These were real problem statements but the solutions are screwed up with no empathy towards people.

For most of the cases, the companies are at fault.

But for some cases, people are at fault as well. For e.g. unnecessarily placing refund orders even if the item is good. The company makes losses because of this, and now if someone genuinely needs refund but they might not get it.

I think offline is better.

I can call a hotel owner and confirm prices and stay. I can go to local vegetable vendor and check the quality of vegetables before buying. I can connect with a local transport service which might not be better but would be definitely cheaper and it at least not sell false promises at higher costs.

The belief with technology was that competition could've fostered better services, more employment could've been generated. But that hasn't happened.

What do you think can fix these issues?

I believe the root of the problem does indicate the civic sense of people. If the companies realise their responibility towards people and if people stop exploiting systems built for their own good, then maybe we will be able to solve this problem.

But that's a long road ahead, and that's the only solution from my perspective. Going offline doesn't make sense because problems existed first in offline business and then those were promised to be fixed by technology which it didn't.

That's it for now.