DEV Community: AKIRI FEJIRO

The Complete Guide to JavaScript Variables for Beginners

AKIRI FEJIRO — Mon, 20 Feb 2023 18:14:35 +0000

Imagine you’re a chef, and you’re preparing a dish that requires many ingredients. You carefully measure and combine each ingredient to create a delicious and balanced flavor. Without the right ingredients, your dish wouldn’t taste the way you wanted it to.

In the same way, when it comes to building a website or application, it’s important to have the right tools and programming language to create a user experience that stands out. Just like a recipe, each line of code serves a specific purpose in creating the result.

JavaScript is one of the most crucial ingredients in modern web development, allowing developers to create dynamic and interactive user experiences. And at the core of JavaScript programming are variables—the containers that hold and manipulate data.

In this guide, we’ll dive into everything you need to know about JavaScript variables and how to use them to create powerful and dynamic user experiences. Whether you’re a seasoned developer or just starting, this guide will provide a complete introduction to JavaScript variables and give you the foundational knowledge you need to use them effectively in your code.
So, let’s start cooking up some amazing web applications with JavaScript!

Declaring and Initializing Variables

Just as a chef carefully measures and combines different ingredients to create a delicious dish, a developer uses variables to store and manipulate different types of data in their code.

In JavaScript, variables are containers that hold values, such as strings, numbers, or booleans, and can be used to store data or perform calculations. Before you can use a variable, you need to declare it, which involves creating a name for the variable and specifying its data type.

To declare a variable in JavaScript, you use one of three keywords: var, let, or const. The var keyword was used in older versions of JavaScript, but now it's recommended to use either let or const, which provides more predictable behavior and better scope control.

Once you’ve declared a variable, you can then assign a value to it using the assignment operator (=). For example, you could declare and initialize a variable called myName with the value "Alice" like this:

let myName = "Alice";

In this example, the variable myName is declared using the let keyword, and its value is initialized to the string “Alice.”
In addition to strings, variables can also hold other types of data, such as numbers or booleans. For example, you could declare and initialize a variable called myAge with the value 25 like this:


let myAge = 25;

Or you could declare and initialize a boolean variable called isStudent with the value true like this:

const isStudent = true;

In each of these examples, the variable is declared using a different keyword (let or const) and is assigned a different data type (string, number, or boolean).

Understanding how to declare and initialize variables is a critical skill in JavaScript programming, and it provides the foundation for working with more complex data structures and functions.

In the next section, we’ll explore how to use variables in more advanced ways to create dynamic and interactive web applications.

Variable scopes and Hoisting

As we’ve seen, variables are like ingredients in a recipe—they allow you to store and manipulate data to create amazing web applications. But there’s more to variables than just declaring and initializing them. In JavaScript, variables have different scopes, which determine where and how they can be accessed.
Let’s take a closer look at variable scopes and hoisting in JavaScript.

Variable Scopes

In JavaScript, variables can be either global or local. A global variable is declared outside of any function and can be accessed from anywhere in your code. A local variable, on the other hand, is declared inside a function and can only be accessed within that function.

Here’s an example of declaring a global variable:


let globalVar = 'I am a global variable';

function logGlobal() {
  console.log(globalVar);
}

logGlobal(); // output: "I am a global variable"

And here’s an example of declaring a local variable:


function logLocal() {
  let localVar = 'I am a local variable';
  console.log(localVar);
}

logLocal(); // output: "I am a local variable"
console.log(localVar); // ReferenceError: localVar is not defined

As you can see, the global variable globalVar can be accessed from both the logGlobal() function and outside of it, while the local variable localVar can only be accessed within the **logLocal() **function.

For example:


console.log(myVar); // output: undefined
var myVar = 'I am hoisted';

console.log(myVar2); // ReferenceError: myVar2 is not defined
let myVar2 = 'I am not hoisted';

In the first example, the variable myVar is declared and assigned a value after it’s called in the console.log() statement. However, because of hoisting, the variable declaration is moved to the top of its scope, so the variable is defined but has a value of undefined

