Forem: Aria Azadi Pour

What is the best programming language to start with?

Aria Azadi Pour — Tue, 16 Nov 2021 19:25:29 +0000

Redis Quick Tutorial!

Aria Azadi Pour — Tue, 16 Nov 2021 10:36:27 +0000

In this article, you will learn about Redis and what it does, and how you can use it.

Install Redis

First, you need to install Redis. It is important to practice while learning. If you haven't already Installed Redis you can check out Redis's official download page or you can check out my article on How to install Redis on your OS of choice?. My preferred way of installing/using Redis is via Docker.

Redis, Itself

Redis is a very popular database. It is usually used for caching data and one of its main features is being an in-memory database which makes it very fast and very good for caching which is its main purpose.

Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions, and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.

from redis.io

Redis is a database in the family of key-value databases. That means you can store a value with a key and later on use that key to get the value again.

Redis Commands

Redis has multiple commands that you can use to work with the database. The commands have an overall structure, look at the example below:

> SET user:name "Aria"

In the example at top, we are saving the value "Aria" with the key of "user:name". We will the SET command later but for now, let's focus on the structure of the command that we just called. Look at the structure below:

> ACTION (...arguments)

In Redis, the structure is like what we have shown you at the top. ACTION is the command that we want to call, for example in our first example the SET command that we called is the action that we are asking Redis to take, and then the rest of the detail given to the command are the arguments that Redis uses to do the action that we have asked the database.

So with this knowledge in mind, let's continue our journey.

Basic Redis Commands

In this section, we are going to talk about the basic Redis commands, how we can save a key-value pair, and how to get and delete that value on the database.

Saving key-value pairs

One of the important things that we need to do is to save data on our database. For such action, we can use the SET command. Look at the syntax below:

> SET KEY VALUE

Using this syntax we can save data in our databases. We need to replace the KEY with the chosen key and replace the VALUE with the value that we want to save on the database. Look at the example below:

> SET user:age 17

So let's explain the example at the top. We are saving the value 17 with the key of user:age. Very basic, but very useful and important.

Getting value

After storing the value that we want in the database we need a way to receive the stored data. For this, we can use the GET command. Look at the syntax below:

> GET KEY

Using this syntax we can receive the data stored in the database. We need to replace the KEY with the key that we used when we were saving the value in the database. Look at the example below:

> GET user:age

If you did exactly as I did in the example of saving key-value pairs, you will receive the line bellow in the return of this command:

"17"

See, quite easy to start. Using these commands we can save and receive the values that we need and it will be extremely fast to use this database to work with our data.

Deleting value

Now that we can store and receive the value that we have saved, it's time to take it forward and delete some of the values that we have said. For deleting stored values we use the syntax below:

> DEL KEY

With this syntax, we will be able to delete the unwanted values saved on our database. Look at the example below:

> DEL user:age

If you did exactly as I did in the examples before you will see the result of an (integer) 1, something like below:

(integer) 1

If you try this command again you will receive an (integer) 0, meaning that the key that you have given to the command doesn't exist. The result will be something like below:

(integer) 0

Getting non-existing value

When you delete a value or never create one with the key that you what to receive value with, you will get a nil value in return for your GET command. Look at the example below:

> GET user:age

If you continued every step that I took, you will not have anything stored with the key of user:age and you will receive nil in the result. It will be something like below:

(nil)

Check value existence

If you want to check if a key holds a value in the database you can use the EXISTS. Look at the syntax below:

> EXISTS user:age

This will return an integer number, 1 or 0, 1 meaning yes, and 0 meaning no.

Let's store a new value in our database:

> SET user:occupation "developer"

Now, let's check if it exists on the database or not:

> EXISTS user:occupation

This will return an (integer) 1 in a result like below:

(integer) 1

Now let's check if the record that we have deleted on the database, exists or not:

> Exists user:age

This will return an (integer) 0, which means the record doesn't exist on the database. See the result below:

(integer) 0

Now we know the basics of a Redis database and already we can do a lot with our knowledge but let's take it forward in the next sections.

Working With Numbers

In this section, we are going to cover a couple of commands to work with numbers in Redis. It's important to keep in mind that Redis doesn't save numbers and integers or floating points in the database and instead saves them as string, but if you use these commands on the string that are numbers it will work perfectly without any problems.

For this section, let's create a record to save the number of user's devices:

> SET user:devices 2

Increasing and Decreasing numbers by 1

Redis has two commands that help us increase or decrease numbers by one, the INCR command is used to increase a number by one and the DECR command is used to decrease a number by one. Look at the syntax for increasing a number:

> INCR KEY

And look at the syntax for decreasing a number:

> DECR KEY

As you can see it is pretty clear and easy to work with these commands. When you call these commands it will return the new integer value. Look at the example below:

> INCR user:devices

This will increase the value stored at user:devices by one and return the new value which in our case is (integer) 3. It will return the line below:

(integer) 3

Now let's see an example of decreasing the number by one. Look at the example below:

> DECR user:devices

This will also return the new value just like the increasing command. It will return the line below:

(integer) 2

Increasing and Decreasing number by value of choice

Other than increasing and decreasing numbers by one we also can increase and decrease it with any value that we choose. There are two commands to do these actions, INCRBY and DECRBY. Look at the syntax for INCRBY:

> INCRBY KEY INCREMENT

And look at the syntax below for DECRBY:

> DECRBY KEY DECREMENT

In these syntaxes, the KEY is the key that we used to store the value like always and the INCREMENT and the DECREMENT should be replaced by the values that we want to use. Loot at the example below:

> INCRBY user:devices 2

In this example, we are increasing the value stored by 2 and as the commands that we talked about before this command also return the new stored value, like below:

(integer) 4

And the same goes for the example below:

> DECRBY user:devices 2

In this example we are decreasing the value stored by 2 and same as before it will return the new value like below:

(integer) 2

Errors in working with numbers

There can be some errors accrued while working with numbers that are important to keep in mind. In this part we are going to talk about some of the most problems accrued in this area and then talk about how numbers work more in detail.

Non-integer values

There can be many times which you accidentally or unknowingly use these commands on non-integer values. It is important to note that you can only use these commands on integers and you can't use them even on floating points.

