Forem: Dsysd Dev

Implementing your own stack in golang

Dsysd Dev — Wed, 13 Mar 2024 13:56:41 +0000

In this post I will be teaching how to implement your own stack data structure in golang from scratch.

If you would prefer the video format then follow the link below.

https://www.youtube.com/watch?v=uf24EYeJoaM

Here is the code

type StackIface interface {
    Empty() bool
    Top() byte
    Pop() bool
    Push(b byte)
}

type Stack []byte

func (s *Stack) Empty() bool {
    return s == nil || len(*s) == 0
}

func (s *Stack) Top() byte {
    // CAUTION! we are not handling those cases where stack is empty
    // to be handled by caller
    if s == nil {
        // handle ?
    }
    ss := []byte(*s)
    return ss[len(ss) - 1]
}

func (s *Stack) Pop() bool {
    if s.Empty() {
        return false
    }
    ss := []byte(*s)
    ss = ss[0:len(ss) - 1]
    *s = Stack(ss)
    return true
}

func (s *Stack) Push(b byte) {
    ss := []byte(*s)
    ss = append(ss, b)
    *s = Stack(ss)
}

func isValid(s string) bool {

    brackets := []string{"()", "{}", "[]"} // can add more such pairs if needed
    counter, opening := make(map[byte]byte), make(map[byte]bool)
    for _, bracket := range brackets {
        counter[bracket[1]] = bracket[0]
        opening[bracket[0]] = true
    }

    var stack Stack
    for _, r := range s {
        c := byte(r)
        if opening[c] {
            stack.Push(c)
        } else {
            // stack keeps track of opening brackets which need to be popped out
            if !stack.Empty() && stack.Top() == counter[c] {
                stack.Pop()
            } else {
                return false
            }
        }
    }
    return stack.Empty()
}

StackIface Interface:

Declares an interface StackIface with four methods: Empty() bool, Top() byte, Pop() bool, and Push(b byte).

Stack Type:

Defines a type Stack as a slice of bytes.
The methods of the StackIface interface are implemented for the Stack type.

Empty() Method:

Checks if the stack is empty.
Returns true if the stack is either nil or has a length of 0.

Top() Method:

Retrieves the top element of the stack.
Note: The code contains a cautionary comment, indicating that it doesn't handle cases where the stack is empty. This responsibility is left to the caller.

Pop() Method:

Removes the top element from the stack.
Returns false if the stack is empty; otherwise, it pops the top element.

Push() Method:

Adds a byte to the top of the stack.

isValid() Function:

Takes a string s as input and checks whether the string has valid bracket pairs.

Initializes brackets with pairs of opening and closing brackets.

Creates two maps: counter to map closing brackets to their corresponding opening brackets and opening to track opening brackets.

Initializes an empty Stack to keep track of the opening brackets encountered.

Iterates through each character in the input string.

If the character is an opening bracket, it is pushed onto the stack.

If the character is a closing bracket, it checks if the stack is not empty and if the top of the stack matches the corresponding opening bracket. If so, it pops the opening bracket from the stack. Otherwise, it returns false.

After iterating through the entire string, it checks if the stack is empty. If so, it means all opening brackets had matching closing brackets, and the function returns true; otherwise, it returns false.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

twitter: https://twitter.com/dsysd_dev
youtube: https://www.youtube.com/@dsysd-dev
github: https://github.com/dsysd-dev
medium: https://medium.com/@dsysd-dev
email: dsysd.mail@gmail.com
linkedin: https://www.linkedin.com/in/dsysd-dev/
newsletter: https://dsysd.beehiiv.com/subscribe
gumroad: https://dsysd.gumroad.com/
Dev.to: https://dev.to/dsysd_dev/
Instagram: https://www.instagram.com/dsysd.dev/
Hashnode: https://dsysd-dev.hashnode.dev/

Building golang project from scratch - part 3 - setting up the database using docker

Dsysd Dev — Fri, 29 Dec 2023 10:07:36 +0000

For those who prefer the video format

https://www.youtube.com/watch?v=kww6LL7OWdY

Explanation

Setting up your own postgres database using docker container
Instead of installing the postgres database on your system, you can use docker container to initiate a database for quick tests

version: '3.8'

services:
  postgres:
    image: postgres:latest
    container_name: my_db_pg_container
    restart: always
    environment:
      POSTGRES_DB: my_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"
    volumes:
      - ./migrations/1_db_init.up.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - my_network

networks:
  my_network:

