DEV Community: Somnath Singh

The Story of AI: From Brain Cells to ChatGPT(… and what it really wants)

Somnath Singh — Fri, 11 Jul 2025 08:35:10 +0000

it was 1943.

world war II was raging.

meanwhile two guys - mcculloch and pitts - sat down and asked a weird

question: can we describe the brain… using math?
the first time we tried to make a machine think… we weren't building computers.

we were trying to decode ourselves.

they weren't coding. they were dreaming.
they imagined a network of simple units - on or off - just like neurons.

it didn't do much. it couldn't learn. but it was enough to start a fire.

they sparked a new kind of thinking…

one where intelligence wasn't magic or soul or mystery…
but computation.

fast forward to 1950s…
alan turing asked, can machines think?

but nobody could even define "thinking."

in the 60s, we tried rule-based logic.

in the 80s, we returned to neural nets.

in the 2000s, we gave up again.
**
then came 2012.**

a deep net beat everyone at recognizing cats on the internet.
the floodgates opened.

we taught sand to dream in probabilities.

we made silicon hallucinate.

we layered millions of artificial neurons and whispered billions of words into them.

today, we have chatgpt.

tomorrow… god knows what.

that's why i have created boringskool.

we're not here to predict the future.

we're here to trace how we got here… and how to ride the next wave with eyes wide open.

our first video is out now. it's not a tutorial. it's a story.

the truth is, this isn't just about ai.
it's about you.
your attention.
your curiosity.
your ability to still be surprised.
watch the story.

and then ask yourself:
are you still sleepwalking through this era…
or are you finally waking up?

this is the first video i've ever put out. and if you're reading this…

it means the world. seriously. your support right now isn't just clicks or views… it's momentum.

it's what keeps this thing going.
boringskool isn't backed by some big team or fancy funding…
it's just an idea i believe in. for the lazy and ambitious ones.

for the misfits trying to stay relevant in the ai storm.

so if this video hits something in you… share it, talk about it, reply.

this is just the beginning.

Struggling with Promises? You Are Not Alone!

Somnath Singh — Sun, 03 Jul 2022 13:19:09 +0000

Do you like to cook? I’m not sure about you, but I enjoy cooking. I usually cook by myself, although I’m not opposed to having some help.

Many times you’ll find yourself in a situation where you will need something in the middle of cooking and that damn thing isn’t in your house and you have to ask someone to get it for you while you’re cooking. In the meantime, you keep doing your job!

You may be familiar with this way of doing things — in programming languages — we refer to it as asynchronous.

We often do things asynchronously in programming. That is we initiate something and before even it completes we initiate some other task.

In JavaScript, we rely a lot on asynchronous operations — whose results we don’t have yet but will at some later point.

JavaScript in itself is not asynchronous but it supports asynchronous programming.

ES6 has introduced an idea that makes handling asynchronous tasks easier: Promises.

A promise is an object — a placeholder for the eventual result.

It is not that we could not do the async operation before. We did!

All we had to do is to make use of Callbacks in a certain way! Doing so was a torture when we needed to do a task when our operation failed.

Promises standardized the way to deal with asynchronous events *and *callbacks.

I’ve seen people struggling with promises. This post aims to assist individuals in comprehending this amazing topic. We will endeavour to gain a proper mental model of promises through real-life examples.

The more you struggle to understand, the less you understand any problem. To understand, the mind must be quiet.

— Jiddu Krishnamurti

Since people forget things but remember stories.

Let us understand promises with this little story

I am not yet a master storyteller! However, the preceding scenario contains all of the necessary information to help you comprehend the concepts of Promises.

Let us take the key points from it and apply them to JavaScript World.

We need a standard description of what a Promise is — nothing better than MDN.

Let us see, how this definition relates to our story.

The definition makes a lot more sense now!

In JavaScript, a Promise is just an object. It is a placeholder for a value we do not have right now but will have later. It ensures that we will eventually know the result of an asynchronous operation.

Circumstances do not matter — only your state of being matters — what state of being are you choosing?

A promise is nothing more than an object, and it is usual for objects to retain a state. By modifying the state, we do many complex tasks in programming.

A promise is always in one of the three states:

pending: which is the initial state — that is neither fulfilled nor rejected.
fulfilled: meaning that the operation was completed successfully.
rejected: meaning that the operation failed.

Let us establish a strong mental model by tying the underlying principles to our tale before diving into the code.

How to work with promises?

If we want to use promise in our code, then we must first understand these three fundamental concepts.

How a to create Promise?
How to Fulfil or Reject a Promise?
How to Run a Callback Function — Depending on Whether the Promise Is Resolved or Rejected.

“It is not the answer that enlightens, but the question.”

— Eugene Ionesco

If you understand these three things, dealing with promises will be a breeze.

Let’s take a look at each one individually.

How to create a Promise?

We create an instance of a promise using the new keyword with the promise constructor function.

How to fulfill or reject the promise?

The promise constructor function accepts one function as its argument — let us pass in an arrow function (but we could just as easily use a function expression).

This function is called an executor function, it automatically receives two arguments resolve and reject.

Keep in mind — resolve and reject both are functions.

resolve is a function which when called changes the status of the promise from pending to fulfilled.
reject is a function which when called changes the status of the promise from pending to rejected

It is important to keep in mind you cannot directly mutate the status of a promise — you can call the resolve function to fulfill the promise or the reject function to reject the promise.

Both these functions are typically called after an async operation.

To keep things simple, let’s use setTimeout() to simulate the time it takes to search for the Tofu. We’ll assume that it takes your pal five minutes to go out and text you back.

We refactored our code to include the setTimeout function.

If we get the Tofu — we will call resolve after five minutes, if we can not get the Tofu — we call reject after five minutes.

This is pretty much how you fulfill or reject a promise.

**How to Run a Callback Function — Depending on Whether the Promise Is Resolved or Rejected.**

The final step is to understand how to execute callback functions based on a promise’s state change. Remember that callback functions are functions that are supplied as an argument to another function.

Callback function means that we will use that function as an argument to another function.

Let us define two callback functions — onFulfilled and onFailure

onFulfilled() is the function to be called if resolve is called after the async operation

onFailure()is the function to be called if reject is called after the async operation.

Ideally, there would be more code in your callback functions but we simply log into the console and it serves the purpose.

Going back to our analogy, if we found the Tofu then our promise is fulfilled — we want to set up the table to eat. If the couldn’t find the Tofu then our promise is rejected — we have to start cooking the pasta.

You may be wondering how to make use of these two callback functions?

