Forem: Vikram Sahu

What Is Cryptography? And How to Encrypt Data in Postman

Vikram Sahu — Tue, 08 Mar 2022 21:54:59 +0000

With APIs responsible for sending or receiving any sort of information over the internet—from a simple phone call to your bank transactions—today’s increase in internet usage and data sharing means APIs must be aligned with security.

When APIs exchange data over an insecure network, there is a greater chance of that data getting manipulated by a malicious third party. So to make the internet safer and to avoid unnecessary data theft, it is always better to encrypt every piece of information before pushing it to a network.

This is where the concept of cryptography comes in. Cryptography is one of the ways we can keep information secured over an insecure public network. Let’s dive deeper into cryptography, how it works, and how to use crypto encryption with the Postman API Platform.

What is cryptography?

In simple terms, “cryptography” refers to the art of securing sensitive information using mathematical algorithms. These algorithms stop third parties, commonly known as adversaries or hackers, to peep into your data. To avoid unauthorized access to information communicated between authorized parties, cryptography uses encryption and decryption methods. According to American cryptographer and computer security expert Bruce Schneier, cryptography is “the art and science of keeping messages secure.”The cryptography method transforms plain text into encrypted text (aka ciphertext) using the encryption key, and the target receiver can decrypt it using a unique decryption key. This decryption key depends on what type of cryptography algorithm is used by the sender. It’s important to note that encryption algorithms keep the data secure only if the attackers are unaware of your method of encryption or anything else about the key.

Example cryptography workflow

3 types of cryptography

Hash function: Hash functions are the most commonly used cryptography algorithms, in which there is no involvement of any key. In hash functions, plain text is transformed into a fixed-length of value, which is never recovered to its original form.
- The best use of hash functions is password comparison without storing them. The plain text will output the same hash every time whenever a particular function is called.
- Hash functions include MD5, SHA256, RIPEMD160, and more.
Symmetric key encryption: In symmetric cryptography, both sender and receiver share a single key, which they use to encrypt and decrypt. This system is faster and simpler as compared to other encryption types. The only limitation is sharing the key with the recipient over an insecure network. Symmetric encryption is brilliant when data is stored and accessed centrally.
- For example, the password manager encrypts the passwords, which are not sent to anyone and stored on the machine and you’ll only need one key because you are the only one using it.
- Common symmetric encryption algorithms include AES and DES, which we will cover in the later part of this blog post.
Asymmetric key encryption: Asymmetric cryptography uses different keys for encryption and decryption of information. It uses a public key for encryption, but also a private key for decryption of data.
- Common asymmetric encryption algorithms include ECC and RSA.

How to encrypt data in Postman?

Postman allows you to perform different tasks on API requests and test scripts where you might apply encryption—for comparing within the test or authenticating headers—and there are many other possibilities when encryption can be used. To help users work with different options, Postman supports a list ofexternal libraries.

Crypto.js is one of the most requested libraries for encryption and decryption. You can find a list of examples in this crypto.jscollection, which you can start working with by forking to your workspace:

Postman Collections for cryptography algorithms

AES (Advanced Encryption Standard): AES is symmetric cryptography that uses a block cipher. It is used in both software and hardware across the world for encrypting sensitive data. AES uses three block ciphers, which include 128-bits, 192-bites, and 256-bits which are used to encrypt and decrypt data. Code sample for AES encryption:

const Message **=** pm.variables.replaceIn('{{$randomCatchPhrase}}')

const SecretPassphrase **=** pm.variables.replaceIn('{{$randomPassword}}')

var superSecretEncrypted **=** CryptoJS.AES.encrypt(Message, SecretPassphrase);
var noMoreSuperSecret **=** CryptoJS.AES.decrypt(superSecretEncrypted,

console. **log** ("superSecretEncrypted :: " **+** superSecretEncrypted **+**"\n" **+** 
"superSecretDecrypted :: " **+** noMoreSuperSecret);SecretPassphrase);

DES (Data Encryption Standard): DES is also symmetric cryptography, which uses the same key to encrypt and decrypt data. It is considered less secure for powerful attacks, due to which the popularity among others has slightly declined. DES encrypts data in 64-bits, which means that 64-bits plain text input is sent and 64-bits ciphertext output is produced. Similarly, Triple DES can also be used, where the DES encryption is applied three times to each block to increase the key size. Code sample for DES encryption:

const Message **=** pm.variables.replaceIn('{{$randomCatchPhrase}}')
const SecretPassphrase **=** pm.variables.replaceIn('{{$randomPassword}}')

var superSecretEncrypted **=** CryptoJS.DES.encrypt(Message, SecretPassphrase);
var noMoreSuperSecret **=** CryptoJS.DES.decrypt(superSecretEncrypted, SecretPassphrase);

console. **log** ("superSecretEncrypted :: " **+** superSecretEncrypted **+**"\n" **+** 
"superSecretDecrypted :: " **+** noMoreSuperSecret);

