DEV Community: Adrian DY

Blockchain and Smart Contracts integraton, 3D experience

Adrian DY — Sun, 31 Mar 2024 15:33:52 +0000

Revolutionize your digital landscape with our cutting-edge integration of Blockchain and Smart Contracts into your 3D experience! Imagine a world where transactions are secure, transparent, and seamlessly executed within your immersive environment. With our innovative solution, you can unlock new levels of efficiency, trust, and creativity in your 3D projects. Say goodbye to traditional limitations and embrace the future of decentralized, automated transactions. Elevate your digital experiences today with Blockchain and Smart Contracts integration!

https://marketplace.nftspeed.space/

Building a Golang API with JWT authentication

Adrian DY — Sat, 10 Jun 2023 03:29:31 +0000

First, let's start with some background information. JWT stands for JSON Web Tokens, and it is a standard for securely transmitting information between parties as a JSON object. JWTs are commonly used for authentication and authorization purposes, and they are composed of three parts: a header, a payload, and a signature.

When a user logs in to your application, you can generate a JWT and send it back to the client. The client can then include the JWT in subsequent requests to your API, and your API can use the JWT to authenticate the user and authorize access to protected resources.

Now, let's dive into the code. We'll start by creating a basic Golang API using the Gin framework. Make sure you have Gin installed before proceeding:

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    router.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, world!",
        })
    })

    router.Run(":8080")
}

This code creates a simple API that listens on port 8080 and responds with a "Hello, world!" message when you make a GET request to the root endpoint.

Next, we'll add JWT authentication to our API. We'll be using the github.com/dgrijalva/jwt-go package to generate and validate JWTs.

package main

import (
    "github.com/dgrijalva/jwt-go"
    "github.com/gin-gonic/gin"
    "net/http"
    "time"
)

var jwtKey = []byte("my_secret_key")

func main() {
    router := gin.Default()

    router.POST("/login", login)

    auth := router.Group("/auth")
    auth.Use(authMiddleware())
    {
        auth.GET("/hello", hello)
    }

    router.Run(":8080")
}

func login(c *gin.Context) {
    var loginData struct {
        Username string `json:"username" binding:"required"`
        Password string `json:"password" binding:"required"`
    }

    if err := c.ShouldBindJSON(&loginData); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    if loginData.Username != "myuser" || loginData.Password != "mypassword" {
        c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid login credentials"})
        return
    }

    expirationTime := time.Now().Add(5 * time.Minute)
    claims := &jwt.StandardClaims{
        ExpiresAt: expirationTime.Unix(),
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString(jwtKey)

    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not generate token"})
        return
    }

    c.JSON(http.StatusOK, gin.H{"token": tokenString})
}

func authMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        tokenString := c.GetHeader("Authorization")
        if tokenString == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header missing"})
            return
        }

        token, err := jwt.ParseWithClaims(tokenString, &jwt.StandardClaims{}, func(token *jwt.Token) (interface{}, error) {
            if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
                return nil, jwt.ErrInvalidSigningMethod
            }

            return jwtKey, nil
        })

        if err != nil {
            if err == jwt.ErrSignatureInvalid {
                c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token signature"})
                return
            }

            c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
            return
        }

        if !token.Valid {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
            return
        }

        c.Next()
    }
}

func hello(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "Hello, authenticated user!"})
}

Let's go through this code step by step. First, we define a jwtKey variable that will be used to sign and verify JWTs. This key should be kept secret and not shared with anyone.

Next, we define two endpoints: /login and /auth/hello. The /login endpoint accepts a username and password in JSON format, checks if they are valid, and generates a JWT if they are. The /auth/hello endpoint requires a valid JWT to be included in the Authorization header of the request.

The login function first checks if the username and password are valid. If they are, it creates a new JWT with an expiration time of 5 minutes and returnsit to the client in JSON format.

The authMiddleware function is a middleware that checks if a valid JWT is included in the Authorization header of the request. If a valid JWT is present, it calls c.Next() to allow the request to proceed. If a valid JWT is not present or is invalid, it returns an error response.