When we create a new promise using the promise constructor function the promise object gives us access to two methods — then() and catch()

We can call it using promise.then() and promise.catch().

The important bit here is:

If the status of the promise changes from pending to fulfilled by calling the resolve function — the function that is passed to then() function will automatically get invoked
If the status of the promise changes from pending to rejected by calling the reject function the function that is passed to catch() function will automatically get invoked

In our case, we need to pass

onFulfilled function to then()
onFailure function to catch()

Both functions are callback functions since they are supplied as arguments to other functions. I’m reminding you of this repeatedly since I’ve seen many individuals get afraid of the term “callback” — there is nothing to fear — they are just regular functions.

Our promise code works as expected. But there is room for improvement!

What if we want to send out some data when resolving or rejecting a promise?

That way inside our callback functions we can make use of the value to do something else.

Well, it turns out that we can do that by passing an argument to resolve or reject,

for the resolve function, we’ll pass in a string that says Got the Tofu
for reject function, we will pass in a string that says Can’t get Tofu

But how do we access these strings in our callback function?

Well, the great thing about a promise is that it will automatically inject the argument passed to resolve as the argument to the onFulfilled callback and the argument passed to reject as the argument to the onFailure callback.

You can see that I’ve included parameters to both these callbacks and simply log them to the console.

We would now see the output Got the Tofu Set up the table when the promise is fulfilled or if there is an error and hence a rejection we would see Can't get Tofu Cook pasta.

One great example of using promises is fetching data from a server; we promise that we’ll eventually get the data, but there’s always a chance that problems will occur.

In a practical scenario, things will be different.

Your result would be:

an object(JSON)
an array,
or any other data type that your async operation returns.

Essentially this is pretty much is the fundamentals of promises in JavaScript. There are a few more details which we will understand in the next article.

“A promise means everything, but once it gets broken, sorry means nothing”

— anonymous

Summary

A promise is an object — a placeholder for the eventual result.
In past we used Callbacks, to perform the async operation
Using callback was a pain especially when you needed to do error handling.
Promises standardized the way to deal with asynchronous events and Callbacks.
A promise is always in one of three states: pending (the first), fulfilled, or rejected.
The operation was completed was marked as fulfilled. The operation was rejected, which means it failed.
We create a promise using the new keyword with the promise constructor function.
You cannot directly mutate the status of a promise — you can call the resolve function to fulfill the promise or the reject function to reject the promise.
We learned How a Promise is created, How to Fulfil or Reject a Promise, How to Run a Callback Function — Depending on Whether the Promise Is Resolved or Rejected.

Note of Gratitude

I wanted to take this last opportunity to say thank you.

Thank you for being here! I would not be able to do what I do withoutpeople like youwho follow along and take that leap of faith to read my post.

I hope you’ll join me in my future blog post and stick around because I think we have something great here. And I hope that I will be able to help you along in your career for many more years to come!

See you next time. Bye!

Secret of Great Programmers Revealed

Somnath Singh — Mon, 06 Dec 2021 08:23:07 +0000

A human being is always longing to be something more than what he is right now. This desire to be something more pushes humans to greatness.

One sure way you can achieve greatness in any field is through deliberate practice.

If you don’t practice deliberately, you’re wasting your time.

As to popular notion, deliberate practice is not performing a task again and again.

For example, if you ask yourself, “Why am I performing this task?” and your answer is, “to complete the task,” then you’re not doing deliberate practice.

You need to do the right things — if you want the right things to happen to you

Yes, deliberate practice means repetition, but repetition doesn’t mean doing the same thing mindlessly. It means performing the task to increase your mastery of one or more aspects of the task.

You do deliberate practice to improve your ability to perform a task. It’s about acquiring the skill with the correct technique.

It means doing the repetition while giving all your attention . Doing the task over and over again, until you achieve your desired level of mastery.

The only one who devotes himself to a cause with his whole strength and soul can be a true master.

For this reason, mastery demands all of a person.

— Albert Einstein

You do deliberate practice to master the task, not to complete the task.

The main aim of professional development is to finish a product. Where as the main aim of deliberate practice is to improve your performance — both are not the same.

Ask yourself:

How much of your time do you spend developing someone else’s product? And how much developing yourself?

Let me know your answers in the comments section.

If you show me the HOW — I will find the WHY

Peter Norvig has written the most popular book ever on Artificial Intelligence.

In his famous post, Teach Yourself Programming in Ten Years, he says that “it may be that 10,000 hours…is the magic number.”

I remember reading this article by Peter Norvig in my teens and thinking this must be a joke! After all, who can spend that much time? No, this isn’t a joke.

There is no substitute for personal experience — once you have it, you know it.

Peter Norvig explains:

The key to developing expertise is deliberate practice: not just doing it again and again, but challenging yourself with a task that is just beyond your current ability, trying it, analyzing your performance while and after doing it, and correcting any mistakes.

There is little point in practicing something you are already good at. Deliberate practice means practicing something you are not good at.

Quantity Leads To Quality

As David Bayles and Ted Orland write in Art and Fear:

The ceramics teacher announced on opening day that he was dividing the class into two groups. Students on the left side of the studio would be rated on quantity, while students on the right would be graded on quality.

His procedure was simple:

On the final day of class, he would bring in his bathroom scales and weigh the work of the “quantity” group: fifty pounds of pots rated an “A”, forty pounds a “B”, and so on.

However, those graded on “quality” needed to produce only one pot — albeit a perfect one — to get an “A”.

Well, came grading time and a curious fact emerged: the group graded for quantity produced the highest quality works.

It seems that while the “quantity” group was busily churning out piles of work — and learning from their mistakes.

The “quality” group had sat theorizing about perfection, and in the end, had little more to show for their efforts than grandiose theories and a pile of dead clay.

TAKEAWAY:

Don’t get too hung up initially on polishing your work to perfection. Instead, focus on cranking out as much as you can.
Doing something will lead to doing it well.

Never give up — great things take time

When you first learn to program, you are forced to practice purposefully. Since everything is new and challenging — you put in the hard work.

But this phase fades and motivation to study tough new topics also fades away.

Once we achieve a certain skill level (like getting a good job), it’s easy to stop pushing ourselves, settle for the daily grind, and shun all challenges.

Take Shinji for example, he is considered the “most graceful” swimmer in the world.

He started frequently swimming in his late 30s, and now his swimming video on YouTube is more popular than Michael Phelps’.

How did an average guy with a job and a family get so good?

He practiced a lot.

“I made it my goal to become the ‘most graceful swimmer in the world.’