MD5 (Message-Digest Algorithm): MD5 is a protocol used for authorizing messages, content, and digital signature verification. It generates a hash that can be used to verification of data or files by sender and receiver. Previously, MD5 was majorly used for encryption of data, but now it’s primarily used for authentication. The algorithm converts data into a string of 32 characters, irrespective of file size. Code sample for MD5 hash:

const Message **=** pm.variables.replaceIn('{{$randomCatchPhrase}}')
//setting up collection variable as MD5hash
var MD5hash **=** CryptoJS.MD5(Message). **toString** ();
console. **log** ("MD5hash :: " **+** MD5hash)

SHA-256 (Secure Hashing Algorithm): SHA-256 is a patented algorithm that is a part of the SHA-2 family. This is a hash function that produces 256-bits long ciphertext. It was a successor for SHA-1 which was losing strength against brute force attacks. Code sample for SHA-256:

var sha256Hash **=**   CryptoJS.SHA256(Message). **toString** ();
console. **log** ("sha256Hash :: " **+** sha256Hash)
const Message **=** pm.variables.replaceIn('{{$randomCatchPhrase}}')

Conclusion

After walking through the cryptography algorithms above, we can see that cryptography is an essential tool for encryption that makes data secure and safe. Ultimately, data stored or transmitted with encryption is much safer than data left unencrypted. There are a lot more cryptography algorithms that can be used for different purposes depending on the use cases, so be sure to explore the complete Encrypt Parameters Using CryptoJS collection to learn more.

The post What Is Cryptography? And How to Encrypt Data in Postman appeared first on Postman Blog.

3 Popular Collaboration Features for Postman Collections

Vikram Sahu — Mon, 14 Feb 2022 18:33:27 +0000

We all know that Postman Collections are one of the most important pillars of the Postman API Platform. They allow you to organize, manage, and document your APIs efficiently, and they act as a central storage where you can save your API requests.

But there are many features attached to a collection that make using Postman user-friendly—and a few of the most popular ones are the move, duplicate, and share features. You can find these functions by hovering over a collection name and clicking the three dots as shown in the screenshot below:

Options for collection activity

Let’s have a look at these three foundational features in detail.

1. Move

The move feature allows you to transfer a collection from one workspace to another. This feature helps you collaborate effectively, especially while working with your team.

Let’s assume you’ve made some changes to the collection on your personal workspace, and now you want to hand over the collection to another member of your team. It becomes super simple to transfer the collection using this functionality.

When moving a collection, there are a few prerequisites:

Roles and permissions: To use the move feature without any restriction, you need to have editor access for the collection.
A collection cannot be moved from the team, private, or public workspaces to personal workspaces.

How to move a collection in Postman

Hover over the collection name, click the three dots ( °°° ) beside the star icon.
Select Move from the list.
Find and select the workspace using the search bar, then click on Move Collection.
Check and confirm the target workspace.

Moving a collection

2. Duplicate

The Duplicate feature is similar to cloning a repository on GitHub. This feature can be used to create a copy of the current version of the collection which is kept untouched, and another can be used to work parallely on your new API features.

How to duplicate a collection in Postman

Hover over the collection name, click the three dots ( °°° ) beside the star icon.
Select Duplicate from the list.

Once you click Duplicate , you can find a new collection with the collection name format of “collection name Copy.” (For example, if the initial collection is ABC , then the copy would be ABC Copy and if duplicating recursively, then the resulting collections would be named ABC Copy 2, ABC Copy 3 , and so on.)

Duplicating a collection

3. Share

Collaboration is a vital part of every team, especially when the team is small and everyone is working on similar priorities. Sharing helps users to collaborate conveniently. You can share a collection via the link or by moving it to a shared private, team, or public workspace.

Workspaces can be shared via the Run in Postman button or JSON link, but we need to make sure that the visibility of the workspace is public.

To share the workspace with people, here are a few prerequisites:

You need to have admin access for the workspace from which you will be using the share functionality, or else you will only be able to share with members who are already in the workspace.
If the collection is in a personal workspace, then you need to change the workspace visibility to the team.
If you have Editor access, you’ll have the ability to give new collaborators Viewer or Editor access to the collection.
If you have Viewer access, you’ll be able to share, but you won’t be able to assign roles.

Sharing features allow you to share in three different ways:

Sharing with people:

Sharing a collection via invite using name, email, or group name

The Run in Postman button:

Sharing a collection via the Run in Postman button

JSON link: A public, shareable link to a static copy of your collection:

Sharing collection via JSON link

For collections—and much more

These are a few easy ways you can start collaborating in Postman. Also, just like with a Postman Collection, you can use the above features with other elements in Postman—including APIs, environments, mocks, and monitors.

WebSockets: A Conceptual Overview

Vikram Sahu — Wed, 18 Aug 2021 03:24:30 +0000