In the second example, we’re trying to use the variable myVar2 before it’s declared. However, because** let** declarations are not hoisted, we get a ReferenceError

Understanding variable scopes and hoisting is critical for writing efficient and bug-free JavaScript code. With this knowledge in hand, you’ll be well on your way to becoming a master chef of web development!

Types of Variables in JavaScript

Just as a chef has different types of ingredients to choose from, JavaScript developers have different types of variables to use in their code. In JavaScript, there are three main types of variables: let, var, and const. Each type of variable has its unique characteristics and use cases.

let Variables

The let keyword is used to declare a variable that can be reassigned to a new value. This type of variable is block-scoped, meaning it is only accessible within the block of code where it is defined.

Here’s an example:


let ingredient = "flour";
console.log(ingredient); // output: flour

ingredient = "sugar";
console.log(ingredient); // output: sugar

In this example, we declare a variable called ingredient using the let keyword and assign it the value "flour." We then log the value of the variable to the console, which outputs "flour." We then reassign the variable to the value "sugar" and log it to the console again, which outputs "sugar."

var Variables

The var keyword is similar to let in that, it is used to declare a variable, but it has some important differences. var Variables are function-scoped, meaning they are accessible throughout the entire function where they are defined.

Here’s an example:


function cookDish() {
  var ingredient = "olive oil";
  console.log(ingredient); // output: olive oil
}

cookDish();
console.log(ingredient); // output: ReferenceError: ingredient is not defined

In this example, we declare a variable called ingredient using the var keyword inside a function called cookDish(). We then log the value of the variable to the console, which outputs "olive oil." Since var variables are function-scoped, the variable is only accessible within the function where it is defined. When we try to log the variable outside of the function, we get a ReferenceError because the variable is not defined in that scope.

const Variables

The const keyword is used to declare a variable that cannot be reassigned to a new value. This type of variable is also block-scoped, like let.

Here’s an example:


const ingredient = "butter";
console.log(ingredient); // output: butter

ingredient = "oil"; // TypeError: Assignment to constant variable.

In this example, we declare a variable called ingredient using the const keyword and assign it the value "butter". We then log the value of the variable to the console, which outputs "butter". When we try to reassign the value of the variable to "oil", we get a TypeError because** const** variables cannot be reassigned.

Differences between the Types of Variables

Now that we’ve explored the different types of variables in JavaScript, let’s discuss their differences.

The main differences between let, var, and const variables are their scope and mutability. let and const variables are block-scoped, meaning they are only accessible within the block of code where they are defined. var Variables are function-scoped, meaning they are accessible throughout the entire function where they are defined.

let and var variables can be reassigned to new values, while const variables cannot. This makes const variables useful for defining constants in your code that you do not want to be changed.

In summary, let, var, and const, variables all have their unique characteristics and use cases. As a JavaScript developer, it’s important to understand the differences between these various types of variables so you can use them effectively in your code. By understanding the different types of variables and their characteristics, you can write cleaner, more efficient, and more maintainable code in your JavaScript applications.

Best Practices for Using Variables in JavaScript

When working with variables in JavaScript, following best practices can make your code cleaner, more efficient, and easier to understand. Here are a few key best practices to keep in mind:

Use Descriptive Variable Names Choosing clear and descriptive variable names is essential for writing readable and maintainable code. Good naming conventions include using descriptive names that reflect the purpose of the variable, avoiding abbreviations and acronyms, and using camel cases to make names easier to read.


// Example of good variable naming conventions
let userName = "John Smith";
let numberOfUsers = 10;
let isLoggedIn = true;

2.Initialize Variables When Declared

Initializing variables when they are declared can help you avoid unexpected errors and make it easier to keep track of the data being stored in the variable.


// Example of initializing a variable when it's declared
let message = "Hello World!";

3.Avoid Common Mistakes

