Forem: yas

Predictable Pan Card Generation Algorithm.

yas — Thu, 21 Jan 2021 08:00:29 +0000

In any fintech company in India, an important data point is the user's pan number which is used as primary identification.

A common strategy used in creating test users in such an application is generating a random pan number but one drawback with this approach is any newly generated pan should be checked against the database if it already exists to avoid a collision.

The better way is to serially generate the pan numbers to avoid a collision.

I believe it's an interesting problem of generating Pan Card numbers serially so I wrote an algorithm to do the same which would predictably generate a pan card number for a given number x.

Github: pan-number-generator

This could be used be imported in test cases to generate unique pan numbers and while masking pan data for production dumps.

The series would go as:

  'AAAAA0000A',
  'AAAAA0000B',
  'AAAAA0000C',
  'AAAAA0000D',
  'AAAAA0000E',
  'AAAAA0000F',
  'AAAAA0000G',
  'AAAAA0000H',
  'AAAAA0000I',
  'AAAAA0000J',
  'AAAAA0000K',
  'AAAAA0000L',
  'AAAAA0000M',
  'AAAAA0000N',
  'AAAAA0000O',
  'AAAAA0000P',
  'AAAAA0000Q',
  'AAAAA0000R',
  'AAAAA0000S',
  'AAAAA0000T',
  'AAAAA0000U',
  'AAAAA0000V',
  'AAAAA0000W',
  'AAAAA0000X',
  'AAAAA0000Y',
  'AAAAA0000Z',
  'AAAAA0001A',
  'AAAAA0001B',
  'AAAAA0001C',
  'AAAAA0001D',
  'AAAAA0001E'

Visualisation tool for sorting algorithms.

yas — Tue, 28 Apr 2020 07:57:29 +0000

Edit: Added explanation on how it works.

This is a tool which visualises how algorithm works.

It is so good if we can SEE how it works in real time. Even more amazing to go back and forward, to see how the sort series was in the past.

I started working on this project so i can help young people to learn and understand how something works.

lets begin with sorting algorithms..

I created a framework where we can plug a sorting algorithm and see how it does sorting.

How It Works....

So first the framework generates some random numbers.

Once the algorithm is selected,
all the random numbers are passed to that selected algorithm.

The selected algorithm then does sorting and stores each change in sorting order and the index which got changed.

Then it is returned to the react component which iterates through each change and updated the state after a few milliseconds.

Thats how it looks like animating.

So you can select one of the algorithm and click play to start rolling...

i selected merge sort.

Then you can click pause and use arrows to go back and forth to exactly see how it gets sorted.

Link For website:
https://visual-algos.netlify.app/algos/sorting

There is a long list of sorting algorithms that needs to be implemented. It would be great help if someone can contribute to it.

🕒 currently working
✅ finished implementing

Selection Sort ✅
Insertion Sort ✅
Merge Sort ✅
Heap Sort 🕒
Bubble Sort
Binary Insertion Sort
Quick Sort (LR ptrs)
Quick Sort (LL ptrs)
Quick Sort (ternary, LR ptrs)
Quick Sort (ternary, LL ptrs)
Quick Sort (dual pivot)
Cocktail Shaker Sort
Gnome Sort
Comb Sort
Shell Sort
Smooth Sort
Odd-Even Sort
Bitonic Sort
Cycle Sort
Radix Sort (LSD)
Radix Sort (MSD)
std::sort (gcc)
Tim Sort
Block Merge Sort (WikiSort)

Link for github repo:
https://github.com/SrikanthYashaswi/visual-algos

Embedded visit counter doesn't work here. Any Idea why?

yas — Sat, 16 Nov 2019 21:50:26 +0000

Testing if this works...

Got a visit counter from https://www.freecounterstat.com/ .

URL: https://counter9.wheredoyoucomefrom.ovh/private/freecounterstat.php?c=p8pa7snn91j8x7gashjuua3smee7r8m6

I embedded it as an image. But dev.to is caching images through a proxy, so the image URL is not being hit.

it's always 1

Any idea whats happening?

Building a messaging server from scratch. (Java)

yas — Fri, 15 Nov 2019 19:21:18 +0000

This requires you have good understanding of
Java,
ServerSocket,
ClientSocket.

I was motivated to build it, when i couldn't understand how modern app servers scales to millions of connections with single instance. So i started working on it. I couldn't get much help from internet when i started building, so writing this documentation...

Jumping straight at code.

This is the main class where the ConcurrentServer will start running.

class ConcurrentServer{
     public static void main(String[] arg) throws IOException, InterruptedException
     {
            int port;
            if(arg.length == 0){
              port = 8080;
            }
            else{
              port = Integer.parseInt(arg[0]);
            }

            new ConcurrentServer().start(port);
     }
}

Wait a sec....
Remember this List<User> clients here. It plays an important role.

public class Shared {

    public static List<User> clients = new ArrayList<>();

    public static int count= 0;

    private Shared(){

    }
}

When a new user is connected to the server, the connection object is pushed to the client list in Shared class (see below).

The User class below extends from ClientSocket.

public ConcurrentServer{
    public static void main.....
    .
    .
    .
    .

    public void start(int port) throws IOException, InterruptedException{   
        try(ServerSocket server = new ServerSocket(port)){

            Thread channelReaderThread = new Thread(channelReader);
            channelReaderThread.start();

            while(ALWAYS_RUNNING){
                User client = new User(server.accept());
                Shared.clients.add(client);
            }
        }
    }   
}

Next we read the user messages which might pop up at any time.

private void process()
{
    int maxSize = Shared.clients.size();

    for(int i = 0 ; i < maxSize ; i++)
    {
        User user = Shared.clients.get(i);

        queryClient(user, i);
    }
}

private void queryClient(User user,int index)
{
    InputStream inputStream = user.getInputStream();

    if( inputStream.available() <= 0 )
    {
        return;
    }

    ConnectedBy connection = user.getConnectionType();

    connection.handle(user);
}

Remember this guy Shared.clients, this is an array where pushed the connected users in main thread.

The process method above is triggered run every 100ms. Java provides a method called inputStream.available(), if user sends any message, inputStream.available() will > 0. Thats the time, we can read the message from the inputStream.

Once you are able to read message and as you already have all the clientConnections in Shared.clients you can iterate it and send the incoming message to all clients in it.

Hence you have a functioning messaging application.

It is tested with a few thousand parallel connections, it delivers messages most of the time.
But Caution.
There are occasions when messages are dropped, i could not figure out yet, why these messages are dropping. So any help would be highly appreciated.

Any one who understands or didn't understand it, do comment, i would be highly interested to reach out.

Source Code. https://github.com/SrikanthYashaswi/messenger

deploy on production server ......... git pull-> maven build -> run jar

yas — Fri, 25 Oct 2019 20:26:40 +0000

We started to decouple our codebase to multiple microservices.

we created a few java springboot microservices.

Our deploy strategy

Once we commit our files to git.
our deploy script will git pull the changes to the production server
do -> mvn build -> move JAR to a path -> start it up.

And its incredibly fast.

What do you think about this approach?

#2019 Awesome Indian Music Composers

yas — Fri, 18 Oct 2019 06:52:32 +0000

Listen to songs by them and stay focussed...

Nucleya
Ritviz
The Local Train
Parvaaz
aswekeepsearching
Ankur Tewari
Prateek Kuhad
Seedhe Maut
Prabh Deep

do share cool playlists...