Note: This article is for technical folks ranging from beginner to intermediate level. so if you are already aware of a particular topic, please feel free to check the Table of Content ⏩

✔ Introduction

Real-time communication has taken a great pace in shaping the world of the internet. In the post COVID era, every type of communication has changed, right from sending emails and waiting for your client's response to interacting with them on Slack communities.

This instant messaging, video/audio calls, and other similar technologies have gradually helped us to improve with time management and reduced the overall response time.

These innovations have become possible just because of WebSockets 🔌.

In this article, we will go through some amazing concepts of WebSockets and how APIs are implemented for fluent real-time communication.

✔ Table of Content

Introduction
What is a WebSocket?
Why WebSocket?
Lifecycle of a WebSocket
WebSockets Protocol Overview.
WebSocket APIs
Advantages of WebSockets
Conclusion
Reference

✔ What is a WebSocket?

WebSocket is a transport layer protocol that provides a persistent connection between client and server. This WebSocket operates over a TCP/IP socket connection and provides a full-duplex and bidirectional functionality for the communication.

E.g., Let's assume we want to create a wired connection where two-person want to communicate with each other (ie. A wants to talk with B). Now, to start the conversation it becomes mandatory for one end(A) to have a dial-in number (acts as handshake) for connecting to the other end(B).

Here, once (assuming) A has successfully dialed to B, then a persistent connection will be established between A and B just like a tunnel where the information can flow from both ends.

Messaging applications work the same as the wired connection we discussed above where a connection is created and the sequence of messages is exchanged with great speed.

But wait... ⏳

Can't these messages be sent using REST APIs? Why do developers prefer switching to WebSockets? Is there some issue with REST APIs?

Well, no worries! Let's dig up more and understand why WebSocket was introduced when there were REST APIs?

⬆Back to Top

✔ Why WebSocket?

The API is an HTTP-based technology that allows two applications to communicate with each other. This HTTP-based technology strictly operates over unidirectional protocol. Here, the server makes sure that every response data sent has to be requested from the client.

Now, let's get back to our messaging application where two people chat using APIs. Since HTTP APIs are unidirectional the client and server have to act both respectively and make continuous to and fro connections to get response data (relay messages from A to B and vice versa). These connections are tedious to handle.

To avoid this messy connection, there comes a concept of long polling. This long polling acts as a workaround for the above scenario where a client can send an HTTP request with a long timeout period and the server can keep pushing data back to the client.

Since this is just a workaround, you can expect some drawbacks as well, i.e. long polling works perfectly when the client and server are having continuous data transfer, but the problem arises when there is no data available to send back to the client. The server unnecessarily holds the resources throughout the length of the poll (timeout).

To overcome the above limitation of HTTP-based Technology, *WebSockets was born*.

The resources are unnecessarily tied up to the server throughout the length of the poll in HTTP., On the other hand, WebSocket allows communicating over the network freely. This communication is quite similar to UDP but with the security of TCP.

⬆Back to Top

✔ Lifecycle of a WebSocket

WebSocket follows RFC 6455 - protocol where it asks for an opening handshake followed by a basic message framing, layered over TCP.

Image credits: raywenderlich

WebSockets begin their life cycle by initiating a standard HTTP request and response as shown in the image above. Within this request, the client asks servers to open a web connection. If the server agrees, then an initial handshake is established successfully.

This handshake is a piece of evidence that the client and server have agreed to share the TCP/IP socket for communication as a WebSocket connection. Now the information can flow using basic message framing protocol. To close the socket both ends should acknowledge for turning down the TCP connection.

I hope by this time you might have understood why WebSockets are used instead of REST APIs.

⬆Back to Top

✔ WebSockets Protocol Overview

WebSockets URIs are the same as HTTP URIs but the only difference you can find is the scheme. WebSockets don't use an HTTP/HTTPS scheme; instead it uses ws/wss (web socket secure) to connect with the hosts/endpoints. E.g.

HTTP URIs:



http://domain-name[:port]/resource-path/resource-id
{secured} https://domain-name[:port]/resource-path/resource-id

WebSocket URIs:



ws://domain-name[:port]/resource-path/resource-id
{secured} wss://domain-name[:port]/resource-path/resource-id

To establish a secure WebSocket connection, the HTTP request/response calls need to be upgraded. So, the clients/server both need to support the WebSocket connection and pass a few request headers.



GET ws://localhost2.com:3000/ HTTP/1.1
Host: localhost:8000
Connection: Upgrade
Pragma: no-cache
Upgrade: websocket
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: q3xPeO32u5496gldTuKaSAh==

Let us understand each header that is required to establish a WebSocket connection.