Your Docker Compose file sets up a PostgreSQL database using the official PostgreSQL Docker image. It also includes a volume mount for initializing the database with an SQL script and uses a custom network. Here’s a breakdown of the key components:

Docker Compose Version:
version: ‘3.8’: Specifies the version of the Docker Compose file syntax.
Services:
— postgres: Defines a service named “postgres.”

image: postgres:latest: Specifies the PostgreSQL Docker image to use. latest refers to the latest version of the image.

— container_name: my_db_pg_container: Assigns a custom name to the PostgreSQL container.

— restart: always: Configures the container to restart automatically if it stops.

— environment: Sets environment variables for the PostgreSQL container.

— POSTGRES_DB: my_db: Specifies the name of the initial database to be created.

— POSTGRES_USER: postgres: Sets the default user for the PostgreSQL database.

— POSTGRES_PASSWORD: postgres: Sets the password for the default user.

— ports: Maps the host machine’s port 5432 to the container’s port 5432, allowing access to the PostgreSQL database.

— volumes: Mounts the ./migrations/1_db_init.up.sql file into the /docker-entrypoint-initdb.d/init.sql path inside the container. This file is executed during the initialization of the database.

— networks: Connects the service to a custom network named “my_network.”

Networks: — my_network: Defines a custom bridge network named “my_network” to allow communication between containers.

This configuration is useful for setting up a PostgreSQL database with a predefined schema or initial data using the SQL script (1_db_init.up.sql). When the container starts, it will execute the script, initializing the database with the specified settings.

To use this Docker Compose file

Save the file with a .yml or .yaml extension (e.g., docker-compose.yml).
Open a terminal in the directory containing the file.
Run the following command to start the PostgreSQL container:

    docker-compose up -d

This will download the PostgreSQL image (if not already present) and start the container with the specified configuration. The PostgreSQL server will be accessible on localhost:5432, and you can connect to it using the provided credentials.

To stop the container, use:

    docker-compose down

Adjust the configuration based on your specific requirements and security considerations.

Conclusion

In this article we learnt how we can quickly spin up a database using docker compose

Happy coding!

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow me on Medium for regular awesome content and insights.
Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

Building a Golang Project from Scratch — Zero to Hero — Part 2

Dsysd Dev — Tue, 10 Oct 2023 18:19:22 +0000

In this part of the series, we will be designing the whole system which we will be coding in go in the future videos
dsysd dev

Youtube Link

https://www.youtube.com/watch?v=yiCXjacyOVU

Brief Explanation

We will have users interact with out system.

They will be saving their data in the postgres database which is the database we will be using in the backend.
Schema

Table blogs     (id, name, content, created_at, updated_at, deleted_at)
Table user       (id, username, created_at, updated_at, deleted_at)
Table tag         (id, name)
Table blog_user   (user_id, blog_id)
Table blog_tag   (blog_id, tag_id)

The tables blog_user and blog_tag will be for keeping the relationships.

One user can have many blogs and one blog can have many tags

Architecture

The user will interact with the system. All data will be saved to postgres database.

The data will be synced to elasticsearch in the backend. This sync will take place at regular intervals.

The user will be able to search the data using keywords (which will be fetched from elasticsearch).

Elasticsearch is a highly available nosql database optimised for searching.

We cannot fire

select * from postgres_table where content like %VALUE%

The query above is super costly especially if have 10s of 1000s of blogs.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

Join me on Twitter for a daily dose of knowledge, fascinating trivia, and valuable insights. Let’s embark on a journey of continuous learning and discovery together! Follow me to stay inspired and informed. 🚀

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

Twitter: https://twitter.com/dsysd_dev
Youtube: https://www.youtube.com/@dsysd-dev
Github: https://github.com/dsysd-dev
Medium: https://medium.com/@dsysd-dev
Email: dsysd.mail@gmail.com
Telegram 📚: https://t.me/dsysd_dev_channel
Linkedin: https://www.linkedin.com/in/dsysd-dev/
Newsletter: https://dsysd.beehiiv.com/subscribe
Gumroad: https://dsysd.gumroad.com/
Dev.to: https://dev.to/dsysd_dev/

Let’s build our own protocol using tcp and net package in go, part 1

Dsysd Dev — Sun, 17 Sep 2023 15:05:39 +0000

Building your own protocol using the TCP package in Go involves defining a set of rules for communication between a client and a server.

These rules determine how data is structured, how messages are framed, and how the client and server interact.

We are going to build our own custom protocol.

But before that we must know how to implement a custom net connection in golang where we have a server and clients connect to the server.

The clients sends messages to the server and we simply print those messages.

