Top 10 List of Week 07

1. Introduction to semaphores in C
   This is a YouTube video explaining the basic concept of semaphores. Learning semaphore in the first place got me confused on several cases such as “What happen if I call post() first instead of wait()? Is it possible to call wait() at the same time?” and so on. Luckily, this video explains very well and provides graphical representation which really helps me understand the basic of semaphores and answers those questions. A very good video that is worth to check out!

2. Multithreading Code - Computerphile
   This is the same YouTube video from Week 06 about Multithreading. I’m putting the same video because of how good it is. In the later half of the video, we get to learn one of the solution dealing with critical-section problem, which is Mutex. Mutex or Mutex Locks is one of sync tools that acts like a token in order to make sure there’s only one process (that holds the token) between multiple threads. The way Dr. Steve explains it is very clear and unique, which helps me understand even more about it.

3. Dining Philosophers Problem with Solution
   This is a YouTube video explaining about Dining Philosophers, one of synchronization problem. The explanation is understandable and it’s explaining the way Deadlock can occurs in the problem. Besides that, it’s provided with solution as well which is helpful.

4. Race Conditions and Critical Sections
   This is a website providing information about Race Condition & Critical Section. These two are problems that can happen in synchronization. When first learning these terms, I thought that both are pretty much the same. Turns out it doesn’t (obviously), but at least both are related. The website explains very depth and provided with examples which is helping me to understand. It

5. Contrasting Peterson’s and Dekker’s algorithms
   This is a website that answers difference between Peterson’s and Dekker’s algorithms in dealing with critical section problem. I’ve found that both solution looks quite similar that both process are taking turns by sending a signal when the first thread trying to do process. Turns out there’s a difference in the processes’s behaviour, a rather interesting difference for me to read on.

6. Starvation and Fairness
   This is a website that provides information about Starvation and Fairness. Starvation is an event that occurs in multiple threads that there’s one thread getting all of CPU time, leaving the other thread starved to death not getting CPU time. Fairness is the solution of it. This website explains the cause of starvation and the fairness implemenation example in Java. Its explanation is very good to be read and its example could be useful as well.

7. Introduction to DEADLOCK in Operating System
   This is a website explaining about Deadlock, an event when multiple process waiting each other to be process, creating a circular wait, making the system stuck in the process. This website provides pretty much everything, from its definition, detection, prevention, avoidance, and others, which is why I like it.

8. Bounded Buffer Problem
   This is one of the problem in synchronization, which also called producer consumer problem. This occurs because there’s a limitation in the way buffer works concurrently. The solution to this problem is by using semaphores. I really like this website content and style which is refreshing to my eyes.

9. Peterson’s Algorithm
   This is website that provides information about Peterson’s Algorithm. Having a comperhensive explanation really helps me understand it. Besides that, it also provided with table representation which is making this website a helpful guide.

10. Race Conditions and How to Prevent Them - A Look at Dekker’s Algorithm
    This is a YouTube video explaining about Dekker’s Algorithm through cute animation. It may not be as comperhensive as other, but hey, it’s really good introduction into synchronization (well at least for me).