DEV Community: Tanmoy Sarkar

Swiftwave PaaS: One Year in Development

Tanmoy Sarkar — Mon, 24 Jun 2024 12:35:54 +0000

From last year (July~August), I am working on an open source PaaS to deploy and manage applications easily on any VPS. I have a motive to create a solution which you once setup on your cloud, you will get same kind of experience like other platforms like Heroku, Railway or Render.

Little bit about the project - SwiftWave

SwiftWave is a self-hosted lightweight PaaS solution to deploy and manage your applications on any VPS.

Website - https://swiftwave.org/
Github - https://github.com/swiftwave-org/swiftwave
If you like the intiative give it a ⭐ star in GitHub.

Why did I decide to start developing this open source PaaS?

Incentive Motive - I am absolutely exhausted from doing LeetCode. I don't usually enjoy CP or Leetcode, but need to do for placements. I began questioning if I really had a problem being consistent for long time (at-least 6 months). I therefore made an effort to push myself to create a project that I will stick with for a very long period.

Passive Motive - I like development and computer science core concepts so much and on every week build something for just fun or for hackathon. Anyway I don't want to spare money for deployment, so used Heroku, then moved to AWS EC2 (free tier) after getting familarized with linux. Many times my friends reach out to me for deploying in EC2.

While I was learning k8s and preparing for CKA, I amazed by it's internals & started thinking to build something lightweight with cool UI/UX. That's where it all get started.

Target of Building Swiftwave -

Being lightweight : Swiftwave + Postgres + HAProxy + UDP Proxy = ~180MB of system. So leaving a lot of room for your deployed apps.
Scalable : This isn't meant for huge-scale operations - Kubernetes handles that. Instead, it's aimed at meeting the needs of small startups, individual users, home labs, and internal company tools.
Full-Featured: Swiftwave offers a wide range of capabilities. Visit swiftwave.org to explore all the features available in the platform.

Sprint vs Continuous Development

Before this project, I always go in Hackathon Mode for building project, giving all my free time. After launching the project, I often lost the motivation to keep maintaining it.

With Swiftwave, I started the same way but quickly realized this approach wouldn't work long-term. So, I switched it. For the first time, I tried a more structured approach, dedicating a consistent 1 to 1.5 hours daily to the project. This method proved effective. After a year of steady effort, we've successfully released a stable version of Swiftwave.

A small effort every day builds more than occasional bursts of productivity.

DSA is not useless

While I initially expressed disinterest in LeetCode, I don't find Data Structures and Algorithms (DSA) boring or unimportant. Many people think DSA is only useful for job interviews, but that's not the case.

Over the past year, I've applied DSA concepts in various parts of my projects. This experience has shown me that DSA knowledge is crucial in software development. However, it's worth noting that real-world problem-solving often takes more time than the quick solutions expected in interview.

For instance, in Swiftwave, we implemented a feature for uploading code directly to deploy apps. On the frontend, we create a tar archive of the project to send to the server. For NodeJS apps, we needed to exclude the 'node_modules' and other folder by following .gitignore rules.

Our first attempt at this was inefficient, taking about 30 seconds just to scan files, apply ignore rules, and create the archive.

In the end, we used a tree-based method to organize files and handle .gitignore rules. This new approach was much faster, finishing everything in about half a second."

Source Code of tartplus - https://github.com/swiftwave-org/tartplus

Automation is a Must

For those starting an open source project with long-term maintenance in mind, automation is crucial. Initially, it's often a one person project or the work of a very small team.

Alongside maintaining a OSS project, maintainers have their full time job or academics. So, It's vital to automate all repetitive tasks, allowing maintainers to focus solely on coding and reviews.

In swiftwave, we have various things -

*.swiftwave.xyz DNS Resolver
APT Repository - http://deb.repo.swiftwave.org/
RPM Repository - http://rpm.repo.swiftwave.org/
Custom build images for some one-click apps - https://github.com/swiftwave-org/app-store
Deployment of documentation and websites

All these processes are automated.