If you prefer the video format with indepth explanation

https://www.youtube.com/watch?v=t5u-iHBgEUY

Explaining the code

func main() {
 // Create a TCP listener on localhost:3000
 l, err := net.Listen("tcp", "localhost:3000")
 if err != nil {
  log.Fatalln("couldn't listen to network")
 }

main Function: This is the entry point of the program. It does the following.

It attempts to create a TCP listener on localhost at port 3000 using the net.Listen function.

If an error occurs during this process, it logs an error message and exits the program using log.Fatalln .

 for {
  conn, err := l.Accept()
  if err != nil {
   log.Fatalln("err while accept", err)
  }
  go handle(conn)
 }
}

Accepting Connections: Inside an infinite for loop, the code does the following...

It waits for incoming client connections using l.Accept() . When a client connection is accepted, it returns a new connection object (conn) and any potential errors.

If an error occurs during the acceptance of a connection, it logs an error message and continues listening for connections.

When a connection is successfully accepted, it spawns a new goroutine by calling the handle function with the conn as an argument.

This allows the server to handle multiple client connections concurrently.

func handle(conn net.Conn) {
 // We keep reading all the messages from the connection
 // until the connection is closed.
 fmt.Println("connected to: ", conn.RemoteAddr())
 for {
  var buffer [1024]byte // 1KB buffer to read data
  _, err := conn.Read(buffer[:])
  if err != nil {
   log.Printf("err while reading from conn: %v, exiting ...", err)
   return
  }
  fmt.Println("message read: ", string(buffer[:]))
 }
}

handle Function: This function is called for each client connection. It handles the communication with connected clients.

It prints a message indicating that a connection has been established, including the remote address of the client.

Inside a loop, it uses a 1KB buffer (buffer) to read data from the client connection using conn.Read().

If an error occurs while reading data from the client, it logs an error message and returns from the function, effectively closing the connection.

Otherwise, it prints the received message to the console.

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

Join me on Twitter for a daily dose of knowledge, fascinating trivia, and valuable insights.

Let’s embark on a journey of continuous learning and discovery together! Follow me to stay inspired and informed. 🚀

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

Dependency Injection like a Pro in Golang

Dsysd Dev — Wed, 13 Sep 2023 09:20:18 +0000

Are you ever confused about dependency injection ? What if i tell you that it's the simplest topic ever! It's just about passing values to a function !!

If you prefer the video version

https://www.youtube.com/watch?v=AJ6uz9mlFOA

Dependency Injection is just a fancy way of saying "passing stuff into a function." It's about giving a function or object the things it needs to work.

It's like baking pizza. You don't bake the pizza at home; you call a pizza place and tell them what you want. The pizza delivery is like a function that takes your order (dependencies) and delivers the result (pizza).

func OrderPizza() {
    oven := NewOven()
    pizza := oven.BakePizza()
    // ...
}

This function creates its own dependencies (the oven) instead of having them provided.

func OrderPizza(oven Oven) {
    pizza := oven.BakePizza()
    // ...
}

The function is more flexible because you can now choose which oven to use (e.g., regular oven or wood-fired oven).

Dependency Injection is widely used in Go, especially in building HTTP servers. Explain that you can pass different routers, middleware, and database connections to the server as dependencies.

package main

import (
 "fmt"
 "net/http"
)

// Router defines the interface for a router.
type Router interface {
 HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
}

// MyRouter is an example implementation of the Router interface.
type MyRouter struct{}

func (r *MyRouter) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
 http.HandleFunc(pattern, handler)
}

// LoggerMiddleware is an example middleware.
func LoggerMiddleware(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  fmt.Println("Logging:", r.URL.Path)
  next.ServeHTTP(w, r)
 })
}

func main() {
 // Create a router instance
 router := &MyRouter{}

 // Attach middleware
 http.Handle("/", LoggerMiddleware(router))

 // Define routes
 router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Welcome to our website!")
 })

 router.HandleFunc("/about", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "About Us")
 })

 router.HandleFunc("/contact", func(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Contact Us")
 })

 // Start the server
 fmt.Println("Server is listening on :8080")
 http.ListenAndServe(":8080", nil)
}

In this example:

We define a Router interface that has a HandleFunc method, which mimics the behavior of Go's http.HandleFunc.

MyRouter is an implementation of the Router interface.
We create a LoggerMiddleware function, which is a middleware that logs incoming requests.

In the main function, we create an instance of MyRouter.
We attach the LoggerMiddleware to the router to log requests.

