Forem: Chandra Prakash Tiwari

How to integrate Free SSL into your website?

Chandra Prakash Tiwari — Tue, 09 Feb 2021 09:53:23 +0000

Adding an SSL certificate is really important for modern web applications or websites.

So without taking too much time, let's dive directly into the free SSL implementations site.

First login to ZeroSSL website to generate SSL certificate.

After sign up, you just click on the New Certificate button to generate a new SSL certificate for your website.

Then, add your domain name, and move to the next step.

You have three options to verify your domain, choose any one of the options.

After verification, you will have the certificate to install in your website server.

For further details, you can go to their official documentation.
https://help.zerossl.com/hc/en-us/articles/360058295094-Before-Installation

Thanks!

Manage Pabbly Payments in Node.js application

Chandra Prakash Tiwari — Tue, 10 Nov 2020 10:57:02 +0000

Hello everyone,
Pabbly is an Indian Software to manage and automate stuff. Its one product called Pabbly subscription helps users to make payment pages and accept payments.

I have created a simple code which can help you to create plans and handle payments.

I have created a github gist for you.
Please look at it.
https://gist.github.com/cptiwari20/28d79f4e13161b9c13cebfa5f5a6333b

Thanks

Manage Thrivecart Payment using webhooks in Node.js

Chandra Prakash Tiwari — Mon, 14 Sep 2020 17:07:07 +0000

I really found it difficult to start with thrive cart integration for my marketing application.
The lack of complete API reference makes it confusing to use.

After some trial and errors, I have created the simplest approach to handle the thrivecart webhook events.

Please visit this gist for more reference.
https://gist.github.com/cptiwari20/836e7875d38dd4965faeb14fb8f3a4ad

If you are new to thrivecart, Please use my promo code 'cptiwari20' to get 50% OFF on the premium plans.

Node Vs Deno

Chandra Prakash Tiwari — Fri, 22 May 2020 11:12:46 +0000

Node vs Deno

Similarities

Developed by a single person( Ryan Dahl)
Both are JavaScript runtime
Both help in developing applications
Both support Typescript
Both uses chrome v8 engine

Differences

Node is written in C++, deno is using Rust language.
Node uses npm and imports libraries locally, deno uses urls for module usage
Node doesn't have built Typescript support, deno has
Node was launched in 2009 and Deno launched in 2020.

Funfact: “Deno” is actually an anagram for “Node”.

What is Big-O Notation? Understand Time and Space Complexity in JavaScript.

Chandra Prakash Tiwari — Fri, 10 Jan 2020 08:43:05 +0000

As we know, there may be more than one solution to any problem. But it is hard to define, what is the best approach and method of solving that programming problem.
Writing an algorithm that solves a definite problem gets more difficult when we need to handle a large amount of data. How we write each and every syntax in our code matters.

There are two main complexities that can help us to choose the best practice of writing an efficient algorithm:

1. Time Complexity - Time taken to solve the algorithm

2. Space Complexity - The total space or memory taken by the system.

When you write some algorithms, we give some instructions to our machine to do some tasks. And for every task completion machine needs some time. Yes, it is very low, but still, it takes some time. So here, is the question arises, does time really matters.

Let's take an example, suppose you try to find something on google and it takes about 2 minutes to find that solution. Generally, it never happens, but if it happens what do you think what happens in the back-end. Developers at google understand the time complexity and they try to write smart algorithms so that it takes the least time to execute and give the result as faster as they can.

So, here is a challenge that arises, how we can define the time complexity.

What is Time Complexity?:

It quantifies the amount of taken by an algorithm. We can understand the difference in time complexity with an example.

Suppose you need to create a function that will take a number and returns a sum of that number upto that number.
Eg. addUpto(10);
it should return the sum of number 1 to 10 i.e. 1 + 2+ 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;

We can write it this way:
function addUpTo(n) { let total = 0; for (let i = 1; i <= n; i++) { total += i; } return total; } addUpTo(5); // it will take less time addUpTo(1000) // it will take more time
Now you can understand why the same function takes different time for different inputs. This happens because the loop inside the function will run according to the size of the input. If the parameter passed to input is 5 the loop will run five times, but if the input is 1000 or 10,000 the loop will run that many times. This makes some sense now.

But there is a problem, different machines record different timestamp. As the processor in my machine is different from yours and same with multiple users.

So, how can we measure this time complexity?

Here, Big-O-Notation helps us to solve this problem. According to Wikipedia, Big O Notation is a mathematical notation that describes the limiting behavior of a function when the argument tends towards a particular value or infinity. The letter O is used because the growth rate of a function is also referred to as the
order of the function.

According to Big O notation, we can express time complexities like

