Forem: Augusta Ehihebolo

Easy and Clean Way to Use Fastest-Validator in Your Express.js App

Augusta Ehihebolo — Fri, 23 Dec 2022 06:18:31 +0000

Introduction

Data validation is a way of checking the integrity, structure and accuracy of data before sending to the database. It is a way of ensuring that your data have been cleaned before entering the database to assure data quality, that is, that they are both accurate and valuable. You do not want to go to bed thinking of the possible wrong data users might have sent to the database. Therefore, data validation must be placed as a topmost priority while creating your API.

Fastest-Validator is one of the different types of validation libraries used for data validation. All thanks to everyone behind the numerous validation libraries that have made data validation a lot easier lately.

In this tutorial, we shall understand what the fastest-validator is, its advantages over other types of validation libraries, and learn the simple and clean way to validate data using the fastest-validator. We shall achieve this by building a product management API using Express.js, MongoDB database and the fastest-validator library to validate every input.

Prerequisites

This tutorial is a hands-on-tutorial, code along with me to get the most out of it and ensure you have:

Node.js installed
Knowledge of Express.js
knowledge of MongoDB.
Your favorite code editor opened
Postman or Insomnia installed.

What is Fastest-Validator

Fastest-validator is a validation library for Node.js, browser, and Deno used to validator input data to ensure clean and quality data in our database. It is very easy to use. Some of its key features are:

It's super fast.
It has custom validators & aliases.
nested objects & array handling.
strict object validation.
customizable error messages.
It has no dependencies.

Advantages of Fastest-Validator Over Other Validation Libraries

Compared to other popular validation libraries, the fastest-validator is super fast.
It has a customizable error message and a programmable error object

Project Set-up

Without further ado, let’s start our project by creating the project directory and installing the necessary dependencies.

First, create your project directory:

mkdir Fastest_Val_Express

Open the folder in your code editor and initialize npm by running npm init -y

Install Dependencies

Now that we have set-up our project by initializing npm, let’s install the necessary dependencies to get us started.

Go to your terminal, run:

npm install express dotenv

Take a deep breath, in a few seconds, the installation will be done.

After installing express and dotenv, create a src folder, and inside the folder, create models, validations, controllers, routes folders, and app.js file; create a .env file in the root directory. Then, create a product file inside each of the folders in the src folder.

Your project directory should look like this:

Fastest_Val_Express
│
└─src
│ └───controllers
│ │ └───product.controller.js
│ │
│ └───models
│ │ └───product.model.js
│ │
│ └───routes
│ │ └───product.route.js
│ │
│ └───validations
│ │ └───product.vaidation.js
│ │
│ └───app.js
│ │
└─.env

Create Server

Moving on, we need to create the server

Go to your app.js file, then require express and create the server.

src/app.js

const express = require('express');
const app = express();

const port = 5000;

app.listen(port, console.log(`server is listening on port: ${port}...`));

You can start the server by running the command node src/app.js, but to avoid restarting our project every time we make any change, let's install nodemon to help monitor our project for any change and automatically restart the server.

In your terminal, run: npm install --save-dev nodemon

Take another deep breath while nodemon is installing, it only takes a few seconds. Once you have installed nodemon, head to your package.json file, and add "dev": "nodemon src/app" to the scripts object, then run npm run dev to re-start the server.

Connect Database

Once the server is up and running, you need to set up and connect the database. Since we will be using MongoDB database, install mongoose with the command: npm i mongoose, then set up and connect the database.

N.B: as a best practice, put your database-sensitive information in your .env file, require the file in your app.js file so you can have access to the environment variables.

src/app.js

const express = require('express');
const mongoose = require('mongoose');
const { config } = require('dotenv');
config();

const app = express();

app.use(express.json());

//connect database
mongoose.set("strictQuery", false);
mongoose
  .connect(`mongodb+srv://${process.env.DB_username}:${process.env.DB_password}@cluster0.kngtf.mongodb.net/${process.env.DB_name}?retryWrites=true&w=majority`)
  .then(console.log('database connected...'))
  .catch((err) => console.log(err));

