Consistent Hashing Explained: System Design Fundamentals | Scalable Thinking

[00:00:00]hey what's up everyone and welcome to daily quid buffer we are starting a new series on system design and the main idea and the goal about this entire series named scalable thinking is to not just get you prepared for your system design interviews but also to make sure that you learn all the concepts about system design so that you can use those Concepts and build the scalable solution as well in your job so with this series we are trying to hit a two Targets with a single Arrow where it will prepare you for your interviews as well plus it will prepare you for your job as well to build the scalable system designs so that's why we calling this series as a scalable thinking now within this topic we are going to cover the basics about each and every algorithm each and every component that we can use in the system design and we are also going to go deep dive into each and everything about how we are going to use this what is the purpose of using it which all companies and which all Technologies are using this and how to implement this with the help of a code as well so there are a lot of components that we can actually learn more about by implementing it so we are trying to implement all those details as well so we are going to Deep dive into each and everything within this series with this the first topic that we are going to cover is the consistent hashing so let's understand about what is consistent hashing why we use consistent hashing and how to implement it so welcome to the series of scalable thinking now before we understand about the consistent hashing first we need to understand why why we need a consistent hashing and why it was introduced okay so let's consider about a simple example where we want to create a simple web application where there is a client which connects to server okay now this is a system that we have built now what happens is as the application grew right more and more number of users are coming to your application we needed more servers to handle a lot of different traffics so what we did is we created another server server two and we added one more server server three now all the traffic from the different clients C1 C2 can go through different servers server 3 maybe server two and so on based on the load balancer okay so you will put a load balancer here in between which will handle all your traffics okay that's how generally we do now all your different clients is been served by the different servers for your different requirements now the similar kind of requirement we get while storing the data as well right as we are working with the database we store all those different data into database so suppose let's say a DB here that this is my DB now all this request comes here and I want to store all those data in my database as well now just using a single database will not be sufficed here because as we have added multiple servers here and our application is just using single database it is a single point of failure for us right it's a blocker for us if this DB goes down if there's any issue within this DB then all those servers connecting to a single DB will not be able to serve the request or serve the traffic so for that what we can do is we can do the database sharding database partitioning now all those things how can we do we have to do partition the data based on the different request coming to the different servers based on the hashing algorithm okay so what we will do is suppose rather what we did we took this database okay and we created three more databases suppose it's DB1 db2 and db3 okay and data is coming through all those three servers okay so now you can see that I have my database but I have three instances of my database okay now which server should send the request where okay suppose I have uh 100K users okay 100K users are trying to serve the data or trying to get the data from my servers now all the servers has to store the data in each of the database I have to Shard my database okay I will we will learn about all the sharings and everything in the later part of the video but just understand that that I want to store the data equally within these three databases so how I can do I can do or I can store the data into this three database for all these 100,000 users by dividing all those data into three parts so if I have 100,000 users right I will divide by three because I have three servers and all those data will be sent to this three servers so 3 33,000 will send to here 33,000 will send here and 33,000 will be send here okay so now I am dividing the data here now suppose user one okay let's take the user one user two and user three there are the three users okay now user one's request went to server one and it went to Ser to DB1 okay so user one went to DB1 user 2 went to db2 and user 3 went to db3 okay so all those three requests sent to different users and the data has been sent to different databases now we need to make sure that whenever the request comes for the user one again okay if user one is doing the request again my request should go to DB1 only because DB1 has the data for my user one if it goes to db2 then it will not be able to get the data right because I have stored my data into my database 1 and if the user two is is coming my request should go to db2 only and for user 3 my request should go to db3 okay so that's how it should work because I need to figure out that as I have stored my data for user one into database 1 rest all the request coming to my server should go to database 1 for the user one that's what I need to make sure okay how do I make sure I do make sure using the hashing so what I will do is as I have three servers okay server one server 2 server three rather let's call this as a DB right these are three different database servers for us okay so now what I will do is whenever I get the request okay here I can say that n equals to 3 right because I have three servers now so now what I will do is whenever I get a request for user one okay suppose I'm getting a request for user one now for user one what I will do is to make sure that for user one all the request should go to an unique server every time unique database server every time what I need to do is I will do an hashing algorithm on this so I'll perform an hashing algorithm so performing and hashing algorithm on the user will give me some input okay some value and with this value what I will do is I will do modu of n n is the number of servers that I have if I have three I will do modulo by three if I have four I will do modulo by four if I'm doing modulo by N I will get a value either 1 2 or three okay S1 S2 or S3 three databas servers I will get the value now whatever the value I get I will sve the traffic there if I get the value to I'll sve the traffic there if I get three I will solve the traffic there accordingly I will do now this will only be a applicable when I have a fixed set of servers okay now if I add a server three S3 sorry S4 okay so let me just ch to S4 so now if I add the server 4 now my n will become nals to 4 now if I get value one for the user one okay and what I will do I will do the hashing again I will do that value whatever I get from the value because we make sure that whenever we do has the value that we get should be same then I will do again module of n which is four then I will not get one again I might get something else right so what will happen is if I get something else is I will be able to go to that particular server and I will not get the data for that user so now what I'm trying to say is as I have limited number of servers with that limited number of servers when I'm doing hashing and doing module operator to identify which server I want to go to I am not able to perform consistent operation because I'm not getting the consistent hash value or consistent server value to connect to okay now when this situation occurs like you are not able to add to that or serve the traffic to the particular server what you need to do is whenever you add a new server whatever the data that you have in the existing servers for Server one server 2 and server three you need to perform rehashing for each and every every data existed in that server right because whatever the data is stored in server one is stored with the help of hashing modul by three okay now as we have added a server or we have removed the server either of the cases we have to do the hashing operation on all of this and then we can add a new node and then start serving the traffic so you can see that if I have stored 1 million records okay I I have to do the hashing operation again for all those 1 million records and store against four servers again okay so this operation I have to do for all the data which I already have now this is not an ideal scenario where we will not be able to do this millions of Records available to do rehashing and re storing all the data so in that case what we can do is rather than just having this hashing algorithm approach we can use the consistent hashing algorithm now in consistent hashing algorithm what will happen is rather earlier we were what we were doing is we were creating the array of servers right where n equals to the number of servers so if we had three servers we'll be creating three arrays to just store that which server information we have okay now what we will do is in consistent hashing we will create an array okay where n = to 0 to n = to n okay where n is the number which will change eventually okay so what we will do is we will create a huge set of array and what we will do is we will connect this two ends so we will take this end and we will connect to this so we will create a circular array so at the end we will end up creating the ring so it's a ring for us okay so this is what we are going to create where n = to 0 = to n so both of them will connect to each other so your ring is created okay now rather than storing your data in a array we are storing we are going to store the data in a circular ring so now if I have four servers server 1 server 2 server 3 and server 4 what I will do is I will add all those servers within a ring so I will add server one here I will add server 2 year I will add server 3 year and I will add server 4 year so here you can see that I have added four servers here okay now what I will do is I will create this ring okay now whenever the request comes right so suppose let's say we got a request for a object one or request one okay now what we will do is we will again do the same hashing algorithm here here also we did the hashing algorithm with the hashing algorithm only we kept the four servers within a ring okay the same algorithm we will execute on the request that we got and within this particular request we will get to know that where we can keep so suppose we understood that the object we are getting is somewhere here okay now we got the object two so let's see object two this object two is somewhere here okay now what will happen is we will go in a clockwise Direction okay now what it will happen is so whatever the request comes right that request will be executed by the next server available within the clockwise Direction so this request will be handled by this This Server that is server two this is server one server 3 and server 4 okay so this request will be executed by server two this request will be executed by server 3 if any of the request comes and hash keeps the object here then this will be executed by here okay so now you can see that we are executing all those objects and request with the consistent hashing where whatever the objects are kept here will be executed by the next set of servers available okay so this is how the consistent hashing will work based on a hash algorithm we will put everything within a ring and all the request will also be put within a ring and we will execute all those requests within the clockwise Direction okay now within this there is a drawback as well so what will happen is suppose let's create a ring again okay and let's keep four servers here suppose server one server 2 server 3 and server 4 okay now we added the hashing algorithm here and what will happen is suppose uh we got the hash here server two year server three year and server four year okay so now you can see that we added four servers here and the hashing kept all those data within this one part only now you can see that from server 4 to server 1 we have a huge gap right now so you can see that all the objects coming here all the objects coming here within this part has to be handled by server one only so you can see that now server one will be getting a lot of load compared to server two server 3 and server 4 okay this condition is also not ideal right so sometimes this will happen where if we are adding a new node of server or we are adding or we are removing a node suppose we just remove this S2 as S2 was uh down right so what will happen is we remove the S2 here we remove this S2 and now all the data from here from S1 to S3 has to be handled by S3 now okay and you can see that the data range got increased for processing request so there will be a lot of load in one of the servers okay so this also needs to be handled now we need to understand so we will take this part later how to handle this okay how to handle this uh huge uh sets of data now suppose earlier we saw that earlier within this particular example we saw that if there was any new servers added what we had to do is we had to do the rehashing of all the data available on all the servers okay but in case of consistent hashing what we need to do is suppose we got this server to be removed okay now what we need to do is as we know that we just execute the data in the clockwise Direction okay what we just need to do is as this server has been removed then the data between This Server and the previous server this one only this much data needs to be rehashed and all those data should be solded by the S3 so now this entire block okay so you can see that every every time when we remove or add a server suppose I'm adding a server s fire okay so what will happen is all the data from this particular position to the previous position so all those data only needs to be rehashed so that it can know that all those request should be handled by S5 compared to S1 earlier it was soed by S1 now as we added s y all the data previous to S5 till the previous server has to be handled by S5 server so only you can see the a part of rehashing we are doing rather than doing a complete rehashing on all the data okay now let's handle this scenario where we have a huge range of data to be handled so in that case what we will do is suppose let's do the consistent hashing again so this is the ring okay and now let's see we have server one server two server three okay now for this three servers what we have is suppose we have three servers one 2 and three okay this is S1 this is S2 and this is S3 okay now we have added three servers so you can see that we have a huge range of data to be handled suppose if this servers goes down then for Server one or server three has a huge ring to handle all those data so to handle the scenario what we can do is we can add the virtual servers or it's also called as a virtual nodes okay so what we will do is we will take any of the server and add the end number of nodes suppose we are adding suppose 20 nodes per server okay for the simple scenario let's add that we are adding two nodes per server okay two virtual nodes so for S1 we are adding two for S2 we are adding two and for S3 we are adding two so what will happen is for S1 suppose we added a one node here so that is S1 0 we added one here that is S1 0 we added one here as s20 we added one here as S21 we added one here as S31 S3 0 and we added one suppose here s S31 so here you can see that for each and every server we added a virtual node as well so now you can see that your ring is trying to get a complete ring where you have lot of different servers available okay now for each of these servers available within this node if the request comes right so suppose let's take a request so request comes here okay so now you can see that with this request what we do is we do clockwise direction right so with this clockwise Direction you can see that we got the virtual node that is S2 of one right so this particular request will be handled by S2 simple right because we have added this virtual node so we know that where to handle the request now for this request if the request comes here so we'll go clockwise direction we know that it's s30 so this request has to be handled by S3 same goes with every node so you can see that now we are dividing the request equally so that all the servers that we have gets the equal amount of request with this it will not be an exact amount or very equal amount of request but moreover we will be able to distribute load very evenly okay so this how you can see that we are trying to add a lot of virtual nodes for a server that we have and we are trying to handle the request so rather than just couple of servers within the nodes we are adding lot of servers within the uh nodes and all those requests will be handled by the each of the particular servers so that's how how we are trying to build a ring and in Practical this ring will be very used suppose if I take the example that suppose I have five nodes or five servos available then in reality what I will do is I will create 100 nodes per server so in my ring I will be having around 500 virtual nodes and all the request coming in will be handled by all those 500 virtual nodes okay so the data will be divided more or equally so we'll be able to perform all the operations equally so there will be no huge burden in anyone of the servers so that's the idea behind it okay so that's how you can see that that's how we are trying to build a consistent hashing where uh ring like structure we going to create this is something a data structure we are going to create and this data structure will hold the data for us within this way where it will store the servers and the virtual not information and similarly where Whenever there is a request coming in that request will also be hashed within the same way and we will get a similar way where we are placing the request and it will be handled by the next set of server okay so that's how the consistent hashing works we are going to see the code as well how we can build the consistent hashing but this is how the entire structure works now when we use the consistent hashing mainly consistent hashing is used where you want to have the highly scalable system well you and you do not know how many servers that you have right so you have so here you can have end number of servers you can add end number of servers and you you can remove a number of servers with this you won't be able to face any issues while implementing this sorts of algorithm okay so when you have high scalability requirement and you want to make sure that all those servers are getting a n number of or equal number of request at the time we will use the consistent hashing algorithm to divide the traffic to the particular servers now where this algorithm is been mainly use so uh generally like uh creating a CDN system creating a key Value Store databases like uh Cassandra database P Dynamo DB all those system uses this consistent hashing to make sure that the data has been persisted equally or the data has been partitioned equally within the system companies like Google Uber all those uses this consistent hashing algorithm to make sure that Google uses for load balancing system to make sure that the load is been divided equally Uber uses the system to make sure that all those apis are been hit to the nearest server possible CDM system uses this type of algorithm to make sure that the uh CDN data is been served from the nearest server available to the user so to do all those such kind of operation uh consistent hashing has been used widely within the industry so as a software engineer you should know that how the consistent hashing works and what are the drawbacks of it and what is the problem that it is trying to solve so let's go to the code as well and understand that how the consistent hashing works so what I have done is I've written the code in Java I will just walk you through that code as well and then later we will try to understand how to build this as a distributed way as well so uh I will share this repository with you as well so you can go through this code as well and if you want to implement you can Implement within your system so here you can see that this is the consistent hashing class that I have created now what it does okay so here you can see that I have created a consistent hashing class and it takes the number of virtual notes okay so suppose I want to create create a consistent hashing algorithm with hundreds of with 100 notes so per server I want 100 notes that's what I simply I want to do okay so that's why I'm taking a virtual node and you can see that couple of things I'm doing I'm taking an md5 system to create a hashing for me and I'm taking an S 256 you can take either of the things there are multiple hashing algorithms available but I have just kept two years so when you go through the code you just know the difference like actually how the hashing algorithm will work okay we just need to and whatever the exist existing algorithms are there you do not have to worry about how this hashing will work you just need to make sure that whatever the hashing that you use whatever the hashing technique you use that will give you consistent output so that the data is been divided across the ring it should not be like there will be a one Hotpot created within the ring you should be able to move the data evenly within the entire ring okay so this is the a normal md5 you can see that uh hash function for md5 and hash function for 256 algorithm so here you can see that we are doing very simple thing we are taking a key and based on that key we are taking the object of a s 256 and converting that into a bite array so this will give us a data into a bite array and from this bite what we are doing is we are taking the first four elements of the array okay so here you can see that 0 1 2 and 3 so we are taking the first four elements of of the array from that uh bite array and what we are trying to do is we are making sure that that value is been converted to unsigned integer okay you might get a negative values as well so we are trying to convert to unsigned integers and we are shifting it to get a long value so whatever the values that you are getting when you shift it so what so here you can see that we are shifting this value to eight this value to 16 this value to 24 and this value To None So at the end we are trying to shift it to 32bit integer value okay that's what we are trying to get so at the end once this entire operation is been performed so I will add in the repository as well what this entire operation does so if you go to the readme file you will get a complete understanding how this works but eventually understand that this is an hushing algorithm where you will get an integer or long value with which you can map your server okay so with this you are getting a value and with this value what you will do is you will add a node node so this you can see this is a add node function and it's taking a node value and this node value would be what a combination of the server and the virtual node okay so server is one and the node is 20 so it will be like server one hyphone 20 so that will be your key so taking that what it will do is you can see that for each of the virtual nodes okay so for a server what I need for a server I need 100 virtual nodes so that's what it is doing okay so for any server added it will add the 100 virtual nodes so you can see that for every virtual node it is trying to get a hash value this hash value is from here okay so once you get the hash value what we are doing is we are adding to a ring what is this ring this is the ring that we have created it's a tree map it's a hash map that we have created which will store Key and value okay that's the simple thing that we are doing okay and internally we know that map creates an array list okay so by adding a node what we do is we create a hash value and against that hash value we are creating or we are adding a server node okay so if I have 100 so it will be 100 different uh values to be added within the ring and all of which will know that which node particular it is okay so this entire ring will be created once this ring is created you have a method to remove as well so remove also works the same way it will take the node and what it will do is it will remove all the virtual nodes from the system because if you do not have the server there is no point of keeping the virtual nodes to point to the server so it will remove all those particular from The Ring as well and to get the node you can see that it's a simple method what we do is we just take the key here and we check that if ring is not empty if that particular key whatever we are getting okay and if my entire ring if my entire consistent hashing ring is empty then there is no point of sending the data we just send the error otherwise what we do is whatever the key that we get we hash that value and from that hash what we try to do is we try to get the ceiling entry from the map so what it will do is it will try to map to a particular next set of value available so what it will do is if your particular key is coming somewhere here okay then the ceiling value you will get it here simple so it will give you the next virtual node available okay so that's what we are trying to do so it will tell us that okay wherever whatever my hash value is based on that hash value what is the next server available get me that server and based on that server I will execute my request that's a simple hashing that we are doing okay and for running it what we have done is we have created uh I have created one this particular code where it will run the code for me so here you can see that I have created a consistent hashing where I need 100 servers and I have added five servers here okay now for all these five servers you can see that I want to do 1 million request okay now for all this 1 million request you can see that what I'm doing is I'm just looping through this 1 million request and I'm finding a Nord and I am trying to just increment the value that for which of the particular server is been handling how many number of request okay so at the end of this code I will get to know that out of these five servers how many request was handled by each of the servers okay a simple code that I have written so here you can see that the entire code is completed so here you can see that it was able to run all the million request and at end you can see that it gets me the data like which particular server has handled how many request so you can see that most of the request have been handled very evenly it's not like that one of the server is only handling 100 requests and rest of the servers are handling more requests you can see that more of the same we are getting the even number of data and we also make sure that we don't give the red zone or the hotspot near to the one of the servers So eventually data is been consistent now let's understand how to make sure that whatever the ring that we created this ring is not a single point of failure right because if this ring is only running on one server okay suppose if this is running on one server and all the request all the clients right all the these clients are coming to here to identify which server to go to and then all the requests are coming to server one server two server three right then if this breaks then we are not able to serve any traffic right so we need to make sure that whatever the consistent ring that we create that also should not be a single point of failure we should also make sure that that is replicated right so so this also we need to do now how to do this replication like to make sure that this consistent hashing is not a single point of failure for our entire system application now to do that there are multiple options one thing is we need to replicate this across all the nodes so what we can do is if we have a consistent hashing gear and if you have multiple clients what we can do is as I have client C1 C2 C3 and C4 all those request can get go to any of the nodes available okay and that particular node for consistent hashing suppose I have three nodes and 100 servers so now you can see that I now I do not have a single point of failure I have multiple nodes available and this multiple nodes so all this traffic will go to here either here here or here and based on that I have the list of different 100 servers and it will send the traffic pi to any of the servers available okay so now this we need to implement how do we do we do based on the replication so what we can do is we can do this replication either based on the Kafka based on the redis based on the Zookeeper anything okay so what we can do is we can make sure that if we do redis right suppose I just want to make sure that I Implement redice with this redis what I can do is whenever I will store the data okay so what I will store as R is is a distributed system it will have a different set of different servers available which will store all the information about a different servers available and what is the state of the server so if I have four servers available then this red is within the distributed way it will know the information about how many servers are available how many virtual nodes are there and how we can handle the traffic okay so with redis we can implement this as well so what we can do is we have the consistent ring created and what we'll do is whenever there is an add node operation or a remove node if the server is added or if the server is removed we will create a event and that event should be listened by all the different redish servers and based on that event it will just create a new hashing ring or it will update the hashing ring so everyone will have the latest information about the hashing ring about how many servers and how many nodes are available this is the one way of doing it but what will happen in this is that it will be an eventual consistency because we are creating an events okay so events will be created and all of those servers will be reading those events So eventually all those Rings will be consistent but it might be a case where out of the four servers available one the server is down and that information is not there in one of the Rings okay that can happen but with RIS we can have the eventual consisten consistency if the requirement is to do that we can Implement using the redis similarly we can implement this using the Kafka as well where rather than using the redis with a pub sub model we can have this Kafka topic created where we can have the producer consumer model where all of those servers will be a producer as well and a consumer as well where all of those ad nodes and remove nodes request will be handled as Kafka is also distributed it can handle multiple servers to make sure that all of those servers have the latest data available this also is an eventual consistency so whenever there is an eventual consistency requirement we can use this but it will make sure that you do not have a single point of failure and you have your ring distributed across your multiple systems so another way is to implement using the gossip protocol so what gossip protocol will do is suppose you have this consistent ring okay and within this cons assistant ring Let's see we have servers available so it's server one server 2 server 3 and server 4 okay now in Gossip protocol what will happen is every server will try to gossip with each other okay so it's like okay and this gossip and for gossiping everyone will be elected randomly so suppose this one is selected S4 okay so S1 will try to gossip with someone else so suppose S1 will try to gossip with S2 okay that okay what is your latest update on the consistent ring so S2 will say that okay I have four servers available as for said oh I only have three servers available so what it will do is as it has the latest data available with the latest time s we can have this algorithm implemented in any way that how to handle that so as S4 understood that okay there is some latest data available which I do not have then it will pull those data and it will create so it will pull those data and it will create the new ring for them okay similarly it will try to connect with someone else as well and someone else will try to connect with someone else so they will keep on gossiping with each other and eventually everyone will have the latest consistent drink available now this particular approach is self-healing approach as you can see that everyone is trying to reach to everyone else and it's trying to get the latest information but the only drawback of this is it's very slow because we won't be able to understand like suppose if all the servers are down if only S2 has the latest information and if S3 is trying to connect to S1 S3 is trying to connect to S4 S4 is trying to connect to S1 but no one has yet connected to S2 right so the latest information will not be available right so that's why it is a very slow conversion system so we will not be able to get the latest information very quickly similar to what we get in Kafka and redish model but this is a self filling algorithm where a chattiness will be created between all the servers and we will get the consistency the next one we can use is using the Zookeeper So within the Zookeeper what we can do is as we know that the role of Zookeeper is to make sure that to manage all the different servers for Kafka also we have seen that Kafka also uses zookeeper to maintain all those servers because of its leader election capabilities so what zookeeper will do is Zookeeper will select an leader and based on that leader it will try to give the information to all the different nodes connected to it so if I have five servers so every time a different leader is elected and it will emit the data to rest of the servers to make sure that all of data is updated so this is how the so this is how the continuous leader election and the data transmitted to all the nodes will be happening so all of those servers will have a strong consistency between all the different nodes so if you have the requirement about a strong consistency Within your system at the time you can use this consistent hashing with zookeeper implementation okay so that's how the different ways that you can Implement and what are the different advantages of using zookeeper or using a red dis based or a chatty algorithm I will show you how you can do using the cfan redish so if you go to the code here right I have created a similar folder structure here you can see that I I've created redish and if you see within the redish what I have done is I have just created a ready source which will have a publish And subscribe methods there so it will be able to publish And subscribe but the ideal scenario is you can see that this is my consistent hashing algorithm this is very similar to what we have seen earlier but the only difference here you can see that whenever you are trying to add a node so at the time you add the node what it will do is it will publish the data that okay I have added this particular node and when you remove the node it will also publish the message that okay I have removed the node as well okay so every time there is an update operation happening it will try to publish the event that okay something happened and all of them it will also try to subscribe to those updates okay so you can see that you are also trying to subscribe to that update and trying to always understand that okay it was an add operation or a remove operation if it was a add operation update your ring it was a remove operation update your ring and remove the data as well So eventually you can see that you are emiting the data as well and you're subscribing to the data as well to make sure that your ring is always updated similarly it has been implemented for the Kafka as well where you creating a Kafka topics and based on that Kafka topic you are doing the same operation for updating and deleting the nodes so you can see that how simple it is to implement consistent hashing within your system but how powerful an algorithm it is right you can see that it's been used by many of the companies to make sure that they are able to serve the traffics very evenly throughout the servers so that been it in this video regarding the consistent hashing so make sure that you understand this particular consistent hashing algorithm and you understand how it's been implemented as well this will not be asked within your interview how to implement consistent hashing algorithm but you should know how the internal working is and how that particular thing works so that you have a deeper understanding about how you can tweak it as well based on your requirement within your job profile as well so that's been it if you have liked this video give us a thumbs up and subscri subcribe to my channel for the upcoming videos you can also click on join button to join my channel and support me share this video with your friends and colleagues who wanted to understand about the consistent hashing and who can get help from this kind of videos I'll keep posting new videos regarding the system design and how you can improve your knowledge on system design and Implement a really better system using the scalable thinking so that's been I will see you in the next video till then Happy coding bye-bye