GET ws://localhost2.com:3000/ HTTP/1.1: This is an actual GET call that connects a WebSocket insecurely {ws} having endpoint as localhost2.com:3000 using the first version of the HTTP protocol.
Host: localhost:8000: This is a Host from where the request is initiated. Currently, it is a local machine localhost:8000.
Connection: Upgrade: Connection header manages the opening and closing of network connection after the HTTP call. It is normally set to keep-alive which helps to keep the connection persistent while HTTP calls. Using Upgrade makes sure to keep the connection active and notifies that communication will open for non-HTTP requests only.
Pragma: no-cache: It is a means for the browser to tell the server and any intermediate caches that it wants a fresh version of the resource, not for the server to tell the browser not to cache the resource
Upgrade: websocket: The header is used by the client to ask the server to follow one of the protocols for connection. In this case, the client is asking for a WebSocket connection.
Sec-WebSocket-Version: 13: The WebSocket protocol only accepts the usage of version 13, any other version will be considered invalid here.
Sec-WebSocket-Key: q3xPeO32u5496gldTuKaSAh==: This is one time randomly generated unique key which is 16-byte and base64 encoded.

Once the client has securely established a WebSocket connection, it waits for the server's response which has HTTP 101 Switching Protocols. The server's response headers are shown below.



HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: aGVsbG8gZXZlcnlvbmUg=

The HTTP 101 Switching Protocols response indicates that the server is switching to the protocol that the client requested in its Upgrade request header. In addition, the server must include HTTP headers that validate the connection was successfully upgraded.

⬆Back to Top

✔ WebSocket APIs

WebSocket API allows creating a bidirectional, full-duplex persistent connection that helps two applications to interact with each other fluently.

This can be visualized as a tunnel where data can be sent and received constantly without waiting for each other's response.

✔ Advantages of WebSockets

Bidirectional: In HTTP, the client needs to wait for the server's response after every request, whereas on the other side WebSockets allows the client/server to send and receive real-time updates asynchronously. E.g. stocks dashboard where data is continuously pushed and the graph is plotted against the same.
Low-Latency: WebSockets doesn't create a new connection for every request therefore the network latency is automatically reduced. After the initial handshake, which includes standard HTTP header information, all subsequent messages include only relevant information. This reduction in latency enables lightning-fast communication
Extensible: The WebSocket API supports over
40 subprotocols such as WAMP, XMPP, AMQP, and MQTT, as well as extensions that enable powerful functionality like
multiplexing and data compression.
Secure: The WebSocket Secure (WSS) protocol uses standard SSL and TLS encryption to establish a secure connection
between the client and server. While unsecured WebSockets use TLS port number 80, WSS uses port 443.

⬆Back to Top

✔ Conclusion

In this article, we began with the introduction of WebSockets and learned how WebSockets are used behind the scenes while building Real-time applications to make our life faster and simpler.

Next, we went through some technical concepts of the WebSocket protocol. Also, we compare how WebSockets are different from HTTP-based technology with some real-life examples.

As we end this article, you should have a clear understanding of WebSockets and how they can be used in your future applications.

Please leave your feedback and doubts in the comments below! 😃

✔ Reference

Explaining Bots and Its types - Part 1

Vikram Sahu — Tue, 07 Apr 2020 16:59:46 +0000

Fact: Do you know that a normal person interacts at least 3-4 times a day with a bot? but when? and how? impressive isn't it...
It is also said that in the future a person will interact more with a bot than their spouse.

Let's unfold the truth behind this...

Introduction

In simple words, bots are dumb machines that are programmed to do repetitive tasks, which are automated by a human being to save time. This was the definition that I concluded after working on a few bots.

Bots are coming into existence more and more because of their accuracy, speed and much more similar behavior to humans. if you ask me where I can find a bot? I would reply in just a few words "Everywhere on the web".

The most common bot/type of bot that you can experience right now is
Just unlock your phone and speak:

"Hey, Siri" if you have iPhone.
"Ok, Google" if you have Android.

Similarly, you can find Alexa or Google Home/mini which are also home assistants used for many tasks that a human wants to execute within the house like playing music, asking for news or setting reminders and many more.

The above examples are advance bots that were contributed by Gaint technology leaders, but there are many small bots that developers write for their own convenience, it can be chatbots, a web crawler, social bots, and some malicious bots.

Good Bot vs Bad Bot

This is the section, let's dive deep with nature of bots and how they are helpful to us with our day to day task.

So, Bots are developed to automate various repetitive tasks which turns out to be useful in many ways, but few are developed to harm your resource which is classified into good bots and bad bots.

What is a Good Bot?
- Good bots are built to gain profit for the business. These bots are beneficial for both businesses and individuals. The simple example you can assume is whenever you search for any websites, products or any services, you often get next to accurate results, how?
- This is possible because of search engines spider bot which is also known as crawler bot. Bots like
  - Googlebot
  - Slurp Bot [yahoo]
  - Alexa crawler [Amazon Alexa]
- Reputed companies often deploy this bot by following the rules of the webmaster crawling activity and indexing rate at websites robot.txt.
- Besides from these search engine crawlers, there are many different third party bots like
  - Slack bot. (Any complex integration can be done which can be notified directly on the channel).
  - telegram bot.
  - Pingdom bot. (website monitoring bot)