When working with variables, it’s important to avoid common mistakes. Two common mistakes are declaring a variable with the wrong data type and using global variables unnecessarily.


// Example of declaring a variable with the wrong data type
let price = "10.99"; // should be a number

// Example of using global variables unnecessarily
let counter = 0; // should be a local variable within a function

By following these best practices and avoiding common mistakes, you can create cleaner, more efficient code and become a better JavaScript developer. Just like a chef who follows best practices in the kitchen, a JavaScript developer who follows best practices for using variables can create more reliable, functional, and visually appealing web applications.

Case study

Now we will move on to a case study on using variables in a shopping cart application. In this example, we’ll explore how variables are used to store product information and calculate order totals, and how they can be used to enhance the functionality and user experience of the application.

Imagine you’re building an e-commerce website that allows customers to add items to their shopping cart and place orders. To create a shopping cart, you’ll need to use variables to store information about each product, such as its name, price, and quantity.

Here’s an example of how you might use variables to store product information:


const product1 = {
  name: "T-shirt",
  price: 20,
  quantity: 2
};

const product2 = {
  name: "Jeans",
  price: 50,
  quantity: 1
};

In this example, we’re using objects to store information about each product. The name, price, and quantity properties are all variables that store specific information about each product.

To calculate the order total, we can use variables to keep track of the total price of each product, and then add them together to get the final total. Here’s an example of how you might do that:


const total1 = product1.price * product1.quantity;
const total2 = product2.price * product2.quantity;
const orderTotal = total1 + total2;

In this example, we’re using variables to calculate the total price of each product and then add them together to get the order total.

Using variables in this way can help to make your shopping cart application more dynamic and interactive. For example, you could use variables to update the order total in real-time as the customer adds or removes items from their cart.

Conclusion

Just like a chef needs to understand the ingredients and techniques to create a delicious dish, a JavaScript developer needs to understand variables to write clean and efficient code. I covered the different types of variables, scopes, and best practices for using them.

I applied this knowledge to a shopping cart application, demonstrating how variables can enhance functionality and user experience. I encourage readers to practice using variables in their code and explore additional resources to improve their craft. Understanding variables are fundamental to programming in JavaScript, and I hope this guide has helped demystify them. Happy coding!

NFT explained

AKIRI FEJIRO — Thu, 31 Mar 2022 16:42:20 +0000

NFT explained

If you are in any way as curious as I am, well I am sure you have asked the question; what are NFTs? or what is it about NFTs that make them so mainstream. While NFTs have been around for quite a while, it took Beeple, Cryptopunks, and Bored Ape Yacht Club to put this new technology on the map. Ever since then Adidas, Nike, Disney, and many celebrities have jumped into NFTs. And just like we saw with Crypto’s developmental cycle as Chris Dixon explained;

Chris Dixon’s on Cryptonetworks and why they matter via a16z

it started with Price which led to interest, then new ideas erupted and then we had startup projects created related to it and we saw further increase in value and a directly proportionate increase in price.
NFT’s can be tricky to understand, however, the more they make headlines the more reasons we have to understand just what it is.

What are NFTs?

Let’s start with a definition. To expand on the acronym. It simply means Non-Fungible Token. To elaborate on that;

NFT which stands for Non-fungible token is just a term used to describe a unique digital asset, whose ownership is tracked on a blockchain. This can be a really broad set of assets from;

A unique digital artwork
A digital collectible
An essay
A virtual baseball trading card
An in-game item
A music
A video
These digital assets are bought and sold online typically with cryptocurrency. To make it much simpler to understand, NFTs are simply a way to make digital files ownable. You can now own a JPEG or an MP3. So, when you say you create an NFT, you’re metaphorically ‘uploading’ that file to the blockchain such that anyone can track its provenance and attribution.

What Makes Non-Fungible Tokens Important?
The focus is on the word fungible which in the simple dictionary meaning means changeable, replaceable, interchangeable, you get the idea. Something fungible simply means it can be changed and replaced. For example, when you think of $1, that’s fungible or even a single BTC is fungible as it can be replaced. Meaning it retains the same value.