Whenever I was in Japan, I spent 3 to 4 hours in the endless pool, usually from 10PM to 2AM, four days a week, recording my swim, analyzing it frame by frame, finding and fixing small flaws, one by one.” -Shinji

This is an excellent example of deliberate practice. You work hard, push yourself to your limits, and keep going until you progress and move up a level.

If something feels uncomfortable it means you are pushing your limits — Do it until you get comfortable — Embrace it.

Mile by mile one hits the milestone

No matter how great the talent or efforts, some things just take time. You can’t produce a baby in one month by getting nine women pregnant.

— Warren Buffet

Mary Poppendieck has co-created lean software.

She’s also co-authored award-winning books.

In the book Leading Lean Software Developmen_t, Mary Poppendieck notes that “_it takes elite performers a minimum of 10,000 hours of deliberate, focused practice to become experts.”

The expertise arrives gradually over time — not all at once in the 10,000th hour!

How to do it:

Nevertheless, 10,000 hours is a lot: about 20 hours per week for 10 years.

Given this level of commitment, you might be worrying that you’re just not expert material.

You are.

Greatness is essentially a matter of conscious choice — y_our choice._

Every artist was first an amateur.

— Ralph Waldo Emerson

You don’t have to see the whole staircase — just take the first step

Over the last two decades, research has proven that deliberate practice is most critical factor in building a skill — not ones innate talent.

There is broad consensus among researchers of expert performance that inborn talent does not account for much more than a threshold. You have to have a minimum amount of natural ability to get started in a sport or profession. After that, the people who excel are the ones who work the hardest.

Deliberate practice does not mean doing what you are good at. It means challenging yourself, doing what you are not good at. So it’s not necessarily fun.

A kid may move his body a lot, but that does not make him a martial artist.

This is just like this: you have to do it consciously and increase your difficulty every time.

That doesn’t mean programming has to feel uncomfortable all the time, but it should regularly confront you with some difficulties.

Deliberate practice is about learning — learning that changes you, learning that changes who you are.

Also, it is essential to remember that learning is never created equally. There is a world of difference in what you learn by working alone and working among a group of people.

It is a rough road that leads to the path of greatness.

— Seneca

How to do it:

When you are building something, don’t do it just for the sake of doing it.

Before you begin your coding session, have a clear goal in your mind what you want to achieve through your coding session.
Don’t get stuck trying to get it right the first time. Instead, start making one or two things everyday.
Check where are you before doing something and where are you after doing it — is there an improvement? If not, then why — if yes, then what?
Make an account of your progress.[Important]

In any reasonable application, you probably have a lot of really easy stuff. Things like variable assignments, function definitions, or setting up the databases.

Maybe for you, the edge of your abilities is on more complex algorithms, data structures or mathematical equations.

However, if you approach practice blindly, you’ll probably spend 90% of your time on the basics with only 10% of your time on the really difficult stuff that pushes you.

So for every hour you spend practicing, you’re only really improving for six minutes of that time.

The solution here is to craft projects, problems, or practice sessions which deliberately eliminate the easy stuff.

Deliberate Practice your programming problem in such a way that it deliberately forces you to learn the new data structure or algorithm.

10,000 Rule Is a Myth

There are a lot of people who say that the 10,000 rule is a myth.

Some people spend thousands of hours learning and executing a craft and stay mediocre, while others become experts in their field with the same time investment

As we already discussed, Deliberate practice is not how much time you spend doing something — It is about how you do it.

When you are on the path of mastery:

Conscious Repetition > Inattentive Repetition.

10,000 figure is a close number where one achieves mastery over something, but it isn’t absolute.

If one has a razor-sharp focus, what others do in 10 years; he can do it in 4–5 years or even less.

Note of Gratitude

I wanted to take this last opportunity to say thank you.

Thank you for being here! I would not be able to do what I do without people like you who follow along and take that leap of faith to read my post.

See you next time. Bye!

Git Commands That Will Save Your Job

Somnath Singh — Thu, 02 Dec 2021 12:59:01 +0000

In this article, we are going to learn some life-saving Git commands.

We will not only learn about them, but we will also construct a mental model by understanding how they work behind the scenes.

Some of these you may have used before, while others may be new to you, but they are all lifesavers.

The Real Fault Is to Have Faults And Not to AMEND Them

“You will be remembered in your typos and edit history”

— Anonymous

Typos happen all the time!

Git gives us the option to correct our mistakes.

When committing, sometimes we can hit “Enter” too quickly and have a typo somewhere in the commit message.

use -amend command to fix the typo

Perfect! Now, your co-workers will not see that your “commit” was originally spelled “committ”.

Well Crafted Thing Is a Thing to Behold

You might have used the command git add <file> or git add . many times but doing so doesn’t allow us to commit just a section of a file.

git add -p allows you to stage parts of a changed file, instead of the entire file.

This allows you to make concise, well-crafted commits that make for an easier-to-read history.

Doing so can improve the quality of the commits.

It also makes it easy to remove parts of the changes in a file that was only there for debugging purposes — before the commit without having to go back to the editor.

Once this command runs, we’ll be asked about “hunks”.

“Hunks” are the _chunks_ of code that we’ll decide what to do with.

You’ll see the question, “Stage this hunk [y, n, g, a, d, e, ?]?” at the bottom of the terminal.

When finished with all the “hunks”, we will be able to see that our commit is ready and we can continue to the push!

Bonus Tip:

git commit -p combines git add -p and git commit in one command.

Your Mistakes Don’t Define You

You made a commit but now you regret it? Maybe you committed secrets by accident — not a good idea — or maybe you want to add more tests to your code changes.

These are all legit reasons to undo your last commit.

Git gives us a command to undo our last commit.

The command git reset has a variety of things you can trail onto it, let’s talk about the "soft" trailing.

git reset —soft HEAD~ removes the commit from the current branch, but keep the changes!

The cool thing about this command is that the changes won’t disappear!

All the changes will stay in the working tree!

We ran the command git reset — soft HEAD~2 — it moved the HEAD to the previous two commits.

If you don’t want to keep the changes that were introduced by certain commits then use git reset —hard HEAD~

Bonus Tip:

The git pre-commit hook is a built-in feature that lets you define scripts that will run automatically before each commit. Use it to reduce the need to cancel commits.

Look for your choices, pick the best one, then go with it.

Suppose you are working with a team of developers on a medium to large-sized project.

Another team member proposed some changes, and you want to apply a few of them to your main project, not all.

Since managing the changes between several Git branches can become a complex task, and you don’t want to merge a whole branch into another branch.