By this time you might be clear about good bots, so any bot who follow the rules and regulation of webmaster and the policies which result in profit for business are good bots.

What is a Bad Bot?
- As we know Bad is always opposite to Good. These bots are built by hackers, cybercriminals, fraudsters so that they get engaged in illegal activities.
- These bots are programmed for doing malicious jobs on the web.
- Let's take an example, you have a business setup for toys and you have a unique toy that is made by you. your competitor may build a bot that can be a scraper that can collect all the content, product reviews, feedbacks and what new toy you are working on and publish fake reviews on other websites.
- The second example is they travel thousands of visits on your website within the minimum span of time, that chokes the availability for other genuine users.

This bot is highly injurious for brand reputation which results in hampering of search engine website ranking.

Types of Bots

Good Bots are used to gain profit for the business and also helps to build your domain and website health. This bot helps by crawling website for search engine optimization(SEO), Collecting information, obtaining marketing analytics and many more.

Social Network Bots: These bots are managed and supported by social networking sites like Facebook, Twitter. Bots help to give visibility to the brand website and drive engagement to their platforms.
Feedfetcher Bots: These bots are used to collect information from different websites and help to keep subscribers updated with the product, events, and blog posts.
Parter Bots: These bots are third party bots that are developed and supported by the SaaS organization like Slack, PayPal, Stripe and many more. these bots help to integrate directly with the program within the organization.
Monitoring Bots: These bots are programmed in such a way that they periodically monitor and updates us about the uptime and health of the server/websites.
Search Engine Crawlers: These are the most common and maybe most used bots in this modern world. No matter, who you are you need search engines for simplicity and get your work done.

Let's look at few Bad Bots

Scraper Bots:
- These scrapers are used to steal vital information, prices, updates, and content. This will help the competitor to undermine the business strategies which will help them to target the company's revenue.
- Point to remember is that competitor ofter use third-party scrapers to perform this illegal act.
Spam Bots:
- These Spam Bots target community forums, lead collection forms, and comments sections.
- They usually target this section by adding unwanted promotional advertisements, links, and flood up the comment section by trolling users.
- The above activities frustrate genuine users to comment or use the forum's information. The main motive of such bots is to insert the link to phishing pages which are build to collect user critical information which included bank account, username, and passwords.
Scalper Bots:
- These bots target ticketing websites, they purchase 100-1000 of tickets and sell them to third party seller due to which the genuine ticket selling website lose their customers.

Each and every activity of a bot depends on the data it can be a training data or real-time data.

I always recommended not to expose your websites on HTTP instead always use HTTPS or use appropriate protocols to restrict such bots to crawl your website.

Concluding...

In this world of Machines and Artificial intelligence, I always want each and everyone to learn how the bot works and why you need a bot.
If you are keen to learn this new world paradigm, "First decode it" that is what I have discussed above in this blog.

I hope you enjoyed reading! Stay tuned for Part 2 where I will be building a Telegram bot from scratch.

Thank You! Do follow and share 🤗

Ref: shieldsquare

Learning ES6/JavaScript - Part 2

Vikram Sahu — Sun, 29 Mar 2020 15:16:05 +0000

Introduction: Let's revise a bit

An amazing curve of learning is to learn facts and then implement it. I started JavaScript with the curiosity of learning front-end technologies but now it is getting more interesting as I am moving forward with this language.

I started with facts here and now I think its time to dive deep with the basics so that while implementation we are not left out with theoretical questions in mind.

Topics

Everything about Objects.
Unique datatypes.

1. Everything about Objects

Objects are used almost in every programming language, it is used to store the keyed collection of various data and probably the complex entities. The data is store in a key-value structure where the key has to always string or any symbol(special type will discuss below) and value can be anything.

How to create an object?
There are two ways of creating an empty object either using the object constructor or literal.

I will try to explain using an example of a register which as a piece of developer information like their name, age, years of experience and a few more...

let register = new Object{}; //using object constructor syntax. 
// OR
let register = {};   // using object literals syntax.

1.1 Adding, Accessing and deleting

Key = property name.
Value = property value.

In an object, the key and value should be separated using (:)colon while initialization. An object can be added using a (.)dot notation or []square bracket for the multiword key. Let's look at the simplest example for each of the cases.

let register = {
  user:"vikram",
  age:24,
  isAdmin:true,
};

console.log(register); 
// Output: { user: 'vikram', age: 24, isAdmin: true } 

register.experience = 78; // adding data in object

register["university education"] = "Mumbai"; 
/* adding data with the multiword key
you can't access multiword key by (.), you need to access in the same way of addition. 
ie. alert(register["university education"])
*/

delete register.isAdmin; // deleting key

//do check the output and spot the difference.
console.log(register);

I think I don't need to explain the above code. It is a simple and self-explanatory right.

