DEV Community: Bilal Niaz

Error: @prisma/client did not initialize yet. Please run "prisma generate" and try to import it again.

Bilal Niaz — Mon, 19 Jan 2026 11:14:33 +0000

This error is very common with Prisma, and it means the Prisma Client was not generated

First, check if both required Prisma packages are properly installed in your project:

npm ls @prisma/client prisma

You should see both packages listed. If either is missing, install them:

npm install @prisma/client
npm install prisma --save-dev

Why both packages?

@prisma/client - The runtime client you import in your code
Prisma: The CLI tool used for migrations and generating the client

Prisma requires a schema file at a specific location. Check that you have a file at:

your-project/
├── prisma/
│ └── schema.prisma
├── node_modules/
├── package.json
└── index.js

Your schema.prisma file must contain the client generator configuration:

generator client { provider = "prisma-client-js" }

If you don't have this file, initialize Prisma:

npx prisma init

Run migration (recommended).

npx prisma migrate dev --name init

This is where many developers make mistakes. Ensure you're importing Prisma Client correctly in your code

Correct:

const { PrismaClient } = require('@prisma/client'); const prisma = new PrismaClient();

How to install Prisma in express.js

Bilal Niaz — Mon, 19 Jan 2026 11:01:21 +0000

Before we install Prisma in Express.js. Let's explain what Express.js and Prisma are.

Express is a popular, free, open-source, and minimalist web application framework for Node.js. Express is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.

Prisma is a modern, open-source database toolkit for Node.js and TypeScript that simplifies database interactions by providing a type-safe, object-oriented API, replacing raw SQL with intuitive code for tasks like CRUD operations. It features a powerful ORM (Object-Relational Mapper) for easy data modeling, a migration system (Prisma Migrate), and a GUI for database inspection (Prisma Studio). It supports various databases (PostgreSQL, MySQL, MongoDB, etc.) and ensures type safety, catching errors at compile time, making development faster and more reliable

Prerequisites for Installing Prisma ORM

Node.js (version 16.13.0 or higher)
npm or yarn package manager
A basic Express.js application setup
A database (PostgreSQL, MySQL, SQLite, MongoDB, or SQL Server)

Step 1: Set Up Your Express.js Project

If you haven't created an Express.js project yet, initialize one with these commands:

mkdir express-prisma-app
cd express-prisma-app
npm init -y
npm install express

Create a basic Express server in index.js:

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

app.use(express.json());

app.get('/', (req, res) => {
  res.json({ message: 'Express server with Prisma ORM' });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Step 2: Install Prisma ORM Dependencies
Install Prisma CLI as a development dependency and Prisma Client as a regular dependency:

npm install prisma --save-dev
npm install @prisma/client

For TypeScript projects, also install type definitions:

npm install typescript ts-node @types/node @types/express --save-dev

Step 3: Initialize Prisma in Your Express Application
Run the Prisma initialization command to create the necessary configuration files:

npx prisma init

This command creates:

A prisma directory with a schema.prisma file
A .env file for your database connection string

Step 4: Configure Your Database Connection
Open the .env file and add your database connection URL. Here are examples for different databases:

PostgreSQL:

DATABASE_URL="postgresql://username:password@localhost:5432/mydb?schema=public"

MySQL:

DATABASE_URL="mysql://username:password@localhost:3306/mydb"

SQLite:

DATABASE_URL="file:./dev.db"

MongoDB:

DATABASE_URL="mongodb+srv://username:password@cluster.mongodb.net/mydb"

Step 5: Define Your Prisma Schema
Edit the prisma/schema.prisma file to define your database models. Here's an example schema:

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"  // Change to your database
  url      = env("DATABASE_URL")
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  posts     Post[]
  createdAt DateTime @default(now())
}

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
  createdAt DateTime @default(now())
}

Step 6: Run Prisma Migrations
Create and apply your database migrations:

npx prisma migrate dev --name init

This command:

Creates SQL migration files
Applies migrations to your database
Generates the Prisma Client

Step 7: Generate Prisma Client
If you need to regenerate the Prisma Client after schema changes:

npx prisma generate

Step 8: Integrate Prisma Client with Express.js
Create a prisma.js file to instantiate the Prisma Client:

const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

module.exports = prisma;

Step 9: Use Prisma in Express Routes
Update your Express application to use Prisma for database operations:

const express = require('express');
const prisma = require('./prisma');

const app = express();
app.use(express.json());

// Create a new user
app.post('/users', async (req, res) => {
  try {
    const { email, name } = req.body;
    const user = await prisma.user.create({
      data: { email, name }
    });
    res.json(user);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Get all users
app.get('/users', async (req, res) => {
  try {
    const users = await prisma.user.findMany({
      include: { posts: true }
    });
    res.json(users);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Get user by ID
app.get('/users/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const user = await prisma.user.findUnique({
      where: { id: Number(id) },
      include: { posts: true }
    });
    res.json(user);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Express server with Prisma running on port ${PORT}`);
});

Prisma Studio is a visual database GUI (Graphical User Interface) included with Prisma, allowing developers to easily explore, view, and edit data in their databases directly in a web browser through a user-friendly interface, supporting CRUD operations, filtering, sorting, and visualizing data relationships, accessible locally via

npx prisma studio

Conclusion
Installing Prisma ORM in Express.js enhances your Node.js application with type-safe database queries, automatic migrations, and excellent developer experience. By following this guide, you've successfully integrated Prisma with Express.js and learned how to perform CRUD operations efficiently

What is this in JavaScript?

Bilal Niaz — Sat, 16 Apr 2022 04:46:00 +0000

In JavaScript, the this keyword operates a little differently than in other languages. There are also some distinctions between stringent and non-strict modes.
The this keyword refers to different objects depending on how it is used:

In an object method, this refers to the object.
Alone, this refers to the global object.
In a function, this refers to the global object.
In a function, in strict mode, this is undefined.
In an event, this refers to the element that received the event.

this in a Method:
When used in an object method, this refers to the object.

const person = {
  firstName: "John",
  lastName: "Doe",
  id: 5566,
  fullName : function() {
    return this.firstName + " " + this.lastName;
  }
};
console.log(person.fullName()) //output : John Doe

this Alone:
When used alone, this refers to the global object.
Because this is running in the global scope.
In a browser window the global object is [object Window]

let x = this;
console.log(x) //output is :[object Window]

In strict mode, when used alone, this also refers to the global object:

"use strict:";
let x = this;
console.log(x) //output is :[object Window]

this in a Function(Default):
In a function, the global object is the default binding for this.
In a browser window the global object is [object Window]:

function myFunction() {
  return this;
}
myFunction() //output is : [object Window]

this in a Function (Strict):
JavaScript strict mode does not allow default binding.
So, when used in a function, in strict mode, this is undefined.

"use strict";
function myFunction() {
  return this;
}
myFunction() //output is : undefined

this in Event Handlers:
In HTML event handlers, this refers to the HTML element that received the event:

<button onclick="this.style.display='none'">
  Click to Remove Me!
</button>

PHP Data Types:

Bilal Niaz — Mon, 04 Apr 2022 06:58:57 +0000

PHP Data Types:
Variables can store data of different types, and different data types can do different things.
PHP supports the following data types:

String
Integer
Float (floating point numbers - also called double)
Boolean
Array
Object
NULL
Resource PHP String: A string is a sequence of characters, like "Hello world!". A string can be any text inside quotes. You can use single or double quotes:

<?php
$x = "Hello world!";
$y = 'Hello world!';

echo $x;
echo "<br>";
echo $y;
?>

PHP Integer:
An integer data type is a non-decimal number between -2,147,483,648 and 2,147,483,647.
Rules of integer:

An integer must have at least one digit
An integer must not have a decimal point
An integer can be either positive or negative
Integers can be specified in: decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2) notation. In the following example $x is an integer. The PHP var_dump() function returns the data type and value:

<?php
$x = 5985;
var_dump($x);
?>

PHP Float:
A float (floating point number) is a number with a decimal point or a number in exponential form.
In the following example $x is a float. The PHP var_dump() function returns the data type and value

<?php
$x = 10.365;
var_dump($x);
?>

PHP Boolean:
A Boolean represents two possible states: TRUE or FALSE.
Booleans are often used in conditional testing. You will learn more about conditional testing in a later chapter of this tutorial.

$x = true;
$y = false;

PHP Array:
An array stores multiple values in one single variable.

<?php
$cars = array("Volvo","BMW","Toyota");
var_dump($cars);
?>

PHP Object:
Classes and objects are the two main aspects of object-oriented programming.
A class is a template for objects, and an object is an instance of a class.
When the individual objects are created, they inherit all the properties and behaviors from the class, but each object will have different values for the properties.

class Car {
  public $color;
  public $model;
  public function __construct($color, $model) {
    $this->color = $color;
    $this->model = $model;
  }
  public function message() {
    return "My car is a " . $this->color . " " . $this->model . "!";
  }
}

$myCar = new Car("black", "Volvo");
echo $myCar -> message();
echo "<br>";
$myCar = new Car("red", "Toyota");
echo $myCar -> message();

PHP NULL Value:
Null is a special data type which can have only one value: NULL.
A variable of data type NULL is a variable that has no value assigned to it.

$x = "Hello world!";
$x = null;
var_dump($x);

PHP Resource:
The special resource type is not an actual data type. It is the storing of a reference to functions and resources external to PHP.
A common example of using the resource data type is a database call.

How to Install Laravel on Ubuntu 20.04

Bilal Niaz — Sat, 26 Mar 2022 13:29:50 +0000

Laravel is an open-source PHP web framework. It is mainly used for building PHP-based web applications.

Laravel is suitable for both small-scale and enterprise-level application development. Its elegant syntax, advanced features, robust tools help simplify web application development. Laravel is highly scalable and has built-in support for distributed cache systems.

Step 1: Install Apache web server:

 sudo apt install apache2

Once installed, Apache should be running. If it's not, for whatever reason, start it:

sudo systemctl start apache2

Then enable it to start on boot time.

sudo systemctl enable apache2

To verify the status of Apache, execute:

 sudo systemctl status apache2

Step 2: Install PHP and additional PHP extensions:

sudo apt install php libapache2-mod-php php-mbstring php-cli php-bcmath php-json php-xml php-zip php-pdo php-common php-tokenizer php-mysql

When the installation is complete, verify the PHP version.

php -v

Step 3: Create Database for Laravel Application:
But first, we need to install a database server. Laravel supported database systems are MariaDB, MySQL, SQLite, Postgres, or SQL Server.
We will go with the MariaDB database engine.

sudo apt install mariadb-server

Once the database server is installed, log into the MariaDB prompt:

sudo  mysql -u root -p

Once logged in create the database, database user, and grant all privileges to the database user.

CREATE DATABASE laravel_db;

CREATE USER 'laravel_user'@'localhost' IDENTIFIED BY 'secretpassword';

GRANT ALL ON laravel_db.* TO 'laravel_user'@'localhost';

FLUSH PRIVILEGES;

QUIT;

Step 4: Install Composer:
Composer is a dependency package manager for PHP. It provides a framework for managing libraries and dependencies and required dependencies. To use Laravel, first install composer.

curl -sS https://getcomposer.org/installer | php

This downloads the composer.phar file.

Next, move the composer file to the /usr/local/bin path.

sudo mv composer.phar  /usr/local/bin/composer

Assign execute permission:

sudo chmod +x   /usr/local/bin/composer

Verify the Composer version installed:

composer --version

Step 5: Install Laravel 8 on Ubuntu:
With Composer installed, the next course of action is to install Laravel.

Navigate to the webroot directory, type:

cd /var/www/html

Now, install Laravel using the composer command, type:

sudo composer create-project laravel/laravel laravelapp

The command creates a new directory called laravelapp and installs all the files and directories for Laravel.

Change the ownership of the Laravel directory to the webserver user and also the permissions:

sudo chown -R www-data:www-data /var/www/html/laravelapp
sudo chmod -R 775 /var/www/html/laravelapp/storage

Feel free to replace laravelapp with a preferred directory name.

Once the installation is done navigate to the installation directory and check the Laravel version.

 cd laravelapp

php artisan

Step 6: Configure Apache to serve Laravel site:
Lastly, we need to set up the Apache webserver to host the Laravel site. For that to happen, we need to create a virtual host file

sudo vim /etc/apache2/sites-available/laravel.conf

Next, past the content shown and replace the example.com ServerName directive with the FQDN or public IP of the server ( Or private IP in case the server is on a LAN network ).

<VirtualHost *:80> ServerName example.com ServerAdmin admin@example.com DocumentRoot /var/www/html/laravelapp/public <Directory /var/www/html/laravelapp> AllowOverride All </Directory> ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined </VirtualHost>
Save the changes and exit the file. Next, enable the Laravel site and Apache rewrite module using these two commands.

sudo a2ensite laravel.conf

sudo a2enmod rewrite

To apply the changes, restart Apache

sudo systemctl restart apache2

Step 7: Access Laravel from a browser:

Follow Me : Twitter LinkedIn

Interaction in Javascript

Bilal Niaz — Fri, 18 Mar 2022 09:39:55 +0000

We have the ability to connect with the user and answer appropriately thanks to Javascript. It has a number of user-interface functions that aid interaction. Let's take a look at each one individually.

Alert:
Simply produces an alert box that may or may not contain the supplied content, but always includes a 'OK' button. It just displays a notice and stops the script from running until you press the 'OK' button. The modal window is the name for the pop-up mini-window.
alert('text');
Example:

// alert example
<script>
 alert('HI there'); // with specified content
 alert(); // without any specified content
</script>

Output:

It can be used for debugging or simply for popping something to the user.

Prompt:
Prompt is another user-interface function which normally contains two arguments.
prompt('text', default value);

The default value parameter is optional, albeit it functions as a placeholder inside a text field. The text is basically what you want to show the user, and the default value argument is what you want to display the user. It is the most commonly used interface since it allows you to ask the user for input and then use that information to build something.
Example:


<script>
// prompt example
let age = prompt('How old are you?', 50);// For default arg 
alert(`You are ${age} years old!`); 
</script>

Output:

You can enter anything and it will print that, it doesn’t necessarily have to be a number. Without the default value, you have to enter something in the text-field otherwise it will print a blank space simply.

<script>
// prompt example
let age = prompt('How old are you?');

alert(`You are ${age} years old!`); 
</script>

Confirm:
The confirm function basically outputs a modal window with a question and two button ‘OK’ and ‘CANCEL’.
confirm('question');
Example:

<script>
// confirm example 
let isHappy  = confirm('Are you Happy?');
alert(`You are ${isHappy}`); 
</script>

Output:

It will print true or false based on your choice of clicking the ‘OK’ button or ‘CANCEL’ button respectively.

What is the scope and compiler?

Bilal Niaz — Sun, 13 Mar 2022 11:25:33 +0000

Scope:
A scope is a section of the programme where variables can be declared, and there are three places where variables can be declared in general:

Inside a function or a block which is called local variables,
In the definition of function parameters which is called formal parameters.
Outside of all functions which is called global variables.

Without such a concept, a program could perform some tasks, but they would be extremely limited and not terribly interesting.
We'll approach learning about scope by thinking of it as a dialogue.

Engine: responsible for start-to-finish compilation and execution of our JavaScript program.
Compiler: one of Engine's friends; handles all the dirty work of parsing and code-generation (see previous section).
Scope: another friend of Engine; collects and maintains a look-up list of all the declared identifiers (variables), and enforces a strict set of rules as to how these are accessible to currently executing code.

Compiler:
A compiler is a special program that processes statements written in a particular programming language and turns them into machine language or "code" that a computer's processor uses.
In a traditional compiled-language process, a chunk of source code, your program, will undergo typically three steps before it is executed, roughly called "compilation":
Tokenizing/Lexing:
Breaking up a string of characters into meaningful (to the language) chunks, called tokens.For instance, consider the program:var a = 2;This program would likely be broken up into the following tokens:var, a, =, 2, and ;. Whitespace may or may not be persisted as a token, depending on whether it's meaningful or not.
The difference between tokenizing and lexing is complex and technical distinction.
Parsing:
Converting a stream (array) of tokens into a tree of nested elements that collectively indicate the program's grammatical structure This type of tree is known as a "AST" (Abstract Syntax Tree).
The tree for var a = 2; might start with a top-level node called VariableDeclaration, with a child node called Identifier (whose value is a), and another child called AssignmentExpression which itself has a child called NumericLiteral (whose value is 2).
Code-Generation:
The procedure for converting an AST into executable code. This component varies a lot based on the language, the platform it's aimed towards, and other factors.

We need a little bit more compiler terminology to proceed further with understanding.

When Engine executes the code that Compiler produced for step (2), it has to look-up the variable a to see if it has been declared, and this look-up is consulting Scope. But the type of look-up Engine performs affects the outcome of the look-up.

In our case, it is said that Engine would be performing an "LHS" look-up for the variable a. The other type of look-up is called "RHS".

I bet you can guess what the "L" and "R" mean. These terms stand for "Left-hand Side" and "Right-hand Side".
let give a example:
console.log( a );
The reference to a is an RHS reference, because nothing is being assigned to a here. Instead, we're looking-up to retrieve the value of a, so that the value can be passed to console.log(..).
By contrast:
a = 2;
The reference to a here is an LHS reference, because we don't actually care what the current value is, we simply want to find the variable as a target for the = 2 assignment operation.

Data type in javascript:

Bilal Niaz — Fri, 04 Mar 2022 10:42:34 +0000

There are eight basic data types in JavaScript. We can put any type in a variable. For example, a variable can at one moment be a string and then store a number:

// no error
let message = "hello";
message = 123456

1) Number
The number type represents both integer and floating point numbers.

let n = 123;
n = 12.345;

Aside from conventional numbers, this data type also includes "special numeric values" such as Infinity, -Infinity, and NaN.
Infinity represents the mathematical Infinity ∞. It is a special value that’s greater than any number.

We can get it as a result of division by zero:

alert( 1 / 0 ); // Infinity

NaN represents a computational error. It is a result of an incorrect or an undefined mathematical operation, for instance

alert( "not a number" / 2 ); // NaN, such division is erroneous

Special numeric values formally belong to the “number” type. Of course they are not numbers in the common sense of this word.

2) BigInt
The "number" type in JavaScript cannot express integer values greater than (2^53-1) (that is, 9007199254740991), or negative values less than -(2^53-1). It's a technological stumbling block resulting from their internal representation.
BigInt type was recently added to the language to represent integers of arbitrary length.
A BigInt value is created by appending n to the end of an integer:

// the "n" at the end means it's a BigInt
const bigInt = 1234567890123456789012345678901234567890n;

3) String
JavaScript's String type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. Each element in the String occupies a position in the String. The first element is at index 0, the next at index 1, and so on. The length of a String is the number of elements in it. In JavaScript, there are 3 types of quotes.
Double quotes.
Single quotes.
Backticks.
Double and single quotes are “simple” quotes. There’s practically no difference between them in JavaScript.

Backticks are “extended functionality” quotes. They allow us to embed variables and expressions into a string by wrapping them in ${…}, for example:

et str = "Hello";//double quotes
let str2 = 'Single quotes are ok too';//single quotes
let phrase = `can embed another ${str}`;//Backticks

4) Boolean (logical type)
Boolean represents a logical entity and can have two values: true and false .

let nameFieldChecked = true; // yes, name field is checked
let ageFieldChecked = false; // no, age field is not checked

Boolean values also come as a result of comparisons:

let isGreater = 4 > 1;
console.log( isGreater ); // true (the comparison result is yes)

5) null
The Null type has exactly one value: null.

let age = null;

n JavaScript, null is not a “reference to a non-existing object” or a “null pointer” like in some other languages.

It’s just a special value which represents “nothing”, “empty” or “value unknown”.
6) undefined
A variable that has not been assigned a value has the value undefined.

let age;
console.log(age); // shows "undefined"

Technically, it is possible to explicitly assign undefined to a variable

let age = 100;
// change the value to undefined
age = undefined;
console.log(age); // "undefined"

7) Object
In JavaScript, objects can be seen as a collection of properties. With the object literal syntax, a limited set of properties are initialized; then properties can be added and removed.An object can be created with figure brackets {…} with an optional list of properties. A property is a “key: value” pair, where key is a string (also called a “property name”), and value can be anything.

let user = new Object(); // "object constructor" syntax
let user = {};  // "object literal" syntax

We can immediately put some properties into {...} as “key: value” pairs. The last property in the list may end with a comma:

let user = {     // an object
  name: "John",  // by key "name" store value "John"
  age: 30        // by key "age" store value 30
};

Property values are accessible using the dot notation:

// get property values of the object:
console.log( user.name ); // John
console.log( user.age ); // 30

Adding a new value to an object is as follows:

user.city = "Lahore"

To remove a property, we can use delete operator:

delete user.age;

8) Symbol
A Symbol is a unique and immutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called "atoms".

// Here are two symbols with the same description:
let Sym1 = Symbol("Sym")
let Sym2 = Symbol("Sym")

console.log(Sym1 === Sym2) // returns "false"
// Symbols are guaranteed to be unique.
// Even if we create many symbols with the same description,
// they are different values.

Symbol type is a new feature in ECMAScript 2015. There is no ECMAScript 5 equivalent for Symbol.

Summary
number for numbers of any kind: integer or floating-point, integers are limited by ±(253-1).
bigint is for integer numbers of arbitrary length.
string for strings. A string may have zero or more characters, there’s no separate single-character type.
boolean for true/false.
null for unknown values
undefined for unassigned values
objectfor more complex data structures.
symbol for unique identifiers.
I hope you enjoy it.

Differences Between Arrow and Regular Functions

Bilal Niaz — Sat, 26 Feb 2022 12:37:46 +0000

The fat arrow function is another name for an arrow function. It's a new feature in ES6 that allows you to write function expressions in a more compact manner. Regular JavaScript functions and arrow functions are similar in operation, although there are several distinctions. Let's have a look at the differences:

Syntax
Arguments binding
Use of this keyword
Using a new keyword

Syntax By writing a few lines of code using arrow functions, a programmer can get the same result as ordinary functions.

Arguments binding arguments object inside the regular functions contains the list of arguments.

The arrow function, on the opposite, doesn’t define arguments i.e. they do not have arguments binding.

Use of this keyword This value is dynamic inside a standard JavaScript function. Because of the dynamic context, the value of this variable changes depending on how the function is called.

Because an arrow function lacks its own "this" keyword, the behaviour of this inside an arrow function differs significantly from that of an ordinary function.
This inside an arrow function has the same value throughout its lifetime and is always linked to the value of this in the nearest non-arrow parent function, which means This value inside an arrow function always equals this value from the outer function, regardless of how or where it is executed.

Using a new keyword Regular functions can be built and called. The new keyword can be used to call them.

But, the arrow functions are only callable and not constructible, i.e., arrow functions can never be used as constructor functions.

summary
Inside a normal function, this value is dynamic and changes depending on how the function is called. However, the inner arrow function is lexically bound and equals the outer function. This a value is always bound to the class instance using fat arrow methods.

What is the difference between ES5 and ES6?

Bilal Niaz — Thu, 17 Feb 2022 14:07:38 +0000

*1. ECMAScript 5 (ES5P) : *
The first major modification to JavaScript was ECMAScript 2009, sometimes known as ES5.Contractors who focus on how objects are instantiated are known as function contractors. In ES5, you must use the function keyword and return to define the function, just as you would in any other JavaScript language.
*2. ECMAScript 6 (ES6) : *
The second major change to JavaScript was ECMAScript 2015.Its class allows developers to create an object with the new operator and an arrow function if they don't need to use the function keyword to specify the function, and they can also avoid using the return keyword to get the computer value.
*Difference between ES5 and ES6 : *

String, integer, boolean, null, and undefined are all primitive data types supported by ES5.
But In ES6, there are some additions to JavaScript data types. It introduced a new primitive data type ‘symbol’ for supporting unique values.
Only the var keyword can be used to define variables in ES5. In ES5,let and const are two new ways to define variables.
When compared to ES6, the performance of ES5 is lesser.
In ES 6 Object manipulation is less time-consuming then ES5.
To define a function in ES5, both the function and return keywords are used. An arrow function is a new feature introduced in ES6 by which we don’t require the function keyword to define the function.
Follow Me : Twitter LinkedIn

Some Best Linux distributions .

Bilal Niaz — Sat, 12 Feb 2022 10:00:50 +0000

Linux is a Unix-based free and open-source operating system. Because of its security and versatility, Linux has gotten a lot of attention lately and is widely utilised. We'll go over some of the top Linux Distros, also known as Linux Distributions, in this blog. Linux distros are operating systems that use the Linux kernel as their foundation.
Linux Mint:
Linux Mint is a popular distribution of Linux based on Ubuntu and Debian. It is a community-driven free and open-source Linux distribution providing a huge number of packages. It is easy to use with an interactive User Interface. In October 2012, Linux Format titled Linux Mint as the best distribution of 2012. It was first released as a beta version 1.0 called 'Ada' in 2006.

Ubuntu:
This is one of the most commonly used Linux distributions. It is frequently chosen among Linux newcomers because of its user-friendly interface and aesthetics. It is compatible with not only PCs, but also tablets and cellphones. Many other Linux distributions, such as Lubuntu 20.04 LTS, Kubuntu 20.04, and Linux Mint 20.04 LTS, use Ubuntu as a base (Ulyana). Every six months, it provides updated versions with security and bug patches.

Pop_OS! from System76
System 76's Pop OS! is a Linux distribution with a customised GNOME desktop. It was originally released in October 2017 after only a few months of development. Pop OS! also includes a number of pre-installed applications such as Geary, LibreOffice, and Firefox, with additional software available through APT, Pop OS's package manager.

MX Linux:
MX Linux is a popular Linux distribution based on Debian. It was initially launched in March 2014 and is designed to be user-friendly for both beginning and advanced Linux users. Its development began with a discussion inside the MEPIS community, which was later joined by antiX. MX Linux comes with several basic utilities, such as a graphic installer, a GUI-based mechanism for changing the Linux kernel, MX-snapshot, and so on.

Elementary OS:
Elementary OS is a Linux distribution developed and maintained by Elementary, Inc. that is based on Ubuntu LTS. It includes Pantheon, a unique desktop environment, as well as numerous custom programmes such as Photos, Music, Videos, Calendar, Terminal, Files, and more. It also includes some well-known applications, such as the Epiphany web browser and a branch of Geary mail. According to Elementary OS, it is a quick, open, and privacy-conscious alternative to Windows and macOS.

Fedora:
Fedora is created by the Fedora Project, which is supported by Red Hat. It's one of the most user-friendly distributions out there. GNOME is Fedora's default desktop environment, and the GNOME Shell is the default user interface, but other desktop environments are also available and can be installed. Fedora comes with a variety of software pre-loaded, and additional software can be installed using the DNF package manager. When Red Hat Enterprise Linux was discontinued in 2003, Fedora Linux was released.

Zorin:
Zorin is an Ubuntu-based Linux distribution. It includes a simple graphical user interface (GUI) and programmes that are comparable to those found in Windows, and it was created with beginners transitioning from Windows to Linux in mind. It allows customers to utilise Windows software that is compatible with it for a smooth transition. Zorin OS Company, based in Dublin, was founded in 2009 and is written in C, C++, Python, D, and Java.

Deepin
Deepin Linux is also known as Linux. Deepin and Hiweed Linux is a Debian-based operating system. DDE, the Deepin Desktop Environment, is its own desktop environment. Wuhan Deepin Technology in Wuhan, China, created and maintains it. As a result, Chinese people are the ones who use it the most. It was first launched in February 2004, and Wuhan Deepin Technology later joined the Linux Foundation in 2015.

Solus:
Solus is a Linux kernel-based operating system. It was previously known as Evolve OS. It is designed for usage on personal computers and in private. It makes no particular claims about software support for corporate and server environments. Version 1.0 of Solus was released in December 2015. It's reliable, simple to use, and appears to contain a large variety of the most recent software in its own repositories. Budgie, GNOME, KDE Plasma, and MATE are among the desktop environments available. Solus is only compatible with 64-bit PCs.

Manjaro:
Manjaro Linux is based on the Arch Linux operating system. It uses the Pacman package manager to allow the installation of software and programmes. Manjaro uses the GNOME desktop environment, and while it can be installed on any computer, some manufacturers sell their products with Manjaro already installed.

What are NPM, NPX, NVM, YARN, PNPM?

Bilal Niaz — Thu, 03 Feb 2022 13:24:44 +0000

You've probably heard of NPM, NPX, NVM and Yarn if you deal with JavaScript. Almost certainly, you've used them to install something. In this piece, I'll explain what they are, as well as the differences between NPX, NPM, NVM, and Yarn as well as their benefits and drawbacks.
NPM:
When you install Node on your PC, you also install npm (which is included by default).
NPM(Node Package Manager) is the package manager for the Node JavaScript platform. It puts modules in place so that node can find them, and manages dependency conflicts intelligently.
Packages are updated as well, and npm makes it easy for us to stay on top of things. It allows us to.
If we want to, we can upgrade the package, or we can utilise a different version if that's what we need.
NVM:
NVM(Node Version Manager) which stands for Node Version Manager, is to allow you to check the version of Node JS.you have installed and even to install a fresh, most up to date version of Node. It also allows you to install numerous instances of Node, allowing you to test your app in different versions of the programme to see if it works.
NPX:
The npx stands for Node Package Execute and is included with npm. If you install npm above version 5.2.0, npx will be installed as well.
It's a npm package runner that allows you to run any package from the npm registry without having to install it. During a one-time usage package, the npx is useful. Npx is not installed in your computers if you have installed npm prior to 5.2.0.
YARN:
YARN(Yet Another Resource Negotiator) is a package manager similar to npm, but One of the main difference between NPM and Yarn is how they handle the package installation process. Yarn installs packages in parallel.
Yarn is optimized to fetch and install multiple packages simultaneously(yarn is faster than npm at installing packages).
PNPM:
PNPM is an alternative package manager for Node.js which stands for “Performant NPM”.
The main purpose of PNPM is to hold all the packages at a global (centralized) store and use them if needed by other projects too by creating hard links to it.

Note:
The V8 Javascript runtime underpins Node.js. A Javascript engine is built into each browser, including Firefox, Safari, and Chrome, to handle Javascript files on webpages. The V8 engine is used by Google Chrome and Node.js to interpret Javascript files.

I hope this information will assist you in deciding whether to use Yarn, NPM, or NVM in your projects. This article will be updated on a regular basis, and I encourage suggestions and comments.
Follow Me : Twitter LinkedIn