For instance, I usually do a weekly release. I only need to draft and publish the release. Building APT & RPM packages for different architectures and uploading them to the repository server are all automated.

We primarily use Github Actions for nearly all our automation needs.

Testcases boring but gives peace of mind

When I first started contributing to open source last year, I was assigned in some issues for writing test cases for software. I also had to write integration tests during my GSoC'23 project with CircuitVerse. Back then, I found writing tests tedious.

However, now that I'm developing my project, my perspective has changed. I've realized how crucial it is to write tests and increase code coverage. With good coverage, I don't need to manually check if features are affected by changes.

For software like Swiftwave, which users install on their own servers, a buggy release could seriously disrupt their systems. It's essential to ensure nothing breaks in stable releases. Having numerous test cases makes this process smoother and more efficient.

It's not bad at all to reinvent the wheel

Sometimes, creating your own solution can be beneficial. Swiftwave needed a pubsub system and queueing mechanism. While RabbitMQ and Redis are common choices, they use up valuable server resources, leaving less for deployed apps.

My solution? I built an in-memory pubsub and persistent task queueing system with using goroutines. This approach uses minimal resources. As a result, Swiftwave typically runs using only about 45MB of RAM.

Swiftwave with all this things takes ~45MB of ram most of the time.

However, we've kept it flexible. Users can still configure Swiftwave to use Redis or RabbitMQ instead of the built-in system if they prefer.

Changes in POV of Open Source

In the 'Indian YouTube Space', there's often too much focus on just contributing to open source, which might have changed what open source is really about. I used to think this way too.

Contributing to open source shouldn't feel forced. Here's a better approach:

Start by using open source software
Keep using it if you like it
If you find an issue or want a new feature, try to help fix or add it
Create your own open source projects that can help others
If a project dependency isn't working well, try to fix its issues
Engage in conversations and forums, helping others who are stuck

Project Maintainers, Creator become more happy when you use their products.

Why Open Source code matters ?

Swiftwave is primarily built on two key softwares: Docker Swarm and HAProxy.

To develop various features, I had to understand how these tools work. This led me to explore several repositories:

Docker Engine - https://github.com/moby/moby
Docker CLI - https://github.com/docker/cli
Libnetwork - https://github.com/moby/libnetwork
HAProxy DataplaneAPI - https://github.com/haproxytech/dataplaneapi

One particular challenge was implementing direct SSH support for applications. I delved into the code for 'docker exec', which was quite complex. After grasping the concept, I was able to implement a similar feature in Swiftwave.

The End

Developing Swiftwave has been an exciting and challenging journey that I want to continue long-term. It has been a great learning experience for me.

There's still lot of rooms for improvement in Swiftwave to make it an even more dependable deployment tool. We have many areas we'd like to enhance in the future.

Website - https://swiftwave.org/
Github - https://github.com/swiftwave-org/swiftwave
If you like the intiative give it a ⭐ star in GitHub.

-

Tanmoy Sarkar — Thu, 09 Feb 2023 18:52:24 +0000

Redis VS Memcached for cache

Tanmoy Sarkar — Thu, 02 Feb 2023 17:23:18 +0000

Redis :

Redis is an open-source, in-memory data structure store, used as a database, cache, and message broker.

Memcached:

Memcached is a distributed, high-performance, in-memory caching system. It is used to temporarily store and serve frequently requested data from memory.

The similarity between Redis and Memcached

Both are key-value storage
Both system store data in memory or RAM
Both Redis and Memcached are capable of running on multiple servers

Data structure

Redis: This supports various ranges of data types based on the additional module and some built-in support. Some data types: strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperlog, and geospatial indexes with radius queries
Memcached: This support only string as the value in key-value entry

Transactions

Memcached doesn't support transactions, although its operations are atomic.
Redis provides out-of-the-box support for transactions to execute commands.

Architecture

Redis uses a single-core architecture.
Memcached implements a multi-threaded architecture by utilizing multiple cores.

Is there any speciality in Redis?