We define routes using the HandleFunc method provided by our router, which is the equivalent of http.HandleFunc.
Finally, we start the server using http.ListenAndServe.

This example demonstrates how you can use dependency injection to pass in routers and middleware to create a flexible and modular web server in Go.

You can easily swap out different routers or middleware components to customize your server's behavior.

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

Join me on Twitter for a daily dose of knowledge, fascinating trivia, and valuable insights. Let's embark on a journey of continuous learning and discovery together! Follow me to stay inspired and informed. 🚀

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

Building a Golang Project from Scratch - Zero to Hero - Part 1

Dsysd Dev — Tue, 29 Aug 2023 07:06:06 +0000

In this tutorial series we will be a building a full end to end golang backend project.

We will be building a full end to end golang backend project. This series will be useful for anyone learning to use golang for their backend development projects.

So if you are a beginner who is just starting out with golang, backend development or software development in general, follow along.

https://www.youtube.com/watch?v=rDSOpr3kuWE

Watch the video above to understand how you can instantiate a simple golang server using go-chi.

Github project

You can follow the github project here

https://github.com/dsysd-dev/go-learning-series/tree/main/go-server

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

A great use case of golang channels

Dsysd Dev — Sat, 26 Aug 2023 03:08:17 +0000

In this post we will explore how we can use golang channels for doing a graceful shutdown.

In the world of web development, managing server shutdowns is a critical aspect that often goes overlooked.

Abrupt server terminations can lead to data loss, incomplete transactions, and a degraded user experience.

Fortunately, Go offers a straightforward and elegant solution to this problem through graceful server shutdowns.

In this article, we'll explore the concept of graceful shutdowns in Go and provide step-by-step guidance on how to implement them in your applications.

Understanding the Need for Graceful Shutdowns

When a server is abruptly terminated, active connections and ongoing processes are forcibly interrupted, resulting in potential data corruption and an inconsistent state.

Graceful shutdowns, on the other hand, allow the server to complete its ongoing operations and connections before exiting, ensuring that no data is lost and users are not disrupted.

Implementing Graceful Shutdowns in Go

Prerequisites

Before we proceed, make sure you have a basic understanding of Go programming.

Capturing OS Signals

Go provides the os/signal package to capture OS signals like SIGINT (Ctrl+C) and SIGTERM. These signals indicate the need for a graceful shutdown.

Creating a Shutdown Channel

Create a channel that will act as a signal to initiate the shutdown process. This channel will be used to communicate between the main routine and the server's goroutines.

quit := make(chan os.Signal, 1)

Listening for Signals

Use the signal.Notify function to listen for specified signals and send them to the quit channel when received.

signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

Implementing Shutdown Logic

In your main function or where the server is initialized, implement a select statement that waits for either a signal from the quit channel or a timeout.

select {
case sig := <-quit:
    fmt.Printf("Received signal: %s\n", sig)
    // Perform necessary cleanup and graceful shutdown
case <-time.After(time.Second * 10):
    fmt.Println("Timeout reached, shutting down...")
    // Perform necessary cleanup and graceful shutdown
}

Putting It All Together

Here's how the full code may look like

package main

import (
    "fmt"
    "time"
    "os"
    "os/signal"
    "syscall"
)

func main() {
 quit := make(chan os.Signal, 1)
 signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 select {
 case sig := <-quit:
  fmt.Printf("Received signal: %s\n", sig)
  // Perform graceful shutdown logic
 case <-time.After(time.Second * 10):
  fmt.Println("Timeout reached, shutting down...")
  // Perform graceful shutdown logic
 }
 fmt.Println("Server gracefully shut down")
}

Conclusion

Implementing graceful server shutdowns in your Go applications is a crucial step toward maintaining data integrity, ensuring consistent user experiences, and preventing abrupt disruptions.

By capturing OS signals and using a well-designed shutdown mechanism, you can handle server terminations in a controlled and graceful manner.

As you continue to enhance your Go applications, keep the concept of graceful shutdowns in mind to create robust and user-friendly systems.

Happy coding!

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Video Format

https://www.youtube.com/watch?v=_OYGYVMU_oA

if you prefer to watch a live coding video, click on the link above!

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

Understand Ownership and borrowing in Rust

Dsysd Dev — Mon, 21 Aug 2023 06:08:23 +0000

There are many tutorials available on this topic, here I try to show you how I understand this simple but very important concept