1.2 Property value shorthand

Shorthand is a way of optimizing code and removing complexities. let's learn by using an example:

//before shorthand
function myUser(name,age){
return {
  name:name,
  age:age,
 }
}
let getUser = myUser("vikram",24);
alert(getUser.name);

As you can see the above example becomes complex if the key name conflicts with the argument. so let's see at the shorthand version.

function myUser(name,age){
return {
 name,
 age,
 }
}
let getUser = myUser("vikram",24)
alert(getUser.name)

isn't is simplified? the fact is you can use both the normal property value assignment and shorthand.

1.3 Cloning and Merging

Cloning is creating a copy of an object without affecting the original one. Ya! the copying by reference can be used most of the time instead of cloning. Cloning an object is doable though it is not a built-in function. Let's look at an example:

let register = {
  "name":"vikram",
  "age":24,
}

let clone_register = {}

//copying register properties to clone_register
for (let key in register){
  clone_register[key] = register[key];
}
console.log(clone_register);

Above example is self-explanatory. There is one more way of directly getting clone of an object by using object.assign, you can find syntax in below example.

let newObjectName = Object.assign(dest,[src1,src2,src3....srcN])

Let's learn by building a user access level using the below example

let clone_register = {};
for (let key in register){
  clone_register[key] = register[key];
}

let permission1 = {canView : "true"};
let permission2 = {canRead : "true"};

Object.assign(clone_register, permission1, permission2);
console.log(clone_register);
/* output:
{ user: 'vikram',
  age: 23,
  experience: 78,
  'university education': 'Mumbai',
  canView: 'true',
  canRead: 'true' }
*/

2. Unique datatypes

Javascript is unique in its own way in the previous part you might have seen from interesting datatypes like maps, sets, and iterables like an array, strings, list and few more.

I will mention a few more in this part like

WeakMap and WeakSet.
Destructing assignments.

2.1 WeakMap and WeakSet

WeakMaps:
Let's learn by comparing Map and WeakMap. The very first difference is that WeakMap must have Object as Key, not usual primitive values. Since you will be using an object as a key in it all the other references will be removed automatically and memory will be released.
I know it is confusing, OK let us assume Vikram as key for Map now and sahu as key for WeakMap. When we delete the keys from respective Maps then key Vikram will be removed but memory allocated will not be released but in case of sahu as key in WeakMap, the memory reference to the key will be automatically released.

Example of WeakMap:

let john = { name: "Vikram" };
let weakMap = new WeakMap();
weakMap.set(Vikram, "...");

Vikram = null; // overwrite the reference

// Vikram is removed from memory!

WeakMap has similar methods as compared to Maps like:

weakMap.get(key)         //returns value for the key if exists
weakMap.set(key, value)  //Adds new entry in WeakMaps
weakMap.delete(key)      
weakMap.has(key)

WeakSet
WeakSet is similar to WeakMap.

It is analogous to Set, but you can only add objects to WeakSet and not primitives datatypes.
An object exists in the set while it is reachable from somewhere else.
Like Set, it supports add, has and delete, but not size, keys() and no iterations. Let's take an example where we will add some users as visited website and later will remove the same by redeclaring as null.

let visitedSet = new WeakSet();

let Vikram = { name: "Vikram" };
let Nikhil = { name: "Nikhil" };
let Anish = { name: "Anish" };

visitedSet.add(Vikram); // Vikram visited us
visitedSet.add(Nikhil); // Then Nikhil
visitedSet.add(Vikram); // Vikram again

// visitedSet has 2 users now

// check if Vikram visited?
alert(visitedSet.has(Vikram)); // true

// check if Anish visited?
alert(visitedSet.has(Anish)); // false

Vikram = null;
// visitedSet will be cleaned automatically

2.2 Destructuring assignments

In Javascript, the most used datatype for storing, retrieving and manipulating data are Object or Arrays.

Sometimes, you might just need to pass a single value at a particular index instead of passing the whole object or Array to the function for computing right? here's were destructing assignments comes into the picture.

It is simply assigning the Array to a single variable. Let's make it clear using an example:

let myData = ["Ed","Eed","Eddy","tom And jerry"];

let [pyscho,pyschoFriend,pyschoFriend2,EveryOneFvrt] = myData;

console.log(EveryOneFvrt); //tom And jerry

Isn't it simple? yes, I know it quite easy. Destructing assignments doesn't mean destructive instead it means destructurizes has it assigns the array/object element to variables.

Concluding...

I hope you have enjoyed the above blog. I will be back again with some basics but tricky fun Javascript like proto, getter and setter and few more.

Thank you! Do share 🤗

Simplifying Computational Complexity {time and space}

Vikram Sahu — Thu, 26 Mar 2020 13:56:17 +0000

Introduction

When someone wants to master computer programming, the best way to start is to learn the complexity of the system. Before you start with coding common questions you should ask yourself are:

Why should I write the program in this way only?
What will be the benefit of this program?
How many resources my program will consume?
How fast it will execute?

These questions will help you write efficient code.

Computational complexity is all about the writing optimized, efficient and blazing fast programs/code.

In this blog, you will be going through a few amazing theories of the computer system with examples.

Before learning complexity

Let's learn a bit about an algorithm:

A sequence of logical computation is called as the algorithm of the program. These algorithms are analyzed by calculating their time or space complexity. It is proved that your algorithm will always execute in worst-case complexity or an average-case complexity.

Worst-case complexity: Maximum resource utilized by your algorithm to execute with respect to the number of inputs.
Average-case complexity: Average resource utilized by your algorithm to execute with respect to the number of inputs.

I hope now you are getting a bit of an idea about the complexity theory. Let's dive deep to clear all our doubts...

Topics:

Resources.
Asymptotic complexity.
Computational models.

1. Resources

What are the resources as per you?
You might be thinking Human, keyboard, electricity, CPU, monitor & all the hardware stuff that you need while using your system then that is wrong❌.

The actual resource that I will be talking about is

Time.
Space.

Time complexity

The time complexity of an algorithm is measured irrespective of hardware and software associated with the system. The complexity considers the maximum time required to run an algorithm which is measured in asymptotic notation.

Space complexity

The amount of memory your algorithm requires to run is called space complexity.

Other complexities are arithmetic complexities which depend on the arithmetic computation that has been used in the algorithm and totally depends upon the size of input n.

2. Asymptotic Complexity

It is difficult to describe the compute of an algorithm precisely which falls between the worst-case and the average-case complexity. So in order to calculate the near to accurate complexity, it is always better to keep the input size n as infinity.

These asymptotic complexities are the boundary limits of an algorithm that includes upper bound(big-oh notation), lower bound(big-omega) and the tight bound(big-theta).

If you are pretty confident that your algorithm is good and won't hamper your system computational complexity below is the table of complexities you can assume your algorithm might take.

For analyzing any algorithm, it is recommended to consider the big-oh notation because it helps us to get the idea of the upper limit of the execution time of the algorithm.

I would recommend a 5 minutes read on hackerearth before proceeding further.

3. Computation Models

This is one of the vast topics which can be totally debatable. The model of computation describes how an output of the mathematical expression is computed when input is given. Similarly, the algorithms rely on these mathematical operations. So it is very important to choose the correct model for computation.

Deterministic models: These models are the exact opposite of random. It helps us to predict the exact event that will occur in the future without any involvement of randomness. So if you have some data you can predict the exact outcome with 100% certainty. for example :
- Rolling a fair die.
- Calculating Kelvin using Celsius.
Non-Deterministic models: These models are the opposite of deterministic where you will start with some sort of straightforward events later randomness will be getting added to it. Here you don't have the idea of what will be the future event. Since every time you run you will get a different output. In order to differentiate you can consider the below image.

Quantum computing models: These models follow the rules of quantum mechanics(the fundamental theory of physics describing the properties of nature.) The very famous example of quantum computing is AI(Artificial Intelligent). you can find more examples here

Concluding...

Any algorithm without proper computational logic is just a waste of resources. you can save those resources or use them in a better way by optimizing, building concise code better.

I hope you understood the very basic fundamentals of Complexity. Do share & comment! 🤗

Learning ES6/JavaScript - Part 1

Vikram Sahu — Wed, 25 Mar 2020 15:38:27 +0000

Note: javascript & java both are very different from each other

What is javascript?

Javascript is a programming language that was developed to add life to web pages ie. displaying realtime props by loading pages dynamically.

Anything & everything you are browsing on the internet has javascript in it. Right from googling things to scrolling videos to reading blogs, Even this blog is having Javascript. Isn't it impressive? let's dive deep.

Adding Life to webpages, How?

The HTML (structure) is just a skeleton for your web page and CSS (style) is all about beautifying the web page but what about all the major logical things?

Here comes the JavaScript (behavior) who is responsible for handling each and every behavior of your webpage.

Common Behavior includes :

Action to be taken when the button is clicked.
Pop-ups to notify your user with information.
Scrolling and Animations.
Tracking and capturing data (scrapping).

What is ES6? Is it different from Javascript?

As per Wikipedia, ES or ECMAScript is a scripting language specification that was introduced to standardized Javascript. ES6 is the 6th version of ECMAScript which was released in 2015 which brought some changes to javascript. I will be discussing those changes in this blog which will start from very basics.

Before starting I would recommend you going through basics of Javascript suggested by the Open source guy Ameer

Topics

Declaration and scope: Let vs var vs const
Arrow functions
for..of vs for..in
Spread attributes
Map & Set
Static methods

1. Declaration and scope: Let vs var vs const

Declaring a variable in javascript is all about using one of these. In simple words

Let is a block scope.
var is function scope.
const can be only declared once and its value can't be changed throughout the script.