You only need to pick one or two specific commits. To pick some changes into your main project branch from other branches is called cherry-picking.

In this command, we can pick a particular branch that has a commit and pull it into another. Let’s walk through this.

A commit is a snapshot of your git repository at one point in time and each commit cumulatively forms your repo history.

The cherry-pick command takes changes from a target commit and places them onto the HEAD of your currently checked-out branch.

From here, you may either continue working with the changes in your working directory or you may commit the cherry-picked changes immediately.

This is helpful if you accidentally make a commit to the wrong branch.

With cherry-picking, you can get those changes onto the correct branch without redoing all that work again.

However, use cherry-pick sparingly!

Overusing cherry-pick can lead to duplicate commits, and sometimes a merge may be preferred to preserve commit history.

Real-Life Scenario:

Let’s say we have a branch 76d12 and we have committed all of our changes.

There’s another branch, we’ll just use master but this can be any branch, and we want to pull in 76d12’s commit.

By using the command, git cherry-pick 76d12we can get that entire commit into another branch.

`cherry-pick b`_ring an entire commit from one branch into another._

Don’t Want All Of It? No Problem — Just Checkout

Want to Pick a specific file from a branch and bring it into the current branch?

Som, I use git checkout mostly for switching from one branch to another.

Yes, I know but we can also use it for checking out files and commits.

It’s like git cherry-pick but rather than "cherry-picking" an entire commit, we are diving even deeper into a branch and picking just a particular file that we want to be merged.

While staying in master the entire time, we can run the command git checkout Som-test index.js to grab that particular committed file in that particular branch and bring it over to master to eventually push.

That’s pretty neat when a particular branch’s changes are many and we’re only looking for one file to test or push.

How does it work:

git checkout tells Git which branch or commit to apply your new changes.

A branch is just a pointer to 1 specific commit, and a commit is a snapshot of your repository at a certain point in time.

The branch pointer moves along with each new commit you make.

If you want to make changes on a branch that you don’t currently have checked out, you first need to checkout the branch.

Checking out a branch will update your repo’s files to match the snapshot of whichever commit the branch points to.

From here, the branch pointer will follow each new commit that you make on the branch.

It’s also possible to directly checkout a commit, which will update your repo’s files to match the snapshot of whichever commit you’ve checked out.

Be aware that checking out a commit moves the HEAD pointer to a commit instead of a branch, putting your repo into what is called a “detached head state” where any changes will not be committed to a branch.

While git checkout is great for getting to work with branches, it’s also a useful tool for reviewing old commits since it switches the version of your repo to this older snapshot.

Someday…But Not Yet, Not Yet

Suppose we have a bunch of changes to a file but need to go back and test something out before we commit and push this or we’re just not ready to commit our changes.

That’s where git stash comes into play.

Save uncommitted changes and stash them for later. This is useful for when you want to commit and push, but aren’t ready to commit the changes since the last commit.

When we run the command git stash it takes those saved, uncommitted changes and "stashes" them for later.

We can then move around different branches, pull changes into master, etc.

Once we have finished testing or doing whatever we needed to do, we can go back into our branch, run the command git stash pop and our changes will come back! It’s like we never even left!

It Is Time For You To Get Some Help.

There are a plethora of git commands to choose from. And it’s critical that we don’t run commands without knowing what they’ll do to our code.

If we were to run just git help <command> then we would get an explanation of the command right there in our terminal.

Bonus Tip:

Running the command git help -w <command> takes us directly to the website that we can read up on all the things with the command in question.

Conclusion

Git is an extremely useful tool. It may be a nightmare if handled incorrectly. I hope these hidden treasures make your Git experience a little more productive.

What is your go-to Git command? Please let me know in the comments!

Note of Gratitude

I wanted to take this last opportunity to say thank you.

Thank you for being here! I could not be able to do what I do without people like you who follow along and take that leap of faith to read my post.

I hope you’ll join me in my future blog post and stick around because we have something great here.

And I hope I will help you along in your career for many more years to come!

See you next time. Bye!

Become Super Productive with Console.X

Somnath Singh — Sat, 24 Jul 2021 13:11:36 +0000

The better you know the machine, the better you can use it!

Yes or no?

Whether you make your living in a blue-collar or white-collar career, you must always have access to the right tools you need to do your job. Otherwise, not only will you not be able to perform in the ways you need to, but you also won’t have as positive a relationship with your work.

“A man is only as good as his tools.”

― Emmert Wolf

Developers debugging console has been available in one form or another in web browsers for many years.

Starting as a means for errors to be reported to the developer, its capabilities have increased in many ways, such as automatically logging information like network requests, network responses, security errors, or warnings.

There is more to the console object than just console.log(). Though the console object has got a shedload of features — very few get explored.

In this article, We will unravel the console object — things that remain hidden for most of the developers.

Come, let us sit at the table and have some conversation!

You might have put an array or object inside a console.log()many times.
But do you know that there’s another option for these data types for a more structured display, which is the console.table()?

Be patient, the tables will turn.

(And if they won’t, make them turn.)

— The Ruhaniyat

This looks much slick, isn’t it?

Time to add some flavors to your life.

JavaScript gives us are five options to log messages.

console.log( ) | console.info( ) | console.debug( ) | console.warn( ) | console.error( )

“People try to hold onto the sameness. This holding onto prevents growth.”

— Bruce Lee

At first glance they seem to do the same thing and technically, they do! The browsers provide additional features tied to the five commands to give each their own distinct benefit.

The intentions for the usage of error and warn are easy to determine — how to use the other choices is up to you.

Don’t just write better error messages, write code that doesn’t need them.

Darling, you need to add some colour to your life.

Wouldn’t it be amazing if the errors come up in red and warnings in yellow?

Is it possible? Definitely!

You can apply CSS styles to the console’s output. It works just like the string substitution method where you insert a %c variable for styles to be applied from the parameters.

Notice the %c before the I in the above statement.

“Colour to the eye what music is to the ear.”

— Louis Comfort Tiffany

This is just a sample, you can achieve a lot of things using CSS. If you are interested then, have a look at this thread.

Memories of a past love — C Programming.

In C programming there is something called placeholders. These placeholders are also called format specifiers. It determines the format of the input and output.

Not many know this but JavaScript also provides us placeholders. We can make use of those placeholders in JavaScript’s console.log()

Notice the %s and %o that we have used in the console.log()

Can You Describe that thing a Little Better?

When something is descriptive it gives us a better idea of what that thing possibly would be.

The console**.**dir() displays an interactive list of the properties of the specified JavaScript object. The output is presented as a hierarchical listing with disclosure triangles that let you see the contents of child objects.

