DEV Community: Brijesh Shah

Cowin Vaccine Notifier

Brijesh Shah — Mon, 03 May 2021 21:15:43 +0000

To help people notify about new vaccination slots being opened in their area in India, I have developed a very simple app:

https://cowin.tuls.in

Just enter your email id, age & area pincode against which you want to search the slots. If a valid slot is found matching your age group and pincode, you will be sent an email with the details of the same.

Currently:

the system checks for new slots every 2 hour, which might be changed depending on the users registration. This also means that you will receive the same emails every 2 hour. Please feel free to block the sender's email id if you are done with the vaccination and no londer require the service. An unsubscription functionality is in plan to rectify the same
the system checks for new slots for today & 7 upcoming days
the system automatically deletes users who registered before 7 days, to ensure new users get an equal chance to register. Also because the system is running on a server with limited resources. So, if you want to continue getting the updates, just register once again after 7 days

Future improvements:

Allow users to unsubcribe
Allow users to enter multiple pincodes
Allow users to enter till how many upcoming days do they want to check the slot availability for

Please share your feedback at: openciappdev@gmail.com

Algorithms 101 - Two Numbers Sum

Brijesh Shah — Thu, 25 Feb 2021 16:09:29 +0000

Problem Statement

Given an array of distinct integers, find the pair of integers whose sum is equal to the target number, if any.

Arguments

numbersArray - Array of distinct integers
targetSum - Target sum number

Solution

Approach 1

Run 2 for loops, one nested inside the other.
Check if the sum of the iterating elements equal the target sum.

const twoNumerSum = (numbersArray, targetSum) => {

    for (let i = 0; i < numbersArray.length; i++) {

        const firstNumber = numbersArray[i];

        for (let j = 0; j < numbersArray.length; j++) {

            const secondNumber = numbersArray[j];

            if (firstNumber + secondNumber === targetSum) {

                return [firstNumber, secondNumber];

            }

        }

    }

    return [];

};

Time complexity O(n^2)

Space complexity O(1)

Approach 2

Initiate an empty object & iterate through the input array using a for loop.
Because we already know the target sum, we can instead search for the unique number, whose summation with the iterating number will be equal to the target sum.

const twoNumerSum = (numbersArray, targetSum) => {

    const numbersMap = {};

    for (const number of numbersArray) {

        const match = targetSum - number;

        if (numbersMap[match]) {

            return [match, number];

        } else {

            numbersMap[number] = 'true';

        }

    }

    return [];

};

Time complexity O(n)

Space complexity O(n)

Approach 3

Input array can be sorted in O(nlogn) using quick sort. Let's do that first.
Begin summation from the extreme indices and close in. If the sum is less than the target sum, move one index further from the left side, else, the right side.

const twoNumerSum = (numbersArray, targetSum) => {

    numbersArray.sort();

    let left = 0, right = numbersArray.length - 1;

    while (left < right) {

        const currentSum = numbersArray[left] + numbersArray[right];

        if (currentSum === targetSum) {

            return [numbersArray[left], numbersArray[right]];

        } else if (currentSum < targetSum) {

            left += 1;

        } else {

            right -= 1;

        }

    }

    return [];

};

Time complexity O(nlogn)

Space complexity O(1)

Link to Code

in node.js. Feel free to raise a PR in any other language.

For the latest updates on the upcoming articles in this series, you can subscribe to the newsletter.

How I started generating passive income

Brijesh Shah — Fri, 01 Jan 2021 08:45:03 +0000

Introduction

I believe, in this day and age, everyone should have a passive source of income, certainly when job security holds lesser value with each passing day. As I already had a blog where I write about tech, I thought to monetize the same. I knew that it won't bring me loads of cash, not initially for sure. But, something is better than nothing. So, what did I do? I started looking for possible options to monetize by blog keeping in mind that I do not want to bombard the visitors with loads of ads. Because at the end of the day, I still want to help them by sharing what I've learned so far.

The search for possible options

As soon as you type the words "how to monetize your blog" in Google, you will be hammered by different opinions from innumerable results. After analyzing different methods, I finally decided to go with adf.ly URL shortener service. Ok, I hear you say "You're just promoting", and I agree. I will promote a service if it helps me in achieving my goal.

Why adf.ly?

Because it allows me to control the placement and nature of ads. Even though it's selling point is that it's a URL shortener service which displays ads on shortened URLs, it provides an option to add banner ads, pop ads, etc., which an average ads platform offers to only websites with huge traffic. You can earn anywhere around $1-$10/1000 views, depending on the traffic source. It also provides $1 as a bonus on your first 100 views and a chance to earn commission via referral programs. I mean, what's not to like?

So if you genuinely want to build a passive income, my advice would be to at least try it out.

Architecting a URL Shortener

Brijesh Shah — Sun, 13 Sep 2020 07:30:06 +0000

Introduction

This is the first article of what will be a series on how to architect, code, and deploy a URL Shortener. So let's begin.