const port = 5000;

app.listen(port, console.log(`server is listening on port: ${port}...`));

Example of dotenv file

.env.example

DB_username = 
DB_password = 
DB_name =

Having cleared that up, let’s create our product schema; we want the product name, the category it belongs to and the price.

Go to your product.model.js file in your models' folder, and create your product schema.

product.model.js

const mongoose = require('mongoose');
const ProductSchema = new mongoose.Schema({
  productName: {
    type: String,
    trim: true,
  },
  category: {
    type: String,
    trim: true,
  },
  amount: {
    type: Number,
  },
},
{ timestamps: true },
);
module.exports = mongoose.model('Product', ProductSchema);

With that out of the way, we need to validate every data going to our database using the fastest-validator library.

Install the fastest-validator library with the command: npm install fastest-validator

Go to your product.validation.js file in your validation folder, and require the fastest-validator library, then instantiate Validator.

src/vaidation/product.validation.js

const Validator = require("fastest-validator");
const validate = new Validator();

Using the Fastest-Validator library is quite easy; the simple, clean and fastest way to use it is to compile the schema first to a compiled "checker" function. After that, to validate your object, just call this "checker" function. The error reporting is pretty detailed and straightforward.

Now, head over to your product.validation.js file, write your schema, and compile it to a compiled "checker" function, then export the module so you can call the checker function in your controller.

src/vaidation/product.validation.js

const Validator = require("fastest-validator");
const validate = new Validator(); 

const productVaidationSchema = {
    productName: {
        type: "string", 
        min: 3, 
        max: 255,
        label: "Product name error"
    },
    category: { 
        type: "string", 
        min: 3, 
        max: 255,
        label: "Product category",
        optional: true
    },
    amount: {
        type: "number",
        positive: true, 
        integer: true,
        label: "Amount"
    }
};
const check = validate.compile(productVaidationSchema);

module.exports = check

If you have successfully accomplished the steps so far, you should take a chilled glass of wine and relax, knowing that every data going to your database is accurate and valuable. Cheers to that!

Project Logic

Now, we need to write our logics.

Go to your product.controller.js file in your controller folder, and require both the product.validation.js and product.model.js files.

For the createProduct and updateProduct functions, we need to check if the input data we are sending to the database meet the validation conditions we specified in our product.validation.js file, if "noError" is not true, then all validation conditions are not met, and so, it returns the error message else we proceed.

src/controllers/product.controller.js

const Product = require('../models/product.model');
const check = require('../validations/product.validation');
const  ObjectId = require('mongoose').Types.ObjectId;

module.exports = {
  //create product function
  createProduct: async (req, res) => {
    //check if validation conditions are met
    const noError = check(req.body);
    if (noError != true) {
      return res.status(400).json({ status: 400, error: noError});
    };
    //check if product already exists
    const productExist = await Product.findOne({ productName: req.body.productName});
    if (productExist) {
      return res.json({msg: "Product already exist"})
    };
   //create the product
    const product = await Product.create(req.body);
    res.status(201).json({ msg: 'successfully added a product', product });
  },

  //get all products function
  getAllProducts: async (req, res) => {
    const products = await Product.find({});
    res.status(200).json({ products, number: products.length });
  },

  //get product by Id function
  getProductById: async (req, res) => {
      const productId = req.params.id;
      const product = await Product.findById(productId);
      //check if product Id is valid
      if (!product || ObjectId.isValid(productId) == false) {
      return res.status(404).json({
             message: `No product with id: ${productId}` 
     });
  }
    res.status(200).json({ message: product });
  },

  //update product by Id function
  updateProductById: async (req, res) => {
    const productId = req.params.id;
    const product = await Product.findByIdAndUpdate(productId, req.body);
    //check if Id is valid
    if (!productId || ObjectId.isValid(productId) == false) {
    return res.status(404).json({ 
           message: `No product with id: ${productId}` 
   });
} 
    //check if validation conditions are met
    const error = check(req.body);
    if (noError != true) {
      return res.status(400).json({ status: 400, error: noError});
    };
    res.status(200).json({ message: `Product successfuly updated` });
  },

  //Delete product by Id
  deleteProductById: async (req, res) => {
    const productId = req.params.id;
    const product = await Product.findByIdAndDelete(productId);
    //check if Id is a valid
    if (!product || ObjectId.isValid(productId) == false) {
   return res.status(404).json({
          message: `No product with id: ${productId}` });
  }
    res.status(200).json({message: `Product successfuly deleted`});
  },
};