To further explain this, let’s talk a bit about how NFTs are different from Cryptocurrency;
NFT stands for non-fungible token. It’s generally built using the same kind of programming as cryptocurrency, like Bitcoin or Ethereum, but that’s where the similarity ends. Physical money and cryptocurrencies are “fungible,” meaning they can be traded or exchanged for one another. They’re also equal in value — one dollar is always worth another dollar; one Bitcoin is always equal to another Bitcoin. Crypto’s fungibility makes it a trusted means of conducting transactions on the blockchain.
NFTs are different. Each has a digital signature that makes it impossible for NFTs to be exchanged for or equal to one another (hence, non-fungible). One NBA Top Shot clip, for example, is not equal to every day simply because they’re both NFTs. (One NBA Top Shot clip isn’t even necessarily equal to another NBA Top Shot clip, for that matter.) NFTs are unique in value, each has a different value.

A Brief History of NFTs
Before there was Ethereum there as always been NFTs.

2012: Colored Coins

The concept of NFTs was introduced in 2012 when a paper by Meni Rosenfeld introduced the concept of “Colored Coins” issued on the Bitcoin blockchain. The paper was titled overview of colored coins. The term “Colored Coins” loosely describes a class of methods for representing and managing real-world assets on top of the Bitcoin Blockchain and can be used to prove ownership of those assets.

Colored coins aid the groundwork for further experimentation in the future. This is the beginning of our origin story.

2014–2016: Counterparty

During those years, a significant amount of development and experimentation has taken place in platforms built on top of the Bitcoin blockchain. It was the start of Ethereum’s reign over NFTs. Most notable is the Counterparty platform which allowed the creation of digital assets. Later on, Spells of Genesis followed Counterparty’s footsteps and through its platform pioneered issuing game assets.

Counterparty is a peer-to-peer financial platform and open-source, distributed Internet protocol constructed on top of the Bitcoin blockchain. It was among the early Bitcoin 2.0 platforms and provided a way for users to create their tradable currencies or assets. It was used for, among other things, meme trading in 2016 with the release of Rare Pepes NFTs. This was the beginning of the shift for NFTs to the Ethereum blockchain.

NFTs go public: 2017–2021

NFTs find a better home on Ethereum
With the introduction of the Ethereum blockchain in 2014 and its platform going live on July 30, 2015, a new age for the NFTs began. The Ethereum blockchain introduced a set of token standards that allowed the creation of tokens by developers. In brief, the token standard is the subsidiary of the smart contract standard. For the blockchain that supports the smart contracts, the token standard is often included to tell people how to create, issue and deploy new tokens, which are based on their underlying blockchain.

2017: Cryptopunks
Building on the popularity of the likes of the Rare Pepe Directory, creative technologists John Watkinson and Matt Hall created a set of 10,000 unique characters on the Ethereum blockchain, whereby no two were the same. The 10,000 Cryptopunks were rapidly snapped up and traded online.

The influence of the Cryptopunks project helped inspire the NFT ERC-721 standard and establish the current crypto art movement.

2017–2018: CryptoKitties

CryptoKittiesis a blockchain-based virtual game that allows players to adopt, breed, and trade virtual cats from the safety of their wallets. It was released by a Vancouver-based company called Axiom Zen and was introduced during the world’s largest hackathon for the Ethereum ecosystem. With over 400 developers attending, it was the perfect place to introduce the game. This project went viral soon after. It was so popular that people were making crazy profits trading those cats.

Also, the activity was so high that CryptoKitties clogged the Ethereum blockchain in general, which made it even more prominent. After witnessing this activity, people began to realize the true power and potential of NFTs.

NFT gaming: 2018–2020

Between this period and moving forward, NFTs slowly but surely caught public attention, most certainly through NFT gaming and metaverse projects. The first to enter this space with its decentralized Ethereum-based VR platform was Decentraland (MANA). In Decentraland, gamers can explore, build, play games, collect items, and more. Imagine Minecraft, but whatever you build, find and earn there, you own as well.