Finally, the hello function is a protected endpoint that requires a valid JWT to be accessed. If a valid JWT is present, it returns a "Hello, authenticated user!" message in JSON format.

Let's start by discussing the jwt-go package that we used to implement JWT authentication in our Golang API. This package provides functions for creating, parsing, and validating JWTs.

When creating a JWT, we first create a StandardClaims struct that includes any claims that we want to include in the JWT payload, such as an expiration time. We then create a new JWT using the jwt.NewWithClaims function and sign it using our jwtKey variable. The resulting signed JWT is then included in the response to the client.

When validating a JWT, we first extract the JWT from the Authorization header of the request and parse it using the jwt.ParseWithClaims function. We pass in our jwtKey variable as the second argument to this function to verify the signature of the JWT. If the JWT is valid and has not expired, we call c.Next() to allow the request to proceed. If the JWT is invalid or has expired, we return an error response.

It's important to note that JWTs should be used in conjunction with HTTPS to ensure that they are transmitted securely. JWTs should also be kept secret and not shared with anyone else.

In addition to the jwt-go package, we used the Gin framework to create our Golang API. Gin is a lightweight web framework that provides features such as routing, middleware, and error handling. We defined two endpoints in our API: /login, which generates a JWT if the user provides valid credentials, and /auth/hello, which requires a valid JWT to be accessed.

That's it! With this code, you have created a Golang API with JWT authentication. Of course, you can customize this code to fit your specific needs, but this should give you a good starting point.

Concurrency in Go: Goroutines, Mutexes and Channels

Adrian DY — Mon, 22 May 2023 03:32:02 +0000

Go (Golang) is a popular programming language that has been designed to support concurrency by making it easier for developers to write concurrent programs.

Goroutines are a key feature of the Go programming language (Golang) that make it easy to write concurrent code. Goroutines enable developers to execute multiple functions or methods at the same time, without blocking other parts of the program. In this article, we’ll explore how goroutines work, and how they can be used to write efficient and robust concurrent code.

What is a Goroutine?

In Golang, a goroutine is a lightweight thread of execution that is managed by the Go runtime. Goroutines enable developers to run multiple functions or methods concurrently, without the need for complex locking or synchronization mechanisms.

Creating a Goroutine

To create a new goroutine in Golang, use the go keyword, followed by the function or method that you want to execute concurrently. Here’s an example:

func main() {
    go myFunction()
    // do other work
}
func myFunction() {
    // do something
}

In the example above, the myFunction() method is executed concurrently, in a new goroutine. The main program can continue to execute other code, without waiting for myFunction() to complete.

Synchronization and Sharing Data

Goroutines in Golang share the same memory space, which means they can share data between them. However, this can create synchronization issues, as multiple goroutines may attempt to modify the same data at the same time.

To prevent this, Golang provides synchronization primitives such as mutexes and channels. Mutexes are used to prevent multiple goroutines from accessing shared data simultaneously, while channels enable safe communication between multiple goroutines.

Mutexes

In Golang, mutexes are used to allow exclusive access to shared resources. A mutex is a mechanism that is used to prevent two goroutines from accessing a shared resource at the same time. When a goroutine acquires a mutex, all other goroutines attempting to acquire the same mutex will block until the mutex is released.

Here's an example of how to use a mutex in Golang:

import (
    "sync"
    "fmt"
)
 var count int
var mutex sync.Mutex
 func increment() {
    mutex.Lock()
    count++
    mutex.Unlock()
}
func main() {
    var wg sync.WaitGroup
     for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }
    wg.Wait()
    fmt.Println(count)
}

In this example, we're using a mutex to protect the count variable which is being used by multiple goroutines. The increment() function increments the count variable and uses the mutex.Lock() and mutex.Unlock() methods to ensure that the variable is being accessed by only one goroutine at a time. The end result is that the count variable is incremented by all the goroutines, resulting in a value of 1000.

Channels

Channels are a way for goroutines to communicate with each other. A channel allows one goroutine to send data to another goroutine. This is useful for sharing data between goroutines that might otherwise need to be protected with a mutex.

Here's an example of using a channel in Golang:

import (
    "fmt"
)
func producer(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}
func consumer(ch <-chan int, done chan<- bool) {
    for value := range ch {
        fmt.Println("Received:", value)
    }
    done <- true
}
func main() {
    ch := make(chan int)
    done := make(chan bool)
    go producer(ch)
    go consumer(ch, done)
    <-done
}

In this example, we've created a producer function that sends ten integers to a channel and then closes the channel. We've also created a consumer function that reads values from the channel and prints them. The main function creates the channel and a done channel to signal when the consumer has finished. When the consumer has finished reading from the channel, it sends a value to the done channel. The main function waits for the done channel to receive a value.

Conclusion

Goroutines are a powerful feature of the Go programming language that enable efficient and robust concurrent programming. By using goroutines, developers can write code that can execute multiple tasks simultaneously, without the need for complex locking or synchronization mechanisms. However, it’s important to be aware of synchronization issues when sharing data between goroutines, and to use synchronization primitives such as mutexes and channels to prevent them.

Mutexes and channels are powerful tools for managing concurrency in Golang programming. Mutexes can be used to ensure that shared resources are accessed in an exclusive manner, while channels enable goroutines to communicate with each other in a safe and efficient manner. By using mutexes and channels correctly, Golang developers can write efficient, scalable, and robust concurrent programs.

Understanding Golang Object Oriented Programming (OOP) with Examples

Adrian DY — Thu, 18 May 2023 03:45:37 +0000

Introduction

Object-oriented programming (OOP) is a popular programming paradigm that emphasizes the use of objects and their interactions to design and build applications. Go is not a pure object-oriented language like Java or Python, but it does support many OOP concepts like encapsulation, abstraction, inheritance, and polymorphism. In this article, we will explore how to write object-oriented programs in Go.

Defining a Class

In Go, we define classes as structures. A class is a collection of attributes (fields) and behaviors (methods). Here's an example of a class representing a Person :

type Person struct {
    Name   string
    Age    int
    Gender string
}

This defines a class Person with the three fields Name , Age , and Gender .

Creating an Object

In Go, we create an object by instantiating a structure. We can create an object of class Person like this:

person := Person{Name: "John Doe", Age: 30, Gender: "Male"}

This creates an object person with the values "John Doe" , 30 , and "Male" .

Encapsulation

Encapsulation is the concept of wrapping data and methods inside a single unit. In Go, encapsulation is achieved by using a naming convention for fields and methods: Private fields and methods start with a lowercase letter, while public fields and methods start with an uppercase letter.
Here's an example of a Person class with private fields and public methods:

type Person struct {
    name   string
    age    int
    gender string
}
func (p *Person) SetName(name string) {
    p.name = name
}
func (p *Person) GetName() string {
    return p.name
}

In this example, we've made the fields name , age , and gender private by using lowercase letters. We've also defined two public methods SetName() and GetName() to access and modify the value of the name field.

Abstraction

Abstraction is the process of hiding implementation details while showing only the necessary information to the user. In Go, we can achieve abstraction by using interfaces. An interface specifies a set of methods that a struct must implement to satisfy the interface.
Here's an example:

type Animal interface {
    Speak() string
}
type Dog struct {
    Name string
}
func (d Dog) Speak() string {
    return "Woof!"
}
type Cat struct {
    Name string
}
func (c Cat) Speak() string {
    return "Meow!"
}
func main() {
    animals := []Animal{Dog{Name: "Fido"}, Cat{Name: "Fluffy"}}
    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }
}

In this example, we've defined an interface Animal with a single method Speak() . We've also defined two implementations of this interface: Dog and Cat . We can now create a list of Animal objects and call the Speak() method on each of them to get their respective sounds.

Inheritance

Inheritance is the concept of creating a new class from an existing class. In Go, we achieve inheritance using composition. Composition is the process of combining different structures to create a new one.
Here's an example:

type Animal struct {
    Name   string
    Origin string
}
type Bird struct {
    Animal
    SpeedKPH float32
    CanFly   bool
}

In this example, we've defined a class Animal with two fields Name and Origin . We've also defined a class Bird that "inherits" all of the fields and methods from Animal using composition. In addition, Bird has two additional fields SpeedKPH and CanFly .

Polymorphism