You can assume that the variable declared with var is defined throughout the program as compared to let. Consider the below example

var b= 40;
if(true){
  let a = 20;
  console.log(a + b); // output:60
}
//console.log("value of a : " + a); 
//if above uncommented "error : *ReferenceError: a is not defined*"
console.log("value of b : " + b); // 40

I think the above block of code is self-explanatory. The scope of let is within the if block and if you try to access the variable outside the block it will throw an error, but var will be accessible throughout the program within the if block and outside also.

Using const:
The difference between const and other variable declaration are const cannot be reassigned. let's consider the below example:

const PI = 3.14 //can't be changed through the program
let radius = 5;
let c_o_c = 2 * PI * radius;
console.log(c_o_c);

The value of PI can't be change so it will remain same through out the program where other values can change dynamically.

2. Arrow Functions (() =>)

A simplest and concise way of defining the function better than function expression. let's learn by example

//The older approach
function sum(n1,n2){
  return n1+n2
}
console.log("This is older approach : " + sum(34,54))

//The new approach
var es6_sum = (n1,n2) => {
  console.log("The new approach : ", n1+n2);
}
es6_sum(55,65)

The above example is simple and self-explanatory.Its straightforward.

3. for..in vs for..of

Humans are for innovation not for doing the same tasks repeatedly but machines are built for doing such repetitive tasks without getting tired. Here come the Loops for doing repetitive task. For loop is one of the widely used loops in computer science. Let's dive deep with these for..of and for..in

for..in
This loop over the enumerable properties of an object. The syntax looks something like:

for (variable in object){
// your logic here
}

example:

var person = { 
  firstName: "Vikram", 
  lastName: "Sahu",  
}; 
var userId = ""; 
var i; 
for (i of person) { 
  console.log(person[i]) // prints the value of object
  userId += person[i]; 
}

for..of
This loops over the iterable data structure like an array, maps, strings, nodes, and lists. The syntax looks something like this

for (variable of iterable){
// your logic here
}

example:

let fruits = ["pineapple","mango","watermelon","banana"]
for (let fruit of fruits){
  console.log(fruit)
}

4.Spread attributes

As the name suggests Spread attributes helps to spread the expression. ie. it converts the list of elements to an array.

Example without Spread attribute:

let s_att = (arr) => {
  console.log(arr);
  let sum = 0;
  for (let ele of arr){
    sum += ele
  }
  console.log(sum)
}
s_att([2,42,51,12,32,98,08])

As you can see the above example is straightforward where it accepts the array and give the sum of an array.

Example with Spread attribute:

let s_att = (...arr) => {
  console.log(arr);
  let sum = 0;
  for (let ele of arr){
    sum += ele
  }
  console.log(sum)
}
s_att(2,42,51,12,32,98,08)

small task for you spot the difference.. you have 3 sec

1.. 2.. 3..

I hope you have so very small change we have just converted the argument from array to single arguments and convert (arr) to (...arr) in the function.

5. Map & Set

MAP

A map is a collection of keyed data item the same as an object but the difference is it allows the key of any type.

Methods & Properties
- new Map() : creates new map.
- map.set(key,value) : adds/store the value by key
- map.get(key) : greturns the value by the key, undefined if key doesn’t exist in map.
- map.has(key) : returns true if key exists
- map.delete(key) : removes key from the map
- map.clear() : removes everything from map
- map.size() : returns the count of map

let map = new Map();
map.set("name","Vikram")
map.set("designation","Developer Evangelist")

// looping over map
for (let [ele_key, ele_value] of map){
  console.log(ele_key + " -- > " + ele_value)
}
console.log(map.get("name"))
console.log(map.keys())  //return all the keys within map
console.log(map.size())  
console.log(map.values()) // return all the value within map
console.log(map.delete("designation"))
console.log(map.clear())

SET

A set is a unique type collection that has a "set of values"(without keys), where each value occurs once(no duplicate values will be inserted). Let's assume a simple example :

var mysets = new Set();
mysets.add("a");
mysets.add("b");
mysets.add("a"); // We are adding duplicate value.
//looping over sets
for (let element of mysets) {
 console.log(element);
}
mysets.has("b")
mysets.delete("b")

6. Static methods

You can assign a method to the class function itself, not to its "prototype". Such methods are called static. you can find the syntax as follows:

class Mydata{
  static CallMe(){
  console.log("Hello i am static function")
  }
}
Mydata.CallMe() // returns "Hello i am static function"

what you need to notice is that:

I have not written function within the class still I can access the function.
I have called the function without creating an instance of the class.

Concluding...

Javascript/ES is a weird but amazing language. This was the start of my learning curve will update with the further path soon.

I hope you like the blog. Do share! 🤗

Where should I save my passwords ? To more specific which editor ?

Vikram Sahu — Sat, 09 Nov 2019 06:47:50 +0000

I think vim for Linux