Soon after, platforms and games with Enjin Coin (ENJ) started emerging, a blockchain-based platform that allows developers to tokenize in-game items on Ethereum. With the use of ENJ, it can back those items with real-world value. Likewise, Axie Infinity (AXS) surfaced, a blockchain-based trading and battling game that’s partially owned and operated by its players. All those platforms were in development through the crypto-winter (bear market) and under the radar of many people. That is until 2021 came and NFTs went mainstream.

What the future holds: 2021
The NFT explosion 2021

In 2021, interest in NFTs increased. Other Blockchains such as Cardano, Solana, Tezos, Flow, etc. started getting into the game with their version of NFTs, establishing new standards to ensure that the digital assets represented are authentically one of a kind. Specifically, at the beginning of the second quarter of the year, the buying surge was so astonishing that the mainstream media often called for a huge bubble that was about to burst. Likewise, the fourth quarter showed a significant surge in NFT demand, especially in the metaverse field just after the announcement of Facebook renaming itself as Meta and moving to the metaverse as well.

2021 and beyond
The history of non-fungible tokens is much longer than most people realize. As we start moving from an experimental era to the mainstream, the future holds endless opportunities. Despite the massive growth that we recently experienced, I believe that this space is still young, and growth will only continue. I believe that the NFT space will grow as more and more people realize the impact that NFTs can have in most of our current fields. To get a deeper understanding of the history of NFTs you can check out this article written by Andrew Steinwold.

What is NFT Minting?
Minting an NFT involves uploading a digital art file such as an image, gif, or video and bringing it onto the blockchain network. Once the NFT is brought onto the decentralized network, it will live there forever and cannot be removed or modified.
Whoever brought the NFT onto the blockchain will have their crypto wallet address tagged to the NFT. This means that even if an NFT is bought and sold between 200+ people, its provenance is trackable to its original creator/owner.
As complicated as it may sound, most marketplaces (Opensea, Rarible, Foundation, MakersPlace) have simplified the process. Market places are places you can mint and sell your NFTs. Will talk more about marketplaces when I share a few steps by step on how to mint an NFT.

How do NFTs work?
NFTs exist on a blockchain, which is a distributed public ledger that records transactions. You are probably most familiar with blockchain as the underlying process that makes cryptocurrencies possible. Specifically, NFTs are typically held on the Ethereum blockchain, although other blockchains support them as well.

An NFT is created or minted from digital objects that represent both tangible and intangible items, including:

Art
GIFs
Videos and sports highlights
Collectibles
Virtual avatars and video game skins
Designer sneakers
Music

Even tweets count. Twitter co-founder Jack Dorsey sold his first-ever tweet as an NFT for more than $2.9 million.
Essentially, NFTs are like physical collector’s items, only digital. So instead of getting an actual oil painting to hang on the wall, the buyer gets a digital file instead. They also get exclusive ownership rights. Yes! NFTs can have only one owner at a time. The unique data of NFTs makes it easy to verify their ownership and transfer tokens between owners. The owner or creator can also store specific information inside them. For instance, artists can sign their artwork by including their signature in an NFTs metadata.

Conclusion
Essentially, NFTs are still a very recent development in the world but the crypto space moves at a fast pace and there have already been a lot of developments in NFTs so that they provide more utility rather than just images such as providing unique experiences to the owner.

It’s an inevitable story of technology that you give people tools and things will happen — so it’ll be interesting to see what happens as we keep on innovating within this space.

Web 2.0 vs Web 3.0- The Old vs the New.

AKIRI FEJIRO — Tue, 08 Mar 2022 16:15:40 +0000

To dive into our understanding of Web 3. We need to get a brief on the evolution of the web from its very first version; web 1, web 2, and finally web 3. To understand the future, best we take a quick trip through time. Let's create a bridge from the past to the present and trail a road to the future.