I know this portion is a little bit out of topic. But I have seen, in many blogs or youtube videos, shows redis is the key-value store only to just cache or temporary database.

So let's know a little bit about the full potential of Redis.

By enabling different modules, we can achieve the full potential

RedisJSON to store JSON database directly in Redis.
RedisGraph is a graph database built on Redis. This graph database uses GraphBlas under the hood for its sparse adjacency matrix graph representation.
RedisSearch is a high-performance, full-text search engine that is built as a Redis module, offering efficient indexing and querying capabilities for text-based data within Redis.
RedisTimeSeries is a Redis module for efficiently storing and querying time-series data, providing functionality for querying and analyzing time-stamped data, such as metrics, events, and logs.
RedisBloom is a Redis module that provides scalable probabilistic data structures, such as Bloom filters, counting filters, and others, to support high-performance and memory-efficient data analysis and storage operations.

After seeing the modules and capability of Redis, we can only think of this

Now, what is best for caching?

Here we need to think about the data structure.

The best case to use Memcached over Redis

The cached data format is plain string data to cache like HTML pages, CSS, JS or anything other than that.
The dataset size is going to be very large in future

If these two conditions are satisfied then it will be best to go with Memcached.

In other cases, you can go with Redis.

We have reached the end of this blog.

Docker CLI & Dockerfile In One Shot

Tanmoy Sarkar — Wed, 04 Jan 2023 16:15:34 +0000

In this blog, I will try to provide you with a complete cheat sheet on Docker CLI & YAML so that you can quickly revise the Docker without wasting any time.

This blog is intended for those who have learnt Docker Previously and want to revise that.

If you like this blog, give a 👍 and follow for more content.

Dockerfile

It's just a text file that contains instructions for building a Docker image.

It's just to automate the process that you do manually. So if you know how to do a process manually, you can learn it quickly.

Format

INSTRUCTION arguments

Instruction Set

In the below table, I have mentioned some sort terms. dir -> Directory, src -> Source, dst -> Destination

INSTRUCTION	DESCRIPTION
FROM <image_name>	Fetch base image for Docker
COPY <src_dir_host> <dest_dir_container>	Copy a folder of the host system to the container
WORKDIR <dir_path_contaiiner>	Set the working directory of the container where the commands will run
RUN <command>	Run commands in a shell
RUN [<command arg1>, <command arg2>]	We can break the command in command args also.
Ex : `RUN "apt-get update"` -> `RUN ["apt-get", "update"]`
ENV <key>=<value>	Set environment variables
EXPOSE <container_port>	Expose the port of a container to make it accessible in the same network
ENTRYPOINT <command>	That command will execute as soon as the container boot up
ENTRYPOINT [<command arg1>, <command arg2>]	We can break the command in command args also.
Ex : `RUN "/bin/sh sample.sh"` -> `RUN ["/bin/sh", "sample.sh"]`

There is one more command, which you see mostly. CMD

The purpose of this command is to run the commands specified in arguments. It also has two formats, for example.

CMD echo "hello-world."
CMD ["/bin/sh", "echo", "hello-world"]

You might be confused now about the difference between RUN and CMD.

RUN runs all the commands specified in the argument
For CMD there is some particular case.
- If you have provided some commands to run in docker run command, CMD is going to be ignored.
- If you have listed multiple CMD statements, only the last CMD will be executed.
- IF ENTRYPOINT in Dockerfile is provided, CMD it is going to be ignored.
- In any container deployment platform, you can see the CMD to run manually.

🔵 As the blog's purpose is to give concise details of Dockerfile and CLI, we are not attaching Dockerfile examples here. But will create some blogs on Dockerfile and attach links to them.

Docker CLI

Arguments List

Argument	Description
-u	Username
--name	Name [Normally used for container]
-d	Detach [Run in the background]
-a	All [Stopped + Paused + Running]
-i	Interactive
-t	- tty [stdin] [For Container] - tag name [For Image]
-it	Interactive with stdin
-w	Working directory [example -w '/opt/test']
-p	Port [Example : -p <host_system_port>:<container_port> ]
-v	Volume Mount [Example : -p <host_system_volume_path>:<container_volume_path> ]
-e	Environment Variable [Example : -e <variable_name>=<value> ]

