🍻 Pub Sub 🍻

ufko — Thu, 12 Dec 2019 08:28:49 +0000

A terrible pun intended ☝️

Have you ever joined a mailing list or followed an account on social media? Have you ever subscribed to a channel on YouTube?

If your answer is "Yes!" to any of the questions above then congrats! 🎉 You pub-subbed.

Pub-subbed [ 📢 puhb-suhbd ]
⚪ verb
Becoming a part of publish-subscribe messaging system.
Creating a publish-subscribe messaging system.
"He pub-subbed his way out of the problem."

More accurate image to represent pub/sub

What is pub/sub?

Pub/sub in its full form publish/subscribe is a messaging pattern. It is a way for different components of a system to notify each other and it's a great alternative to polling.

In this pattern there are - you guessed it - publishers📤 and subscribers📥. In addition to them there are messages✉️ and channels/topics 📫.

💯 Publishers can have any amount of subscribers
🕵️‍♂️ Publishers don't have to know about their subscribers
⬅️ Publishers send messages to channels or topics to which subscribers can subscribe

💯 Subscribers can subscribe to any amount of publishers
🕵️‍♂️ Subscribers don’t need to know who the message comes from
➡️ Subscribers receive messages from channels or topics to which publishers send messages

What are the advantages of pub/sub?

✅ Decoupling/Loose coupling

Since neither the publishers nor the subscribers have to know about each other pub-subbing helps with the decoupling of system components.

✅ Scalability

When number of subscribers or channels/topics increases adding new servers to the system helps with dealing with the increased load.

✅ Asynchronicity

Since publisher sends its messages to a channel or topic it doesn't have to wait for a subscriber to receive the message. And since the subscriber receives messages from a channel/topic it doesn't have to wait for a message. In fact it doesn't have to be up when the message was sent.

Do all these remind you something? Hint: The answer is a design pattern.

.
.
.
.

The answer is: Observer!

Pubsub is similar to Observer design pattern of Gof 🙆‍♂️.

🔒 Which problems does Observer solve? 🔒

From Gof

How can a one-to-many dependency between objects be defined without making the objects tightly coupled?
How can an object notify an open-ended number of other objects?

🔑 How does Observer solve these problems? 🔑

From Gof

Define Subject and Observer objects
- Subject -> Publisher and channel/topic
- Observer -> Subscriber
When a subject changes state, all registered observers are notified and updated automatically
- Subject changes state -> Publisher sends a message to channel/topic
- Observers are notified and updated -> Subscribers are notified and updated

Similarities

Just like in pubsub, in observer the subjects don't have to know about their observers and vice versa.
Just like in pubsub, in observer the subjects can have any amount of observers and vice versa.
Just like in pubsub, subjects and observers are loosely coupled.
Just like in pubsub, observers can be updated asynchronously.

If you're not sick of me associating things, both observer pattern and pub/sub messaging reminds me of the mailing systems in human world 🤷‍♂️. It's really cool to see concepts from computing world resemble human world 💻 🌎.

Cover Image: Photo by Mary Rebecca Elliott on Unsplash

Body Image: Photo by Mathyas Kurmann on Unsplash

Javascript uses call by sharing for objects

ufko — Fri, 27 Sep 2019 17:53:50 +0000

I recently watched a course about javascript on Udemy. It was a great course from a great instructor who provided great content - except for one thing. He said that

"Javascript is pass by reference for objects and pass by value for primitives."

This statement is only 50% correct 🌓 The incorrect half - as it is hinted in the title of the post - is the first half. Javascript doesn't use pass by reference for objects. It is commonly stated that javascript uses pass by value for objects too and that the value for objects is actually the reference of that object. That's what I thought about javascript's evaluation strategy, too. But that statement is not 100% correct either 😲😓💥 TIL it uses call by sharing for objects 😲 💥

So let's dive into these aforementioned evaluation strategies and try to understand the differences between them and hopefully clear up the confusion:

Pass by reference vs. Pass by value vs. Call by sharing

Pass by reference

I want to use an analogy here. Let's consider soccer. In soccer there is one ball and players pass the ball to each other (to simply put it). If the ball so to say gets muddy, dirty and a player passes the ball to another player the second player will receive the muddy, dirty ball. And
let's assume the players decided to clean the ball because it got so dirty that it made it impossible play the game. When game continues with the clean ball none of the players will receive the old dirty, muddy ball they will all be playing with new clean and shiny ball.

This is pass by reference. The ball here is the reference. In pass by reference function receives a reference to the variable. If any change occurs in the reference every piece of code which uses that reference will be affected and will use the changed version of the reference.

Pass by value

Let's use another analogy here. Let's consider books. A person writes a book and publishes it. If you want to read that book you go to the bookstore and get yourself a copy of that book. You don't go to the author's house and grab the original writings. And if you decide to underline a sentence in your book the other books don't get the same sentence underlined, you only change your copy.

This is pass by value. The book here is the value. In pass by value function receives a copy of the value. If the function changes the value, the change will be limited in the function's scope.

Call by sharing

Unfortunately I don't have an analogy for this evaluation strategy 😥 So I'm just going to write it as it is.

In call by sharing the function receives a copy of the reference to the object. If the object gets mutated, every piece of code which uses that object will use the changed version of the object.

By now the evaluation strategies playing part in the confusion and the differences they have should be clear which means we can skip to the reason behind the confusion part 🎉🎊 Let's consider the following code snippet:

When john is passed to confusionCreator(), actually the reference to john is copied and passed to confusionCreator(). Since there is a copying process it resembles pass by value.

When name attribute is updated inside confusionCreator() but affected the code pieces using john outside the confusionCreator() it resembles pass by reference.

These resemblances are the reason behind the confusion around javascript's evaluation strategies.

I hope this post helped in some way to clear up the confusion around javascript's evaluation strategies.

DEV Community: ufko