
**Goroutines** are a lightweight form of concurrency in the Go programming language. They are similar to threads in other languages, but they are managed by the Go runtime rather than the operating system, making them more lightweight and efficient. In this blog post, we will learn about goroutines, how to use them, and some best practices for writing concurrent code in Go.

A goroutine is created by calling the go keyword followed by a function call. For example, the following code creates a goroutine that runs the printHello function:

```go
package main

import "fmt"

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

func main() {
    go printHello()
}
```

Once a goroutine is created, it runs independently of the main function, and the program continues to execute the next line of code.

Here is an example of how to use goroutines to perform concurrent operations:

```go
package main

import (
	"fmt"
	"time"
)

func printNumbers() {
	for i := 1; i <= 10; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(i)
	}
}

func printLetters() {
	for i := 'a'; i <= 'j'; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(string(i))
	}
}

func main() {
	go printNumbers()
	go printLetters()
	time.Sleep(11 * time.Second)
}
```

In this example, the main function creates two goroutines, one that prints the numbers 1 through 10 and another that prints the letters 'a' through 'j'. The goroutines run concurrently and their output is interleaved.

One important thing to note is that, once a goroutine is created, it runs independently of the goroutine that created it. This means that the goroutine that created it will not wait for it to complete before moving on. In the example above, the main function calls time.Sleep(11 * time.Second) to wait for the two goroutines to complete before exiting.

Another important thing is that, goroutines does not have a direct way of communication. In order to communicate between goroutines, you can use channels. Channels are a way to pass data between goroutines and synchronize their execution.

Here is an example of how to use channels to pass data between goroutines:

```go
package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
	x, y := <-c, <-c // receive from c

	fmt.Println(x, y, x+y)
```


In this example, the main function creates a channel c and starts two goroutines. Each goroutine computes the sum of a half of the slice s and sends the result on the channel c. The main function receives the results from the channel and prints them.

Channels can also be used to synchronize the execution of goroutines. Here is an example of how to use channels to synchronize the execution of goroutines:

```go
package main

import (
  "fmt"
  "time"
)

func worker(done chan bool) {
  fmt.Print("working...")
  time.Sleep(time.Second)
  fmt.Println("done")

  done <- true
}

func main() {
  done := make(chan bool, 1)
  go worker(done)

  <-done // wait for the worker to finish
}
```

In this example, the main function creates a channel done and starts a goroutine. The goroutine executes the worker function and sends a value on the channel done to indicate that it has finished. The main function waits for the worker to finish by receiving a value from the channel done.


## Best practices

Here are some best practices for writing concurrent code in Go:

- Use channels to communicate between goroutines. Do not share memory by communicating.


- Channels are typed by the values they convey. You can use the same channel to send and receive values of the same type.


- By default, sends and receives block until the other side is ready. This allows goroutines to synchronize without explicit locks or condition variables.


- The select statement lets a goroutine wait on multiple communication operations.


- The sync package provides useful primitives, such as mutexes, for managing state.


- The context package defines the Context type, which carries deadlines, cancellation signals, and other request-scoped values across API boundaries and between processes.


## Conclusion

In this blog post, we learned about goroutines, how to use them, and some best practices for writing concurrent code in Go. If you have any questions or comments, feel free to ask.


Concurrency in Go


**Principal Component Analysis (PCA)** is a widely used dimensionality reduction technique that is employed in various fields such as machine learning, computer vision, and statistics. It is a powerful tool that can be used to extract the most important features from a dataset, reduce noise, and improve the performance of machine learning models. In this blog post, we will learn how to implement PCA from scratch in Python, along with the required mathematical background in detail.

The PCA algorithm can be broken down into the following steps:

**Mean centering**: The first step in PCA is to mean center the data. This means subtracting the mean of each feature from the corresponding feature values. This is done to ensure that the first principal component has zero mean.

**Covariance matrix calculation**: Next, we calculate the covariance matrix of the centered data. The covariance matrix is a d x d matrix where d is the number of features in the data. Each element in the matrix represents the covariance between two features.

**Eigenvalue and Eigenvector calculation**: Next, we find the eigenvectors and eigenvalues of the covariance matrix. Eigenvectors are the directions along which the data varies the most, and eigenvalues are the magnitudes of the variations.

**Sorting eigenvectors**: We then sort the eigenvectors by decreasing eigenvalues. This is done to ensure that the first eigenvector corresponds to the largest variation in the data, the second eigenvector corresponds to the second largest variation and so on.

**Choosing the top n_components eigenvectors**: We then choose the top n_components eigenvectors based on the number of components we want to retain.

**Projecting the data onto the new feature space**: Lastly, we project the data onto the new feature space by computing the dot product of the centered data and the chosen eigenvectors.

Now let's see how to implement PCA from scratch in Python using Numpy library:

```py
import numpy as np

def pca(X, n_components):
    """
    Perform PCA on the input dataset X.
    :param X: numpy array with shape (n_samples, n_features)
    :param n_components: number of principal components to keep
    :return: tuple (X_transformed, eigenvectors, eigenvalues)
    """
    # Mean centering
    X = X - np.mean(X, axis=0)
    # Computing the covariance matrix
    cov_matrix = np.cov(X.T)
    # Computing the eigenvectors and eigenvalues of the covariance matrix
    eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
    # Sorting the eigenvectors by decreasing eigenvalues
    eigenvectors = eigenvectors[:, np.argsort(-eigenvalues)]
    eigenvalues = eigenvalues[np.argsort(-eigenvalues)]
    # Choosing the top n_components eigenvectors
    eigenvectors = eigenvectors[:, :n_components]
    # Projecting the data onto the new feature space
    X_transformed = np.dot(X, eigenvectors)
    return X_transformed, eigenvectors, eigenvalues

# Example usage
X = np.random.rand(100, 5)
X_transformed, eigenvectors, eigenvalues = pca(X, 2)

```

The above code snippet shows how to implement PCA from scratch in Python. The function pca takes the input dataset X and the number of components to retain as input parameters. It then performs mean centering, covariance matrix calculation, eigenvalue and eigenvector calculation, sorting eigenvectors, choosing the top n_components eigenvectors, and projecting the data onto the new feature space. The function returns the transformed dataset, eigenvectors, and eigenvalues.


## Conclusion
In this blog post, we learned how to implement PCA from scratch in Python. We also learned the required mathematical background to understand the algorithm. We also saw how to use PCA to reduce the dimensionality of a dataset and improve the performance of machine learning models. I hope you found this blog post useful. If you have any questions or suggestions, feel free to ask.

