DEV Community: nehabharati

5 ways to stay motivated on your coding journey

nehabharati — Fri, 17 Jul 2020 11:17:50 +0000

If you're learning to code, there's one thing that you need more than your ability to code itself - and that is MOTIVATION. It's hard to stay motivated all the time, in fact, it's impossible. There are a lot of things that can hinder your progress and you need to stay committed in spite of them.

So how do you keep yourself from procrastinating or altogether giving up? I'm going to share a few ways to help you maintain your streak and make progress every day.

1. Share your journey on the web

If you're all alone on your journey with nobody to answer to, chances are you wouldn't care if you finish your assignment today or meet your daily goals.

But if you share your journey to the world you'd feel accountable to them. It would push you to reach your goals, either short-term or long-term.

One of the best ways is to follow the #100DaysOfCode challenge on Twitter. The goal is to code for at least one hour every day for the next 100 days and share your progress with the twitter community. This is helpful because the dev community will share their views and suggestions too which will keep you on the right track.

2. Pair programming

If you feel you're not ready to share with the whole world just yet, you can start small and find a code buddy. It's a great way to learn as you both stay accountable to each other's progress i.e. pair programming.

Pair programming is a technique where two developers collectively code to find solutions to different coding problems.
There are many advantages to pair programming

You make sure your code is less prone to errors
You learn interpersonal skills and how to interact with other people
You learn from each other.

3. Get inspired

If you're really demotivated, I recommend reading about other people's journeys. How they became something from nothing. They could be an inspiration to you and you can learn from them.

Twitter and Linkedin are the best sources to connect with such people. You could follow their advice and ask them any questions that you have.

4. Taking breaks

The main reason why people get demotivated is because they think that they need to be coding 24/7. Having this mindset can make coding feel like a daunting task and it instantly flips the switch off.

The mind can only take so much. You cannot master everything in 1 day or 1 month or 1 year. Without resting your mind it's impossible to make progress and you can easily burn out.

Instead, take breaks. By break, I mean don't think about code. Go for a walk. Take a trip. Take the weekend off. Read a book. This refreshes your mind and also gives you new ideas to implement into your project.

5. Remove all distractions

The most important thing needed to train your brain to stay motivated is FOCUS. If you lose focus, you lose interest, you procrastinate. How do you lose focus? DISTRACTIONS

So find a way to avoid all these distractions. Find a quiet place and turn off your phone while you're working. You can give yourself a few minutes break in the middle and then tend to those distractions.

Thank you very much for reading. I hope this helps you in your journey like it has helped me. Happy coding!

What is short-circuit evaluation?

nehabharati — Wed, 29 Apr 2020 16:16:33 +0000

Introduction

We all know about the different kinds of operators in Javascript. There's arithmetic, logical, relational, unary, ternary and so on. We also know what they do and when they should be used. Here I'm going to discuss some peculiar conditions using a few of these operators to see how they behave with other data types and more importantly about short-circuit evaluation

All logical expressions evaluate from left to right. The logical operators && and || behave differently when dealing with values of different types.

&& operator

When the value to the left of the and operator is evaluated to false, the condition returns false
When the value to the left of the and operator is evaluated to true, it checks if the value to the right is true or false and accordingly provides a result.

console.log(NaN && 0)
//NaN
console.log(0 && NaN)
//0
console.log(NaN && null)
//NaN
console.log(null && NaN)
//null
console.log(1 && NaN)
//NaN

Note: 0, -0, NaN, null, undefined and ""(empty string) are considered as false in Javascript.

|| operator

or operator works the other way around.

When the value to the left of the or operator evaluates to true, the operation returns true.
When the value to the left of the or operator is evaluated to false, it checks if the value to the right is true or false and accordingly provides a result.

console.log("" || "user")
//user
console.log(null || "user")
//user
console.log("i"||"u")
//i

The above code shows an interesting way or works. The first value that evaluates to true is returned.
The cases seen till now are all due to short-circuit evaluation. You can read more about it here.

Relational Operators

console.log(2 < 3)
//true
console.log(10 < 2)
//false

This is how a typical relational operator(<,>,>=,<=, etc) works.
But what if we were to compare other data types like below.

console.log("ant" < "Bat")
//false
console.log("Ant" < "Bat")
//true

Strings are compared from left to right. The ASCII representation of strings can be found here. Lowercase letters are always greater than uppercase letters. So the code above is valid.

Summary

Short-circuit evaluation handles logical operation with different data types
and operator behaves in such a way that it returns the value which evaluates to false
or operator behaves in such a way that it returns the value which evaluates to true
Strings are compared from left to right depending on their ASCII value

That's it for this article. Hope you liked it and please leave your comments below. :)

Learn all about null,undefined and NaN

nehabharati — Sun, 26 Apr 2020 12:19:04 +0000

Introduction

We all come across null, undefined and NaN at some point in our coding journey. As a beginner, I'd always wanted to know how and why these special values behave the way they do. So I'm going to illustrate just that in this article.

What is null?

Null represents an empty value and carry no meaningful information.
If you use the typeof operator on null, it shows that null is an object. You can read all about it over here. In fact, null is one of the primitive values in JavaScript.

console.log(typeof(null))   
//object

What is undefined?

Undefined represents any value that has not been defined anywhere in the program.
If any variable or operation isn't able to produce a meaningful value, it returns undefined.

let a = [1,2]
console.log(a[2])
//undefined

In the above example, there is no meaningful value for a[2] because it doesn't exist, so it returns undefined

What is NaN?

NaN stands for Not a Number. You get this value when you try to do some operation that can't yield a meaningful result. If you use the typeof operator on NaN, it shows it is a number.

console.log(0/0)
//NaN
console.log("five" * 2)
//NaN
console.log(typeof(NaN)) 
//number

Behavior of null,undefined,NaN

Let's have a look at how these values behave with each other, and why.

null and undefined

console.log(undefined===false)
//false
console.log(undefined===true)
//false
console.log(null===false)
//false
console.log(null===true)
//false

null and undefined return false when compared with any value. Or does it? Let's take a look.

console.log(null==undefined)
//true
console.log(null===undefined)
//false

Before going into the explanation, let's take a look at how "==" and "===" work.
"==" performs a loose equality operation between its operands and does type coercion.
This means that if you use "==" between two values of different types, JavaScript tries to convert one operand's type into the other's to provide a result.

Whereas "===" performs a strict equality and does not try to convert the type of either value. It checks if the type of the values are the same. If not it returns false.

Now let's get back to the code. Let's look at the two cases.

==

null and undefined are both falsy values and that is why it returns true in the first line. Also == operator needs its operands to contain some value. Since null and undefined don't contain any value, it returns true.
===
Since null and undefined are of different types, it returns false.

So null and undefined return true only when they're loosely compared with each other.

NaN

console.log(NaN===NaN)
//false

NaN is in itself the result of a nonsensical computation, so equating it with any other nonsensical computation will return false. This is the only value in JavaScript that isn't equal to itself

Let's make it a little interesting.

console.log(!!NaN)
//false
console.log(!NaN)      
//true     
console.log(NaN === true)   
//false 
console.log(NaN === false)    
//false

Since NaN is a falsy value !NaN returns true.
NaN is not equal to any value. It always returns false.

Summary

null and undefined are values that contain nothing.
null and undefined are loosely equal to each other but are strictly not equal to each other.
NaN is a result of nonsensical computation which cannot produce a meaningful result.
NaN is the only value which isn't equal to itself.

I hope this clears some of your doubts about these special values. And I hope you enjoyed reading this!