---
title: Change Is Not the First Step You Need to Take
date: 2024-11-08
tags: ["personal development", "self-awareness", "change"]
summary: We all have those days where we feel motivated, and want to change all the harming behaviours in one day.
cover: change_cover.jpg
---


Is your rational mind urging you to change a harmful habit?

Listen to it, but don’t act impulsively.

Before jumping into change, take time to analyze yourself carefully.

Have an honest conversation with yourself about this behavior.

Why is it there? When does it show up? What triggers it? As we all know, understanding the root of a problem is the first step to fixing it.

Once you understand, remind yourself of all the positive ways changing this habit will improve your life. Let these reasons motivate you.

Then, start slowly.

When you catch yourself hesitating, reassure your subconscious. Tell it, 'It’s okay; I know why we’re resisting. But I’m choosing this change for the better.

I made this guide which you could use as a reference, to when you feel like you need a change in our life, then start with this.

<img src="/image/articles/diagram.png" alt="diagram" />

---

Thank you for reading.
I post everything on my [substack](https://substack.com/@diarselimi) as well, so subscribe there to get the latest updates.

We all have those days where we feel motivated, and want to change all the harming behaviours in one day.

Change Is Not the First Step You Need to Take

---
title: The Town of hidden beauty
summary: A small town in size but a huge one from the inside.
cover: magic-town-min.jpg
tags: ["adventure", "traveling", "france"]
date: 2024-11-05
---

I finally arrived in the village with my best friend, something we were looking forward after a long journey. As I depart the bus, the fresh mountain air smell of the town blows over me. While the bright sun rays were warming up my face.

The stunning views combined with the old architecture of the town, and the mountains that are partly covered by the glaciers, which had started to become grayish. I couldn’t believe my eyes what I'm seeing.

I'm wandering through the town, and the deeper I go, the more beauty I discover, how can a place have so much beauty?

A familiar sound draws me in, I walk over to see and indeed it is a river flowing through the city, where people were rafting in, the screams of joy mixed with fear are barely audible from the river’s powerful flow.

As I went deeper I found these big rocks facing the sun, I could hear the sound of metal hitting the rock, the sound of struggle people were making while they were climbing on, some were just watching the others climb, some were facing the other way and enjoying the view that they had behind.

The town never stops giving. I turn a corner — there’s a beautiful lake, so calm with its dark green color reflecting the mountains like a perfect mirror.

As the day drifted on, I kept hearing different languages that people were talking, some I recognised some not, but I understood that this is a very international town.

As I walk into the hotel where I'm going to stay for the night, The English receptionist hands me the cool, brass key, directing me to my room with a deep accent.

-----

Thank you for reading!

If you enjoyed this short story, feel free to hit the like button or leave a comment—I’d love to hear your thoughts.


A small town in size but a huge one from the inside.

The Town of hidden beauty

---
title: Navigating Deadlock Challenges in Real-World Scenarios
summary: Deadlock problems in software often occur when two processes are trying to write into one resource at the same time, causing both to fail. This can be likened to two buyers trying to purchase the last product at the same time, both failing because they try to update the product data simultaneously.
tags: ["concurrency", "go", "deadlock"]
date: 2024-05-15
cover: deadlock-concurrency.png
---

Deadlock problems in software often occur when two processes are trying to write into one resource at the same time, causing both to fail. This can be likened to two buyers trying to purchase the last product at the same time, both failing because they try to update the product data simultaneously.

One of the best ways to explain deadlocks is through the Five Philosophers Problem.

## The Five Philosophers Problem

Imagine five philosophers seated around a circular table. Each has a plate of noodles and a chopstick on both sides of their plate. The complication arises when they all try to eat at once, each needing both chopsticks to eat.

### Scenario Explanation

- **Setup:** Five philosophers sitting at a round table, each with a chopstick on either side.
- **Eating Process:** To eat, a philosopher must pick up both the left and right chopsticks.

Consider the following image for clarity:

*Five philosophers sitting at a round table with a chopstick on each side of their plate. If each philosopher picks up their left chopstick, they all hold one chopstick and wait indefinitely for the right one, resulting in deadlock.*

*Deadlock happened since everyone picked up a chopstick and waited for each other.*

## Implementing the Solution in Go

### Basic Eating Simulation

First, let's write a simple program to simulate the philosophers eating.

```go
package main

import "fmt"

type philosophers []string

func main() {
    philosophers := philosophers{"Aristotle", "Plato", "Socrates", "Descartes", "Kant"}

    for _, p := range philosophers {
        fmt.Printf("%s is eating\n", p)
    }

    fmt.Println("All philosophers are done eating")
}

*Output:*

```console
Aristotle is eating
Plato is eating
Socrates is eating
Descartes is eating
Kant is eating
```

### Introducing Chopsticks

Now, we introduce chopsticks, so each philosopher picks up the chopsticks before eating.

```go
type chopstick []int

func main() {
    chops := chopstick{0, 1, 2, 3, 4}
    philosophers := philosophers{"Aristotle", "Plato", "Socrates", "Descartes", "Kant"}

    for i, p := range philosophers {
        leftChop, rightChop := chops[i], chops[(i%4)+1]
        fmt.Printf("%s picked up chop %d \n", p, chops[leftChop])
        fmt.Printf("%s picked up chop %d \n", p, chops[rightChop])
        fmt.Printf("%s is eating \n", p)
    }

    fmt.Println("All philosophers are done eating")
}

```

*Output:*

```console
Aristotle picked up chop 0 
Aristotle picked up chop 1 
Aristotle is eating 
Plato picked up chop 1 
Plato picked up chop 2 
...
```

### Preventing Deadlock with Mutex

Next, we need to introduce a locking mechanism to prevent a chopstick from being used by two philosophers at the same time.    

The red connections to the chopsticks mean that the chopstick is locked and the therapist needs to wait for it to be available.     

To prevent deadlock, we use a locking mechanism. Each chopstick will be protected by a Mutex. I explained how mutex work in this article posted on my blog.

```go 
package main

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

type Chop struct {
    sync.Mutex
}

type Philosopher struct {
    name     string
    eatCount int
}

func (p *Philosopher) Eat(leftChop, rightChop *Chop) {
    leftChop.Lock()
    rightChop.Lock()
    fmt.Println(p.name, "is eating")
    time.Sleep(time.Second)
    leftChop.Unlock()
    rightChop.Unlock()
}

func main() {
    var wg sync.WaitGroup
    chops := make([]*Chop, 5)
    for i := 0; i < 5; i++ {
        chops[i] = new(Chop)
    }

    philosophers := []Philosopher{
        {"Aristotle", 0},
        {"Plato", 0},
        {"Socrates", 0},
        {"Descartes", 0},
        {"Kant", 0},
    }

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            philosophers[i].Eat(chops[i], chops[(i+1)%5])
        }(i)
    }

    wg.Wait()
    fmt.Println("All philosophers are done eating")
}
```

In the code above, we execute 5 goroutines for each philosopher to eat, and each of them waits for the other chopstick to be free in order to eat.     

But since we go in order 1…5, there won’t be a deadlock because they are just waiting until it’s their turn.

*Output:*

```console
Kant is eating
Plato is eating
Aristotle is eating
Descartes is eating
Socrates is eating
All philosophers are done eating
```

### Running Goroutines Indefinitely

In the following code, we will add an infinite loop that will just run goroutines in order, and each loop will wait until the previous 5 goroutines are done.

```go
func main() {
    var wg sync.WaitGroup
    chops := make([]*Chop, 5)
    for i := 0; i < 5; i++ {
        chops[i] = new(Chop)
    }

    philosophers := []Philosopher{
        {"Aristotle", 0},
        {"Plato", 0},
        {"Socrates", 0},
        {"Descartes", 0},
        {"Kant", 0},
    }

    for {
        for i := 0; i < 5; i++ {
            wg.Add(1)
            go func(i int) {
                defer wg.Done()
                philosophers[i].Eat(chops[i], chops[(i+1)%5])
            }(i)
        }
        wg.Wait()
    }
}
```

*Output:*

```console
...
Kant is eating
Plato is eating
Descartes is eating
Aristotle is eating
Socrates is eating
Plato is eating
Aristotle is eating
Kant is eating
Descartes is eating
...
```

This will give you a simple visualization of how the philosophers are going to eat and how they won't be able to eat if the adjacent one is eating.

## Conclusion

While this solution reduces the likelihood of deadlocks, it is not entirely foolproof.    

Go's concurrency model and goroutine scheduling help manage execution order, making deadlocks less common. Avoiding deadlocks in Go is easier thanks to its built-in tools and mechanisms.    

Deadlocks are a frequent problem in software, especially when working with microservices and multiple storage instances for data read/write operations. As you scale your project horizontally—running multiple instances—the chances of encountering deadlocks increase.      

Understanding and implementing proper concurrency control is crucial to mitigating these risks.

Deadlock problems in software often occur when two processes are trying to write into one resource at the same time, causing both to fail. This can be likened to two buyers trying to purchase the last product at the same time, both failing because they try to update the product data simultaneously.

Change Is Not the First Step You Need to Take

The Town of hidden beauty

Navigating Deadlock Challenges in Real-World Scenarios

Experience 🚀