Let's see this in practice. Now I'm going to store a new record in the database for the user's amount of money in the wallet:

> SET user:wallet 7.89

Now let's try to increase it using the INCR command:

> INCR user:wallet

If you try to take this action you will face the error below:

(error) ERR value is not an integer or out of range

This error means that these actions can not be taken on the value stored with the provided key.

Out of range integers

As you see in the error accrued on incrementing non-integers, it said the value is either not an integer or out of range. Redis numbers work on a 64 bit signed integer system, so when you want to work with a number out of this system Redis will return an error.

Let's see this in action. First, we are going to store a new value in the database for the user's ID that exceeds the limit of a 64 bit signed system:

> SET user:id "12345678912345678901"

The value that we have saved is clearly out of the 64 bit signed number system. Now let's try to increase the number using the INCR command:

> INCR user:id

Using this command on this record in the database will return the familiar error that we saw in the past like below:

(error) ERR value is not an integer or out of range

This time this error accrued because the number was too big for Redis to process and It is important to keep this note in mind and don't use increment and decrement commands for potentially big numbers.

Expiration

As I said Redis is used a lot for caching And if you know a little bit about caching you are aware that the data that has been cached is not there to stay forever and at some point, we want to get rid of it and set a new value or recalculate it or many other actions. We can easily automate such actions by setting an expiration date and time for the record that we want to save and that can be helpful for many developers and make their work easier with implementing many functionalities that if Redis didn't have it, it would take such a long time to implement a high-quality system like this.

Setting an expiration date

There are two ways to set an expiration date. One, setting it while storing data at Redis database, and two, setting expiration date after the record is stored in the database.

Setting expiration date while storing the record

First, let's talk about the first way. This isn't much different from how we stored the records before we just need to pass two more arguments to the SET command. Look at the syntax below:

> SET KEY VALUE EX SECONDS

In the syntax shown at the top, the KEY and the VALUE is like before and we just need to add an EX at the end of our command and then put the expiration time in seconds in place SECONDS. Look at the example below:

> SET user:age 17 EX 2592000

In this example, we are storing 17 with the key of user:age and setting the expiration time in 2592000 seconds from now which is the equivalent of 30 days from now. So after 39 days, this record will no longer exist on the database.

Note: Keep in mind you can use PX instead of EX in order to use milliseconds instead of seconds.

Setting expiration date after storing the record

After we stored the data there is still a way to put the expiration date for the record. We can use the EXPIRE command to take such action. Look at the syntax below:

> EXPIRE KEY SECONDS

In this syntax, we need to replace the KEY with the key that we used to store our data, and then we can replace the SECONDS with the number of seconds that we want Redis to wait before removing the record from the database. Look at the example below:

> EXPIRE user:age 2592000

If you did what we did before and stored a value with the user:age and expiration date of 2592000 seconds, This will just set the expiration date again. That means 30 days from when you called the command.

Checking remaining of expiration date

If you need to check how much time is left for the record to expire, you can use the TTL command. This command will return the number of seconds left before the record expiration. Look at the syntax below:

> TTL KEY

In this syntax, we just need to use the key that we use to store the record and then we can get the remaining Seconds left to expire. Look at the example below:

> TTL user:age

In this example, Redis will return the time left to expire for the record with the key of user:age. The return line will be something like below:

(integer) 2591685

Note that depending on when you called the first command and when you called this command, you will receive different results.

One of the questions that you might have now is what happens when we call the TTL command on a record that doesn't have an expiration date. Well, the answer is simple it will just return an (integer) -1 to indicate that this record doesn't have an expiration date. The return line will be something like below:

(integer) -1

Removing expiration date

One of the other actions that you might what to take after putting an expiration date on a record, is to remove the expiration date if necessary. Well, we can do that using the Persist command. This command will help us remove the expiration date. Look at the syntax below:

> PERSIST KEY

All you have to do to remove a record's expiration date is to use its key instead of KEY and you will have its expiration date removed. Look at the example below:

> PERSIST user:age

This example will remove the expiration date of the record with the key of user:age and if we call the TTL command on this record, we will receive an (integer) -1.

Note: Keep in mind you can use PEXPIRE and PTTL commands instead of EXPIRE and TTL commands in order to use milliseconds instead of seconds.

Lists

In this section, we are going to talk about one of the more advanced data structures in Redis. Everything that we have talked about until this point was just string. Even the numbers that we talked about at the end of the day are saved as strings inside the database. So we are going to learn how we can use Lists inside Redis with a couple of simple commands.

Storing lists and adding item to lists

Storing a list in a Redis database is somewhat different from what you might expect. To start it doesn't happen with the SET command and you need to use another set of commands to work with lists.

To add an Item to the list or create a list, We use RPUSH and LPUSH commands. The RPUSH command adds one or more items from right to our list and the LPUSH command adds one or more items from left to our list. Look at the syntaxes below:

> LPUSH KEY VALUE (...VALUE)
> RPUSH KEY VALUE (...VALUE)

As always KEY is the key that we use the save the record on the database and VALUE is the value that we want to add to the list. It is important to keep in mind you can add more than one value with one command and that is why we have the (...VALUE) to represent unnecessary more than one value. Look at the example below:

> LPUSH user:languages "English" "Persian" "Kurdish"

In this example, we are creating a new record with the type of list and key of user:languages and adding English, Persian, and Kurdish to the list. If we want to add more we can just use this command again and add more items to the list. Look at the example below:

> RPUSH user:languages "Arabic"

In the example above, using the RPUSH command we are pushing a new item to the right of the list with the key of user:languages.

These commands will return an integer in the result that indicates the length of our list. For example, this was the return line of the last command:

(integer) 4

Another important point to make is that when we use RPUSH and LPUSH commands with multiple items, it won't take the items we gave to them and put them directly inside the right or left of the list. It will go one by one over our items and take the actions on them. This means when we called LPUSH user:languages "English" "Persian" "Kurdish", first "English" was pushed to the left side then "Persian" was pushed to the left, and finally "Kurdish" was pushed to the left of our list, which makes "Kurdish" the first item of our list from left and "English" the last item of our list from left.

Getting stored lists