console.dir() didn’t just give an output but also told what kind it is.

Things get interesting is when we start using DOM nodes. So let’s look at the difference when we use dir and log on document.body

Notice, console.log() prints the element in an HTML-like tree and console.dir() prints the element in a JSON-like tree.

console.log() gives special treatment to DOM elements, whereas console.dir() does not. This is often useful when trying to see the full representation of the DOM object.

In other words, console.dir() is the way to see all the properties of a specified JavaScript object in the console by which the developer can easily get the properties of the object.

Alone we are strong, together we are stronger!

A group is a set of things that are considered because they have something in common. It is quite possible to group the messages with the console.

Using console.group() we can group different console outputs together to show a form of relationship among them.

We use group. End() to close the group.

You can count on me like 1,2,3 & I’ll be there!

Man, even in the lower stages of development, possesses a faculty which, for want of a better name, I shall call Number Sense. This faculty permits him to recognize that something has changed in a small collection when, without his direct knowledge, an object has been removed from or added to the collection.

“Many of the things you can count, don’t count. Many of the things you can’t count, really count.”

— Albert Einstein

Ever wonder how many times a certain thing happens in your code? For instance, how many times does a particular function get called during a sequence of events? That’s where the console.Count() command can help out.

To know oneself, one should assert oneself.

In life, truth is the only authority. One must reject everything but not the truth.

It is truth that liberates, not your effort to be free.

— J. Krishnamurti

Ever thought of logging something when it is not true?

console.assert() comes quite handy when you only want to print some selected logs i.e. it will only print the false argument. It does nothing at all if the first argument is true.

Are you tracing it?

Bugs can be a source of frustration. It’s impossible to know straight away which call to the function is creating the bug. Understanding the code execution flow, one can have a better grip on them.

You can use console.trace() to get a quick and easy stack trace to better understand code execution flow.

In simple terms, console.trace() will log to the console the call stack that exists at the point console.trace() was called.

console.trace() can be very helpful especially, in a large codebase where we have established that the code has a bug in it somewhere but, we aren’t sure exactly where it is.

Do you realize that’s the first time you’ve done that?

The majority of code execution time is spent within loops. Understanding the performance impact of loops in JavaScript is essential in becoming a better developer.

Using console.time() one can get an idea of how long a certain section of code is taking.

“Time is a created thing. To say ‘I don’t have time’, is like saying, ‘I don’t want to.”

― Lao Tzu

When I covered the performance of loops in an article, I found that the Performance Interface gives more accurate results.

Learn to see the console object as a multifaceted tool. Each tool is designed precisely for a specific purpose. Choosing the correct tool will decrease the amount of effort required to get a job done. I hope you will choose well.

Summary

console.table() gives b*etter visualization of data.*
Other than **console.log( )** we can have**console.info( )** | **console.debug( )** | **console.warn( )** | **console.error( )**
You can insert a %c variable and use various CSS styling options.
We have placeholder in JavaScript like %s %d %i %f %o that can determine format of the output.
console.dir() prints a JSON representation of the specified object.
console.group() can be used for grouping messages in the console.
console.count() logs the number of times that this particular call to count() has been called. This function takes an optional argument label.
console.trace() method displays a trace that show how the code ended up at a certain point.
console.assert() prints a statement when it is false.
console.time() can be used to track the micro-time taken for JavaScript executions.
Learn to see the console object as a multifaceted tool, use the right tool for the job.

Note of Gratitude

I wanted to take this last opportunity to say thank you.

Thank you for being here! I would not be able to do what I do without people like you who follow along and take that leap of faith to read my post.

I hope you’ll join me in my future blog post and stick around because I think we have something great here. And I hope that I can help you along in your career for many more years to come!

See you next time. Bye!

Master ‘this’ in JavaScript

Somnath Singh — Sun, 30 May 2021 06:21:19 +0000

In this article, we cover the all-important yet so confusing topic in JavaScript which is the “this” keyword.

TL;DR

If “this” scares you, do not worry! We will learn how to determine the value of the “this” keyword using five simple rules.

Those five simple rules are as follows:

The Regular One — Default binding
Function Inside an Object — Implicit binding
Function Borrowing — Explicit binding
Using Function to Create Objects — New binding
How Arrow Function Differs from the Regular Ones— Lexical binding

Don’t worry about these scary names. Computer Science people have a fancy for naming terms so that they sound extra-terrestrial. Under the hood, they are just common concepts that any willing human can understand.

The “this” variable corresponds to how you invoke a function. These rules help us to determine the value of this in various scenarios.

Once you understand these rules, then you would not fear them anymore.

Before we begin, please go through this article to understand how this works.

What is “this” in brief

In JavaScript, whenever a function is called, a new execution context is created by the JavaScript engine. That execution context exists until the function has finished executing. Every execution context contains a variable called ‘this’.

#Rule 1. Default binding

When calling a function in a standard way shown above, “this” will actually refer to the global object!

In the browser, the global object means the Window object.

One exception to remember — that is when strict mode is enabled. By writing “use-strict” you can prevent anything from being declared on the global object.

#Rule 2. Implicit binding

If the function is contained within an object, then that object will be referenced by “this”.

For the above, the this keyword will point to the personObj

#Rule 3. Explicit binding

We saw how this points to the global object and in another case, it points to the object which contains it. Wouldn’t it be nice to able to control what this variable ends up being when the function is called?

Words like call, apply, and bind usually causes terror in new developers. In reality, they are all functions that can be used to explicitly set the value of “this”.

Let us understand it with an example.

Suppose we have two objects, let us say personObj and readerObj

Both the object has a name property. The personObj has a function that can print the value inside the name but, the readerObj does not have any such feature!

Here we can make use of one of the three methods — call, apply or bind.

This process is called function borrowing.

We borrowed the sayName method for the readerObj.

Now we can print the name property that is in readerObj

We are calling the sayName method from personObj, but at the same time, we are instructing the JavaScript engine that the ‘this’ variable in the sayName method should point to readerObj.

So when the JavaScript engine executes the code, the this variable in the sayName function does not point to the personObj but it points to the readerObj.

Does that make sense?

Not just that — we can also pass some arguments when we use the call function.

We passed Namaste as an argument

We can make use of the argument in the sayName method.

When we execute the code, we will get the output along with the passed argument.

The apply method works the same way, but instead of regular arguments, it takes an array as an argument.

The bind method also works the same way — it can accept a regular argument.

But unlike call and apply — bind returns a function — that function can be stored in a variable and can be executed in the future.

