During a robbery in Zimbabwe, the bank robber shouted to everyone in the bank: "Don't move. The money belongs to the State. Your life belongs to you."

Everyone in the bank lay down quietly. This is called "Mind Changing Concept” Changing the conventional way of thinking.

When a lady lay on the table provocatively, the robber shouted at her: "Please be civilized! This is a robbery and not a rape!"

This is called "Being Professional” Focus only on what you are trained to do!

When the bank robbers returned home, the younger robber (MBA-trained) told the older robber "Big brother, let's count how much we got."

The older robber said: "You are very stupid.

There is so much money it will take us a long time to count. Tonight, the TV news will tell us how much we robbed from the bank!"

This is called "Experience.” Nowadays, experience is more important than paper qualifications!

After the robbers had left, the bank manager told the bank supervisor to call the police quickly. But the supervisor said to him: "Wait! Let us take out $10 million from the bank for ourselves and add it to the $70 million that we have previously embezzled from the bank”.

This is called "Swim with the tide.” Converting an unfavorable situation to your advantage!

The supervisor says: "It will be good if there is a robbery every month."

This is called "Killing Boredom.” Personal Happiness is more important than your job.

The next day, the TV news reported that $100 million was taken from the bank.

The robbers counted and counted and counted, but they could only count $20 million. The robbers were very angry and complained: "We risked our lives and only took $20 million. The bank manager took $80 million . It looks like it is better to be educated than to be a thief!"

This is called "Knowledge is worth as much as gold!"

The bank manager and the supervisor were all smiling and happy afterall !!


 Corruption and the Power of Education

What is a liquidity pool and how are token prices determined?

In our voting contract we have the following features:

Everyone can check the total number of votes of a party.

For creating such a contract, first I am making a contract named 

mapping's keys are string (party name) and values are uint (no. of votes of that party). After that, I declare a variable owner and inside a constructor, I am setting the owner to msg.sender. Inside the constructor parameter, I take the Array of parties. I iterate the parameter Array and assign each iterated value to the 

Value 1 is for represents that the party is valid, further, it becomes the total votes for that party.  

Now, I have to define a Struct for voting with some information. Struct 