"What is a URL Shortener?" you ask, you might have come across it more often than you think. In simple words, a URL Shortener converts long URLs to short ones. Upon clicking the short link, you will be redirected to the original URL.

"Well then why do we need them in the first place?" Because they are easy to type, i.e., preventing typos. They also help in saving a lot of space while displaying, texting, or posting on social media.

Let us see an example:

Input

https://tuls.in/prevent-opening-of-files-over-existing-tabs-in-vs-code/

Output

https://bit.ly/3h8erO6

Some of the popular URL Shorteners are: bitly, tinyurl, etc. Some more use cases of such services include better management and analyzing the audience.

By the look of it, sounds pretty simple, right? Let's think about the requirements before jumping the gun.

System Requirements

The below points can be treated as the static system requirements from a higher standpoint.

Assign a unique short link for a given URL.
Upon accessing a short link, redirect to the original URL with minimum latency.
Use encoding to prevent short links from being guessed.
Expire the short links after a certain timespan.

Technical Requirements

To keep it short and straightforward, we will keep these requirements to a minimum. FYI, I will be rendering the frontend using a template engine so that I can incorporate everything in a single backend focussed repository.

Frontend

Home Page: To ask users to input a URL.
Output Page: To display the generated short link and provide options to the user such as copying the short link or opening it in a new tab.
Invalid Page: To display an appropriate message on receiving invalid requests.
Expired Page: To display an appropriate message when a user tries to access a short link which has expired.

Backend

Home Page Render API: To render the Home page.
Assign Short Link API: To assign a short link from the database against the incoming URL and return an encoded string to the frontend.
Display Short Link API: To decode the encoded string and return the assigned short link to display it to the user.
Redirect API: To redirect the user to the original URL.

"Hmm, but why do we need to send an encoded string to the frontend in the first place, only to decode it back again to send the generated short link?"

Hang on, I will clarify this in an upcoming section when I explain the flow from a user perspective.

Database Design

We need only one table to store about the URL mappings.

+---------------------------+---------------------------+-----+--------------------+
| Field                     | Type                      | Key | Default            |
+---------------------------+---------------------------+-----+--------------------+
| _id                       | String                    | PRI | URL Safe String    |
| is_active                 | Boolean                   |     | true               |
| is_used                   | Boolean                   |     | false              |
| original_url              | String                    |     | null               |
| creation_date             | Date                      |     | Date.now           |
| expiration_date           | Date                      |     | Date.now           |
+---------------------------+---------------------------+-----+--------------------+

Note For our case, a URL Safe String will contain a combination of the following characters: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~

Since we do not have any requirement of creating relationships and we might need to store several rows, a NoSQL database will be a better choice as it will be easier to scale. Hence, we will be using MongoDB.

Purpose of Fields

_id: This will the short link which will be served. Its length can be 6 in the beginning and can be increased as per the traffic. (Number of unique combinations of length 6 from the string which will be used to generate the URL Safe String will be huge). We will be using an npm package to generate it at the time of the creation of a document.
is_active: A flag to control whether a document is active or not. It might not be helpful early on, but it is always good to have a fallback, just in case you might need to disable certain short links on an urgent basis.
is_used: A flag to check whether a document, i.e., a short link, is in use or not.
original_url: The original URL from the user.
creation_date: The date of creation of the document.
expiration_date: The date of expiration of the document. When the document expires, the short link will expire. We will be leveraging a built-in functionality of MongoDB via Mongoose ODM (Object Document Mapper) while coding to attach a counter for the expiration of a document.

System Design

The How Part

The problem we have on our hands is, how to generate a short and unique link for a given URL.

Approach 1

Generate a new document in the database after receiving a URL from the user. However, some of the issues with this approach are as follows:

Suppose the storage space allocated for the database is full. Now because the system won't be able to create new documents for incoming requests, the availability of your service goes for a toss.
Thinking about scale, if and when the server will serve considerable traffic, creating a document runtime will result in the consumption of more resources, in turn slowing down the system and increasing the latency.

Approach 2

A better solution to overcome the limitations with the first approach is to create x number of documents beforehand using a cron that runs every y minutes or hours, depending on the traffic.

Cron A command to an operating system or server for a job that is to be executed at a specified time.

Now, whenever a user will ask for a short link, your system will do the following:

Pick a document with is_active as true and is_used field as false.
Update the original_url of the document with the user's URL, is_used as true and expiration_date to the current timestamp.
Return the _id (short link) of the document.

The User Perspective Part

To summarize, the user flow will be as follows:

The user visits the Home Page. Home Page Render API is in action.
User inputs a URL and clicks on the Submit button. Assign Short Link API is called, which returns an encoded version of the short link.
Upon successful response from Assign Short Link API, the frontend redirects to a new route that uses the encoded short link as a path parameter. Display Short Link API is triggered on visiting of this new route.
Display Short Link API decodes the encoded short link, finds the corresponding document against it in the database, and returns the short link in the rendered Output Page.
Redirect API comes into action when a user clicks on a short link. It basically extracts the unique alias (which is actually the _id) and finds the document against it. If the document exists, it will redirect the user to the original_url stored against it, else it will display the Expired Page.
Invalid Page will be rendered only in a particular scenario that we can address when writing the code.