One can see the use of bind in function currying — a topic that we will cover in the future.

#Rule 4. New binding

We use the new keyword to create an instance or copy of an object. What the new keyword does is:

It creates an empty object and then instructs the keyword this to point to that empty object.
It then adds a return this statement to the end of that function.

Remember, when an instance of an object gets created using the new keyword, “this” always points to that newly created instance.

Let us understand this with an example.

When we run this code, what are we supposed to get?

As we said — an empty object!

What is happening under the hood is

What? Are we invoking the function?

Yes!

See, I told you it is getting invoked.

Let us look at the whole thing.

If we put some value in the function, it will put that in the newly created object and then return it!

When we console.log(newPersonObj)

Let us finish this concept with an animation.

Since dev.to supports animation of 500 frames only, I am attaching an external link to the animation
Go here for the animation

In the above example, we are using a function to create an object.

This type of function is known as a function constructor.

Remember, in the newPersonObj, which stores the copy of personObj— the “this" variable points to empty personObj

Does it make sense now?

Good! Let us now understand the last rule.

#Rule 5. Lexical binding

With the advent of ES6 — we got arrow functions. Arrow functions with their ultra-lean syntax are a natural replacement for their traditional anonymous counterparts.

To explicitly invoke an arrow function, as with a regular anonymous function, you would assign it to a variable first:

Arrow functions are just like regular anonymous functions, with one major exception- the behavior of this object inside the function.

In a regular function, the value of "this" is context-based- call the function inside a link, and "this" points to the link's object; call it inside one more function like setInterval(), then "this" points to the global window object.

For example, the following example attempts to call the start() method of a custom object to increment its counter property by 1 every second, though it fails due to an incorrect assumption of the "this" object reference counter.

In the above, this.counter fails to properly reference the counter property of the countup object, though the error may not be so obvious to spot. One can either mistakenly or carelessly assume that "this" points to the countup object, when in fact it points to the global window object due to the context "this" is being called- inside the global window method setInterval().

The result is a reference to a non-existent window.counter property that will repeatedly return NaN when we try to increment it. To properly reference the countup object then inside the anonymous function, we should cache a reference to the correct "this" object before the context changes to a different one:

The "this" object inside an arrow function is lexically bound, which is just a fancy way of saying its value is static and determined by the place where the “this" keyword is defined.

Contrast that with regular functions, where "this" is dynamic and based on the context it's called regardless of the scope at the time "this" was defined.

Let’s take the previous example that gave us trouble initially, and see how changing over to using an arrow function intuitively addresses the problem:

We solved the problem by just using an arrow function.

Conclusion

If you understood all the rules, then pat yourself on the back — you deserve it! Now you are no more someone who is afraid of JavaScript’s most confusing concept — the "this" keyword.

In this article we learned:

When calling a function in a standard way shown above, “this” will actually refer to the global object!
If the function is contained within an object, then “this” will point to that object.
call, apply and bind are functions that are available to us by JavaScript to alter the behaviour of “this” in our program.
new keyword or operator when used makes an empty object, then instructs “this” to point to that newly created object
Arrow function enables us to lexically bind the “this” keyword in the program, what this means is its value is static and determined by the place where the “this" keyword is defined.

Note of Gratitude

I wanted to take this last opportunity to say thank you.

Thank you for being here! I would not be able to do what I do without people like you who follow along and take that leap of faith to read my post.

See you next time. Bye!

Explain API in Plain English

Somnath Singh — Mon, 29 Mar 2021 13:01:36 +0000

Have you ever heard the word “API,” and wondered exactly what it is? Do you have a vague idea of what it does or what it is used for?

This is something that you will encounter when you first start programming with any sort of web technology. Many newcomers struggle with this concept, and many get some vague ideas about it and assume that they know what it is.

Now APIs aren’t exclusive to web programming but it’s something that you use a lot when you are programming for the web or mobile. In the past, APIs were largely associated with computer operating systems and desktop applications. In recent years though, we have seen the emergence of Web APIs.

What is an API?

It stands for Application Programming Interface. This sounds scary and fancy at the same time! What does that mean? What exactly is an API?
Like most places, I won’t give you a vague definition, full of technical jargon.

So, here it is:

In a nutshell, API is some code that you didn’t write yourself, and that code has some methods that you are allowed to call. It could be something that you download and run from your computer or it could be something that’s someplace else on the web.

That’s all an API is, in its essence.

Don’t think anything else, when we say an API just stick with the definition mentioned above!

Is that’s all it is? In its essence, Yes.

Then why such a fancy name?

Lets find out!
Let us build an API in JavaScript that will enable us to cook our dinner 🍜(virtually ofc).

Our API Code that is stored in the computer

As I said, we can have APIs that are local on our computer or saved in a remote server, or it could be something that you can download. We have made one locally and named it API, but it can be named anything.

It is a JavaScript file that I’ve downloaded and saved into a local folder.

When I run my webpages, I’m able to use this piece of code:

There is an immediately invoked function expression(IIFE) that is going to run itself.

At the very bottom, it’s going to return an object, and the object that it’s returning has three properties.

We can call these methods using a dot operator.

Calling methods described in our API.

When will call these methods in a row, we get an output like this:

We have function steamVeggies() that calls other function addSpices()

Here addSpices() can’t be called directly but I can call steamVeggies() which will then run the function addSpices()

Now what this is doing is just console logging out some messages, it’s not important what’s being done, what is important is that I have an object with a name. This would be one file that I can download and use, or it could be saved on a remote server, or it could be something that I download and keep with my files, then in my script file, I can use that.

So, I could say API then dot, and here are the things that were returned from this function.

These are the methods that we can call:

We could say, alright I’m going to call the function step1() and then I need to call the function step2()

There are other ones in the API like addSpices() that we can’t call one directly.

calling this one would give us an error

So there’s code inside there that’s hidden away from us. We don’t know what it is doing, but some things are exposed to us, which are public . We can access those in our code. I can use a step1(), step2() and step3(). These are the things that are available to us from the API.

In the Application Programming Interface, the Interface part of it is these three methods:

This is the Interface part of the code

Those methods are the interface for me, to interact with this API

This is our Application Programming part of the code

Now, does it make sense why it is called Application Programming Interface?

Now, above we have used the name API, but it doesn’t have to be called API. It could be called anything. You can call it Som if we want.

What you need to understand is that there is this black box hidden away from us. What we know is from the documentation. It says these are the things that we could use and we use those in our program.

That’s all an API is. Code that somebody else has written, that I have access to, that I can use in my code to accomplish some sort of task.