Evolution of the Web
The internet as we know has evolved in different phases over the years since it was created. In the first phase, we had Web 1.0 which included static web pages which served content from the file system of servers. Web 1.0 allowed internet users to access data from almost any corner of the world. However, Web 1.0 did not offer any functionalities for interaction with the content. As a result, Web 2.0 started to gain prominence and the subsequent identification of setbacks in web 2.0 led to the development of web 3.0. Let’s dive into learning about web 2.0 and Web 3.0 before talking about their differences.

What is Web 2.0?

Web 2.0 represents the internet as we know it today and includes all the blogs, social media sites, shopping, the new generation, and more!

It is marked by user-generated content, interoperability across different services, usability, interactiveness, and high levels of participation. While this may seem like a huge leap from the static pages of web 1.0, in reality, there have been little to no changes to the core definition between the two versions.

What has changed is the way we use existing infrastructure, and from this standpoint, it's safe to say that it’s the front-end that has seen the bulk of changes in Web 2.0.

Features of Web 2.0
In Web 2.0, users can:

Classify and sort information
Send and receive information from different sources
Create and share dynamic and responsive content with others.
Access content from mobile devices, multimedia consoles, televisions, and more
Create and develop APIs for interoperability across different software.

The web 2.0 applications have showcased a formidable frontend revolution with more opportunities for interaction with the end-users. Users could find a wide range of applications in web 2.0 for different applications. Some of them include social media, blogging, web content voting, social bookmarking, podcasting, tagging.

As much as these are great features of the technologies accrued to Web 2.0, it doesn’t create a sense of trust among the entities participating in interaction because of a lack of built-in security and authorisation mechanisms.

As users and technologies become more mature, there emerged a greater need for trust, security, privacy, and control. And this led to the evolution of web 3.0.

What is Web 3.0?

Web 3.0 presents a promising improvement over Web 2.0, especially with major transformations in terms of infrastructure. Also referred to as the semantic web, the third generation of the web leverages an advanced metadata system. The metadata system helps in structuring and arranging all types of data for making it readable for humans and machines.

Probably the biggest advantage of web 3.0 is that the information will be universal and can be found by anyone, which means no more digging through the content for hours to find what you want. You might wonder how it overcomes the drawbacks of web 2.0.

Well, the pillars of web 3.0 are artificial intelligence and decentralized networks. The use of artificial intelligence enables machine-to-machine interaction, advanced analytics, and other smart operations that were hitherto impossible on the web.

As for decentralized networks, it pushes data to the edges and into the hands of the entities that own it. In the process, it empowers entities to own their data and determine how it can be shared, thereby giving rise to a philosophy called the Self-Sovereign Identity.
These networks also give privacy and security to users through encryption and the use of Distributed Ledger Technologies (DLT), thereby overcoming the trust barriers that were present in web 2.0.

Features of Web 3.0
A stronger foundation towards understanding the difference between Web 2 and Web 3 is built by understanding and focusing on the features of Web 3. Here are some crucial highlights about Web 3.0 which would help in differentiating it from Web 2.0.

Web 3.0 leverages artificial intelligence for offering correct results at a faster pace alongside accessing real-time insights.
Web 3.0 also enables users to capitalize on the potential of 3D visuals and graphics.
Another critical feature of Web 3.0 refers to the Semantic Web functionality. The Semantic Web can understand the meaning of words, so content can be easily found, shared, and analyzed by both machines and humans.
Web 3.0 protects user identity and data through advanced authorization mechanisms such as encryption and DLTs
Delivers a high level of security and privacy.

Below is a bird’s eye view of the differences between Web 2.0 and Web 3.0.

In all, web 3.0 is a huge leap forward as it creates the infrastructure needed for humans and machines to interact, create, find, and share distributed data, make accurate predictions with artificial intelligence and be empowered to control one’s identity through a web of trust, security, and privacy.

To learn more about Web 3.0 technologies and their innovations, follow Blockgames, Nestcoin, and Zuriteam.