Image Specific Commands

List all local images

docker images

Build Image From Dockerfile in current directory

docker build . -t <tag_name>

Pull an image from Dockerhub

docker pull <image_name>
# example : docker pull redis

Delete an image

docker rmi redis

Remove all unused images

docker image prune

Container Specific Commands

Run a docker container from an image

docker run <image_name>

Now you can refer the Arguments List table to choose your required arguments

I am solving an question for example.

Let's assume, I need to create an container from image of redis with port mapping from container port 6379 to host port 6379 . The name will be redis-instance-1 . Make the instance detachable & run redis-server --requirepass "SECRET_PASSWORD" at its beginning.
docker run --name redis-instance-1 -d -p 6379:6379 redis redis-server --requirepass "SECRET_PASSWORD"
Its important to notice that , you need to pass all the arguments before providing the image name and entrypoint_command

List containers [only Running]

docker ps

List all containers [Stopped + Paused + Running]

docker ps -a

Start or Stop a container

docker start|stop <container_name or container_id>

You can get the Container ID by running the command for list all container

Remove a stopped container

docker rm <container_name or container_id>

Attach to the current process of container

docker attach <container_name or container_id>

Run a command in the container

docker exec <container_name or container_id> <command>

Example : Start a bash terminal in redis instance
docker exec -it redis /bin/sh

❓You may have a question. What's the difference between exec and attach, then

With attach, we attach to the process that's currently running in the container

But with exec, we can run a new process in a container without hampering the running process of the container

Log the data of the current process of the container

docker logs -f <container_name or container_id>

Inspect and grab all the details of a container

docker inspect <container_name or container_id>

It will return the details in an JSON format

Check the stats [CPU, RAM, Network, Storage usage] for all running containers

docker container stats

🏄 You have liked this blog and gained some knowledge, please consider to like & share with your friends.

Deploy AI Models with RabbitMQ Message Broker

Tanmoy Sarkar — Tue, 27 Dec 2022 09:56:47 +0000

⚠️ Disclaimer

This blog is focused on the situation when you need to handle a low number of users to access your AI models, like in a hackathon or a prototype of a product which may not be accessed by more than 500s people concurrently. More optimization and robust design are required for production usage. But this blog can be a good starting point.

🏊 Let's discuss the problem with Client-Server architecture.

We all know maximum AI models are resource-hungry operations and take at least from 1 second to up to 5 minutes, especially for large deep learning models.

The main problem is that we can't run too many requests in a low-end system (2GB RAM, 2vCPUs).
As we have 2 CPU cores, running more than two threads is impossible. As a result, the system crashed.
If the processing time of the model exceeds Nginx/web gateway timeout, it will give the user an error and waste the system's resources.

🏂 Now, What's our approach?

We will take the microservice approach and split our system into three parts. So that user can get a message asap about the request received by the server and later can enquire about the result.

Flask Web Server
RabbitMQ as message broker and queue management [It comes as packaged software. We will use a cloud-based free one. I will discuss this in a later part]
Worker process - will be responsible for running the input data on AI models.

Let's understand the overall architecture of the system by ⏬

Before going into more depth, let's know the process in short

The user will send the request to the server
The server will create an entry in a table with status processing
The server then sends the input and request ID to the RabbitMQ message broker
The worker process will receive the request ID and input. It will run the AI model and generate the output based on the received input.
Then the worker process will submit the result to the server and mark the request-id status as done.
During this, the end-user can request the server for its result. If the result is available to the server, the end-user will get the result else; the end-user will resend the request in a while.

👀 Detailed Concept

We will first clarify how this will work and solve our issue of limited resources. Then we will move to code.

1️⃣ Process New Request Coming From End-user

As soon as the request is received, the backend will do three tasks one by one