Now that we have completed our logic, let’s work on our routes.

Go to your product.routes.js file in your route folder, require Router from express, and all the functions from your controller, then create the routes for the respective functions and export your route.

src/routes/product.route.js

const route = require('express').Router();
const {
  getAllProducts,
  createProduct,
  getProductById,
  updateProductById,
  deleteProductById,
} = require('../controllers/product.controller');

route.post('/product', createProduct);
route.get('/products', getAllProducts);
route.get('/product/:id', getProductById);
route.patch('/product/:id', updateProductById);
route.delete('/product/:id', deleteProductById);

module.exports = route;

Now, take another deep breath because we're almost done, all that is left is to call our route in the app.js file so that our app can access all the routes.

Go to your app.js file, require the routes folder and expose the routes to be used by the app.

src/app.js

const express = require('express');

const mongoose = require('mongoose');

const route = require('./routes/product.route');

const { config } = require('dotenv');

config();

const app = express();

//connect database

mongoose.set("strictQuery", false);

mongoose

  .connect(mongodb+srv://${process.env.DB_username}:${process.env.DB_password}@cluster0.kngtf.mongodb.net/${process.env.DB_name}?retryWrites=true&amp;w=majority)

  .then(console.log('database connected...'))

  .catch((err) => console.log(err));

const port = 5000;

app.use('/api/v1', route);

app.listen(port, console.log(server is listening on port: ${port}...));

Testing our API

Here is the moment of truth, let's test our API routes to see if they work appropriately.
Head over to your postman or insomnia, and test all the routes.

Create Product:

Fastest-validator gives you a detailed error report; for the Create Product route, we were only able to successfully create a product when all validation conditions were met.

Update Product by id:

Like the Create Product, when we try to update a particular product by its Id, it is only successful once it fulfils all validation conditions. Notice that it was also successful without the category because category in our validation is not required.

Get products:

Get Product by Id:

Delete product by Id:

This returns a message "Product successfully deleted" to let you know that the delete process was successful.

Conclusion

The first two things to consider in choosing a validation library are the flexibility of the validation rules and speed. Understanding the pros and cons of a validation library before using it is key to getting the best out of it.
In this tutorial, we learnt what data validation and fastest-validator are; we further briefly looked at some of the advantages of fastest-validator over other types of validation libraries. We demonstrated the clean and easy way to use the fastest-validator library in our Express.js API/application by building a product management API using the express.js framework, MongoDB database, and the fastest-validator library. At the end of the tutorial, the API routes were tested and the results were as expected as seen in the tutorial.

Get the complete code here

connect with me:
Linkedin
Twitter

Master String Manipulation in Solidity

Augusta Ehihebolo — Sun, 15 May 2022 20:17:33 +0000

Introduction

String manipulation in Solidity is not as straightforward as it is in most other programming languages, like JavaScript, Python, Java, etc.; with the entire notion/belief that a good background in JavaScript gives you an edge in Solidity, it sucks and becomes frustrating when you can't just use the (+) sign to concatenate strings in Solidity, like ("a"+"b") or do other simple string manipulations the way we are used to in most other programming languages.

What is string in programming?

String is a piece of text or an array/sequence/collection of alphanumeric characters enclosed within a single or double quote mark, such as 'Welcome!' or "number 3". It is one of the essential concepts in computer programming.

String is a data type used in most computer languages to store data values of ordered sequences of characters. It can be saved in a variable, entered by the user (input), or displayed on the screen (output).

Manipulation of string to deliver information or change its contents is usually possible and relatively simple. The following are some of the things we can do with string:

Check length of a string
Check character position in a string
Concatenate(join strings to form another word) strings
Compare if two strings are the same
Change letters in a string from uppercase to lowercase and verse versa
Reverse a string

String in solidity

String in Solidity has some similarities with bytes; both are dynamic array types, which means they can hold data of any size. Each element of a bytes variable is a single byte, whereas each element of a string variable is a string character. it does not support functions to:

Get string length
Concatenate strings
Convert from upper case to lower case
Join two strings
Reverse string
Compare two strings
To achieve any of the above mentioned, you have to do some sorts of manual manipulations.

In Solidity, string is an array of UTF-8 characters that can be converted to bytes easily, and this is the primary way of manipulating string. It's vital to note that UTF-8 characters don't always match bytes perfectly. Although the conversion will be accurate in either direction, there is no direct relationship between each byte index and the associated string index. It's also worth remembering that string literals are limited to readable ASCII characters.

Project setup

Go to Remix IDE, in your workspace create a new file called stringMan.sol.
Go to your workspace compiler, set the compiler to the latest local version or any version greater than or equal to 0.8.0, and enable the auto compiler so that your work compiles automatically on the go, this will allow you to spot an error easily, that's one great thing I really love about Remix IDE.
Now, open the stringMan.sol file and set the SPDX-Licence-Identifier: UNLICENSED and Pragma solidity ^0.8.0.0;. Awesome! Our environment is all set.

Find the length of a string

Now that we have successfully set up our project environment, let’s start getting our hands dirty!
In your stringMan.sol file, create a contract called StringManipulation, inside the StringManipulation contract, create a string called str1, then set str1 to the string literal "Congratulations".

// SPDX-License-Identifier: UNLICENSED;
pragma solidity ^0.8.0.0;

contract StringManipulation{
    string public str1 = "Congratulations";
}

Moving on, let’s create a function that gets the value of our string variable str1, a function that gets the length of the string, and a function that sets the value of str1 to a new string.

First, declare a function called getStr that returns the string str1, then declare another function called getStrLength that returns the length of the string, and declare another function called setStr that sets the string “str1” to a new string of your choice.

// SPDX-License-Identifier: UNLICENSED;
pragma solidity ^0.8.0.0;

contract StringManipulation {
    //create string
    string public str1 = "Congratulations";

   //get string function
    function getStr() public view returns(string memory) {
        return str1;
    }

    //get string length function
    function getStrLength() public view returns(uint) {
        bytes memory strB = bytes(str1);
        return strB.length;
    }

    //set string function
    function setStr(string memory str) public {
        str1 = str;
    }
}

In the above code, the first function i.e the get string function will return the value of the string variable “str1” which is congratulations, for the second function i.e the get string length function, since we cannot get the length of a string directly, we converted the string str1 to byte and return the length, and for the last function which is the set string function, we set the string variable str1 to a new string variable str which allows us to set the string str1 to any string of our choice.

Concatenate strings

Now that we know how to find our way around getting the length of a string, let’s move on to string concatenation.
In your StringManipulation contract, create another function called concateString, let it take 2 arguments str1 and str2, and return the concatenated string.

// SPDX-License-Identifier: UNLICENSED;
pragma solidity ^0.8.0.0;

contract StringManipulation{
    string public str1 = "Congratulations";

//get string function
    function getStr() public view returns(string memory) {
        return str1;
    }

    //set string function
    function setStr(string memory str) public {
        str1 = str;
    }

    //get string length function
    function getStrLength() public view returns(uint) {
        bytes memory strB = bytes(str1);
        return strB.length;
    }


    //concatenate strings function
    function concatString(
        string memory _str1, 
        string memory _str2
        ) public pure returns(string memory) {
    return string (abi.encodePacked(_str1,_str2));
    }
}

In solidity, you cannot concatenate strings simply by using the plus sign like in JavaScript and some other languages, e.g. (str1 + str2), instead, you call the abi.encodedPacked() function and passed in the strings to be concatenated.

Compare strings

With string concatenation successfully out of the way, you should drink a glass of juice and take a deep breath. having done that, let’s keep on moving…
Head over to your StringManipulation contract again, create another function called compareStr, let it take two(2) string arguments str1 and str2 and return a boolean.

// SPDX-License-Identifier: UNLICENSED;
pragma solidity ^0.8.0.0;

contract StringManipulation{
    string public str1 = "Congratulations";

   //get string function
    function getStr() public view returns(string memory) {
        return str1;
    }

    //set string function
    function setStr(string memory str) public {
        str1 = str;
    }

    //get string length function
    function getStrLength() public view returns(uint) {
        bytes memory strB = bytes(str1);
        return strB.length;
    }

    //concatenate strings function
    function concatString(
        string memory _str1, 
        string memory _str2
        ) public pure returns(string memory) {
    return string (abi.encodePacked(_str1,_str2));
    }

    //compare strings function
    function compare(
        string memory _str1, 
        string memory _str2
        ) external pure returns(bool){
            return keccak256(abi.encodePacked(_str1)
            ) == keccak256(abi.encodePacked(_str2));
            }
}

Just as in concatenation, to compare 2 strings in solidity, we called the keccak256 function and passed in the abi.encoded function which takes the argument, and then compares.

Reverse string

I am sure you are feeling like a boss already, you should be because it’s not easy getting here. Without any delay, let’s see how we can reverse a string.
Still, inside your StringManipulation smart contract, create a function called reverseStr that takes a string argument _str and returns a string(reversed of the string that was passed in)

// SPDX-License-Identifier: UNLICENSED;
pragma solidity ^0.8.0.0;

contract StringManipulation{
    string public str1 = "Congratulations";

   //get string function
    function getStr() public view returns(string memory) {
        return str1;
    }

    //set string function
    function setStr(string memory str) public {
        str1 = str;
    }

    //get string length function
    function getStrLength() public view returns(uint) {
        bytes memory strB = bytes(str1);
        return strB.length;
    }

    //concatenate strings function
    function concatString(
        string memory _str1, 
        string memory _str2
        ) public pure returns(string memory) {
    return string (abi.encodePacked(_str1,_str2));
    }

    //compare strings function
    function compareStr(
        string memory _str1, 
        string memory _str2
        ) external pure returns(bool){
            return keccak256(abi.encodePacked(_str1)
            ) == keccak256(abi.encodePacked(_str2));
            }

       //reverse string function
    function reverseStr(string memory _str) external pure returns(string memory){
        bytes memory baseByte = bytes(_str);
        string memory tempValue = new string(baseByte.length);
        bytes memory reverse = bytes(tempValue); 
        for(uint i = 0; i < baseByte.length; i++) {
             reverse[baseByte.length - i - 1] = baseByte[i];
             }
             return string(reverse);
             }
}

Here, we converted the string to byte, get the instance of the string length, and simply looped through from the back.

Convert string to lower case

Moving further, let’s see how we can convert a string from uppercase to lowercase. In your StringManipulation contract, create a function called toLowerCase that takes a string argument _str and returns a string(the lowercase of the passed in string)

// SPDX-License-Identifier: UNLICENSED;
pragma solidity ^0.8.0.0;

contract StringManipulation{
    string public str1 = "Congratulations";

   //get string function
    function getStr() public view returns(string memory) {
        return str1;
    }

    //set string function
    function setStr(string memory str) public {
        str1 = str;
    }

    //get string length function
    function getStrLength() public view returns(uint) {
        bytes memory strB = bytes(str1);
        return strB.length;
    }

    //concatenate strings function
    function concatString(
        string memory _str1, 
        string memory _str2
        ) public pure returns(string memory) {
    return string (abi.encodePacked(_str1,_str2));
    }

    //compare strings function
    function compareStr(
        string memory _str1, 
        string memory _str2
        ) external pure returns(bool){
            return keccak256(abi.encodePacked(_str1)
            ) == keccak256(abi.encodePacked(_str2));
            }

       //reverse string function
    function reverseStr(string memory _str) external pure returns(string memory){
        bytes memory baseByte = bytes(_str);
        string memory tempValue = new string(baseByte.length);
        bytes memory reverse = bytes(tempValue); 
        for(uint i = 0; i < baseByte.length; i++) {
             reverse[baseByte.length - i - 1] = baseByte[i];
             }
             return string(reverse);
             } 

    //convert string to lowercase
    function toLowerCase(string memory _str) public pure returns (string memory) {
        bytes memory bString = bytes(_str);
        bytes memory bLowerCase = new bytes(bString.length);
        for (uint j = 0; j < bString.length; j++) {
            // Uppercase character...
            if ((uint8(bString[j]) >= 65) && (uint8(bString[j]) <= 90)) {
                // So we add 32 to make it lowercase
                bLowerCase[j] = bytes1(uint8(bString[j]) + 32);
            } else {
                bLowerCase[j] = bString[j];
            }
        }
        return string(bLowerCase);
    }
}

For the toLowerCase function, we first converted the string to byte, then get the instance of the length; since the ASCII values of A - Z are from 65 - 90, and that of a - z, from 97 - 112, we looped through to check if each character is within the range of 65 - 90(A - Z), add 32 if found to be true, to convert it to a lower case else return it that way.

Test functions

If everything went well, your smart contract should be successfully compiled by now since it’s in auto compile. If you didn’t enable auto compile, now is the time to compile your smart contract, hit the compile button to compile it, and head over to deploy once compiled.

Now that you have successfully deployed your smart contract, let’s test all the functions to ensure they are working as they should:

Get string, set string and get string length functions:

Concatenate strings function:

Compare strings function:

Reverse string function:

toLowerCase function:

Conclusion:

It is not very efficient to manipulate strings in solidity, hence it is not recommended. Using strings in solidity is quite expensive since it consumes too much gas thereby costing too much gas fee; if you can, avoid string manipulation and attempt to replace it with byte instead.

Also, Stings in Solidity accepts the backslash character ( \ ) as an escape character and the backslash plus n characters (\ + n) (\n) as a new line character, just like JavaScript.

Reference

Solidity 0. 8. 13 Documentation
Etheruem/Solidity toLower() equivalent
String manipulation in Solidity

Get the complete code here

Let's connect:
Linkedin
Twitter

Comparing Web 3.0 features with Web 2.0 and Web 1.0

Augusta Ehihebolo — Tue, 04 Jan 2022 18:59:18 +0000

It's incredible how technology has extensively transformed our society lately, particularly in the evolution of the Web from 1.0 to 3.0; Truly, there is no such thing as versions of the Web, just a way to help us keep track of what has been, and what currently is. The World Wide Web referred to as the "Web" for short, is the fundamental tool used to view and explore information through the internet by millions of people. It started with the basic browsers like Netscape, Mosaic, etc that only interpreted text, then appeared the HTML, making the pages more friendly and easily accessible. Taking a wild trip down memory lane with me to keep up with the fast-paced advancement of Web features is something worthwhile, so let’s go!

Web 1.0

Web 1.0 is a term used to represent the first stage of the evolution of the World Wide Web, it is the first iteration of the Web, it started from 1990 to 2004. The era of Web 1.0 was the time when the Web was being powered by HTML and CSS; the pages were static and were built using a common gateway interface (CGI) or server-side includes, and contents were served from the server file system. To be able to access the Web, you have to be a programmer or someone who knows about technology. According to Berners-Lee, Web 1.0 is a "Read-only" Web, in order words, we could only search and read information. It only had a few content creators and a large number of users that consume the contents, it brought the people from offline to online to be able to search and purchase products and services. Unfortunately, Web 1.0 couldn't strive because of its inaccessibility problem, users could not interact and contribute to the content that was created.

Web 2.0

The term Web 2.0 has been frequently used since early-2000 to mid-2000. Web 2.0 was the massive adoption age and second iteration of the Web, where innovations moved from being static to dynamic, it can also be referred to as participative or social Web because it made it possible for people to interact and collaborate in social media, it is the “Read-Write” Web. The birth of new technologies that solved the inaccessibility problem of Web 1.0 by giving room to the vast majority of people to be able to publish information with just a click of a button led us to Web 2.0.
Early Web 2.0 companies like Amazon, Facebook, YouTube, Twitter, etc started coming up with easy ways to publish content and make them accessible. Web 2.0 made it possible for us to store our information in the cloud and access it from anywhere.
Web 2.0 is centralized, it uses client/server architecture. Just like the famous quote "if you're not paying for it, you are the product", Web 2.0 gave us value in exchange for our privacy, ownership of our data; the big tech companies decide what to do with our data, we have the power to write contents but we do not have the power to own our contents; they use our data for ads and generate a huge sum of money with it, while we spend money directly or indirectly to access the Web through the internet, only to be welcomed with an unsolicited ad, it sucks right! well, how about a situation where you can reap the reward of your value? exciting right! continue the trip with me, let's take a deep look into Web 3.0.

Web 3.0

Web 3.0 is a Decentralized technology powered by blockchain technology. Blockchain technology makes it possible to store data securely, bringing about a more reliable method of data integrity and checks.
The problems of Web 2.0: centralization of control, ownership of data, privacy issue led us to Web 3.0. One of the Web 3.0 evolutions is transforming the Web into a database. The 2 pillars of Web 3.0 are Artificial Intelligence (AI) which helps the computer to interpret information like humans, and semantic Web; following the explanation of Berners-Lee, Web 3.0 would be "Read-Write-Execute" Web.
According to Sandeep Nailwal, the co-founder of polygon technology, "through Web 3.0, users create the value, control the network and reap the reward". Web 3.0 returns control to users, gives users ownership of data, and allows interaction. Big tech companies like Apple, Google, Facebook, and their likes will have no control over users data because Web 3.0 is semantic Web with no middle man to control the data, it has no centralized database that stores the state of the application, unlike the Web 2.0, the backend logics have no centralized Web server, the apps run on nodes. Web 3.0 allows individual users to monetize the computer and reap the reward of their value. File sharing in Web 3.0 is done through peer-to-peer.

WEB 3.0 FEATURES COMPARED WITH WEB 2.0 AND WEB 1.0

Web 3.0	Web 2.0	Web 1.0
Read-Write-Execute	Read-Write	Read-only
Smart Applications that leverage on Artificial Intelligence	Web applications	Webforms
Behavioral advertising method	Interactive advertising method	Banner advertising method
Content is owned by the network	Content is owned and shared by the entity through a network	Content is consolidated
High security of data and privacy	Low security of data and privacy	No security and privacy concern
The semantic Web (for machine)	The community Web (For people: app/site connectivity them)	The Hypertext/GCI Web (the basics)
Live-streams / Waves	Blogs / Wikis	Home Pages

I believe that we stop living once we stop thinking. As we continue to live, the advancement of the Web and its features are inevitable. Tim Berners-Lee, ‘the Web creator’ once said in one of his interviews in 1999 “people keep asking me what I think of it now that it’s done. Hence my protest: The Web is not done!”. In the same way, I believe a lot of people are currently muttering on what is next after Web 3.0; well, trust me the Web is still not done, we have Web 4.0 (the “Symbiotic Web”) just around the corner.

References:
Comparative Study of Web 1.0, Web 2.0 and Web 3.0
Web 1.0, Web 2.0 and Web 3.0 with their difference
Web 1.0 vs. Web 2.0 vs Web 3: Exploitative Fad or Promising Future?

Connect with me on Linkedin