While working with a list we are going to deal with list indexes. The index of each list starts from left with the number of 0 and as we move on the items, the number of the index increases each item that we pass. In Redis, if we want to get items index from right we use negative integers. That means the first index from the right is -1 because we don't have negative or positive 0 and it's just 0. If you are confused, the image below might help you a lot.

So with this indexing system in mind let's explain the next command that helps us get items inside a list. To get items inside a list, we can use LRANGE. The LRANGE command helps us get items that are between two indexes. Look at the syntax of this command:

> LRANGE KEY START STOP

At this point I expect you to know what the KEY argument is. So with that in mind let's explain the two remaining arguments. First, let's talk about the START argument, this argument determines the index of the first item in the list that Redis should return for us. Now let's talk about the STOP argument, this argument determines the index of the last item in the list that Redis should return for us, and this command together will provide Redis with a range of items that should return in response for us. Let's take a look at this example:

> LRANGE user:languages 0 -1

This example will return every item in the list for us because 0 is the first index in the list and -1 is the last index in the list. The results should be something like below:

1) "Kurdish"
2) "Persian"
3) "English"
4) "Arabic"

Removing items from lists

Now that we can store and receive items from our list, it's time to find out how we can remove items from our list. There are two commands to remove the items from our list, RPOP and LPOP. These two commands will help us pop(remove) an item from the left or right of the list. Look at the syntaxes below:

> RPOP KEY
> LPOP KEY

The RPOP command will remove an item from the right of our list and the LPOP command will remove an item from the left of our list. All we need to do is provide Redis with the list's key. Look at the example below:

> RPOP user:languages

This will remove an item from the end of the list and return the removed item. The return line for the example that we just showed, would be something like below:

"Arabic"

List length

One last command for working with lists that we will cover in this article is the LLEN command. This command will help us get the length of our list. Look at the syntax below:

> LLEN KEY

Using this simple command we will get the length of the list with the provided key. Look at the example below:

> LLEN user:languages

This command will return an integer number showing the length of our list. The result will be something like below:

(integer) 3

Sets

In this section, we are going to talk about another advanced data structure in Redis world, Set. Set is a collection just like list. Sets aren't ordered, which means there is no index when working with sets. Another important feature is the uniqueness of each item and there can't be multiple equal items in one set, unlike lists.

Storing sets and add members to sets

Just like lists, there are no initial declarations for sets, and adding the first member to the set will automatically create the set. In order to add a member to a set, we use the SADD command. Look at the syntax below:

> SADD KEY MEMBER (...MEMBER)

As we have seen in working with lists, this is a very familiar syntax. We can add one or multiple members to a set using this syntax. Look at the example below:

> SADD user:skills "redis"

In this example, we are creating a new set with one member. This command will return the new length of the set. For example in this case the return line will look like below:

(integer) 1

Removing members from sets

Now we can move on to how we can remove members from a set. This action can be taken using the SREM command. Look at the syntax below:

> SREM KEY MEMBER (...MEMBER)

Using this syntax you can remove one or multiple members of a set associated with the provided key. Look at the example below:

> SREM user:skills "redis"

In this example, we are removing "redis" from the set with the key of user:skills. The result of this action will be either an integer 1 or an integer 0. 1 meaning the "redis" was a member of the set and 0 meaning that it wasn't a member of the set.

Checking if a value is member of a set

We can also check if a value is a member of a set using the SISMEMBER command. Look at the syntax below:

> SISMEMBER KEY MEMBER

Using this syntax we can check for the existence of one member in the set. Loot at the example below:

> SISMEMBER user:skills "redis"

This action will check if "redis" is a member of user:skills. This will return an integer number, 1 meaning value is member of the set and 0 meaning value is not a member of the set.

Getting members of a set

Getting members of a set is the last part that we are going to cover related to sets. To get members, we use the SMEMBERS command. Look at the syntax below:

> SMEMBERS KEY

As you see all we need to provide Redis is the key associated with our record and then we can get all the members of a set. To test this, first let's add some members to our set using the command below:

> SADD user:skills "redis" "express" "react"

Now let's test our new command:

> SMEMBERS user:skills

As we said before this will return all the members of this set. The return line will look something like the below:

1) "react"
2) "redis"
3) "express"

Sorted sets

This is one of the newest Redis data structures. We are going to talk a little bit about it to just introduce you to the data structure because this is a quick tutorial and it has already become a very long article. A sorted set is just like the normal set with only one difference, each member is associated with a score when you are creating it and that allows Redis to sort it. We aren't going to cover any commands but you can checkout the documents on the Redis's official website.

Hashes

The last data structure that we are going to cover is hashes. Hashes are maps with string keys and string values and they are the perfect data type to represent objects.

Storing fields

Just like the lists and sets, hashes also doesn't have any form of declaration and by storing the first field you have already created the hash. To create a field, we use the HSET command. Look at the syntax below:

> HSET KEY FIELD VALUE

Using this syntax we can create a field on a hash. Now let's try to recreate our user's model using hashes. Look at the example below:

> HSET user name "Aria"

In this example, we are creating a field named name on the hash with the key of user.

Receive data from hashes

There are two ways to receive data from hashes. One, getting data of all of the fields at once, and two, getting data of each field alone.

Let's talk about the first way. In order to get every field of a hash, we can use the HGETALL command. Look at the syntax below:

> HGETALL KEY

Using this syntax we can get all of the hash's fields and values. It will represent the data in a special way. Let's see this in action:

> HGETALL user

In this example, we are getting every field and value on the hash with the key of user. Redis returns the data in a list. The odd indexes are fields and the even indexes are values of that fields. Take a look at the return line of this command:

1) "name"
2) "Aria"

In here "name" is the field and "Aria" is the value. If we had more fields it would continue with the same pattern.

Deleting fields

We are also able to delete each field instead of deleting the hash altogether. To delete a field we use the HDEL command. Look at the syntax below:

> HDEL KEY FIELD (...FIELD)

Here we need to provide the key of the hash and the name of the fields that we want to remove. Look at the example below:

> HDEL user name

In here we are removing the field name from the hash with the key of user. This action as always will return an integer number to indicate if the field or fields existed on the hash or not.

Final Words