Make an entry in the Request Status Track Table to keep track of request
Push the request details <Request ID, Input> to the queue
Send an acknowledgement message to the user that the request is processing. Also, send the Request ID with the response so that the user can enquire about the result later

2️⃣ Consumer/Worker: Pop Process From Queue and Process It

The consumer/worker listens for new requests, and RabbitMQ is responsible for giving the task to its listeners. It will follow the following steps.

The worker will extract the Request ID and Input it from the received payload.
The worker will run the input to the AI Modal and prepare the output.
Then the worker will update the output and status to done by specifying the request ID. Now, this can be done in two ways -

* Connect to the database directly

* Call API of the backend \[***Recommended***\]

3️⃣ Fetch Result of Request by the End-user

After a fixed interval(for example, 5 sec), the end-user will request the backend to send the result of his query.

Now the process flow of the backend will be

It will check the status of the request by its ID.
If the status is still processing, the backend will tell the end-user about its status and will say to them to re-request later.
If the status is done, the backend will send the output to the end user.

That's all !

💻 It's Coding Time

⚠ Read This Note Before Approaching Coding Part

Using an actual AI model's code will complicate this writing. We prefer to simulate that by a long-run function.

As an example, we will calculate the factorial of a large number.

def calculate_factorial(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
    return result

For factorial(n), n > 150000, it takes more than 10 seconds to compute

It's perfect for our use case.

🕰 Current Backend In Flask

from flask import Flask, request

# Function to calculate the factorial of a number
def calculate_factorial(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
    return result

# create the Flask app
app = Flask(__name__) 

# route to calculate the factorial of a number
@app.route('/factorial', methods=['GET'])
def factorial_handler():
    no = int(request.args.get('no'))
    result = calculate_factorial(no)
    return str(result)

if __name__ == '__main__':
    app.run(debug=False)

Try to run the 5~6 requests at a time and see what happened

curl http://127.0.0.1:5000/factorial?no=150000

See, the last request takes more than 1 minute 💣💣.

As the processing time of the function increases, the waiting time per user will increase exponentially.

⏰ Time To Rebuild Our Backend

🟠 First, create a cloud-hosted RabbitMQ service

Go to https://www.cloudamqp.com/ and create a free account
Create a free RabbitMQ instance
Click on the name of the instance
Copy the URL from AMQP details.

🟡 Run An Redis Instance Locally

You can follow the guide to install Redis in your system. https://redis.io/docs/getting-started/installation/
Run the Redis server locally by running this command
```
redis-server
```

🟢 Prepare the helper functions beforehand

We need to create some functions -

Function	Definition
publish_to_rabbitMQ(data)	It will publish the data to rabbitMQ
create_request(input)	Create a request entry in Redis, do an entry in RabbitMQ and return the ID of the request
get_request(request_id)	It will fetch the request details by the id from Redis
update_request(request_id, status, output)	It will update the status and output of the request in Redis

Implementation of publish_to_rabbitMQ(data):

import json
import pika

def publish_to_rabbitMQ(data):
    # Create connection
    connection = pika.BlockingConnection(pika.URLParameters("amqps://yyyyyy:xxxxxxxxx@puffin.rmq2.cloudamqp.com/yyyyyy"))
    channel = connection.channel()
    # Create queue . For now queue name is factorial_process
    channel.queue_declare(queue='factorial_process', durable=True)
    # Publish the message to the queue
    channel.basic_publish(exchange='', routing_key='factorial_process', body=json.dumps(data))
    # Close the connection
    connection.close()

Implementation of create_request(input) :

def create_request(input):
    # Generate a random ID
    random_id = str(uuid.uuid4())
    # Store the request in Redis
    redis_instnace.set(random_id, json.dumps({'input': input, 'status': 'processing', 'output': ''}))
    # Publish the request to RabbitMQ
    publish_to_rabbitMQ({'request_id': random_id, 'input': input})
    # Return the request ID
    return random_id

Implementation of get_request(request_id) :

def get_request(request_id):
    request_data = redis_instnace.get(request_id)
    if request_data:
        return json.loads(request_data)
    return None

Implementation of update_request(request_id, status, output):

def update_request(request_id, status, output):
    request_details = get_request(request_id)
    redis_instnace.set(request_id, json.dumps({'input': request_details['input'], 'status': status, 'output': output}))

🔵 Re-design Flask Backend

We will remove the processing part from it
Create two more APIs
- /factorial/result?id=random: To fetch the results of the request
- /factorial/update: To update the result and status of the request

from flask import Flask, request
from helpers import create_request, get_request, update_request

# create the Flask app
app = Flask(__name__) 

# route to queue the request
@app.route('/factorial', methods=['GET'])
def factorial_handler():
    no = int(request.args.get('no'))
    id = create_request(no)
    return id

# route to get the result
@app.route('/factorial/result', methods=['GET'])
def factorial_result_handler():
    id = request.args.get('id')
    result = get_request(id)
    return result

# route to update the result
@app.route('/factorial/update', methods=['POST'])
def factorial_update_handler():
    body = request.get_json()
    id = body['id']
    status = body['status']
    output = body['output']
    update_request(id, status, output)
    return 'OK'

if __name__ == '__main__':
    app.run(debug=False)

⚪️ Build The Consumer

import pika
import json
import requests

# Function to calculate the factorial of a number
def calculate_factorial(n):
    result = 1
    if n > 1:
        for i in range(1, n+1):
            result = result * i
    return result

# Create a callback function
def callback(ch, method, properties, body):
    body = json.loads(body)
    request_id = body['request_id']
    print('Received request with ID: ', request_id)
    input = body['input']
    output = calculate_factorial(input)
    # Update the status to done
    requests.post('http://localhost:5000/factorial/update', json={'id': request_id, 'status': 'done', 'output': output})

def start_consumer():
    # Create connection
    connection = pika.BlockingConnection(pika.URLParameters("amqps://yyyyyy:xxxxxxxxx@puffin.rmq2.cloudamqp.com/yyyyyy"))
    channel = connection.channel()
    # Create queue . For now queue name is factorial_process
    channel.queue_declare(queue='factorial_process', durable=True)
    # Listen to the queue and 
    # call the callback function on receiving a message
    channel.basic_consume(queue='factorial_process', on_message_callback=callback, auto_ack=True)
    # Start consuming
    channel.start_consuming()

if __name__ == '__main__':
    start_consumer()

📢 Let's see that in action

Let's send a request to the backend server.

That's our request id 748879f5-6504-4fbf-823a-74e6c44a3357

The consumer is running 🔥. We can also see the consumer has received the request bearing id 748879f5-6504-4fbf-823a-74e6c44a3357.

We queried the server with the id. But that is still processing.

-> After some time 🕓, we rerun the query. And this time, we got our results. The result is too long to show here. So truncated the output.

curl http://127.0.0.1:5000/factorial/result?id=748879f5-6504-4fbf-823a-74e6c44a3357

> {"input": 150000, "output":"....truncated", "status": "done"}

🚀🚀 Congratulations. That's all.

You can spin many consumers to make the resulting process much faster.

Not only AI model, but you can also build many things based on this concept of microservice architecture.

Whatever, with this design, when your userbase grows results may come a bit late but your backend will not be unresponsive. To make it faster you can spin more consumers.

⚡Some Optimization Tips

The polling method is acceptable but is not suitable for large users. We can use WebSocket in place of polling to reduce network calls.
We should consider deleting the processed request records from the database as they have no use.
We can also consider using an in-memory database like Redis to store the data of requests.
The endpoints must be secured so the internal consumer/worker can access them.
Make the consumer/worker dockerize so it can be easy to run multiple consumers using Amazon EKS, ECS, or other services.

If you liked this blog, consider to like and share this blog

What are Singleton classes and Why do we need them?

Tanmoy Sarkar — Sat, 24 Dec 2022 05:23:49 +0000

What is Singleton Class?

While doing projects, we sometimes want to keep only one instance of a class and don't want to pass the instance of an object by argument in each function.


class ClassA {
      // sample codes
}

object1 = ClassA();
object2 = ClassA();
object3 = ClassA();

In the above example, we want that when we call the ClassA constructor, every time it returns the same instance of an object in memory instead of creating a new thing every time the constructor is called.

When do we need Singleton Class?

Let's discuss the real-life use of singleton class.

API Client : During website / android / ios / native application development, we usually need to design an API client to establish communication between our app and server. 90% of the time, the API request is protected by some sort of authentication mechanism.

If we create an instance of an API client for sending each API request, we need to configure the client with authentication details (JWT Key, API Key, Bearer Token, etc.).

But we don't want to do this thing again and again for each request. Here we can use the concept of Singleton Class and resolve the issue.
Database Client : Like the issues for API Client, in the case of database client we have a limit on creating instances of objects of particular database clients. So we need to use only a single instance of Database Client / ORM Client in the whole project.

What is the concept behind Singleton Class?

In every programming language, we get a special type of variable static for class, which helps to keep only a single instance of the variable in all object instances of that particular class.

Let's get started learning this

Let's define a dummy class

class ExampleA{
  // Class variable
  int counter = 0;
  // Special function to create/get object of instance
  static ExampleA getInstance(){
  }
}

We need to create a static variable which will store instances of objects of their own class.

class ExampleA{
  // Static variable
  static ExampleA instance;
  // Class variable
  int counter = 0;   
  // Special function to create/get object of instance
  static ExampleA getInstance(){
  }
}

But we don't want to create an instance of an object if it does not need anywhere in our program.
```
  // Static variable
  static ExampleA instance = null;
```
Now, we came to the main part, designing the getInstance static function. In this function, we will return the instance of already existing object. If no object currently available, we will create

Kindly see the comments of the code to understand

class ExampleA{
  // Static variable
  static ExampleA instance = null;
  // Class variable
  int counter = 0;
  // Special function to create/get the object of instance
  static ExampleA getInstance(){
    // If no instance has already created, create a new one and assign it to an instance variable 
    if(instance == null) instance = ExampleA();
    return instance;
  }
}

That's All 🎉🎉

Let's implement the logic in Java & Run

Code -

class ExampleA{
    static ExampleA instance;
    int counter = 0;

    public static ExampleA getInstance(){
        if(instance == null){
            instance = new ExampleA();
        }
        return instance;
    }
}

Write little bit driver code to test -

public class testProgram {
    public static void main(String[] args) {
        ExampleA object1 = ExampleA.getInstance();
        object1.counter++;

        ExampleA object2 = ExampleA.getInstance();
        object2.counter++;

        System.out.println(object2.counter);
    }    
}

Let's run the program By object1.counter++, the counter goes from 0 to 1. As the object2 is the same instance, by object2.counter++, the counter goes from 1 to 2.

Output -

🏊🏊 Nice, our output comes perfect, which means now in the program, where I want the object, I can simply call ExampleA.getInstance(), and access the function and values of the object.

Best Practice

If the language has concept of public and private methods of class, make sure to make the default constructor to private.

What's your task?

If you leave this after understanding, you gonna face issues..Better write a Singleton Class in your favourite language and post it in a comment for a reference for others.

Thank You 👼👼

Any issue, comment down

Reactivity in Javascript

Tanmoy Sarkar — Sat, 24 Dec 2022 05:20:17 +0000

👀 What is Reactivity?

It's the ability of a piece of code to automatically update or re-render in response to changes in the data it is bound to.

Let's try to understand clearly by ⏬

Selling Price and Buying Price are two state variables on which the value of Profit depends.

In the case of a Reactive System,

The profit variable will be updated upon any changes in Selling Price or Buying Price.

In the initial state, Selling price is 500 and Buying Price is 300, So the Profit will be (500-300) = 200.

When we update buying Price to 100, the Profit is recalculated automatically and updated to (500-100)=400

In the case of a non-reactive system,

Upon any changes in Selling Price or Buying Price, the profit variable will not be updated until calculateProfit() gets called again.

So, In the initial state, Selling price is 500 and Buying Price is 300, So the Profit will be (500-300) = 200.

When we update buying Price to 100, the Profit remains the same as before. (500-300) = 200

🤔 Where is the Reactivity concept used?

The reactivity concept is in the ❤️ of all modern frontend frameworks (React, Next.js, Vue.js, etc.).

Some important parts where this concept and programming practice are used -

useState hook of React.js
re-render widgets when some bounded state variable got updated

🚀🚀 Let us start building a reactive system

Start with a simple non-reactive system

let buyingPrice = 200
let sellingPrice = 500

let profit;

function calculateProfit(){
    profit = sellingPrice - buyingPrice
}

calculateProfit()
console.log("Profit : "+profit) // Profit : 300

// Update the selling price
buyingPrice = 100

// call calculateProfit() to recalculate
calculateProfit()
console.log("Profit : "+profit) // Profit : 400

Let us begin creating a reactive system

Step 1: Create a Dependency Class

Manage the dependencies, who need to be notified when this data got updated or modified.

class DependancyTracker{
    constructor(){
        this.subscribers = []
    }
    // Register the function of dependent code
    depend(){
        if(target && this.subscribers.includes(target) !== true){
            this.subscribers.push(target);
        }
    }
    // Notify the dependent codes to act on update of this data
    notify(){
        for (let i = 0; i < this.subscribers.length; i++) {
            let func = this.subscribers[i];
            func(); // run the function
        }
    }
}

Let's see that in action

let track = new DependancyTracker();
let profit;
let buyingPrice = 200;
let sellingPrice = 400;

function calculateProfit(){
    profit = sellingPrice - buyingPrice
}

// Register the depndent code
target = calculateProfit
track.depend()
target()

// Initial profit 
console.log("Profit : "+profit) // Profit : 200

// Update the selling price
sellingPrice = 500

// Notify all the dependent codes for re-compute
track.notify(); 
// calculateProfit is also an part of the dependent codes.

console.log("Profit : "+profit) // Profit : 300

Step 2: Play with the getter and setter

A dictionary to store initial values

const data = {
    "buyingPrice" : 200
}

Let's set getter and setter for the specified key

let internalvalue = data.buyingPrice;

Object.defineProperty(data, "buyingPrice", {
    get: function() {
        console.log("Get trigerred");
        return internalvalue;
    },
    set: function(val) {
        internalvalue = val;
        console.log("Set trigerred")
    }
})

Let's see that in action

data.buyingPrice=900
console.log(data.buyingPrice)

Output -

Step 3: Create a watch function to make the process a little bit easy

function watch(func){
    target = func;
    target();
    target = null;
}

Step 4: Wrap up !!!

const data = {
    "buyingPrice" : 200,
    "sellingPrice": 400
}

let target = null;

class DependancyTracker{
    constructor(){
        this.subscribers = []
    }
    depend(){
        if(target && this.subscribers.includes(target) !== true){
            this.subscribers.push(target);
        }
    }
    notify(){
        for (let i = 0; i < this.subscribers.length; i++) {
            this.subscribers[i]();
        }
    }
}

Object.keys(data).forEach(key => {
    let internal = data[key];
    let dep = new DependancyTracker()

    Object.defineProperty(data, key, {
        get: function() {
            dep.depend(); // link target function
            return internal;
        },
        set: function(val) {
            internal = val; // set value
            dep.notify(); // notify dependent variables linked funtion
        }
    })

})

// Watch function
function watch(func){
    target = func;
    target();
    target = null;
}

// Link calculateProfit function in watch
watch(() => {
    data.profit = data.sellingPrice - data.buyingPrice
})

console.log("Profit : "+data.profit) // Profit : 200

data.sellingPrice = 700
console.log("Profit : "+data.profit) // Profit : 500

data.sellingPrice = 900
console.log("Profit : "+data.profit) // Profit : 700

Congratulations 🎉🎉

You may have gained an amazing concept from this blog. If you like it, please share it with your friends.