Addressing the dangling question which was left unanswered earlier
There can be several reasons for the whole encoding-decoding process, some of which are:

Increase monetization by showing ads on 2 different pages rather than one, one for inputting the URL and the other for displaying the short link.
To rate-limit the routes with a distinct configuration.
To prevent the short links from being predictable easily.

Corner Cases and Improvements

Here is a list of some corner cases and improvements that I would like you to brainstorm on:

Corner Cases

What if multiple users enter the same URL? They might get the same shortened URL, which is not acceptable.
What if parts of the URL are URL-encoded?

Improvements

Users should optionally be able to pick a custom short link for their URL.
Users should be able to specify the expiration time.

FYI, the coding solution we will implement further in the upcoming articles might not solve all the above issues. These are for you to solve.

Concluding Remarks

I realize that you might have some queries, but I'm sure we will resolve those when implementing the architecture. Till then, try to come up with some new and interesting corner cases and improvements that we can incorporate. And if you understood it well, go ahead and try to implement it yourself.

For the latest updates on the upcoming articles in this series, you can connect with me on LinkedIn by visiting my dev.to profile.

git stash, to the rescue

Brijesh Shah — Mon, 07 Sep 2020 05:46:43 +0000

Introduction

git, the version-control system we all use. It has helped save a tremendous number of work hours by simplifying the process to track changes in source code during software development. Today I will try to demystify one of its commands to help you save some more time.

Use cases

Lets be real, you often come across a situation where you are doing what you do best, writing some awesome code. But, suddenly you are required to just make your changes disappear and test some other code. Now, you are not ready to commit your changes yet. What do you do? The answer to this issue is the git stash command.

The git stash command takes your uncommitted changes (both staged and unstaged), saves them away for later use, and then reverts them from your working copy. For example:

Dirty state

$ git status
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    modified:   index.html

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   lib/simplegit.rb

Stashing the changes

$ git stash
Saved working directory and index state \
  "WIP on master: 049d078 Create index file"
HEAD is now at 049d078 Create index file

Clean state

$ git status
# On branch master
nothing to commit, working tree clean

You can reapply previously stashed changes with git stash pop.

$ git stash pop
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   index.html
    modified:   lib/simplegit.rb

no changes added to commit (use "git add" and/or "git commit -a")

Bonus tip, you can also stash untracked files using git stash --include-untracked.

Prevent opening of files over existing tabs in VS Code

Brijesh Shah — Tue, 18 Aug 2020 11:58:29 +0000

Introduction

Visual Studio Code is an awesome lightweight code editor as we all know it. However, many of us have gone through the situation where when you click or open a file, it opens in one of the existing tabs, replacing the previous file. At a certain point in time, you will get annoyed enough to search through the web looking for an explanation for the same and a way to stop it. Well, look no further.

The Reasoning and Solution

On a closer look, you can notice that the tab which gets replaced has the tab name in italics.

That indicates that it is a preview of the file. As there can only be one preview tab, the preview will change if you select another file. This is intentional and delivered by VS Code as a feature to prevent you from opening several tabs when you are just looking around for a particular file.

One way to resolve this is by double-clicking on that tab. This will remove the file from the preview state and stick it on the panel.

I know your next question will be, "But what if I don't want to move my hands from the keyboard? There has got to be a shortcut.". And there is.

Select the preview tab
Press Command + K (Ctrl + K for Windows) and then hit Enter

You're welcome 😄

Finally, what if one wants to open the files in a new tab every time irrespective of whether they are opened from Explorer on the side or Quick Open.

Open VS Code Settings
Search for “enable preview”

Uncheck Workbench › Editor: Enable Preview and Workbench › Editor: Enable Preview From Quick Open

Saving time with Postman

Brijesh Shah — Fri, 31 Jul 2020 15:02:21 +0000

Introduction

Postman has become an integral part of a developer's life. It offers a variety of features apart from developing and testing APIs to reduce manual work, and I'm going to share a few of them.

PS I have highlighted the used features in the images to follow.

Features

Importing cURL

Remember the time when someone shared a cURL with you and you couldn't make sense of all the flags and options that were used in it? Well, Postman can interpret it for you via a straightforward UI. All you have to do is click on Import, go to Raw Text, paste the cURL, click Continue, and Tada 🎉.

Save the Response

I came across the next feature just a few days back when I wanted to save the response of an API because you know, the servers aren't always working as expected 😄. No problem, Postman had my back. Just click on Save Response as depicted in the following image and you are good to go.

You can now access the saved response for that API as below.

You can also save the response directly to a file via the Send to a file option.

Link to the complete article.