There are many more commands to work with Redis especially with hashes and sorted sets and there is much more than you can explore and learn. This was just a short article to take you to a certain level to make you able to work better with Redis. Continue your journey with Redis. One of the best sources is Redis's official website that I highly recommend for you to check out and see its documents. Have a good journey.

Resources

Huge thanks to the Try Redis website that has helped a lot with the order of this tutorial.

Find Me

@AriaAzadiPour on Twitter

JavaScript use-cases and most popular technologies used with JavaScript

Aria Azadi Pour — Thu, 11 Nov 2021 23:36:09 +0000

JavaScript is one of the most loved and used languages in the development industry. JavaScript came to life at Netscape, Netscape was the creator of the Netscape navigator one of the most popular browsers of the 90s. Netscape came to the conclusion that they need to make some technology that helps developers to create a dynamic website and since they had 90% of the market share at the time, it became the industry standard.

At the start, JavaScript was only used for web development but as time passed and the v8 engine came to life and the rise of Node.js, JavaScript was no longer a language that was only used for web development and became popular for many other use-cases too.

In this article, I'm going to talk about some of the areas that JavaScript is used for and the most popular technologies that are used in those areas.

Use Case

Front-end Development
Back-end Development
CLI Development
Mobile Application Development
Desktop Application Development
Game Development
AI and Data Science
IoT and Robotics
Smart Watch Application Development

Front-end Development

JavaScript's main purpose when it was created was to give the developers more ability to create more dynamic websites. Since then JavaScript has been on a wild journey to become where it is now and at one point was even considered near extinction. JavaScript was revived in 2009 with the comeback of ECMAScript and since then the open-source community has done a lot for JavaScript and brought popularity to the JavaScript world.

One of the important eras for JavaScript was the rise of JavaScript front-end frameworks by the creation of frameworks like AngularJS and Ember.js. Then the community started to pay more attention to the frameworks and a lot of new frameworks were created by big and small companies and sometimes a group of independent people. The top frameworks used these days are React from Facebook, Angular from Google, and Vue from the open-source community. A lot of new frameworks have come to life in recent years too, like Svelte and GatsbyJS.

Back-end Development

JavaScript is also a very popular language to create back-end applications. It first came to life when Ryan Rahl created the Node.js runtime environment. Node.js rise boosts the rise and popularity of JavaScript in every development industry. Node.js main purpose was to help developers use JavaScript not just for the front-end but for the back-end too.

JavaScript is used a lot in back-end development not just by small companies and independent developers but also by big companies like Netflix, Uber, PayPal, and LinkedIn. It is important to note that open-source communities have a big role in most popular node.js frameworks and they are mostly created without any overlook from big companies. Some of the most popular node.js frameworks are Express, Koa, Fastify, and Nest.

It is important to note that Ryan Dahl, later on, left the node.js project to create a better runtime environment for JavaScript and named it Deno. Some of the most popular Deno frameworks to create back-end applications are Oak, Servest, and Drash.

CLI Development

You can use both Node.js and Deno to create CLI applications and publish them to the world. It is just like starting your applications and passing some extra arguments while starting and you can then use your applications as CLI applications. Some of the most popular CLI tools in node.js are Commander and Yargs.

Mobile Application Development

One of the other areas in that JavaScript is very popular is in the mobile app development sector. JavaScript has too popular mobile app development technologies, React Native and Ionic. One of the biggest companies using JavaScript to create their mobile apps is Facebook. Facebook is the creator of React Native and the technology is used in wide categories of Facebook apps.

But React Native and Ionic are not the only technologies that you can use to create mobile applications using JavaScript. Another very popular technology that is wildly used around the community is progressive web applications or for short PWA. PWA is a technology introduced by Google that can help you turn your website into a mobile application in a couple of steps. All of the lite versions of your popular applications are built by PWA which is basically improving your website to be a better mobile application.

Desktop Application Development

You can use JavaScript to create desktop applications. One of the most popular technologies to create desktop applications is Electron. Electron uses a headless browser to create a desktop application that lets developers use HTML, CSS, and JavaScript to create the desktop application and because of this Electron is very popular among front-end developers. But there are drawbacks to this solution too which is a lower performance application that doesn't bother users too much you can be using one of the applications currently without even knowing it is created by Electron. Some of the most popular apps created using electron are Visual Studio Code, WhatsApp, InVission, Figma, and Discord.

Electron is not the only technology that is used to create a desktop application using JavaScript. You can also create desktop applications using React Native and Ionic. You can use React Native to create Windows applications only, but Ionic can create applications for Linux and macOS too.

Also, keep in mind that the PWA technology isn't only used for mobile applications and you can also create website applications with it and it is very popular and used by many big websites like Google Services.

Game Development

This is the area that I have the least experience but I have worked with some 3d engine libraries and I can give you some details. JavaScript is not just used in the game development sector but it is somewhat popular and it is becoming more popular every. Creating 2d games is very easy and JavaScript has built-in functions to help you create 2d games using just plain JavaScript.

JavaScript also has many third-party engines that can help you create games. Some of the most popular libraries are Three.js and PixiJS. Today you can see the rise of 3d engines everywhere in JavaScript, not just to create more games but to create more appealing websites.

AI and Data Science

JavaScript is becoming more and more popular in AI and Data Science sector because the need for a way to use data science and AI in the front-end and back-end is getting bigger and bigger. Working with charts in the front-end and creating artificial intelligence that helps work with data in the back-end is the need of many companies so this sector is really popular. Some of the best libraries in the data science sector are D3.js, Chart.js, and Plotly.js, and TensorFlow.js, Brain.js, and Ma.js are some of the most popular AI libraries in JavaScript.

IoT and Robotics

JavaScript can also be used for Robotics and IoT. This area is really not centralized currently and there aren't any clear winners for the best libraries and frameworks to be used. But I have seen the rise of many platforms in the past years and it is becoming slightly more popular.

Smart Watch Application Development

JavaScript doesn't stop at Mobile and Desktop applications you can also use JavaScript to create Smart Watch applications. Well, I would say this is the most popular one on the list but it is still possible. Bangle.js is one of the most popular platforms to create apps using JavaScript for Smart Watches but also many watches support PWA technology.

Conclusion