string: party  (Here comes the party's name)

power: uint   (this is voting power initially 1)

isVoted: bool (check for already voted or not)

Well, we have now the mapping of parties, owner, and struct of Vote. Now, for total valid votes, I have a 

mapping, where the keys are addresses of voters and values are the votes (struct).

In the first check, I am checking whether the party is valid or not by checking not to 

because at the constructor, I am assigning value 

to each party indicating that the party is valid.

The second check is simple. It simply checks whether the caller's address was already voted on or not.

After passing two checks, I am incrementing the party value that we get from the parameter 

Also, I am passing the caller's address to 

this simply returns the Vote struct for the caller struct from the votes mapping.

which accepts the name of the party and returns the total number of votes of that party.

means removing the default value of votes.

Now we have two additional functionalities:

  By default, all addresses (voters) are whitelisted.

that holds the addresses of voters and bool values for allowed and disallowed.

Because by default the bool values are false resulting in everyone being whitelisted ( allowed ).

this modifier simply checks whether the caller of the function is the owner or not. 

statement is checking that the target address shouldn't already be blacklisted by passing the targeted address to the 

mapping. Then I am passing the target address to votes mapping to get its previous vote.  

for the target address, this means that the target address is already blacklisted so 

 statement toggle value to throw the error.

I am getting the name of the party ( the target address voted for ) and passing that name into 

mapping and decrement the value by the (target address voting) power. By default, 

returns the default value, so the voting power is 0 if the target address doesn't cast the vote.

After I am cleaning the target address vote from the 

Finally, I am assigning true for the target address in 

mapping, ensuring that the address is blacklisted.

The first require checks if the address is already whitelisted by checking isblacklist, if true then our code runs and if false it throws an error.

 mapping, if he didn't cast yet, then it saves the default vote struct.

Then I am incrementing that party votes as I decrement in 

Next, I cleared the (target address) vote from 

Finally, I am removing that address form 

So, our entire code looks like this, if want to get the source code, check out my GitHub repo: 

Basic Solidity Voting Smart Contract  

The this keyword can be confusing to even experienced JavaScript programmers. In other programming languages, this is used to refer to the current instance of an object created from a class. In JavaScript, the this keyword can often appear to work the same way—right up until the moment a change breaks the application and undefined values start to appear.

To demonstrate, I used the fat arrow syntax.

The method uses the same console.log statement, but when the change is saved and the code is executed, the output shows undefined values, like this:

Understanding why this happens and being able to fix the problem requires taking a step back and examining what the this keyword really does in JavaScript.

Understanding the this Keyword in Stand-Alone Functions

The this keyword can be used in any function, even when that function isn’t used as a method

function reads a property named greeting from this in one of the expressions in the template string passed to the console.log method. The this keyword doesn’t appear again in the listing, but when the code is saved and executed, the following output is produced:

JavaScript defines a global object, which can be assigned values that are available throughout an application. The global object is used to provide access to the essential features in the execution environment, such as the document object in browsers that allows interaction with the Document Object Model API.

keyword are assigned to the global object. The statement that assigns the string value Hello creates a variable in the global scope. When the function is executed, this is assigned the global object, so reading 

returns the string value Hello, explaining the output produced by the application.

The standard way to invoke a function is to use parentheses that contain arguments, but in JavaScript, this is a convenience syntax that is translated into the statement.

As explained earlier, functions are objects, which means they define methods, including the call method. It is this method that is used to invoke a function behind the scenes. The first argument to the call method is the value for this, which is set to the global object. This is the reason that this can be used in any function and why it returns the global object by default.

The new statement uses the call method directly and sets the this value to the global object, with the same result as the conventional function call before it, which can be seen in the following output produced by the code when executed:

The name of the global object changes based on the execution environment. In code executed by Node. js, global is used, but window or self may be required in browsers. At the time of writing, there is a proposal to standardize the name global, but it has yet to be adopted universally.

JavaScript supports strict mode, which disables or restricts features that have historically caused poor-quality software or that prevent the runtime from executing code efficiently. When strict mode is enabled, the default value for this is undefined to prevent accidental use of the global object, and values with global scope must be explicitly defined as properties on the global object.

 for details. The TypeScript compiler provides a feature for automatically enabling strict mode in the JavaScript code it generates. 

When a function is invoked as an object’s method, this is set to the object.

When the function is invoked via the object, the statement that invokes the function is equivalent to using the call method with the object as the first argument, like this:

Care is required because this is set differently if the function is accessed outside of its object, which can happen if the function is assigned to a variable.

Functions can be used like any other value, including assigning them to variables outside of the object in which they were defined, as shown in the listing. If the function is invoked through the variable, then this will be set to the global object. This often causes problems when functions are used as arguments to other methods or as callbacks to handle events, and the effect is that the same function will behave differently based on how it is invoked, as shown in the output produced by the code

Changing the Behavior of the this Keyword

One way to control the this value is to invoke functions using the call method, but this is awkward and must be done every time the function is invoked. A more reliable method is to use the function’s bind method, which is used to set the value for this regardless of how the function is invoked.

The bind method returns a new function that will have a persistent value for this when it is invoked. The function returned by the bind method is used to replace the original method, ensuring consistency when the writeMessage method is invoked. Using bind is awkward because the reference to the object isn’t available until after it has been created, which leads to a two-step process of creating the object and then calling bind to replace each of the methods for which a consistent this value is required. This code produces the following output:

function is invoked as a standalone function.

To add to the complexity of this, arrow functions don’t work in the same way as regular functions. Arrow functions don’t have their own this value and inherit the closest value of this they can find when they are executed. To demonstrate how this works.

The getWriter function is a regular function that returns an arrow function as its result. When the arrow function returned by getWriter is invoked, it works its way up its scope until it locates a value for this. As a consequence, the way that the getWriter function is invoked determines the value of this for the arrow function. Here are the first two statements that invoke the functions:

These two statements can be combined as follows:

The combined statement is a little harder to read, but it helps emphasize that the value of this is based on how a function is invoked. The getWriter method is invoked through myObject and means that the value of this will be set to myObject. When the arrow function is invoked, it finds a value of this from the getWriter function. The result is that when the getWriter method is invoked through myObject, the value of this in the arrow function will be myObject, and the this.greeting expression in the template string will be Hi, there.

The statements in the second set treat getWriter as a stand-alone function, so this will be set to the global object. When the arrow function is invoked, the this.greeting expression will be Hello. This code produces the following output, confirming the this value in each case:

I started this section by redefining a function in the arrow syntax and showing that it behaved differently, producing undefined in its output. Here is the object and its function:

The behavior changed because arrow functions don’t have their own this value, and the arrow function isn’t enclosed by a regular function that can provide one. To resolve the issue and be sure that the results will be consistent, I must return to a regular function and use the bind method to fix the this value.

With these changes, the value of this for the writeDetails method will be its enclosing object, regardless of how it is invoked.

Understanding the this Keyword in JavaScript

﻿When we put double equality check operator between two different types of variables, the JavaScript runtime converts one value into an equivalent value in the other type, this process is known as 

This type conversion feature in JavaScript leads to the inconsistent

The double equal sign performs a comparison using type coercion so that JavaScript will try to convert the values it is working with in order to produce a useful result. The double equal sign performs a comparison using type coercion so that JavaScript will try to convert the values it is working with in order to produce a useful result. This is known as the JavaScript abstract equality comparison, and when a number is compared to a string, the string value is converted to a number value, and then the comparison is performed. This means when the number value 100 is compared with the string value 100, the string is converted to the number value 100, and this is the reason why the if expression evaluates to true.

, one of the values is converted. The confusing part is that the conversion isn’t the same as for comparisons. If either of the values is a string, the other value is converted to a string, and both string values are concatenated. This means that when the number value 100 is added to the string value 100, the number is converted to a string and concatenated to produce the string result 100100.

operators, the JS compiler tries to convert values to the number type. 

﻿The output might be  shocking because all the values first converted to number type then further goes into expression.

 ( === ). By using triple checks, JavaScript doesn't converts the datatypes of variables. Type coercion can be a useful feature, and it has gained a poor reputation only because it is applied unintentionally, which is easy to do when the types being processed are changed with new values.

The double equal sign (==) performs a comparison that applies type coercion. The triple equal sign (===) applies a strict comparison that will return true only if the values have the same type and are equal. To prevent string concatenation, values can be explicitly converted to numbers before the + operator is applied using the built-in Number function, with the effect that numeric addition is performed.

Appreciating the Value of Explicitly Applied Type Coercion

Type coercion can be a useful feature when it is explicitly applied. One useful feature is the way that values are coerced into the Boolean type by the logical OR operator 

. Values that are null or undefined are converted into the false value, and this makes an effective tool for providing fallback values.

is set with an expression that checks the 

The undefined type is used when variables are defined but have not been assigned a value, which is the case for the variable named firstCity, and the use of the || operator ensures that the fallback value for secondCity will be used when firstCity is undefined or null.

﻿The problem doesn't just occurs with  null and undefined, but also with zero.

﻿If we assign zero value to a variable, that variable is also considered as false value. Let's take another example:

In addition to null and undefined, the logical OR operator will also coerce the number value 0 (zero), the empty string value (""), and the special NaN number value to false. These values, in addition to the false value, are collectively known as the JavaScript “falsy” values and cause a lot of confusion. In Listing 3-12, the logical OR operator uses the fallback value when the taxRate variable is assigned zero and produces the following output:

The code doesn’t differentiate between an unassigned value and the zero value, which can be a problem when zero is a required value. In this example, it is impossible to set a tax rate of zero, even though this is a legitimate rate. To address this problem, JavaScript supports the nullish coalescing operator, ??, which only coerces undefined and null values and not the other falsy values.

In the first statement, the fallback value will be used because taxRate is undefined. In the second statement, the fallback value will not be used because zero is not coerced by the ?? operator, producing the following output:

What is Type Coercion in JavaScript?

Under the hood, JavaScript manages concurrency and asynchrony. JavaScript is a language with only one thread. In this usage, a thread refers to an execution path. Tasks will have to wait for one another if there is only one path, and only one item can happen at once.

The event loop is this single executor. It is a method for carrying out the actual work. Given that you recently learnt about concurrency and performing tasks simultaneously yet asynchronously, you might be curious about this. JavaScript is single-threaded, but that doesn't mean it can't dispatch some tasks and wait for them to return. This is exactly how JavaScript performs tasks in a multithreaded manner.

All the tasks that JavaScript needs to perform are queued up on a call stack, which is how it operates. The event loop is a process that continuously monitors this call stack. When tasks need to be completed, the event loop completes them one at a time. The tasks at the top are completed first.

Here's a visualization of the call stack and event loop for this script.

No multithreading is going on here. But it is here:

The web API of the browser receives the setTimeout() task. When finished, this shows up in a specific location called the 

queue. The event loop will scan the callback queue for available tasks only when the call stack is empty (and only then!). 

that are still awaiting action will be carried out one by one. The event loop first checks the call stack for work after each action.

Here's a visualization of the situation with the outsourcing of

() expires, the event loop will have done whatever was on the call stack already, and will check the callback queue and execute any tasks on there:

Let's see if you read the above text well.

What do you think will happen when we set the timer to 0 , like here?

The output from this will be the same. When the timer reaches 0 it will also outsource the call to 

(). The event loop won't even check the callback queue until the 

is empty, despite the fact that the callback is immediately added to the callback queue. So even if the timer is at So even if the timer is at 0,

How JavaScript Event loop Manages Asynchronous Tasks?

With Promises, we can organize the sequence of our code in a slightly easier-to-maintain way. A Promise is a special object that connects code that needs to produce a result and the code that needs to use this result in the next step.

When we create a Promise, we give it a function. In the following example, we use a convention that we have seen a lot; we are creating a function on the spot. So, inside the argument list we are defining the function, often done using arrow functions as well. This function needs two parameters, and these parameters are callbacks. We have called them 

You can call these parameters anything you want, but 

() is called, the Promise is presumed to be successful and whatever is between the arrows is returned and used as input for the then method on the Promise object. If 

() is called, the Promise failed and the 

() method on the Promise object (if present) is executed with the argument of the 

We first create a Promise. When creating a Promise , we don't know what the value of the Promise is going to be. This value is whatever is sent as an argument to the resolve function. It is a sort of placeholder. 

So when we call then on the Promise, we basically say: figure out what the value of the Promise is, and when you know, execute one function if the Promise was resolved or a different function if it was rejected. When a Promise is neither resolved nor rejected, we say that the 

() is a Promise itself, so when it returns we can use the result for the next 

() instance. This means we can chain the 

for the next function. You can see that the last block is a catch() function. If any of the functions were to result in a rejection and the Promise were therefore rejected, this 

() block would be executed and print whatever the 

 because the first Promise was rejected instead of resolved. This is great for creating 

processes that need to wait till another process is complete. We can try to do a certain set of actions and when something goes wrong, use a 

Promises in JavaScript

What happens if you try to overwrite an element that does not exist?

The elements in an array can be overwritten. This can be done by accessing a certain element using the index and assigning a new value:

The output of this log is Tesla because it has overwritten the old value, Toyota . If we output the whole array:

Let's see what happens when we try to write the values to the console:

Does negative index values effect the Array's length?

The length is one higher than the maximum index because the index of the 

Ha! They suddenly exist. How is that you may wonder?

For now, just remember that this is not the right way to add values to the array

What happens in JavaScript if you try to overwrite an element that does not exist?

Especially with null and undefined, it can be hard to determine what kind of data type you are dealing with. Let's have a look at type of . This returns the type of the variable. You can check the type of a variable by entering type of , then either a space followed by the variable in question, or the variable in question in brackets:

There is an odd one out, and that is the null type. In the output you can see that typeof null returns object , while in fact, null truly is a primitive and not an object. This is a bug that has been there since forever and now cannot be removed due to backward compatibility problems. Don't worry about this bug, as it won't affect our programs—just be aware of it, since it will go nowhere anytime soon, and it has the potential to break applications.