If the complexity grows with input linearly, that mean its O(n). 'n' here is the number of operation that an algorithm have to perform.
If complexity grows with input constantly then, the Big O Notation will be O(1).
If complexity grows with input quadratically, then the Big O Notation will be O(n^2). you can pronounce it as O of n square
If the complexity grows with input with inverse of exponentiation, we can say.

We can simplify these expressions like below. Basically while calculating the Big O Notation we try to ignore the lower values and try to focus on highest factor which can increase the time of the performance. So,

instead of O(2n) prefer O(n);
instead of O(5n^2) prefer O(n^2);
instead of O(55log n) prefer O(log n);
instead of O(12nlog n) prefer O(nlog n);

For better understanding, please have a look at some algorithms which we use daily that have O(n),O(n^2), and O(log n) complexities?

In Quora, Mark Gitters said,
``
O(n): buying items from a grocery list by proceeding down the list one item at a time, where “n” is the length of the list

O(n): buying items from a grocery list by walking down every aisle (now “n” is the length of the store), if we assume list-checking time is trivial compared to walking time

O(n): adding two numbers in decimal representation, where n is the number of digits in the number.

O(n^2): trying to find two puzzle pieces that fit together by trying all pairs of pieces exhaustively

O(n^2): shaking hands with everybody in the room; but this is parallelized, so each person only does O(n) work.

O(n^2): multiplying two numbers using the grade-school multiplication algorithm, where n is the number of digits.

O( log n ): work done by each participant in a phone tree that reaches N people. Total work is obviously O( n ), though.

O( log n ): finding where you left off in a book that your bookmark fell out of, by successively narrowing down the range
``
and Arav said,
"
If you meant algorithms that we use in our day to day lives when we aren't programming:

O(log n): Looking for a page in a book/word in a dictionary.
O(n): Looking for and deleting the spam emails (newsletters, promos) in unread emails.
O(n ^ 2): Arranging icons on the desktop in an order of preference (insertion or selection sort depending on the person)."

I hope you are now familiar with the complexities.
I am not completing the topic in this article, I will make another in future.
If you have any questions and suggestions please write down the comment or feel free to contact me.

Thanks for giving your valuable time in reading this article.

Set a callback to setState(useState) in React funtional Component

Chandra Prakash Tiwari — Wed, 11 Dec 2019 07:06:02 +0000

It is hard sometime to call something after updating the state using useState hook in functional component in React.

Here is a simple trick:

Define State using UseState

const [filterObj, setFilterObj] = useState({});

Set State first

 // when props updates please update the state.
  useEffect(() => {
      setFilterObj({ ...props.something});
  }, [props.something]);

UseEffect to call the function which you want to call after the setState.

 // on state change call this event
  useEffect(() => {
    fetchData(currentPage); // this is a fuction which calls api
  }, [filterObj])

For Android and IOs development what would prefer?

Chandra Prakash Tiwari — Sun, 10 Nov 2019 13:02:42 +0000

Java Android
Swift IOS
Kotlin
React Native
Flutter
Ionic
Xamerin

Please let me know what's you'll prefer?

How to solve any programming problem?

Chandra Prakash Tiwari — Wed, 30 Oct 2019 16:20:28 +0000

Solving a problem in programming is not always easy. I was very confident after learning some great frameworks like node, express, react, react-native and much more and created some awesome apps with JavaScript, but one day someone asked me a simple question. And the question was, how can you check a number is palindrome or not(condition you can't convert it into string)?

I tried and failed, again tried and failed. I became exhausted and started learning some basic concepts of programming.

In this article I am going to share 5 steps to solve any problem. So lets start.

1. Understand the Problem:

Before start writing the code you need to understand the problem. Understanding the exact problem can solve your problem more than 30%. You can ask some questions before start writing the code:

Can I restate the problem in my own words?
What will be the inputs in the problem?
What would be the outputs should come from the solution?
Would input determine the output?
How should I label the important pieces of data that are part of the problem?

2. Explore problem:

After understanding the problem you need to explore the possibilities like:

What if there is no input or invalid input?
Is any limitations to the output? Try to find the more options to better understand the problem.

3. Break it down:

This is a most important method to solve any problem. You can break down the code into small steps to solve it. Write down the comments in steps, this will help you to be in track of solving the problem without distracting. Suppose, there is time limitation for solving any specific problem, and you are unable to solve it completely, your comments can help to get the good marks in that. Examiner would be able to understand your approach and right approach is the way to solve any problem.

4. Solve and simplify:

After writing the steps, start solving the problem. Try to solve simple steps first and then solve the complex one.

5. Look back and refactor:

After solving the complete problem, look back to your code and try to refactor it. Make it concise and readable. Try to test it at least one time before submitting.

I hope this will help you to get out of any problem easily. :)