You can use JavaScript to use in many sectors that you might be interested in like any other big language. Each language is good in something but that doesn't stop it from being able to work in other sectors too. You should choose your initial career based on your interest in the language and the sector.

Find Me

@AriaAzadiPour on Twitter

Use gRPC with Node.js and Typescript

Aria Azadi Pour — Fri, 08 Oct 2021 04:29:34 +0000

gRPC is a modern open-source high-performance Remote Procedure Call (RPC) framework that can run in any environment. And in this article, I am going to teach you how you can use gRPC to create high-performance RPC apps using node.js and typescript.

What is gRPC?

gRPC is a technology developed at Google in 2015. It is an RPC framework that will help you create RPC applications in many of your favorite languages. If you don't know what RPC is don't worry I'm going to explain it soon. This technology is used by google itself too. It is used quite a lot with microservice structures. according to Evaluating Performance of REST vs. gRPC from Ruwan Fernando gRPC is roughly 7 times faster than REST when receiving data and roughly 10 times faster than REST when sending data in the case he tested.

What is RPC?

RPC is when a computer calls a procedure to execute in another address space. It is like calling another program to run action as it was ran on your computer and because of this, the request can be so much faster than REST.

Now lets go and create a simple application for sending hello messages.

Setup Project.

1- Initialize your project:

mkdir grpc-starter
cd grpc-starter
npm init -y

2- Initialize typescript with your favorite config:

tsc init

I use the following as my typescript configuration in the tsconfig.json file. you can use whatever matches your need the best

{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "lib": [
      "es6"
    ],
    "allowJs": true,
    "outDir": "build",
    "rootDir": "src",
    "strict": true,
    "noImplicitAny": true,
    "esModuleInterop": true,
    "resolveJsonModule": true
  }
}

3- create the folder structure:

/proto: proto buffers folder(I will explain more later)
/src: the source directory
/src/server: server directory
/src/client: client directory
/src/proto: auto generated code from proto buffers

grpc-starter/
├── proto/
└── src/
    ├── client/
    ├── proto/
    └── server/

There are two ways to work with proto buffers and code generation in gRPC; dynamic or static. In static, we will generate types and code from our proto buffers but in dynamic we will not generate any typings from proto buffers and will use the code instead. dynamic can be a pretty good option if we were using JavaScript but since we need the typings to make our work easier while using TypeScript we will use the static way.

Create Proto Buffers

Proto Buffers are a way to serialize data. You may be very familiar with some other serialization languages like JSON and XML. Proto Buffers are just like them and it is developed by Google and wildly used with gRPC. In this article I'm not going to talk more about them, that's for another article.

First, we need to create the language enum. Well, you need to know a bit about folder structure in proto buffers we will create the language enum in /proto/com/language/v1/language.proto this is a package style folder structure that is necessary while using proto buffers with gRPC.

// /proto/com/language/v1/language.proto
syntax = "proto3";

package com.language.v1;

message Language {
  enum Code {
    CODE_UNSPECIFIED = 0;
    CODE_EN = 1;
    CODE_FA = 2;
  }
}

Now we have to create our hello service in /proto/services/hello/v1/hello_service.proto.

// /proto/services/hello/v1/hello_service.proto
syntax = "proto3";

import "com/language/v1/language.proto";

package services.hello.v1;

service HelloService {
  rpc Greet(GreetRequest) returns (GreetResponse) {}
}

message GreetRequest {
  string name = 1;
  com.language.v1.Language.Code language_code = 2;
}

message GreetResponse {
  string greeting = 1;
  reserved "language_code";
  reserved 2;
}

Buf

We will use a tool call Buf that will make code generation way easier for us. Check out the installation page to understand how you can install Buf.

Now we need to generate our buf config file at /proto/buf.yaml

# /proto/buf.yaml
version: v1beta1
build:
  roots:
    - .
lint:
  use:
    - DEFAULT
breaking:
  use:
    - WIRE_JSON

The v1 directory that we have in our folder structure is because of the linting setting that we are using you can default the linting setting and use a different folder structure if you wish. The linting structure has also affected some of my code that you can check in Buf Docs.

Now you can run the commands below in /proto directory to check your code:

$ buf ls-files
com\language\v1\language.proto
services\hello\v1\hello_service.proto

You can check your code for linting errors too. And if your proto buffers don't have any problem the command will return empty:

$ buf lint

If you have used the code provided by me and your buf version is 1.0.0-rc1 your lint command should return no error.

Generating code

Well for code generation you can use protoc as it's the more popular tool but working with protoc is exhausting so we are going to use buf.

Now you need to generate the buf generation config at /proto/buf.gen.yaml:

# /proto/buf.gen.yaml
version: v1beta1
plugins:
  - name: js
    out: ../src/proto
    opt: import_style=commonjs,binary
  - name: grpc
    out: ../src/proto
    opt: grpc_js
    path: grpc_tools_node_protoc_plugin
  - name: ts
    out: ../src/proto
    opt: grpc_js

Now you have to install grpc-tools and grpc_tools_node_protoc_ts using npm or yarn. These two package will help us generate code for TypeScript using buf:

$ npm i -D grpc-tools grpc_tools_node_protoc_ts
or
$ yarn add -D grpc-tools grpc_tools_node_protoc_ts

Now you need to run the generate command inside /proto directory to generate code from proto buffers:

$ buf generate

Implement the server

First thing we need to do is to add the gRPC package to create our server:

$ npm i @grpc/grpc-js
or
$ yarn add @grpc/grpc-js

Now create the /src/server/index.ts file and start the gRPC using the code below:

import {
    Server,
    ServerCredentials,
} from '@grpc/grpc-js';
const server = new Server();

server.bindAsync('0.0.0.0:4000', ServerCredentials.createInsecure(), () => {
    server.start();

    console.log('server is running on 0.0.0.0:4000');
});

Using this code we can create a new server and bind it to 0.0.0.0:4000 which is like starting an express server at port 4000.

Now we can take advantage of our statically generated code to create a typed Greet handler like below:

import {
    ServerUnaryCall,
    sendUnaryData,
    Server,
    ServerCredentials,
} from '@grpc/grpc-js';