fn main() {
    let mut num = 42;

    // Immutable Borrow
    let borrowed_immutable = &num;
    println!("Immutable Borrow: {}", borrowed_immutable);

    // Mutable Borrow
    let borrowed_mutable = &mut num;
    *borrowed_mutable += 10;
    println!("Mutable Borrow: {}", borrowed_mutable);

    // Cannot do an immutable borrow while there's a mutable borrow
    // println!("Immutable Borrow: {}", borrowed_immutable);
}

The main function starts by creating a mutable variable num with a value of 42.

Immutable Borrowing:

An immutable borrow is created with let borrowed_immutable = &num;. This means we're borrowing num in an immutable way, so we can read its value but not modify it.

We can have multiple such shared refereces.

Mutable Borrowing:

A mutable borrow is created with let borrowed_mutable = &mut num;. This allows us to modify the value of num through the borrowed reference.

Since it's a mutable borrow, we use the * operator to dereference the borrowed reference and modify the value. We add 10 to it.

The modified borrowed value is printed with println!.

Trying to create an Immutable Borrow again

The code that attempts to create an immutable borrow after a mutable borrow is commented out.

Rust does not allow an immutable borrow while there's a mutable borrow. This is to prevent potential data races.

In Rust, mutable and immutable borrows have different rules to ensure memory safety.

When you have a mutable borrow, no other borrow (mutable or immutable) can be active at the same time.

This prevents data races where multiple parts of your code try to change data concurrently, which can lead to unpredictable behavior.

Understanding Ownership

fn main() {
    let num: Box<i32> = Box::new(33);

    ownership(num);

    // println!("after owner: {}", num);
}

fn ownership(num: Box<i32>) {
    println!("owned: {}", num);

    let num2 = *num.as_ref() * 2;

    println!("new num: {}", num2);
}

In the main function:

A variable named num is created and assigned a Box that contains the value 33.

The Box is a smart pointer created on heap that helps manage memory allocation and deallocation.

The ownership function is called, passing the num Box to it.

There's a commented-out line that attempts to print the value of num after it's been passed to the ownership function.

However, this line is commented out because Rust's ownership system prevents using num after it's been moved to the ownership function.

The ownership function receives the ownership of the num Box.

The value inside the Box is printed using println!.

The value is then multiplied by 2 and assigned to the variable num2.

The new value, num2, is printed using println!.

The Key Concept

The key concept here is Rust's ownership system, which ensures memory safety and prevents certain types of bugs like null pointer dereferencing and data races.

In Rust, when a value is passed into a function (or moved to another variable), the ownership of that value is transferred.

This means the original variable can't be used afterward, to prevent issues like double freeing memory or using invalid references.

The Box type is used here to allocate memory on the heap for the i32 value (instead of the stack).

When the Box is passed to the ownership function, ownership of the data moves to the function.

This concept is called "moving" in Rust.

This is the rust default as compared to CPP where values are copied.

Video Format

If you prefer video format, then have a look at this short

https://www.youtube.com/shorts/AbsYKCEd-XU

Conclusion

This code demonstrates Rust's strict ownership model and how it helps prevent memory-related bugs.

It might look a bit complicated at first, but Rust's ownership and borrowing rules play a significant role in ensuring the safety and reliability of your programs.

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.
Twitter: https://twitter.com/dsysd_dev
Youtube: https://www.youtube.com/@dsysd-dev
Github: https://github.com/dsysd-dev
Medium: https://medium.com/@dsysd-dev
Email: dsysd.mail@gmail.com
Telegram 📚: https://t.me/dsysd_dev_channel
Linkedin: https://www.linkedin.com/in/dsysd-dev/
Newsletter: https://dsysd.beehiiv.com/subscribe
Gumroad: https://dsysd.gumroad.com/
Dev.to: https://dev.to/dsysd_dev/

Reverse a Generic List in golang

Dsysd Dev — Mon, 21 Aug 2023 05:48:14 +0000

In this post we create a simple program to reverse a list, not a specific type of list but a generic list.
Photo by Thomas Bormans on Unsplash
The Reverse Function