Polymorphism is the concept of using a single interface to represent multiple classes. In Go, we achieve polymorphism using interfaces and method overriding.
Here's an example:

type Shape interface {
    Area() float64
}
type Rectangle struct {
    Width  float64
    Height float64
}
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}
type Circle struct {
    Radius float64
}
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}
func main() {
    shapes := []Shape{Rectangle{2, 3}, Circle{4}}
    for _, shape := range shapes {
        fmt.Println("Area =", shape.Area())
    }
}

In this example, we've defined an interface Shape with a single method Area() . We've also defined two implementations of this interface: Rectangle and Circle . We can now create a list of Shape objects and call the Area() method on each of them to get the area of the shape, regardless of whether it's a rectangle or a circle.

Conclusion

In this article, we've explored how to write object-oriented programs in Go. We've covered defining a class, creating an object, encapsulation, abstraction, inheritance, and polymorphism. By using these concepts, you can write well-organized, modular code that is easy to maintain and extend.

Error Handling in Golang: How to Prevent Application Stop

Adrian DY — Wed, 17 May 2023 13:47:52 +0000

Golang is a programming language that has gained immense popularity among developers due to its robust performance and simplicity. However, like any other programming language, Golang handles errors in its own way.

In this article, we’ll dive deep into how Golang handles errors and explore some effective ways to prevent your application from stopping.

Error Handling in Golang

In Golang, errors are represented as values of the built-in error type. Golang provides a simple, yet effective, way of handling errors using the err syntax:

if err != nil {
    // handle the error
}

This syntax checks if the value of the error is nil , which means there was no error. If the error is not nil , the code inside the if block is executed, which handles the error.

However, one of the biggest mistakes that developers make while handling errors in Golang is to ignore them. Ignoring errors can lead to unexpected application behavior, and in some cases, even result in application stop.

Preventing Application Stop

1. Logging Errors

One of the most common ways to prevent application stop due to errors is by logging errors. You can use the log package provided by Golang to log errors to the console or a file. Here is an example:

import (
    "log"
    "os"
)
 func main() {
    file, err := os.Open("file.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
     // your code here
}

In this example, we’re using the log.Fatal() method to log the error and stop the application.

2. Recovering from Panics

Another way to prevent application stop is by recovering from panics. A panic is a built-in function in Golang that stops the current goroutine and starts the panic sequence. To recover from a panic sequence, you can use the recover() function.

func main() {
    defer func() {
        if r := recover(); r != nil {
            log.Println("Recovered from panic:", r)
        }
    }()
     panic("Something went wrong")
}

In this example, we’re using the defer statement to register a function that will be called when the panic sequence starts. This function uses the recover() function to stop the panic sequence and log the error.

3. Graceful Shutdown

The third way to prevent application stop is by using graceful shutdown. Graceful shutdown is a technique used to stop an application gracefully without losing any data. Here’s an example of how to implement graceful shutdown in Golang:

import (
    "context"
    "os"
    "os/signal"
    "syscall"
)
 func main() {
    ctx, cancel := context.WithCancel(context.Background())
     c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
     go func() {
        <-c
        cancel()
    }()
     // your code here
     <-ctx.Done()
    log.Println("Application stopped gracefully")
}

In this example, we’re creating a context object and a cancel function. We’re also creating a channel to listen for signals that may cause the application to stop, like SIGTERM or os.Interrupt . When one of these signals is received, the cancel function is called to stop the application gracefully.

Some best practices for error handling in Golang

1 - Always handle errors: In Golang, it's essential to handle errors correctly. Ignoring errors can lead to unexpected behavior and even cause your application to crash. When you encounter an error, you should handle it appropriately. You can log the error, return an error value to the caller, or use panic and recover to handle errors.

file, err := os.Open("filename.txt")
if err != nil {
   log.Fatal(err)
}
defer file.Close()
// your code here

In this example, we're using the os.Open() function to open a file. If an error occurs, we log the error and stop the program. If there's no error, we defer closing the file and continue with our code.

2 - Use descriptive error messages: When you encounter an error, make sure the error message is descriptive and helpful. The error message should contain information about what went wrong and where the error occurred. This information can help you debug the error and fix it quickly.

_, err := http.Get("http://example.com")
if err != nil {
   log.Printf("Error making HTTP request: %s", err)
}

In this example, we're making an HTTP request using the http.Get()> function. If an error occurs, we log the error with a descriptive message.

3 - Wrap errors: When you call a function that returns an error, it's a good practice to wrap the error with additional information. Wrapping errors can help you understand the context in which the error occurred and help you debug the error more easily.

func doSomething() error {
   _, err := someFunction()
   if err != nil {
      return fmt.Errorf("Error doing something: %w", err)
   }
   // your code here
   return nil
}

In this example, we're wrapping the error returned by the someFunction() function with additional context information using the fmt.Errorf() function.

4 - Use error types: In Golang, you can define custom error types. Using error types can make your error handling more robust and help you distinguish between different types of errors. For example, you can define an error type for network errors, database errors, or file system errors.

type MyError struct {
   Msg string
   Code int
}
func (e *MyError) Error() string {
   return e.Msg
}
func doSomething() error {
   _, err := someFunction()
   if err != nil {
      return &MyError{
         Msg: "Error doing something",
         Code: 500,
      }
   }
   // your code here
   return nil
}

In this example, we're defining a custom error type MyError and using it to return a specific error when an error occurs in the doSomething() function.

5 - Use defer: Defer is a built-in function in Golang that allows you to schedule a function call to execute after the current function returns. Using defer can help you avoid forgetting to handle errors by ensuring that the error handling code is always executed.

file, err := os.Open("filename.txt")
if err != nil {
   log.Fatal(err)
}
defer file.Close()
// your code here

In this example, we're using defer to ensure that the file.Close() function is always called, even if an error occurs.

6 - Use context: Context is a powerful concept in Golang that allows you to propagate deadlines and other request-scoped values across API boundaries and between processes. Using context can help you manage errors more effectively by providing a way to cancel an operation or request if it takes too long to complete.

func doSomething(ctx context.Context) error {
   // set a deadline of 10 seconds
   ctx, cancel := context.WithDeadline(ctx, time.Now().Add(10*time.Second))
   defer cancel() // cancel the context when the function returns
   // your code here
   return nil
}

In this example, we're using context to set a deadline of 10 seconds for an operation. If the operation takes longer than 10 seconds, the context is canceled and an error is returned.

By following these best practices, you can ensure that your Golang code is more robust and that your error handling is effective.

Conclusion

Error handling is an essential part of any programming language, and Golang is no exception. By following the methods outlined in this article, you can effectively handle errors in your Golang applications and prevent them from stopping unexpectedly.

Golang Pointers and Functions: A Guide with Examples

Adrian DY — Wed, 17 May 2023 02:52:56 +0000

In this article, we'll explore how Golang pointers work in functions, and we'll provide examples of using them with and without memory references.

What are Pointers in Golang?

A pointer is a variable that contains the memory address of another variable. In Golang, a pointer is represented by an asterisk (*) followed by the data type of the variable it points to. For example, the following code declares a pointer to an integer variable:

var ptr *int

This declares a pointer named "ptr" that points to an integer variable. To assign the address of a variable to a pointer, use the "&" operator. For example:

var num int = 42
ptr = &num

This assigns the address of the "num" variable to the "ptr" pointer. Now, the "ptr" pointer points to the "num" variable in memory.

Using Pointers in Functions

When a pointer is passed to a function, the function can modify the value of the variable it points to directly in memory. This is much more efficient than passing a copy of the variable to the function, which requires creating a new variable in memory.

Let's take a look at an example:

func updateValueWithRef(chain *string) {
    fmt.Printf("%p\n", &*chain)
    *chain = "Hello from function"
}

This function takes a pointer to a string variable as its argument. Inside the function, we use the "*" operator to dereference the pointer and access the value of the variable it points to. Then, we can modify the value of the variable directly in memory by using the "=" assignment operator.

With Memory References

Now, let's take a look at an example of using a pointer with a memory reference:

chain := "Hello world"
fmt.Printf("%p\n", &chain)
fmt.Printf("Before function: %s\n", chain)
updateValueWithRef(&chain) // send a reference to the original
fmt.Printf("After function with pointer: %s\n", chain)

In this example, we declare a string variable named "chain" and assign it the value "Hello world". We then print the memory address of the "chain" variable using the "&" operator.

Next, we call the "updateValueWithRef" function and pass it a reference to the "chain" variable using the "&" operator. Inside the function, we modify the value of the variable directly in memory using the "*" operator.

After the function call, we print the value of the "chain" variable again, and we can see that it has been modified by the function.

Without Memory References

To understand the difference between using a pointer with and without memory references, let's take a look at an example of using a pointer without a memory reference:

func updateValue(chain string) {
    fmt.Printf("%p\n", &chain)
    chain = "Hello from function"
}

In this function, we take a string variable as its argument. Inside the function, we modify the value of the variable using the "=" assignment operator.

Now, let's call this function instead of the "updateValueWithRef" function in our previous example:

chain := "hello world"
fmt.Printf("%p\n", &chain)
fmt.Printf("Before function: %s\n", chain)
updateValue(chain) // send a copy, not reference
fmt.Printf("After function: %s\n", chain)

In this example, we call the "updateValue" function and pass it a copy of the "chain" variable. Inside the function, we modify the value of the copy using the "=" assignment operator.

After the function call, we print the value of the "chain" variable again, and we can see that it has not been modified by the function.

Full code example:

package main

import "fmt"

func main() {
    chain := "Hello world"
    fmt.Printf("%p\n", &chain)
    fmt.Printf("Before function: %s\n", chain)
    updateValue(chain) // send a copy, not reference
    fmt.Printf("After function: %s\n", chain)
    updateValueWithRef(&chain) // send a reference
    fmt.Printf("After function with pinter: %s\n", chain)
}

func updateValue(chain string) {
    fmt.Printf("%p\n", &chain)
    chain = "Hello from function"
}

// TODO - pointers *
func updateValueWithRef(chain *string) {
    fmt.Printf("%p\n", &*chain)
    *chain = "Hello from function with ref"
}

/*
    Output:
    0xc00009e230
    Before function: Hello world
    0xc00009e250
    After function: Hello world
    0xc00009e230
    After function with pinter: Hello from function with ref
*/

Conclusion

In conclusion, pointers are a powerful feature of Golang that enable developers to write more efficient code by manipulating data directly in memory. When using pointers in functions, it's important to understand the difference between using them with and without memory references, as this can affect how the function modifies the value of the variable it points to.

By understanding how pointers and functions work together in Golang, developers can write more efficient and scalable code that takes advantage of the language's unique features.

Slicing in Golang: Understanding the Basics

Adrian DY — Tue, 16 May 2023 03:19:24 +0000

Slicing is an essential concept in Golang that allows you to take a portion of a slice without actually copying the underlying data. In this article, we'll explore what slicing is, how it works, and how it can be used to manipulate data. We’ll also dive into an important facet of slicing: how changing the capacity of a slice can affect its sub-slices.

What is Slicing in Golang?
A slice in Golang is a dynamically-sized array. It's created using the make() built-in function and has a type that includes the element type and the size of the array. However, unlike an array, a slice is dynamic; its size can be changed at run-time.
Slicing is the process of taking a portion of a slice and creating a new slice from it. The new slice refers to the same underlying array as the original slice, which means that any changes made to the new slice will be reflected in the original slice.

Taking a Sub-Slice in Golang
To take a sub-slice of a slice, you can use the slice operator. This operator has two parameters: the start index and the end index of the sub-slice. The start index is inclusive, while the end index is exclusive.

Let's take a look at an example:
slicen1 := []int{1, 2, 3, 4, 5}
subSlicen := slicen1[1:3]

In this example, we take a sub-slice of slicen1 from the 1st index to the 3rd index (exclusive). The resulting sub-slice is {2, 3} .

Sub-Slices and Changing Capacity
When you create a sub-slice in Golang, it refers to a portion of the underlying array of the original slice. This means that any changes made to the sub-slice will be reflected in the original slice.
However, there is an important caveat to keep in mind: if you append a new value to the original slice that causes its capacity to increase, it will no longer refer to the same underlying array, and the sub-slice will lose its reference.
Let's look at the code example:

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3}
    subNumbers := numbers[:2]
    fmt.Println("numbers: ", numbers)
    fmt.Printf("Len: %d, Capac: %v, Memory Ref: %p \n", len(numbers), cap(numbers), numbers)
    fmt.Println("subNumbers: ", subNumbers)
    fmt.Printf("Sub - Len: %d, Capac: %v, Memory Ref: %p \n", len(subNumbers), cap(subNumbers), subNumbers)
    numbers[1] = 10
    fmt.Println("numbers[1] = 10")
    fmt.Println("numbers: ", numbers)
    fmt.Println("subNumbers: ", subNumbers)
    numbers = append(numbers, 4)
    fmt.Println("append(numbers, 4)")
    fmt.Println("numbers: ", numbers)
    fmt.Printf("Len: %d, Capac: %v, Memory Ref: %p \n", len(numbers), cap(numbers), numbers)
    fmt.Println("subNumbers: ", subNumbers)
    fmt.Printf("Sub - Len: %d, Capac: %v, Memory Ref: %p \n", len(subNumbers), cap(subNumbers), subNumbers)
    numbers[1] = 20
    fmt.Println("numbers[1] = 20")
    fmt.Println("numbers: ", numbers)
    fmt.Printf("Len: %d, Capac: %v, Memory Ref: %p \n", len(numbers), cap(numbers), numbers)
    fmt.Println("subNumbers: ", subNumbers)
    fmt.Printf("Sub - Len: %d, Capac: %v, Memory Ref: %p \n", len(subNumbers), cap(subNumbers), subNumbers)
    numbers = append(numbers, 5)
    fmt.Printf("Len: %d, Capac: %v, Memory Ref: %p \n", len(numbers), cap(numbers), numbers)
    numbers = append(numbers, 6)
    fmt.Printf("Len: %d, Capac: %v, Memory Ref: %p \n", len(numbers), cap(numbers), numbers)
    numbers = append(numbers, 7)
    fmt.Printf("Len: %d, Capac: %v, Memory Ref: %p \n", len(numbers), cap(numbers), numbers)

    /*
       Output:
        numbers:  [1 2 3]
        Len: 3, Capac: 3, Memory Ref: 0xc00001c1c8 
        subNumbers:  [1 2]
        Sub - Len: 2, Capac: 3, Memory Ref: 0xc00001c1c8 
        numbers[1] = 10
        numbers:  [1 10 3]
        subNumbers:  [1 10]
        append(numbers, 4)
        numbers:  [1 10 3 4]
        Len: 4, Capac: 6, Memory Ref: 0xc000022210 
        subNumbers:  [1 10]
        Sub - Len: 2, Capac: 3, Memory Ref: 0xc00001c1c8 
        numbers[1] = 20
        numbers:  [1 20 3 4]
        Len: 4, Capac: 6, Memory Ref: 0xc000022210 
        subNumbers:  [1 10]
        Sub - Len: 2, Capac: 3, Memory Ref: 0xc00001c1c8 
        Len: 5, Capac: 6, Memory Ref: 0xc000022210 
        Len: 6, Capac: 6, Memory Ref: 0xc000022210 
        Len: 7, Capac: 12, Memory Ref: 0xc00001a120
    */
}

In this example, we create a slice called numbers with three elements. We create a sub-slice called subNumbers that refers to the first two elements of numbers .
Next, we append an element to numbers and modify its second element's value. As you can see from the output, these changes are reflected in both numbers and subNumbers .
However, when we append another element to numbers , its capacity increases to six. Since the sub-slice subNumbers had a capacity of three, it loses its reference to the underlying array and refers to a new array that's created when the numbers slice is appended to.

Conclusion
In summary, slicing is an essential concept in Golang that allows you to take a portion of a slice without copying the underlying data. When you take a sub-slice of a slice, any changes made to the sub-slice are reflected in the original slice. However, if you append to the original slice and its capacity increases, it will lose its reference to its underlying array, and any sub-slices created from it will no longer reflect changes made to the original slice.