import {Language} from '../proto/com/language/v1/language_pb';
import {
    GreetRequest,
    GreetResponse,
} from '../proto/services/hello/v1/hello_service_pb';

const greet = (
    call: ServerUnaryCall<GreetRequest, GreetResponse>,
    callback: sendUnaryData<GreetResponse>
) => {
    const response = new GreetResponse();

    switch (call.request.getLanguageCode()) {
        case Language.Code.CODE_FA:
            response.setGreeting(`سلام، ${call.request.getName()}`);
            break;
        case Language.Code.CODE_UNSPECIFIED:
        case Language.Code.CODE_EN:
        default:
            response.setGreeting(`Hello, ${call.request.getName()}`);
    }

    callback(null, response);
};

...

Now we have to add the service to server:

...

import {HelloServiceService} from '../proto/services/hello/v1/hello_service_grpc_pb';

...

server.addService(HelloServiceService, {greet});

...

At the end your server file should look like something like this:

import {
    ServerUnaryCall,
    sendUnaryData,
    Server,
    ServerCredentials,
} from '@grpc/grpc-js';

import {Language} from '../proto/com/language/v1/language_pb';
import {
    GreetRequest,
    GreetResponse,
} from '../proto/services/hello/v1/hello_service_pb';
import {HelloServiceService} from '../proto/services/hello/v1/hello_service_grpc_pb';

const greet = (
    call: ServerUnaryCall<GreetRequest, GreetResponse>,
    callback: sendUnaryData<GreetResponse>
) => {
    const response = new GreetResponse();

    switch (call.request.getLanguageCode()) {
        case Language.Code.CODE_FA:
            response.setGreeting(`سلام، ${call.request.getName()}`);
            break;
        case Language.Code.CODE_UNSPECIFIED:
        case Language.Code.CODE_EN:
        default:
            response.setGreeting(`Hello, ${call.request.getName()}`);
    }

    callback(null, response);
};

const server = new Server();

server.addService(HelloServiceService, {greet});

server.bindAsync('0.0.0.0:4000', ServerCredentials.createInsecure(), () => {
    server.start();

    console.log('server is running on 0.0.0.0:4000');
});

Now we can add nodemon to run our server and update it on change:

$ npm i nodemon
or
$ yarn add nodemon

And run the following command to start the server:

nodemon src/server/index.ts --watch /src/server

Now that we have our server ready let's go and create our client.

Implement the client

Create the /src/client/index.ts file to start writing the client code.

In the client first we need to connect to our service client using the code below:

import {credentials} from '@grpc/grpc-js';

import {HelloServiceClient} from '../proto/services/hello/v1/hello_service_grpc_pb';

const client = new HelloServiceClient('localhost:4000', credentials.createInsecure());

Now we can create the request and populate it with our values like below:

...

import {Language} from '../proto/com/language/v1/language_pb';
import {GreetRequest} from '../proto/services/hello/v1/hello_service_pb';

...

const request = new GreetRequest();

request.setName('Aria');
request.setLanguageCode(Language.Code.CODE_EN);

At the end you can send the request and receive the response:

...

client.greet(request, (error, response) => {
    if (error) {
        console.error(error);

        process.exit(1);
    }

    console.info(response.getGreeting());
});

Your client file should look like this:

import {credentials} from '@grpc/grpc-js';

import {Language} from '../proto/com/language/v1/language_pb';
import {HelloServiceClient} from '../proto/services/hello/v1/hello_service_grpc_pb';
import {GreetRequest} from '../proto/services/hello/v1/hello_service_pb';

const client = new HelloServiceClient(
    'localhost:4000',
    credentials.createInsecure()
);

const request = new GreetRequest();

request.setName('Aria');
request.setLanguageCode(Language.Code.CODE_EN);

client.greet(request, (error, response) => {
    if (error) {
        console.error(error);

        process.exit(1);
    }

    console.info(response.getGreeting());
});

Run your client using the following command:

$ nodemon src/client/index.ts --watch src/client

Final words

Huge shoutout to Slavo Vojacek for his article on handling the proto buffers for typescript that has helped this article a lot.

You can check out the full repository at my GitHub repo

While gRPC is amazing and super fast but it is not the best practice to use it for freelancing projects and small projects cause it will cost you a lot of time compared to REST but if you are building a dream and you want it to be the best you can have gRPC as an option and think if it is worth the cost.

Resources

Find Me

@AriaAzadiPour on Twitter

How to install Redis on your OS of choice?

Aria Azadi Pour — Thu, 23 Sep 2021 00:45:38 +0000

In this article, I'm going to teach you how you can use the latest version of Redis on your OS(including Windows, Linux-based OS, MacOSX, FreeBSD-based OS) using docker and binaries. We will use three different ways to install and use Redis on your OS.

What is Redis?

Redis is an open-source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions, and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.

How to use Redis on your OS of choice?

I will teach you three ways to install and use Redis on your OS of choice. Keep in mind not all of the methods work for every OS.

Using source code(for Unix-like OS(e.g. MacOSX, Linux-based OS, FreeBSD-based OS))
Using package managers(for Unix-like OS(e.g. MacOSX, Linux-based OS, FreeBSD-based OS))
Using Docker(for every OS that supports Docker)

My preferred method is using Docker, it will work perfectly for every OS and the only thing you need is to install Docker.

I have a complete article on "How to install Redis on Windows?" if you are a Windows consumer that can help you more.

What is Docker?

In 2013, Docker introduced what would become the industry standard for containers. Containers are a standardized unit of software that allows developers to isolate their app from its environment, solving the “it works on my machine” headache. For millions of developers today, Docker is the de facto standard to build and share containerized apps - from desktop, to the cloud. We are building on our unique connected experience from code to cloud for developers and developer teams.

Using source code

You can download the source code from the redis.io website but in this article, I'm going to use wget to download the source for the stable release.

This method only works for Unix-like systems that can run tar and make commands.

If any of these links didn't work just search for Redis's official installation page.

1.First check if you have wget installed on your system:

  wget --version

2.If you don't have wget installed on your system, install it:

CentOS/RHEL/Fedora:
```
$ sudo yum install wget
```
Debian/Ubuntu/Mint:
```
$ sudo apt install wget
```
ArchLinux/Manjaro:
```
$ sudo pacman -S wget
```
openSUSE:
```
$ zypper install wget
```
AlpineLinux:
```
$ sudo apk add wget
```

MacOSX:

# install Homebrew first, then run this command
$ brew install wget

FreeBSD:
```
$ pkg install wget
```

3.Now you need to download the source using wget. I'm going to install the stable release, but if you want any other versions you can check Redis's download page:

  $ wget http://download.redis.io/redis-stable.tar.gz

4.Now you can extract the downloaded files using the tar command:

  $ tar xvzf redis-stable.tar.gz

5.Now enter the directory that is created from extracting the downloaded file:

  $ cd redis-stable

6.Now you need to build the code in order to use it:

  $ make install

If permission was denied, you need to run it as a superuser:

  $ sudo make install

Note that you can just run make and it will build the code to src/ directory and you can run the commands from there.

7.Finally, you can run redis-server and redis-cli to run and use redis in your terminal.

Using package managers

In this method, we are going to use your OS package manager in order to install Redis.

This method only works for Unix-like systems with package managers.

You can install Homebrew for MacOSX to use this method.

1.First, install the Redis package via your package manager:

CentOS/RHEL/Fedora:
```
$ sudo yum install redis
```
Debian/Ubuntu/Mint:
```
$ sudo apt install redis
```
ArchLinux/Manjaro:
```
$ sudo pacman -S redis
```
openSUSE: for different distributions of openSUSE, you can check the official package page.
AlpineLinux:
```
$ sudo apk add redis
```

MacOSX:

# install Homebrew first, then run this command
$ brew install redis

FreeBSD:
```
$ pkg install redis
```

2.Now you have access to redis-server and redis-cli commands.

3.You can also start the redis service on your OS so you don't have to run redis-server to initialize the server and you can have your service running in the background:

Linux:
```
$ systemctl start redis
```
If permission was denied, you need to run it as a superuser:
```
$ sudo systemctl start redis
```
MacOSX:
```
$ brew services start redis
```
FreeBSD:
```
$ service redis start
```

4.Finally, you can stop redis service whenever you don't need it anymore.

Linux:
```
$ systemctl stop redis
```
If permission was denied, you need to run it as a superuser:
```
$ sudo systemctl stop redis
```
MacOSX:
```
$ brew services stop redis
```
FreeBSD:
```
$ service redis stop
```

If you are on a Linux-based system, you can also use the snap store, but I do not recommend it.

Using Docker

In this method, you need to have Docker installed. Docker has pretty good documentation to help you.

1.First, you need to create the Redis container and expose port 6379:

  $ docker container run --name container-name -p 6379:6379 -d redis

docker container run will make docker create and run a new container.

--name flag will specify the name of the container so you can change container-name to your name of choice.

-p flag will tell docker to expose a port from container to computer, in this case, is the Redis default port.

-d flag will start the container in the detach mode so the container won't stop when we close our terminal.

And finally the Redis means use the Redis image.

2.Finally, you can run redis-cli using Docker:

  $ docker container run -it --link container-name:redis --rm redis redis-cli -h redis -p 6379

-it flag will make docker open an interactive instance of the container.

--link flag will link the container we previously created as Redis in this container.

Note that you should change container-name with the name you chose in the first command.

--rm flag will make docker remove the container after we close it. (This is useful cause we will no longer need this container after we ran redis-cli command)

Same as before Redis means use the Redis image.

redis-cli -h redis -p 6379 is the command docker will run for us.

In the redis-cli command -h specifies the host which we set it to redis using --link flag.

And finally in the redis-cli command -p specifies the port which is by default 6379.

Resources

Find Me

@AriaAzadiPour on Twitter

How to install Redis on Windows?

Aria Azadi Pour — Sun, 19 Sep 2021 17:35:23 +0000

In this article I'm going to teach you how you can use the latest version of Redis on windows using WSL or docker. We will use three different ways to install and use Redis on Windows.

What is Redis?

How to use Redis on Windows?

I will teach you three ways to install and use Redis on Windows.

Using WSL(Debian based(eg. Ubuntu)) only
Using WSL and Docker together
Using Docker only

My preferred method is using docker only it will work perfectly and the only thing you need is to install Docker.

What is WSL?

The Windows Subsystem for Linux lets developers run a GNU/Linux environment -- including most command-line tools, utilities, and applications -- directly on Windows, unmodified, without the overhead of a traditional virtual machine or dualboot setup.

You can:

Choose your favorite GNU/Linux distributions from the Microsoft Store.
Run common command-line tools such as grep, sed, awk, or other ELF-64 binaries.
Run Bash shell scripts and GNU/Linux command-line applications including:
- Tools: vim, emacs, tmux
- Languages: NodeJS, Javascript, Python, Ruby, C/C++, C# & F#, Rust, Go, etc.
- Services: SSHD, MySQL, Apache, lighttpd, MongoDB, PostgreSQL.
Install additional software using your own GNU/Linux distribution package manager.
Invoke Windows applications using a Unix-like command-line shell.
Invoke GNU/Linux applications on Windows.

What is Docker?

Using WSL only

In this method, you need to install WSL and a Debian-based OS like Ubuntu on WSL and then open the terminal to start our work. After installing the OS you can follow the process below to start your own redis-server on Windows and use it with redis-cli.

1.As always before installing a new tool we need to update and upgrade our system you can do it with the commands below:



  $ sudo apt update && apt upgrade

2.Then you need to install redis-server package on your subsystem:



  $ sudo apt install redis-server

3.Now you need to start redis-server in order to work with Redis:



  $ sudo service redis-server start

4.Finally you can run redis-cli in order to test and use Redis:



  $ redis-cli

Note that you need to press (CTRL/OPT)+C or use the exit command in order to close the redis-cli.

Redis by default uses port 6379 if the port is not empty the service will not get started.

Redis configuration file is located at /etc/redis/redis.conf if you need to edit any configuration. (you need sudo access in order to read or write the file)

Using WSL and Docker together

In this method like the previous method first, you need to install WSL but you can install your OS of choice, for example, I will use Manjaro in this tutorial. After that, you need to install Docker and enable WSL integration for your OS of choice.