It can be sitting on a remote server,

It can be sitting on my own computer,

It could be something that I have to use HTTP to talk to, I have to make an AJAX requests to the API to get information back.

You may encounter the term RESTful API while doing web development. Don’t get confused, It is also a code but it follows a certain architectural style and uses HTTP requests to access and use data. That data can be used to GET, PUT, POST and DELETE data types, which refers to the reading, updating, creating and deleting of operations concerning resources.

But in a nutshell, It is just code that somebody else has written to make our life a little bit easier!

APIs in the context of Web

APIs are to the Internet what switchboard operators were to early telecommunications!

Like how switchboard operators used to connect calls, APIs enables communication between applications or software. An API or application programming interface is a part of a remote server that receives requests and sends responses when you navigate to a website in your browser.

Take medium.com for example, A request for data goes out to Medium’s remote server. Once your browser receives the data and processes the code response, the browser displays Medium Page. In this case, Medium’s server is the API that enabled communication and allowed you to access the webpage.

What is happening here is that your request goes to a code that someone else wrote and stored on the server. It provided you access to the current page that is stored somewhere in the remote server.

Your request doesn’t go to the server directly! It goes to an API, and that API decides what to do with it.

Client(left), API (Blue bolt), and Server(right)

API are also enables interaction and data alteration between two sites like when a webpage has a share to Twitter button, clicking this button triggers communication with your Twitter account, and alters your account by adding a new Tweet.

Now, this code or API can take many forms depending upon where it is being used. It will get a name respective to that area. To name a few, we have

Open APIs or Public APIs: These are publicly available to developers and other users with minimal restriction.
Partner APIs: These APIs exposed by/to the strategic business partners. They are not available publicly and need specific entitlement to access them.
Internal APIs or Private APIs: These are hidden from external users and only exposed by internal systems. It is not meant for consumption outside of the company but rather for use across different internal development teams for better productivity and reuse of services.

Bird’s eye view 🦅

Beyond the difference between internal, partner, open APIs, we should mention another approach to categorize APIs:

Data APIs provide CRUD access to underlying data sets for various databases or SaaS cloud providers.
Internal service APIs consist of exposing internal services, reflecting parts of internal processes, or some complex actions.
External service APIs are third-party services that can be embedded into the existing services of the company to bring additional value.
User experience APIs leverage composite APIs to help app developers provide the right experience for each specific device (desktop, mobile, tablet, VPA, IoT).

APIs may be further classified as local, web, or program APIs:

Local APIs is the original form, from which the name came. They offer OS or middleware services to application programs. Microsoft’s .NET APIs, the TAPI (Telephony API) for voice applications, and database access APIs are examples of the local API form.

Web APIs are designed to represent widely used resources like HTML pages and are accessed using a simple HTTP protocol. Any web URL activates a web API. Web APIs are often called REST (representational state transfer) or RESTful.(We discussed it above)

Program APIs are based on remote procedure call (RPC) technology that makes a remote program component appear to be local to the rest of the software. Service oriented architecture (SOA) APIs, such as Microsoft*’*s WS-series of APIs, are program APIs.

API examples in the developer community

Companies like Facebook, Google, and Yahoo publish APIs to encourage developers to build on their capabilities. These APIs have given us everything from new internet features that browse the sites of other services, to mobile device apps that offer easy access to web resources.

New features, such as content delivery, augmented reality, and novel applications of wearable technology, are created in large part through these APIs.

Next time, Whenever you hear of the word API, Think of it as a code that allows two software programs to communicate with each other by running back and forth between applications, databases, and devices to deliver data and create connectivity.

What we have learned

API is some code that you didn’t write yourself, and that code has some methods that you are allowed to use.
In context of web, an API is a part of a remote server that receives requests and sends responses when you navigate to a website in your browser.
API can take many forms depending upon where it is being used for example Open APIs or Public APIs, Partner API, Internal Or Private API.
It can further be classified into Local API, Web API, Program API.
In short API is code that allows two software programs to communicate with each other.

Now, I hope you have a clear understanding of what an API is and its various nuances. I have seen people struggling with this term. Looking at it from a broader perspective will put an end to the struggle, that people have while learning this fancy term, which they call an API.

If you still have any questions, you can ask them in comments or reach out to me on my Twitter. 🙏

If you found this article helpful in someway then consider sharing it with others. Let me know your views on it, because to me it matters!

Take Care! See you in my other post!

What's inside the world most popular programming language?

Somnath Singh — Fri, 02 Oct 2020 09:24:53 +0000

A guide for the Ignorant Programmers.

I have tried to explain the concepts using very basic level of English language, so that a lot of newcomers can understand it without getting an imposter syndrome attack 😂

INTRODUCTION

A programming language is like a natural, human language in that it favors certain metaphors, images, and ways of thinking.
— Mindstorms: Children, Computers, and Powerful Ideas, Seymour Papert (1980)

We define programming, as a general human activity, to mean the act of extending or changing a system’s functionality. Programming is a widespread activity that is done both by non-specialists (e.g., consumers who change the settings of their alarm clock or cellular phone) and specialists (computer programmers, the audience for this article).

JavaScript

It is the most popular Programming language today.
Today, Some of the most powerful Software are written in JavaScript.
But how many folks do actually understand this language?
Probably this the only language which is used(usually in scripts) before it is fully understood.
JavaScript is a powerful programming language but Weird at the same time.
Yet we can’t deny this fact that overall it is a beautiful Programming language.

So,

Have you Ever Wondered, how do those assortments of programming statements tell the Computer what to do?

Statements like a = a + 2 are helpful for developers when reading and writing, but are not actually in a form the computer can directly understand.

So an uncommon utility on the Computer (either a interpreter or a compiler) is utilized to decipher the code you compose into directions that a Computer can comprehend!

For some computer languages, this translation of commands is typically done from top to bottom, line by line, every time the program is run, which is usually called interpreting the code.

For other languages, the translation is done ahead of time, called compiling the code, so when the program runs later, what’s running is actually the already compiled computer instructions ready to go.

It’s typically asserted that JavaScript is interpreted, because your JavaScript source code is processed each time it’s run. But that’s not entirely accurate.

The JavaScript engine actually compiles the program on the fly and then immediately runs the compiled code.

In this article we will LEARN about some essential concepts that will help you to understand what actually happens under the hood.
And by the end of the article you will have a clear understanding of what actually happens when you write a JavaScript CODE

Concepts that we will learn here are :

Syntax Parsers
Execution Contexts
Lexical Environments