func reverse[T any](list []T) []T {
    for i, j := 0, len(list)-1; i < j; {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
    return list
}

This is a generic function called reverse that takes a slice of any type T as input and returns a reversed slice of the same type T.

func reverse[T any](list []T) : []T defines the reverse function. The [T any] syntax indicates that the function is generic and can work with slices of any type.

Inside the function, a loop is used to reverse the elements of the list. The loop iterates from the beginning (i) and end (j) of the slice toward the middle, swapping elements at positions i and j until they meet.

list[i], list[j] = list[j], list[i] swaps the elements at positions i and j. Pretty neat way to swap elements !!

i++ increments i, and j-- decrements j to move towards the center of the slice.

Once the loop completes, the function returns the reversed list.

The Main Function

package main

import "fmt"

func main() {
    l := []int{1, 2, 3, 4}
    l = reverse[int](l)
    fmt.Println(l)
}

In the main function, a slice of integers l is initialized with values {1, 2, 3, 4}.

The reverse function is called with the slice l, and the returned result is assigned back to l.

Finally, fmt.Println(l) prints the reversed slice.

Video Format

If you prefer video format, then have a look at this short

https://www.youtube.com/shorts/gt3vRmCG75E

Conclusion

This code demonstrates how to use a generic function to reverse the elements of a slice in Go.

It’s worth noting that the usage of generics in Go is a feature introduced in Go 1.18 and won’t work with versions before that.
Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Youtube channel

Subscribe to my youtube channel if you are on the lookout for more such awesome content in video format.

https://www.youtube.com/@dsysd-dev

Follow me on twitter 🐥

https://twitter.com/dsysd_dev

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

Understanding Lifetime in Rust

Dsysd Dev — Mon, 31 Jul 2023 11:09:21 +0000

When learning Rust, the first time one encounters a compilation error that states about lifetimes, can be a confusing experience.

The first thing to understand about lifetimes is that it provides yet another level of security to our program.

As we all know and probably do, sharing references is a lot better than passing data by copying their values.

Though, references are easily out of scope when not considered carefully.

So for instance

let mut r: &Vec<u32>;
{
   let x = vec![1,2,3];
   r = &x;
}     // <-- the value owned by x is dropped
r    // <-- r points to a dropped value: ERROR!

The “life” of x‘s value is bound to the code block wrapped by { ... }. Therefore, the “life” of a reference like r pointing to this value, exactly has the same “time of life”.

All good — and the Rust compiler would complain when detected an situation like the one above.

Another (C++ -traditional) example is the following:

fn f() -> &Vec<u32> {
  let x = vec![1,2,3];
  &x  // <-- life of x's owned value ends: ERROR!
}

Also here, the compiler would complain since the returned references points to a dropped value.

Note that this wouldn't be a problem in case of golang, infact we do this commonly in go

func f() *[]uint32 {
  x := []uint32{1,2,3)
  return &x
}

And we would let garbage collector take care of that.

So far, there was no need for any lifetime parameter because Rust was able to detect all the bad scenarios for us. But let us look at this one:

struct S{
  x_ref: &Vec<u32>   
}     // does not compile!

fn f() -> S{
  let x = vec![1,2,3];
  S{ x_ref: &x }
}  // <-- life of x's owned value ends

In comparison with the previous example, here we kind of try to trick the compiler.

Instead of a reference, we now try to return a variable that owns its value. But this variable, i.e. the instance of S, wraps a reference to the value owned by x.

However, this reference after being returned again points to a dropped value.

Rust, will not complain at the same position as before, but instead does not allow us to declare a struct containing references without lifetime bounds. So it forces us to write:

struct S<'a>{
  x_ref: &'a Vec<u32>   
}     

fn f<'a>() -> S<'a> {
  let x = vec![1,2,3];
  S{ x_ref: &x }
}  // <-- life of referrence x_ref is shorter than life of S: ERROR!

The compiler now detects a breach in the use of S, that is, it is tried to have an instance of S containing a reference which lives shorter than the instance itself.

Note, the instance lives longer since it is returned, whereas the by x_ref referred value is getting dropped at the end of the function.

As you can see, lifetime parameters is just a way the compilers ensures its checks do run properly.

Most of the time, the compiler is telling us automatically where these bounds are required.

Most important to note, lifetimes do not alter be any means the “life” of a value! Lifetimes are to be considered as additional information of a contract that we do have with the compiler.

For instance, you could have a function looking like

