
In this blog, I'll try to explain some of the most popular keywords that have been around in the last few months.

## Embeddings

Embedding is a technique used to convert digital objects like images, text, audio, etc., into a numeric representation so that the ML model can understand them.

The embedding model is a neural network model that converts the object into a list of numbers. Google has developed a model called `Word2Vec`, and OpenAI also provides an [API](https://platform.openai.com/docs/guides/embeddings) that you can use.

Technically, the embedding is represented as a [vector](https://mathinsight.org/vector_introduction), where the distance between two vectors reflects their relatedness.

![embeddings](/blog/embeddings.png)

## RAG

RAG, which stands for **Retrieval-Augmented Generation**, is another technique used to provide the LLM with information that it might not know.

For example, if you have a small business and created a website for it, and then you go to ChatGPT and ask about your business, it has to fetch the internet to find it. However, it might not find it if your website is not indexed yet.

So how does RAG work? You provide the LLM with the information it needs to answer your question in the question itself. It's as easy as that.

![simple RAG](/blog/rag-1.png)

**But the issue** you will encounter is if you have **large amounts of data** that you need to provide to the LLM. For example, if you have a documentation website and want to add a chatbot that can answer users with accurate and up-to-date information.

In this case, what you need to do is provide only a piece of information that is related to the user's question.

To do so, we need to use [semantic search](https://deepgram.com/ai-glossary/semantic-search-algorithms).

> [!NOTE]
> Semantic search is a technique where data is retrieved based on the meaning of the query rather than simply matching text like traditional search systems (LIKE in SQL, for example).

To implement semantic search, we need to use embeddings. Remember them? What we actually need to do is **convert the large data that we have into embeddings** and store them in a [vector database](https://www.pinecone.io/learn/vector-database/) to enable semantic search.

> [!TIP]
> For better semantic search results, you can **chunk and summarize the data you are embedding into small pieces**. For example, in a help center, you can chunk the data by section. The more chunks, the better the results, as the search will be on a specific piece of information rather than the whole page.

![simple RAG](/blog/rag-2.png)

If we want to implement this in pseudo code, it would look like this:

```js
const data = ["path/to/data.md", "path/to/data.pdf", "..."];
const textData = [];
for (file in data) {
  const text = chunkAndSummarize(readFile(file));
  textData.push(text);
}

const embeddedData = textData.map((text) => {
  return openai.embedding.create({
    model: "...",
    input: text,
    encoding_format: "float",
  });
});

// Index must be created before it's used in Pinecone (index is just to separate data based on type or whatever you want)
pinecone.index.upsert([
  // ...
  {
    vectors: embeddedData[i],
    metadata: {
      context: textData[i],
      section: "How to install",
    },
  },
  // ...
]);

const searchResult = pinecone.index.search(userQuery);

const llmResponse = openai.completions.create({
  prompt: `
      Respond to the user query: ${userQuery}

      Use this information to respond:
      ${searchResult}
   `,
});

return llmResponse.output_text;
```

That's basically how to implement RAG. The code above is pseudo code for demonstration only. You can check the documentation of [Pinecone](https://docs.pinecone.io/guides/get-started/overview) or [ChromaDB](https://docs.trychroma.com/docs/overview/introduction) to learn how to store embedded data and search for them. Also, check OpenAI's documentation on how to create embeddings from data.

## AI Agents

An AI Agent is basically an LLM that can take actions, such as executing functions, launching web browsers, etc.

OpenAI, Anthropic, and other leading LLM providers offer SDKs to [build agents](https://platform.openai.com/docs/guides/agents).

![AI Agent workflow](/blog/ai-agent-workflow.png)

You just define the [tools](https://platform.openai.com/docs/guides/agents#tools), which are predefined schemas of the functions you want to execute. Based on the query you provide, the LLM knows which tool should be executed.

Example of a tools schema:

```js
const tools = [
  {
    type: "function",
    function: {
      name: "get_weather",
      description: "Get the current temperature for a given location.",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "City and country, e.g., Bogotá, Colombia",
          },
        },
        required: ["location"],
        additionalProperties: false,
      },
      strict: true,
    },
  },
];
```

> [!NOTE]
> The LLM **does not actually execute** the function. It just returns a response that contains the function name and needed arguments, and you handle the execution.

Based on what you ask the LLM, it will return a response that includes the tool you need to execute. So if you ask, "What's the weather in Sousse now?", it will return a response like this:

```js
const llmResponse = [
  {
    id: "call_12345xyz",
    type: "function",
    function: {
      name: "get_weather",
      arguments: '{"location":"Sousse, Tunisia"}',
    },
  },
];
```

All you have to do is execute the `function.name` in your code with the given arguments.

You can find a [code example](https://platform.openai.com/docs/guides/function-calling?api-mode=chat&lang=javascript) for implementing an AI Agent that provides the weather from a prompt.

## MCP

MCP (Model Context Protocol) is simply **a standard that defines how to build and interact with AI Agents**.

![MCP](/blog/mcp-1.png)

The **[client](https://modelcontextprotocol.io/quickstart/client)** and the **[MCP server](https://modelcontextprotocol.io/quickstart/server)** connect using a transport layer, which can either be **HTTP SSE** if the server is hosted on the internet or **STDIO** if it's on your local machine.

> [!NOTE]
> An example of a client is Cursor or the Claude desktop app. You can always build your own client, of course.

MCP is not just about tools; it has [several features](https://modelcontextprotocol.io/docs/concepts/resources), making it a powerful standard for building AI Agents.


Embeddings, RAG, AI Agents, and MCP


If you’ve heard about `console.time` before, you can just close the tab. :)

---

JavaScript `console.time` is a great built-in tool that gives you the duration of an operation.

## Usage

`console.time` starts the timer, and `console.timeEnd` stops it, so just wrap what you want to measure between these methods, and you should see the result in the console.

The output is in suitable time units. For example, if the elapsed time is 3869ms, `console.timeEnd` displays "3.869s".

And here’s a real example: as you can see, foo took 1ms to finish looping through an array of 10,000 empty values.

![Preview of console.time](/blog/console-time.png)


Measure your code's performance on the fly


If you typed `git diff --help` in your terminal you get this

> git-diff - Show changes between commits, commit and working tree, etc

This is a short blog about how to use `git diff` to view changes between two commits.

I started using it a lot recently to view what my teamates changed and that gives me a good understanding of how a certain parts of the system works.

the command is:
```bash
git diff <commit_hash_1> <commit_hash_2> -- path/to/file_you_want_to_view
```

normally, `commit_hash_1` should be the old commit and `commit_hash_2` should be the newer one to be able to view a logical difference of the changes. but you can switch them if you want to view the past changes.

> [!NOTE]
> Additions will be green and prefixed by a `+`, deletions will be red and prefixed by a `-`

If you want to view the changes between a certain commit and the latest commit you can change `commit_hash_2` with `HEAD`

```bash
git diff <old_commit_hash> HEAD -- path/to/file_you_want_view
```

If you want to view all the changes your team mates did, for example you ran `git pull` and there were more then a couple of files changed, you can **change the path with an `*`** like so:

```bash
git diff <commit_hash> HEAD -- *
```

Also not to forget that you can run `git log`, to view the commits with it's respective hash, you can add `--oneline` to make your life easier. 
```bash
git log --oneline
```
this is the output you get when you add `--oneline`
![Preview of git log --oneline](/blog/git-log-oneline.png)

this gives you all the list of commits, you can also add `-n <number>` if you want to limit the number of commits displayed on your screen.

git diff


**Today's blog is about refresh tokens: what they are, their use cases, and the critical security concerns you should consider before implementing them.**

Recently, while working on a project at my company, I was tasked with implementing a refresh token mechanism. While I successfully completed the task, I had several questions along the way. This blog is my attempt to share what I’ve learned during that process.

## TL;DR

- Refresh tokens are great for UX, preventing users from needing to log in repeatedly.
- Refresh tokens are powerful but dangerous if compromised — **they can lead to account takeover**
- Luckily, there are a few things you can do to make it secure, like **Refresh token rotation**, **Safe storage**, **Rate limiting**, **Tie it to user context**

## What is a refresh token ?

It's simply a token that's used to obtain a new access token, and it always have a longer life time then the access token.

## How it works ?

![How refresh tokens works](/blog/refresh-token-how-it-works.png)

How it works technically, is you will have a separate endpoint `/refresh-token` where you will send the refresh token and get a new access token, then **retry** the request that the user tried in the first place.

Here is a pseudo code, to show you how you can handle it

```js
http.interceptors.response((resp) => {
  const rt = getRefreshToken();
  // if a 401 (unauthorized) code is returned and the user has a refresh token
  // go ahead and request a new access token and retry the request
  if (resp.status === 401 && rt) {
    try {
      // access token is invalid, request a new one
      const { newAccessToken, newRt } = http.get("/refresh-token", {
        params: {
          rt,
        },
      });

      // You should update the new returned tokens
      updateToken(newAccessToken, newRt);

      // retry request
      const originalRequest = resp.config;
      originalRequest.headers.Authorization = `Bearer ${newAccessToken}`;
      http(originalRequest);
    } catch (err) {
      // refreshing token failed, probably it's invalid, log the user out
      logout(); // remove stored refresh and access tokens
      redirect("/login");
    }
  }
});
```

## Do you need it ?

Well, it depends, and you need a lot to handle as i'll tell you why.

Refresh tokens enhance the user experience by keeping users logged in without requiring them to enter their credentials repeatedly. They also help maintain app security by ensuring access tokens aren’t valid indefinitely.

However, refresh tokens come with significant risks. If an attacker obtains the user's refresh token, they can request a new access token and take over the account.

For critical apps (e.g., payment systems), requiring users to log in repeatedly might be a safer approach. but if you want a better UX, you will need to handle the associated security concerns.

## Addressing security concerns

**A refresh token is like a master key, it grants access to your app as long as it’s valid. If compromised, it can lead to significant security issues.**

Here are some best practices for implementing a secure refresh token mechanism:

1. **Short TTL:** First thing is giving the refresh token a short time to live, _like access token time + 5 minutes_
2. **Refresh token rotation:** Generate a new refresh token and revoke the old ones, whenever a new access token is requested.
3. **Reuse detection:** using an already invalidated refresh token is a sign that the user tokens are compromised, and there for you need to revoke all the users tokens.
4. **Safe storage:** Store the refresh token in a safe place, like a cookie with `httpOnly`, `sameSite=Strict` and `secure=true`
5. **Rate limiting:** Rate limit the number of times an access token is requested
6. **User context:** Tie the refresh token to the user's context, e.g: IP Address, Browser (User Agent), deviceId.. to be able to know which token is related to which client

> [!NOTE]
> These are the security measures I’ve learned and understood through research. If you think something is missing or incorrect, please feel free to reach out. I’d love to learn more from your feedback.

---

If you want to share your thoughts or discuss this topic, feel free to message me, open a GitHub issue, or reach out in any way that works for you.

Salam ✌.


Refresh tokens


In the previous blog, i wrote about how to deploy your backend to the cloud with dokku. deployment was manual where you had to push your code manually to your server so Dokku could build and run it.

In this blog i'll be using **Github Actions** to automate that.

## What is Continuous Deployment (CD)?

Continuous Deployment is a software engineering practice used to make the software development life cycle (SDLC) easier and more productive, by automating the deployment cycle using various techniques and tools.

## Github Actions

Github actions is an automation platform, provided by github to automate tasks like testing, building and deploying code directly from your github repo.

The github action workflow should be a **YAML** file defined inside **`your_project/.github/workflows`** folder, that's where github will look for your actions.

## Let's Automate it

The follwing is the content of my workflow used to automate the deployment of my app, Let's break it down.

```yaml
# .github/workflows/mycd.yaml
name: "Deploy my app backend"
on:
  push:
    branches:
      - master
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: 📌 Cloning repo
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
          ref: refs/heads/master
          sparse-checkout: folder_that_contains_the_code
          sparse-checkout-cone-mode: false

      - name: 🚚 Push to dokku
        uses: dokku/github-action@master
        with:
          git_remote_url: "ssh://dokku@${{ secrets.MY_SERVER_IP }}:22/my_app_name"
          ssh_private_key: ${{ secrets.MY_SSH_KEY }}
```


- **`name:`** a user friendly name you give to your action to understand what workflow is running.

- **`on:`** github workflows are be triggered based on [events](https://docs.github.com/en/actions/about-github-actions/understanding-github-actions#events), such as a pull or push request. in this case we want to deploy the app on every `push` to the `master` branch.

- **`jobs:`** A [job](https://docs.github.com/en/actions/about-github-actions/understanding-github-actions#jobs) is the most important thing here, it's a set of steps, that can be either a shell script or an action that will be run. In this workflow we have 2 steps, the "Cloning repo" and "Push to dokku" steps. before that we have the `deploy` job, it's actually a customizable name you can name it whatever you want.

- **📌 Cloning repo:** to make your code accessible to the workflow, github provides an action template **actions/checkout@v3**. the template has a set of [configurations](https://github.com/actions/checkout?tab=readme-ov-file#usage). like the `ref` which defines the branch you want to access and `sparse-checkout` to checkout a specific folder/files.

- **🚚 Push to dokku:** the step that handles the deployment of the code. dokku provides the template [dokku/github-action@master](https://github.com/dokku/github-action) to deploy your code. It requires a set of configurations, including `git_remote_url` and `ssh_private_key`.
For security you need to hide your keys, you can define your secrets in the settings of your repo, go to **repo settings > Secrets and variables > Actions**, add your secrets, and they will be accessible inside the workflow under the **`secrets`** object.


How to Add Continuous Deployment to a Dokku App with GitHub Actions


Hi folks,

It’s been a long time since I wrote something. In this blog, I’ll be sharing **how to deploy your app backend to the cloud using Dokku**. The app will be a simple pastebin-like API built with NestJS and PostgreSQL.

## What is Dokku?
Dokku is like a tiny and free version of Heroku. You install it on your server, push your code, and Dokku handles the rest.

Your code is essentially pushed to a Git repository on your server that Dokku creates. When Dokku receives your push request, it creates a new container for the updated version. Once it succeeds, it shuts down the previous one, providing zero-downtime deployments.

Dokku has two deployment options: **buildpacks** and **dockerfiles**. In this blog, I’ll be using the first option, which is also the default in Dokku.

## What is a Buildpack?
A buildpack is a set of scripts that handle setting up, building, and running your application automatically. When you push your code, Dokku detects the language and applies the appropriate buildpack.

You can specify how the buildpack should run your application using a Procfile if you need a custom command. For example, if your app is built with Node.js, the buildpack will automatically detect this and try to run the app with `npm run start`.

You can override this behavior by creating a _Procfile_ at the root of your project.
Just like in our case, in nestjs to run the production build, npm start won't work, we need to run npm start:prod so my Procfile will contain this:
```bash
web: npm run start:prod
```

## Getting Started
Everything you need is in the Dokku documentation, but I’ll provide brief descriptions for each step and address some common pitfalls.

**1) Install Dokku**

SSH into your server and download the Dokku installation script:
```bash
wget -NP . https://dokku.com/bootstrap.sh
```

**2) Run the installer with:**
```bash
sudo DOKKU_TAG=v0.34.8 bash bootstrap.sh
```
The version might differ if you’re reading this in the future.

**3) Add your SSH key**

```bash
PUBLIC_KEY="your-public-key-contents-here"

echo "$PUBLIC_KEY" | dokku ssh-keys:add admin

# If you already copied your public key to your server before ssh you can just do
cat ~/.ssh/authorized_keys | dokku ssh-keys:add admin
```
When you push your code to the server, Dokku uses this SSH key for authentication.

Ok, so now we’ve finished setting up Dokku on our server.

## Domains
First, Dokku is not a DNS server; it just configures Nginx. Mapping your IP address to your custom domain should be handled by you. You can use Cloudflare, it’s secure, easy, and free.

To set a custom domain for your app, you have two options:

1. Set a global domain like _mydomain.com_. After creating a Dokku app, it will be accessible at _myapp.mydomain.com_.
```bash
dokku domains:set-global mydomain.com
```
The domain should be the root domain since your Dokku app’s name will be used as a subdomain (e.g., _mydokkuapp.mydomain.com_). This is the domain you need to point your IP address to.

2. If you don’t like having a global domain with subdomains for each app, you can set the domain separately for each app:
```bash
dokku domains:set myapp myapp.com
```
You’ll then need to point your IP address to _myapp.com_ to access it.

For this tutorial, I’ll set a global domain and make my apps accessible via subdomains.

## Creating Your App
Simply run:
```bash
dokku apps:create myapi
```
As mentioned, once your DNS records are configured, your app should be accessible at **myapi.mydomain.com**.

> [!TIP]
> You can see the port mappings for your app with `dokku ports:report myapp`.

> [!IMPORTANT]
> A common pitfall that might waste hours is the port mapping. By default, Dokku maps the HTTP port 80 to port 5000 inside your container. If your app runs on a different port like 3000 or 9999, you need to manually set the port with `dokku ports:set myapp http:80:MY_APP_PORT`.

## Database and Plugins
Now we need a database for storing pastebins. Dokku supports plugins for various services like PostgreSQL, MySQL, Mongo, ect... You can find all available plugins [here](https://dokku.com/docs/community/plugins/).

For this app, I’ll use PostgreSQL, so let’s install the plugin and link it to our app:
```bash
sudo dokku plugin:install https://github.com/dokku/dokku-postgres.git
```
This installs the PostgreSQL plugin. You can see available commands with `dokku postgres`.

Create a PostgreSQL service:
```bash
dokku postgres:create myapidb
```

Link the database to your app:
```bash
dokku postgres:link myapidb myapi
```
Dokku will set and return the `DATABASE_URL` environment variable.

> [!TIP]
> You can view all your Dokku app’s environment variables with `dokku config:show myappname`.

So far, we have:
- Created our app
- Installed PostgreSQL and linked it to the app

## Deploying the App
Deployment is as simple as pushing to a Git repository. First, add the remote:
```bash
git remote add prod dokku@MY_SERVER_IP:MY_DOKKU_APP_NAME
```
The remote username **must** be `dokku`, or the deployment will fail.

> [!NOTE]
> Dokku’s docs suggest that some tools or Git clients might require the upstream to be prefixed with `ssh://`, like this: `ssh://dokku@MY_SERVER_IP:MY_DOKKU_APP_NAME`.

If your SSH keys have a passphrase, pushing directly to the server will fail with a **permission denied** error. You need to register your private key with `ssh-agent`.

> [!NOTE]
> `ssh-agent` is a process that handles authentication for you. If your SSH keys are protected by a passphrase, you register them once with the agent, and it handles subsequent authentications.

```bash
# Start the SSH agent if it's not running:
eval "$(ssh-agent -s)"
# Register your private key:
ssh-add -k path/to/private.key
```

Now deploy your app:
```bash
git push prod master
```

When the deployment finishes, Dokku will display the domain where your app is accessible. Point your server IP to that domain, and everything should work as expected.

## Adding SSL
Adding SSL with Dokku is straightforward, and it even handles automatic renewal. Install the _Let’s Encrypt_ plugin:
```bash
sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git
```

Set a global email address:
```bash
dokku letsencrypt:set --global email your-email@your.domain.com
```

Enable the plugin:
```bash
dokku letsencrypt:enable myapi
```

Enable auto-renewal:
```bash
dokku letsencrypt:cron-job --add
```

Enabling Let’s Encrypt will automatically map the HTTPS port (443) to your app. If your app runs on a different port than 5000, you’ll need to adjust the port mapping as mentioned [earlier](#domains).

> [!TIP]
> If you don't have a domain name and just want to play with dokku, visiting the ip directly might just show the default nginx page, this is because of the default nginx configuration, and dokku using the server hostname which won't resolve to anything. so just remove the default nginx config and everything should work fine `sudo rm -rf /etc/nginx/sites-enabled/default`

---


I hope you found this blog helpful, if you have any questions you can always reach out, i'll be so happy to help if i don't have so many tasks on my list 🙃

You can also check [dokku docs](https://dokku.com/docs) for more information.

I'm planning to write another blog on dokku, maybe, i hope so soon.


How to deploy your backend to the cloud with dokku


In this blog I will be using the **native Golang http package** to upload files, no third party packages. We will see how to upload single and multiple files.

## The HTML form

The form is simple and straight forward. The only thing to note is the `enctype="multipart/form-data"` attribute. This is required for uploading files.

```html
<form action="/upload" method="POST" enctype="multipart/form-data">
  <input name="name" type="text" placeholder="name" />
  <input name="ok" type="checkbox" placeholder="ok" value="aaaaa" /> aaaaa
  <input name="ok" type="checkbox" placeholder="ok" value="bbbbbb" /> bbbbbb
  <input type="file" name="file" id="file" />
  <button type="submit">SUBMIT!</button>
</form>
```

## Single file upload

```go
func uploadSingleFile(w http.ResponseWriter, r *http.Request){
  file, header, _ := r.FormFile("file") // FormFile automatically called ParseMultipartForm
  defer file.Close()

  // create a destination file
  dst, _ := os.Create(filepath.Join("./", header.Filename))
  defer dst.Close()

  // upload the file to destination path
  nb_bytes, _ := io.Copy(dst, file)

  fmt.Println("File uploaded successfully")
}
```

💡**Note:** All of the `_` underscore variables are errors, I just ignored them for the sake of simplicity. so don't do that in production.

As you noticed we get the uploaded file with the `r.FormFile("input_name_here")` function, it returns 3 variables, `file` which is the uploaded file itself, `header` which contains information about the file like the name, size, MIME type etc..., you can use these information to validate the file before uploading it, and finally `_` which is the error if any.

## Multiple files upload

First of all before you can select multiple files, you need to add the `multiple` attribute to the file input

```go
func uploadMultipleFiles(w http.ResponseWriter, r *http.Request){
  // key = "file" in the form
  //first of all ParseMultipartForm must be called 
  r.ParseMultipartForm(32 << 20)
  for key, files := range r.MultipartForm.File {
    for _, file := range files {
      dst, _ := os.Create(filepath.Join("./", file.Filename))
      f, _ := file.Open()
      io.Copy(dst, f)
    }
  }
}
```

Just FYI, the `r.MultipartForm.File` is a `map[string][]*multipart.FileHeader` where the key is the name of the input in the form. The `file` variable contains the same information as the `header` variable in the single file upload example, (size, name, MIME type etc...)

## The other fields

To get the other fields, there are two options, which at some point you will need to use both of them.

```go
// OPTION 1: returns a string which is the first value of the key
r.FormValue("name") // string

// OPTION 2: returns a slice of strings of all the values of the key
r.MultipartForm.Value["name"] // map[string][]string
```

You can use the first option when you want to get a single value, and the second option when you want to get multiple values, in our case the checkbox can have multiple values.

So `r.FormValue("name")` is like doing `r.MultipartForm.Value["name"][0]`.

---
That's it, I hope you enjoyed this tutorial, if you have any questions or suggestions, you can find all of this on GitHub.


How to upload files in Golang ?


*This article assumes that you have read about Golang, and know the basics at least.*

So let me start with the definition of concurrency,
it's simply the execution of some code instructions at the same time. that's it.

### Goroutines
*A goroutine is a lightweight thread of execution.*

> A Thread, or thread of execution, is a software term for the basic ordered sequence of instructions that can be passed through or processed by a single CPU core. - [stackoverflow](https://stackoverflow.com/questions/5201852/what-is-a-thread-really).

so goroutine lets us execute functions concurrently, how is that?
a simple example:
```go
package main

import (
	"fmt"
	"time"
)

func createUser(name string) {
  fmt.Println(name + " has been created successfully")
}
func uploadUserImage() {
  fmt.Println("User image has been successfully uploaded to the cloud !!")
}

func main() {
  go createUser("wassim")
  go uploadUserImage()

  time.Sleep(time.Second)
}

```
Output
```bash
User image has been successfully uploaded to the cloud !!
wassim has been created successfully
```

so as you can see the output of this simple program is not in the function order, cause they are executed concurrently so the result can be unordered.

*But wait a minute, why you put that time sleep at the end there ? is it necessary why is it necessary ?*

The Go program is going to finish executing when the main function ends, So, Our two function calls are running asynchronously in separate goroutines now. Waiting for them to finish, but the main function doesn't wait it doesn't know that the two functions are still running, so if we remove that sleep it won't print anything to the console. try it if you want.

now lets go to channels.

### Channels
*Channels are the pipes that connect concurrent goroutines. You can send values into channels from one goroutine and receive those values into another goroutine.*

lets start with code directly, here is an example using channels.

```go
package main

import (
	"fmt"
)

func createUser(name string, done chan<- bool) {
	fmt.Println(name + " has been created successfully")
	done <- true
}
func uploadUserImage(done chan<- bool) {
	fmt.Println("User image has been successfully uploaded to the cloud !!")
	done <- true
}

func main() {

	done := make(chan bool)

	go uploadUserImage(done)
	fmt.Println("Image uploaded: ", <-done)

	go createUser("wassim", done)
	fmt.Println("User created: ", <-done)
}
```

So let me first tell you what is the difference between this `chan<-` , this `<-chan` and this `chan`.

"chan" => in the function parameter, means that we will read and write from that channel, it's a data type.
"chan<-" => means that we will write only
"<-chan" => means that we will read-only

the output of this program:

```bash
User image has been successfully uploaded to the cloud !!
Image uploaded:  true
wassim has been created successfully
User created:  true
```


so in the main function we created a channel named done, we passed that channel as a parameter to our workers (createUser, and upload), and whenever a worker is done we notify the main function.
we put in the channel with `channelName <- VALUE`

and we consume the message from a channel like this `<-channelName`

if we don't consume the message, the goroutine function is not gonna print anything cause the main will not wait for it, so by using `<-done` we are telling the main function to wait until we get a message from the worker.
so if we removed this line here 
```go
fmt.Println("User created: ", <-done)
```
we will get an output like this:

```bash
User image has been successfully uploaded to the cloud !!
Image uploaded:  true
```

so `<-done` is simply blocking the main function from exiting. and therefore ending the program from executing.

And this is what is called *Channel Synchronization*, its just a fancy word that means blocking until a goroutine finish executing.

But, When waiting for multiple goroutines to finish, you may prefer to use a WaitGroup.


### WaitGroup
*To wait for multiple goroutines to finish, we can use a wait group.*

Again, lets jump directly to code, and then i will explain how and why.
```go
package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func createUser(name string) {
	defer wg.Done()
	fmt.Println(name + " has been created successfully")
}

func uploadUserImage() {
	defer wg.Done()             // defer -> it will delay the execution of this func we upload the user image
	time.Sleep(time.Second * 3) // just to say that this is an expensive function (that took 3s)
	fmt.Println("User image has been successfully uploaded to the cloud !!")
}

func main() {

	go createUser("wassim")
	go uploadUserImage()

	wg.Add(2)
	wg.Wait()
}
```
well, to use WaitGroup, we need to import the sync package, then we declared a global variable wg.

now let me explain how the WaitGroup works. the `wg.Add(NUMBER_OF_GOROUTINES)` this function increment the number of the running goroutines, the `wg.Done()` will decrease the number of goroutines, so whenever a worker (function) is done working you fire the `wg.Done()` function the `defer` keyword just tells the function to delay until the main function ends its work **(by main function i mean its parent wich is the upload and create function)**, lastly the `wg.Wait()` this function blocks the program from exiting until the number of goroutines is 0. so `wg.Done()` will decrease until we reach the 0 then the `wg.Wait()` will fire, and the program exit/finish.

----
Thanks for reading, this is my first post, so if there is anything !good let me know :)

[More to learn about GO](https://gobyexample.com)


Understanding goroutines and concurrency in Golang


Heyy, it's me, this is my first blog post here. I will be sharing my thoughts, ideas, and experiences here. I hope you enjoy reading my posts as much as I enjoy writing them.

### Follow me

You can find me on [Twitter](https://twitter.com/bjwassim), [Github](https://github.com/wassimbj), and [LinkedIn](https://www.linkedin.com/in/wassimbenjdida). and you can find the code of this website [here](https://github.com/wassimbj/wassimbj.github.io).

```py
print 'Wish me luck 😁'
```