GOAL : Understanding Syntax Parsers, Execution Contexts, and Lexical Environments in a Simple Language.

All three of these are complicated sounding terms that actually aren’t that difficult to understand.

SYNTAX PARSER :

A PROGRAM THAT READS YOUR CODE AND DETERMINES WHAT IT DOES AND IF IT’S GRAMMAR OR SYNTAX IS VALID

So when you write JavaScript it isn’t magically directly telling the computer what to do , you are abstracted away from all of that you are writing code! but then someone else or other people built programs that convert your JavaScript into something the computer can understand.

Was that too hard to comprehend?
No, Right?

Anyways,
Those programs are called compilers and at times they also have to do with interpreters, but those programs interpreters and compilers do the process the work of actually reading your code character by character and determining if the syntax is valid and then implementing that syntax in a way the computer can understand,

so when you’re thinking about your code think of it more like :

and a program that is going to convert what computer can understand !

Something like this:

If you have a function with the variable, then that function and variable will be represented in memory but it’s being translated from what you have written what is more human readable to what the computer can understand. There’s a compiler or an interpreter between those two things and part of that is a syntax parser so, it’s going through your code

character by character like f /u/ n/ c/ t/ i/ o/ n

That is, it reads your code in characters

and it says : Oh! that’s function 😃 ,So there should be a space after this ! and then the next thing I see up until the parenthesis ( ) will be the name of the function,

above Greet is next thing the computer sees up until the parenthesis ( ) so it assumes that Greet will be the name of the function.

And all this gets translated by the systems that someone else wrote but that also means that in that translation process ,the programmers who wrote the compiler can choose to do extra stuff .

Your code is not what’s actually being given to the computer but a translation of it and so along the way the engine that is interpreting your code can decide to do other things those programmers could have chosen to do something else and in fact that’s going to come up as an important element of understanding JavaScript so that’s impacts parsers and thinking about the programs that are actually running every time you run your JavaScript code that intermediate program that’s creating your code.

LEXICAL ENVIRONMENT :

The word lexical means having to do with words or grammar so we’re talking about the code you’re writing it’s syntax it’s vocabulary !

Now a lexical environment exists in programming languages in which,where you write something which is important.

It sounds kind of funny but actually not every programming language is that way, but remember we said you might have some code.

let’s say a function with a variable inside of it the variable sits lexically inside the function ,that is : physically the code that you’re writing

function with a variable inside of it.

that’s where it sits but remember we said that your code is not what’s actually given directly to the computer but it’s translated into something the computer can understand

In programming languages where the lexical environment is important that means that where you see things written gives you an idea of where it will actually sit in the computer’s memory of how it will interact with other variables and functions and elements of the program and that’s because the program or the compiler that’s converting your code to those instructions cares about where you put things it makes decisions that syntax parts are going through everything makes decisions so when we talk about the lexical environment of something in the code we’re talking about where it’s written and what surrounds it got that.

To help manage the code that is running there are lots of lexical environments areas of the code that you’re looking at physically but which one is currently actually running is managed via what’s called

EXECUTION CONTEXT:

A WRAPPER TO HELP MANAGE THE CODE THAT IS RUNNING

There are lots of lexical environments which one is currently running and managed via execution contexts.it contain things beyond what you have written in your code!

And in execution context contains your code ,the running code and it’s running your code, but it also can contain things beyond what you’ve written in your code because remember again your code is being translated being processed by a whole other feature a whole other set of programs that someone else wrote and so it’s executing your code and it can do other things as well and that’s what’s happening inside JavaScript.

Execution context is whole topic by itself which we will deal in some other article.

How was the Post ? Tell me in the comments.

DEV Community: Somnath Singh

The Story of AI: From Brain Cells to ChatGPT(… and what it really wants)

Struggling with Promises? You Are Not Alone!

Let us understand promises with this little story

Let us take the key points from it and apply them to JavaScript World.

Circumstances do not matter — only your state of being matters — what state of being are you choosing?

How to work with promises?

How to create a Promise*?*

How to fulfill or reject the promise?

How to Run a Callback Function — Depending on Whether the Promise Is Resolved or Rejected.

Summary

Note of Gratitude

Secret of Great Programmers Revealed

You need to do the right things — if you want the right things to happen to you

Ask yourself:

If you show me the HOW — I will find the WHY

Quantity Leads To Quality

TAKEAWAY:

Never give up — great things take time

Mile by mile one hits the milestone

How to do it:

You don’t have to see the whole staircase — just take the first step

How to do it:

10,000 Rule Is a Myth

Note of Gratitude

Git Commands That Will Save Your Job

The Real Fault Is to Have Faults And Not to AMEND Them

Well Crafted Thing Is a Thing to Behold

Bonus Tip:

Your Mistakes Don’t Define You

Bonus Tip:

Look for your choices, pick the best one, then go with it.

Real-Life Scenario:

Don’t Want All Of It? No Problem — Just Checkout

How does it work:

Someday…But Not Yet, Not Yet

It Is Time For You To Get Some Help.

Bonus Tip:

Conclusion

Note of Gratitude

Become Super Productive with Console.X

Come, let us sit at the table and have some conversation!

Time to add some flavors to your life.

Darling, you need to add some colour to your life.

Memories of a past love — C Programming.

Can You Describe that thing a Little Better?

Alone we are strong, together we are stronger!

You can count on me like 1,2,3 & I’ll be there!

To know oneself, one should assert oneself.

Are you tracing it?

Do you realize that’s the first time you’ve done that?

Further Reading

Summary

Note of Gratitude

Master ‘this’ in JavaScript

TL;DR

What is “this” in brief

#Rule 1. Default binding

#Rule 2. Implicit binding

#Rule 3. Explicit binding

Let us understand it with an example.

#Rule 4. New binding

Let us understand this with an example.

#Rule 5. Lexical binding

Conclusion

Note of Gratitude

Explain API in Plain English

What is an API?

These are the methods that we can call:

APIs in the context of Web

API examples in the developer community

What we have learned

What's inside the world most popular programming language?

INTRODUCTION

JavaScript

So,

For some computer languages, this translation of commands is typically done from top to bottom, line by line, every time the program is run, which is usually called interpreting the code.

For other languages, the translation is done ahead of time, called compiling the code, so when the program runs later, what’s running is actually the already compiled computer instructions ready to go.

GOAL : Understanding Syntax Parsers, Execution Contexts, and Lexical Environments in a Simple Language.

SYNTAX PARSER :

How to create a Promise?

**How to Run a Callback Function — Depending on Whether the Promise Is Resolved or Rejected.**