fn f<'a, 'b, T>(x: &'a T, y: &'b T, z: &'a T) -> &'a T {
    ...
}

No matter what the function’s body is, this just tells us the following thing:

The return value of f cannot be used longer than x‘s and z’s life is.

An alternative interpretation is this: The use of f‘s return value, determines how long the passed references x and z must live at least.

The latter interpretation once more underlines that lifetime parameter are additional contract information the compiler from time to time requests from us.

Why is this all worth the hassle?

Rust’s concept of ownership and rules of borrowing is a lot new material to learn when coming from traditional languages.

Especially, with regard to the concept of lifetime parameter that introduces yet another layer of syntactical symbols, you might be tempted to ask: “Why not just keep the value until no reference points to it anymore?”

The answer, as easy it is, as easy can be forgotten: “By this, Rust does not need a garbage collector, nor you have to garbage collect on yourself.”

Thank you for reading!

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

String vs str in Rust: Understanding the Fundamental Differences for Efficient Programming

Dsysd Dev — Mon, 31 Jul 2023 10:58:55 +0000

Instead, the string data type in Rust is represented by the "String" type (with an uppercase 'S'). The confusion might arise because of the "str" type (with a lowercase 's'), which is used as a string slice in Rust.

String

The String type in Rust is a growable, heap-allocated, UTF-8 encoded string.

It is part of the Rust standard library and is widely used when you need a mutable and dynamic string that can be modified and resized at runtime.

You can create a new String by calling its associated function String::new() or by converting from a string slice using the to_string() method.

let mut my_string = String::new();
my_string.push_str("Hello, ");
my_string.push('R');
my_string.push('u');
my_string.push('s');
my_string.push('t');

println!("{}", my_string); // Output: "Hello, Rust"

str (String Slice)

The str type in Rust is a borrowed string slice, also known as a string reference.

It represents a view into an existing UTF-8 encoded string data. String slices are immutable and have a fixed size that cannot be modified.

String slices are commonly used to pass string data without transferring ownership, reducing the need for unnecessary memory copies.

fn print_greeting(greeting: &str) {
    println!("{}", greeting);
}

let my_string = "Hello, Rust!";
print_greeting(my_string); // Output: "Hello, Rust!"

Differences between "String" and "str" (String Slice)

Ownership:

String owns the data it represents and is responsible for its memory allocation and deallocation.

str (String Slice) is a borrowed reference to a portion of an existing string or string literal, and it does not own the data.

Mutability:

String is mutable, meaning you can modify its content after creation.

str (String Slice) is immutable, and you cannot modify its content.

Size:

String can dynamically grow or shrink as needed and has a flexible size.

str (String Slice) has a fixed size and represents a subset of a larger string data.

Allocation:

String is heap-allocated, and its memory is managed by the Rust standard library.

str (String Slice) does not require any heap allocation and is often used as borrowed references to string literals or other String types.

But what is a view

When we say that a "str" (String Slice) represents a view into an existing UTF-8 encoded string data, it means that the "str" type does not own the actual string data.

Instead, it provides a read-only reference to a portion of an existing UTF-8 encoded string.

Let's break it down

View

A "view" in this context means that the str type acts as a window or a lens through which you can observe a part of a larger string.

It allows you to look at and interact with that specific section of the string without actually copying or owning the entire string data.

Existing UTF-8 Encoded String Data

The data referred to by a str must already exist somewhere in memory.

It could be a string literal (a sequence of characters enclosed in double quotes) or a part of a heap-allocated "String" type.

In either case, the string data must be UTF-8 encoded, as Rust enforces UTF-8 encoding for all its string types.

UTF-8 Encoded

UTF-8 is a character encoding standard that represents characters in a way that ensures compatibility with the ASCII character set while also supporting a vast range of international characters.

Rust's str type enforces UTF-8 encoding to guarantee that strings can represent any valid Unicode text.

Here's an example to illustrate the concept:

fn main() {
    let my_string = String::from("Hello, Rust!"); // A heap-allocated String
    let my_slice: &str = &my_string[0..5]; // A string slice representing "Hello"

    println!("Original String: {}", my_string);
    println!("String Slice: {}", my_slice);
}

In this example, we have a heap-allocated String called my_string, containing the text "Hello, Rust!".

The line let my_slice: &str = &my_string[0..5]; creates a string slice my_slice that borrows a part of my_string, specifically the characters from index 0 to 4 ("Hello").

The string slice my_slice does not own the data; it simply provides a view into the existing string data held by my_string.

The use of string slices allows Rust to efficiently work with and manipulate parts of strings without incurring unnecessary memory copies, making it a memory-safe and high-performance language for string handling.

Summary

In summary, "String" is a dynamic and mutable string type that owns its data, while "str" (String Slice) is an immutable reference to a fixed portion of a string and does not own the data.

Both types are essential in Rust and serve different purposes depending on the use case and requirements of your code.

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe

Important Links

Thanks for reading the post, be sure to follow the links below for even more awesome content in the future.

What is Arc in Rust and how to use it with rust traits ?

Dsysd Dev — Thu, 27 Jul 2023 07:29:40 +0000

Using Arc with traits in Rust is a bit more involved, but I'll do my best to explain it to you step by step.

Understanding Arc : What is it ?

Arc stands for "Atomic Reference Counted" and is a type in Rust's standard library (std::sync::Arc) .

It allows you to share ownership of data between multiple threads, ensuring that the data is deallocated only when the last reference to it is dropped.

This is useful when you need to pass data between threads or share it across different parts of your code safely.

Understanding Traits

In Rust, traits define behavior that types can implement.

Think of them as a set of functions that a type must provide to be considered as implementing that trait.

Traits enable you to write generic code that works with any type that implements the required behavior.

Now, let's see how we can combine Arc with traits.

Defining the Trait

First, you need to define the trait that describes the behavior you want your types to implement.

For example, let's create a simple trait called Printable that requires a print function.

trait Printable {
    fn print(&self);
}

Implementing the Trait for a Struct

Next, let's create a simple struct and implement the Printable trait for it.

struct MyData {
    data: String,
}
impl Printable for MyData {
    fn print(&self) {
        println!("MyData: {}", self.data);
    }
}

Using Arc with the Trait

Now, we want to use Arc to share the MyData instance across different parts of our code.

use std::sync::Arc;

fn main() {
    // Create an instance of MyData
    let my_data = MyData {
        data: "Hello, Arc!".to_string(),
    };
    // Create an Arc that holds a reference to the MyData instance
    let arc_my_data: Arc<dyn Printable> = Arc::new(my_data);
    // Clone the Arc so that we have another reference to the same data
    let cloned_arc_my_data = Arc::clone(&arc_my_data);
    // Now we can use both Arc references to the same data
    arc_my_data.print();
    cloned_arc_my_data.print();
}

In this example, we create an Arc that holds a reference to the MyData instance.

We use the Arc::clone function to create additional references to the same data. The print function is called on both Arc references, and it works as expected.

Understanding Arc

You might have noticed that we used Arc instead of Arc.

This is because Arc needs to know the size of the type it's holding at compile time, and trait objects like dyn Trait have a dynamic size that's not known at compile time.

To use Arc with traits, we need to use the dyn keyword to indicate that it's a trait object.

Using Arc with traits allows us to store different types that implement the same trait within the same Arc, enabling more flexibility and composability in our code.

That's the basic explanation of using Arc with traits in Rust. It provides you with a way to share trait objects across threads while ensuring proper memory management.

But What about Data mutation

You cannot directly mutate the data held by an Arc between different threads.

The whole purpose of Arc is to provide shared ownership of immutable data across multiple threads in a safe manner.

It enforces the rule that the data inside an Arc cannot be mutated once it's shared.

When you have an Arc, it allows multiple threads to have read-only access to the data simultaneously, but it does not provide a way for multiple threads to mutate the data concurrently.

If you need to mutate the data, you should use interior mutability patterns like Mutex or RwLock in combination with Arc.

Using Mutex

If you want to mutate the data in a thread-safe manner, you can wrap the data inside a Mutex.

The Mutex enforces that only one thread can acquire the lock to the data at a time, ensuring exclusive access during the mutation.

use std::sync::{Arc, Mutex};
use std::thread;

struct MyData {
    counter: Mutex<u32>,
}
impl MyData {
    fn increment_counter(&self) {
        let mut counter = self.counter.lock().unwrap();
        *counter += 1;
    }
}
fn main() {
    let my_data = Arc::new(MyData {
        counter: Mutex::new(0),
    });
    let threads: Vec<_> = (0..4)
        .map(|_| {
            let my_data_clone = Arc::clone(&my_data);
            thread::spawn(move || {
                my_data_clone.increment_counter();
            })
        })
        .collect();
    for t in threads {
        t.join().unwrap();
    }
    let counter_value = *my_data.counter.lock().unwrap();
    println!("Final Counter Value: {}", counter_value);
}

Using RwLock

If you need to allow multiple threads to read the data simultaneously but still need exclusive access for mutation, you can use RwLock (Read-Write Lock).

The important thing to remember is that when you use Mutex or RwLock with Arc, you need to wrap the data in these types first before placing it inside the Arc.

This ensures that thread-safe access and mutation are guaranteed.

If you need to mutate the data held by an Arc from different threads, you should use interior mutability patterns like Mutex or RwLock in conjunction with Arc to achieve thread safety.

Claps Please!

If you found this article helpful I would appreciate some claps 👏👏👏👏, it motivates me to write more such useful articles in the future.

Follow for regular awesome content and insights.

Subscribe to my Newsletter

If you like my content, then consider subscribing to my free newsletter, to get exclusive, educational, technical, interesting and career related content directly delivered to your inbox

https://dsysd.beehiiv.com/subscribe