you can enable WSL integration for your OS of choice by opening Docker Desktop and going to Settings>Resources>WSL Integration and from there you can switch on your OS of choice.

1.First you need to create the Redis container and expose port 6379:



  $ docker container run --name container-name -p 6379:6379 -d redis

docker container run will make docker create and run a new container.

--name flag will specify the name of the container so you can change container-name to your name of choice.

-p flag will tell docker to expose a port from container to computer, in this case, is the Redis default port.

-d flag will start the container in the detach mode so the container won't stop when we close our terminal.

2.Then you need to update and upgrade your packages before installing the redis-cli.



  $ sudo apt update && apt upgrade

3.After that you need to install redis-cli using your OS package manager, in my case pacman:



  $ sudo pacman -S redis

note that redis-cli will usually come with another package like redis or redis-server.

note that redis package names can be different in different package managers so if you are using some other OS you can do a google search and find out the name of the package for your OS.

Using Docker only

In this method unlike the other two, you don't have to install WSL and the only thing you have to do is install Docker.

1.First you need to create the Redis container and expose port 6379:



  $ docker container run --name container-name -p 6379:6379 -d redis

docker container run will make docker create and run a new container.

--name flag will specify the name of the container so you can change container-name to your name of choice.

-p flag will tell docker to expose a port from container to computer, in this case, is the Redis default port.

-d flag will start the container in the detach mode so the container won't stop when we close our terminal.

And finally the Redis means use the Redis image.

2.Finally you can run redis-cli using docker:



  $ docker container run -it --link container-name:redis --rm redis redis-cli -h redis -p 6379

-it flag will make docker open an interactive instance of the container.

--link flag will link the container we previously created as Redis in this container.

Note that you should change container-name with the name you chose in the first command.

--rm flag will make docker remove the container after we close it. (This is useful cause we will no longer need this container after we ran redis-cli command)

Same as before Redis means use the Redis image.

redis-cli -h redis -p 6379 is the command docker will run for us.

In the redis-cli command -h specifies the host which we set it to redis using --link flag.

And finally in the redis-cli command -p specifies the port which is by default 6379.

Resources

Find Me

@AriaAzadiPour on Twitter

Specialize your HTML for accessibility and better SEO

Aria Azadi Pour — Sat, 04 Sep 2021 14:32:24 +0000

In this article I'm going to write about difference between semantic-logical(also referred to as logical) and physical-visual(also referred to as physical) HTML tags.
If you are not familiar with these terms don't worry soon you will learn what they mean and how you can use your knowledge to improve your projects.

What are semantic-logical and physical-visual tags?

In HTML there are ways to style a text and there are ways to set the meaning of the text for both browsers, search engines ,and some third-party software.
The difference between styling in HTML and setting the meaning defines semantic-logical and physical-visual tags.
As you may have guessed by the words semantic-logical tags are used to set a meaning for text and physical-visual tags are used to style the text.
Well you may ask what's the difference between styling a text and setting a meaning for a text.
In a very short description setting the meaning will help search engines and software understand what's the text and how important it is and styling the text will define how software should render the text.

Look at the example above.
What you are seeing might fool you in to thinking of there is no difference in using this two tags and the answer is in the look of them in the browsers yes but the  tag will help search engines and third-party software like Jaws for blind people to use lower tone voice for this part.
I hope you understand difference of styling and setting a meaning for text now.

SEO: Should I care?

Well as far as I'm concerned this is not relevant any more and does not have a huge effect of indexing on any of the major search engine like Google, Bing, Yandex ,and Baidu and if you are worried about search engines like DuckDuckGo and Startpage don't worry they all use indexing data of bing and google as far as I'm concerned.

Also Matt Cutts of Google have made a video on Google Search Central that confirms the fact that google makes no difference between semantic-logical and physical-visual tags in indexing of websites.

Does this mean you shouldn't care? well no lots of screen readers still use semantic-logical tags and do not apply the physical-visual styles to the reading process so this is a very good practice for user-experience and like lots of other outdated technologies still many people believe that it have some positive points for your SEO like server-side-rendering.

Some physical-visual tags

 tag:

 tag is used to style the text as bold.
<big> tag:

<big> tag is used to increase the font size.
<blink> tag:

<blink> tag is used to make the text blink.
I know it's weird and probably the most of new generation of developers haven't heard anything about this tag.
This tag isn't a HTML standard.
It was first introduced by Netscape(very old browser but very popular at it's time) and then other browsers implemented the tag too.
At the first it was very fun;
It made background and foreground switch and users loved it but soon developers abused the tag too much and users become frustrated so Netscape dropped the tag at version 6 and soon other browsers stop using the tag too.
 tag:

 tag is used to style text as italic.
<s> tag:

<s> tag is used to put strike over text.
It become deprecated in HTML 4.
 tag:

 tag is used to decrease the font size.
<strike> tag:

<strike> tag is used to put strike over text.
It become deprecated in HTML 4.
 tag:

 tag is used to make text subscript.
 tag:

 tag is used to make text superscript.
<tt> tag:

<tt> tag is used to show text in monospaced typeface.
It become deprecated in HTML 5.
 tag:

 tag is used to put underline under text.
It become deprecated in HTML 4.

Some semantic-logical tags

Well there are lot's of tags introduced in HTML 5 that are used to set meaning for text but they are not subject of this article as we are talking about old concept of semantic-logic and physical-visual tags.
You can find new HTML 5 tags that can help you a lot with meaning in lots of articles but one article that have a good list of this new tags is HTML 5 Document Structure: Elements & Examples.
I hope it will help you.

 tag:

 tag is used to indicate that characters should be emphasized in some form(usually displayed in italics).
 tag:

 tag is used to emphasize characters(usually displayed in bold).
<code> tag:

<code> tag is used to indicate a sample of code(usually displayed in monospaced typeface).
<kbd> tag:

<kbd> tag is used to indicate text that user should enter(usually displayed in monospaced typeface).
<var> tag:

<var> tag is used to indicate a variable(usually displayed in italics).
<cite> tag:

<cite> tag is used to indicate a short quote or citations(usually displayed in italics).

Resources

Find Me

@AriaAzadiPour on Twitter