DEV Community: Abhishek kushwaha

Enhance Your Web Apps: Best JS Libraries 🔧

Abhishek kushwaha — Wed, 19 Jul 2023 16:49:26 +0000

Hi There 👋,

As a full-stack web developer, I'm thrilled to share my favorite JavaScript libraries, which I've used in the past and strongly suggest for any new project. Throughout this post, I'll highlight the libraries I favor, I'd also want to hear your recommendations in the comments section. If you have any suggestions for great libraries, I'm all ears! Let's start and look at some tools to help us on our web development path. Happy coding and exploring!

Nano ID

A tiny, secure, URL-friendly, unique string ID generator for JavaScript.

Nano ID has proven to be a game changer when it comes to generating slugs and unique pathways for user data such as projects and forums. Nano ID is a must-have tool if you work with dynamic URLs and need to construct user-generated items that may be shown on different sites or formats.

One of the major advantages of using Nano ID over other generators includes:

Small. 130 bytes (minified and gzipped). No dependencies. Size Limit controls the size.
Safe. It uses a hardware random generator. Can be used in clusters.
Short IDs. It uses a larger alphabet than UUID (A-Za-z0-9_-). So ID size was reduced from 36 to 21 symbols.
Portable. Nano ID was ported to 20 programming languages.

Working with Nano ID is straightforward. Generating IDs is a breeze, just follow the example below:

import { nanoid } from 'nanoid'
model.id = nanoid() //=> "some_thing_unique"

Have you ever used forms before? If you have a lengthy form with certain restrictions, such as a title that must be 20 characters long or a password that must be long enough, processing user data might be difficult. Setting things up traditionally takes time, and some wise individuals previously cautioned never to trust user data. I have two devoted libraries to assist you here.

ZOD

TypeScript-first schema validation with static type inference

Zod is a schema definition and validation library written entirely in TypeScript. I used the word "schema" to refer to any sort of data, from a basic text to a sophisticated nested object.

Zod was created to be as developer-friendly as possible. The purpose is to eliminate redundant type declarations. With Zod, you specify a validator once and Zod will infer the static TypeScript type for you. Simpler kinds can be easily combined to form more sophisticated data structures.

Other noteworthy features include:

There are no dependencies.
Node.js and all contemporary browsers are supported.
8kb minified and zipped
Immutable Methods (for example,.optional()) create a new instance
Interface that is concise and chainable
The functional approach is to parse but not validate.
It also works with simple JavaScript! TypeScript is not required.

JOI

The most powerful schema description language and data validator for JavaScript.

Joi lets you describe your data using simple, intuitive, and readable language.

I've used both of the aforementioned in a variety of projects, and I found ZOD to be more user-friendly in my situation. However, Joi may be a better choice for you.

Please tell me which of Zod and Joi you prefer. You can also include any comparable choices that are available:)

I was constantly looking for a way to display markdown material as a dev. does. The following library, on the other hand, is capable of performing this function. Where you may write a markdown and it will be rendered as HTML with suitable GitHub-style styling

React Markdown Editor

A basic markdown editor with preview built with React.js and TypeScript. This React Component attempts to provide a basic Markdown editor with syntax highlighting.

I recall searching for options for rendering markdown in NextJS and coming across this package, which worked well. It aided me in getting my blog site up and running.

Features

📑 Indent line or selected text by pressing the tab key, with customizable indentation.
♻️ Based on textarea encapsulation, does not depend on any modern code editors.
😻 GitHub flavored markdown support.
🌒 Support dark mode/night mode.
💡 Support next.js.

Handling Loading states in a Nextjs application is critical if your app relies on an external data source and so on for your browser to generate the page.

I discovered this library while participating in an open-source project through Hacktoberfest.

Next Js TopLoader

A Next.js Top Loading Bar component

This package does one thing extremely well: it provides feedback to users as they navigate across websites.

A progress bar appears on top of the HTML tree and goes away as the page loads on the client side. This provided some input to the end user, which I thought was useful when I needed to make the user feel that something was on the way :D.

You may also configure the loader based on your application theme and the behavior you wish to put up.

color: to change the default color of TopLoader.
initialPosition: to change initial position for the TopLoader in percentage, : 0.08 = 8%.
crawlSpeed: increment delay speed in ms.
speed: animation speed for the TopLoader in ms
easing: animation settings using easing (a CSS easing string).
height: height of TopLoader in px.
crawl: auto-incrementing behavior for the TopLoader.
show spinner: to show a spinner or not.
shadow: a smooth shadow for the TopLoader. (set to false to disable it)

When you work on a large project with few mates, it is important to communicate well through your commitment and sometimes we are lazy, which makes us put not a structured commitment for others that they can understand. To solve this issue we need a way to describe a set of rules that are applied to every commit you do on the project.

YES!! We are talking about HUSKY 😀

HUSKY

Husky improves your commits and more 🐶 woof!

You can use it to lint your commit messages, run tests, lint code, etc... when you commit or push. Husky supports all Git hooks.

To learn more you can refer to this doc.

These are a few libraries that I've found useful and prefer to utilize in my projects. If you appreciated this post and find any new useful libraries, please leave a comment 💬 and a like 👍.

Thank you 😍 for reading to the end. If you find this useful, please share it with your developer friends.

Time Complexity

Abhishek kushwaha — Sat, 21 Jan 2023 16:47:59 +0000

Time complexity is a way to measure how fast an algorithm is. When we talk about the time complexity of an algorithm, we're trying to figure out how long it takes for the algorithm to finish running. We do this by counting the number of steps or operations the algorithm takes.

The way we measure time complexity is by using something called Big O notation. Big O notation is a way to write down how the number of steps an algorithm takes changes as the size of the input gets bigger. We use the letter "O" followed by a number, such as O(n) or O(1).

For example, let's say we have an algorithm that looks through a list of numbers and finds the biggest one. If the list has 5 numbers, the algorithm might take 5 steps to find the biggest number. If the list has 10 numbers, it might take 10 steps. In this case, the time complexity of the algorithm is O(n), where n is the number of items in the list. This means that as the number of items in the list gets bigger, the number of steps the algorithm takes also gets bigger.

def find_biggest(arr):
    biggest = arr[0]
    for num in arr:
        if num > biggest:
            biggest = num
    return biggest

arr = [5, 10, 15, 20, 25, 30]
biggest = find_biggest(arr)
print("The biggest number in the list is:", biggest)

Another example, let's say we have an algorithm that checks if a number is prime or not.

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**(1/2))+1):
        if n % i == 0:
            return False
    return True

n = 11
result = is_prime(n)
if result:
    print(n, "is a prime number.")
else:
    print(n, "is not a prime number.")

In this example, we define a function called "is_prime" that takes in an integer as input. The function first checks if the input number is less than or equal to 1 and returns False if it is. If the input number is greater than 1, the function uses a for loop to iterate through all the numbers from 2 to the square root of the input number +1. For each iteration, the function checks if the input number is divisible by the current number, and if it is, it returns False. If the function completes the for loop without finding any divisors, it returns True, indicating that the input number is prime.

The time complexity of this algorithm is O(sqrt(n)). This is because the number of iterations the for loop goes through is determined by the square root of the input number and regardless of the size of the input.

In summary, the above python code is an algorithm that checks if a number is prime or not. The algorithm takes a constant number of steps regardless of the size of the input, which means that for any input number the algorithm takes a fixed set of steps. Here, the time complexity of the algorithm would be O(sqrt(n)).

It's important to note that measuring time complexity is not always easy and straightforward, sometimes the algorithm may have multiple nested loops and different operations, in such cases we have to consider the worst-case scenario and calculate the time complexity accordingly.

Here is a simple Python code example for calculating the time complexity of an algorithm:

import time

def algorithm(n):
    start_time = time.time()
    # algorithm code here
    for i in range(n):
        print(i)
    end_time = time.time()
    print("Time complexity: O(n)")
    print("Execution time:", end_time - start_time)

algorithm(5)

Binary Search

Binary search is an efficient algorithm for searching through a sorted list of elements. The basic idea behind binary search is to divide the list in half, and repeatedly divide the remaining portion in half until the desired element is found. The time complexity of binary search is O(log n), where n is the number of elements in the list.

The reason why the time complexity of binary search is O(log n) is that, with each iteration, the algorithm eliminates half of the remaining elements from consideration. So, if the list has 8 elements, the algorithm will eliminate 4 elements on the first iteration, 2 elements on the second iteration, and 1 element on the third iteration. This means that, on average, the algorithm will take log2(8) = 3 iterations to find the desired element.

Here is an example of binary search implemented in Python:

def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == x:
            return mid
        elif arr[mid] < x:
            low = mid + 1
        else:
            high = mid - 1
    return -1

arr = [1, 2, 3, 4, 5, 6, 7, 8]
x = 5
result = binary_search(arr, x)
if result != -1:
    print("Element is present at index", result)
else:
    print("Element is not present in array")

In this example, we first initialize the low and high pointers to the first and last element of the list, respectively. We then repeatedly divide the remaining portion of the list in half until the desired element is found.

As we can see, the number of iterations it takes to find the element is dependent on the log of the number of elements, which makes it an efficient algorithm in terms of time complexity.

It is also important to note that, for the binary search to work, the input list should be sorted, otherwise the algorithm will not work correctly and the time complexity will be affected.

In summary, Binary search is an efficient algorithm for searching through a sorted list of elements. Its time complexity is O(log n), where n is the number of elements in the list. This is because, with each iteration, the algorithm eliminates half of the remaining elements from consideration. It is important to have the input list sorted for the binary search to work correctly.

Bubble Sort

One example of a sorting algorithm in Python is the bubble sort algorithm. Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

Here is an example of bubble sort implemented in Python:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]

bubble_sort(arr)
print ("Sorted array is:",arr)

In this example, we first define a function called "bubble_sort" that takes in an array as an input. The function uses nested loops to iterate through the array, with the outer loop going through the entire array and the inner loop comparing adjacent elements and swapping them if they are in the wrong order. The outer loop makes n iterations where n is the length of the array and each iteration reduces the number of elements need to be compared by 1, as the largest element "bubbles up" to the end of the array.

The time complexity of bubble sort is O(n^2), which means that the number of steps it takes to sort an array of n elements is proportional to the square of n. This makes bubble sort inefficient for large arrays. However, bubble sort has the advantage of being easy to understand and implement, and it's a good choice for small arrays or for educational purposes.

In summary, bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted. The time complexity of bubble sort is O(n^2) which makes it inefficient for large arrays but it's a good choice for small arrays or for educational purposes.

Firebase + Nextjs

Abhishek kushwaha — Fri, 20 Jan 2023 17:24:52 +0000

Firebase is a Backend-as-a-Service (BaaS) platform that provides developers with a variety of tools and services to help them build and scale their web and mobile applications. Some of the most popular features of Firebase include:

Real-time Database: A cloud-hosted NoSQL database that allows developers to store and sync data across multiple devices in real-time.

Authentication: A user authentication service that supports different authentication methods such as email and password, phone number, and social media accounts.

Cloud Firestore: A document-oriented database that allows developers to store and query data in a hierarchical structure.

Cloud Functions: A serverless platform that allows developers to run their own code in response to events triggered by Firebase features such as database updates and authentication events.

Hosting: A static web hosting service that allows developers to host their web applications and static files on Firebase servers.

In this blog post, we'll walk through the process of setting up a Firebase project and integrating it with a Next.js application.

Create a Firebase project

To create a new Firebase project, go to the Firebase console and click on the "Create a Project" button. Give your project a name and select your country/region, then click on the "Create Project" button.

Add Firebase to your Next.js application

To add Firebase to your Next.js application, you'll need to install the Firebase SDK by running the following command in your terminal:

npm install firebase

Then, import the Firebase modules that you need in your application. For example, if you're going to use the Real-time Database, you can import it like this:

import firebase from 'firebase/app';
import 'firebase/database';

Initialize Firebase in your Next.js application

To initialize Firebase in your Next.js application, you'll need to create a new Firebase app and configure it with your Firebase project's credentials. You can find these credentials in the Firebase console under the "Project Settings" menu.

const firebaseConfig = {
    apiKey: '<your-api-key>',
    authDomain: '<your-auth-domain>',
    databaseURL: '<your-database-url>',
    projectId: '<your-project-id>',
    storageBucket: '<your-storage-bucket>',
    messagingSenderId: '<your-messaging-sender-id>',
    appId: '<your-app-id>'
};

firebase.initializeApp(firebaseConfig);

Use Firebase in your Next.js application

Now that you've initialized Firebase in your Next.js application, you can start using it to interact with the Firebase services that you've enabled for your project. For example, you can use the Real-time Database to read and write data like this:


const database = firebase.database();

// Read data from the Real-time Database
database.ref('/data').on('value', (snapshot) => {
    console.log(snapshot.val());
});

// Write data to the Real-time Database
database.ref('/data').set({
    name: 'John Doe',
    age:30
});

You can also use the Firebase Authentication service to authenticate users in your Next.js application. For example, you can create a new user with an email and password like this:

const auth = firebase.auth();

auth.createUserWithEmailAndPassword('johndoe@example.com', 'password')
    .then((user) => {
        console.log(user);
    })
    .catch((error) => {
        console.error(error);
    });

And you can also sign in an existing user with an email and password like this:

auth.signInWithEmailAndPassword('johndoe@example.com', 'password')
    .then((user) => {
        console.log(user);
    })
    .catch((error) => {
        console.error(error);
    });

Deploy your Next.js application

Finally, once you have your Next.js application integrated with Firebase, you can deploy it to Firebase hosting. To do this, you'll need to install the Firebase CLI by running the following command in your terminal:

npm install -g firebase-tools

Then, run the following command to log in to your Firebase account:

firebase login

After that, you can run the following command to deploy your Next.js application to Firebase hosting:

firebase deploy

This will deploy 🚀 your application to a public URL that you can share with others.

In conclusion, Firebase offers a wide range of features and services that can help developers to build and scale their applications. By integrating Firebase with a Next.js application, developers can easily add backend functionality such as authentication, database storage, and serverless functionality without having to manage their own servers. This makes the development process fasterand more efficient, allowing developers to focus on building the core functionality of their applications.

Additionally, Firebase also provides additional features such as **Cloud Firestore**, a document-oriented database, and Cloud Functions, which allow developers to run their own server-side logic in response to events triggered by Firebase features.

Cloud Firestore is a NoSQL document-based database that allows developers to store and query data in a hierarchical structure. It can be used to store data such as user profiles, blog posts, or product information. Cloud Firestore can be integrated with a Next.js application by installing the firebase-admin package and initializing it with the Firebase project's credentials.

Cloud Functions are a way to run server-side logic in response to events triggered by Firebase features such as database updates and authentication events. They can be used to perform tasks such as sending email notifications, triggering push notifications, or generating thumbnails for image uploads. Developers can write Cloud Functions in Node.js and deploy them to Firebase using the Firebase CLI.

In addition to these features, Firebase also provides a number of other services such as Cloud Storage, Cloud Messaging, and Firebase Analytics. These services can be integrated with a Next.js application in a similar way as the Real-time Database, Cloud Firestore, and Cloud Functions.

In summary, Firebase **is a powerful backend-as-a-service platform that can be easily integrated with a Next.js application to provide a wide range of backend functionality. With Firebase, developers can focus on building the core functionality of their applications while Firebase handles the backend tasks such as authentication, database storage, and serverless functions. Additionally, Firebase also provides additional features such as **Cloud Firestore and Cloud Functions that can be used to build more complex applications.

Mastering MongoDB and Mongoose in Node.js

Abhishek kushwaha — Sun, 18 Dec 2022 08:19:13 +0000

MongoDB is a popular NoSQL database that is commonly used in Node.js applications. Mongoose is an Object Data Modeling (ODM) library that provides a straight-forward, schema-based solution to model your application data in MongoDB. In this blog, we will learn how to work with MongoDB and Mongoose in a Node.js application.

Setting up MongoDB

To start working with MongoDB, you need to have MongoDB installed on your system. You can download and install MongoDB from the official website (https://www.mongodb.com/download-center/community).

Once you have MongoDB installed, you need to start the MongoDB server. To start the server, open a terminal and navigate to the directory where MongoDB is installed. Then, run the following command:

mongod

This will start the MongoDB server and it will listen for connections on the default port 27017.

Connecting to MongoDB with Mongoose

To connect to MongoDB from a Node.js application, we will use the Mongoose library. Mongoose provides a simple and straight-forward way to model your application data and interacts with MongoDB.

To install Mongoose, run the following command:

npm install mongoose

Once you have Mongoose installed, you can connect to MongoDB by creating a connection. Here's an example of how to create a connection to MongoDB using Mongoose:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/myapp', { useNewUrlParser: true });

const db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
  console.log('Connected to MongoDB');
});

In the above code, we are connecting to a database named "myapp" on the local machine. The mongoose.connect function establishes the connection to the database. The useNewUrlParser option is used to specify that we want to use the new URL parser introduced in MongoDB 4.0.

The db object represents the connection to the database. We are binding an event listener to the error event, which will be triggered if there is an error while connecting to the database. We are also binding an event listener to the open event, which will be triggered when the connection is successfully established.

Defining a Mongoose schema

A Mongoose schema defines the structure of the document, default values, validators, and other options for the documents stored in a collection. To define a Mongoose schema, we need to create a new file and define a schema using the mongoose.Schema constructor.

Here's an example of how to define a schema for a user document:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
``

Creating a Mongoose model

A Mongoose model is a wrapper on the Mongoose schema that provides methods for CRUD operations on the documents of a collection. To create a model, we need to pass the schema to the mongoose.model function.

Here's an example of how to create a model from the user schema defined above:

const User = mongoose.model('User', userSchema);

The first argument of the mongoose.model function is the name of the model, which will be used to create the collection in the database. The second argument is the schema that the model will use.

Creating and saving documents

To create and save a new document in the database, we can use the save method of the model. Here's an example of how to create and save a new user document:

const user = new User({
  name: 'John Doe',
  email: 'john@doe.com',
  password: 'password'
});

user.save((error) => {
  if (error) {
    console.log(error);
  } else {
    console.log('User saved successfully');
  }
});

In the above code, we are creating a new instance of the User model and setting the values for the name, email, and password fields. Then, we are calling the save method on the instance to save it to the database. The save method accepts a callback function that will be called when the save operation is complete.

Finding documents

To find documents in the database, we can use the find method of the model. The find method returns an array of documents that match the query.

Here's an example of how to find all users in the database:

User.find((error, users) => {
  if (error) {
    console.log(error);
  } else {
    console.log(users);
  }
});

The find method accepts a callback function that will be called when the find operation is complete. The callback function will be passed two arguments: an error object (if an error occurred) and an array of documents.

We can also specify a query to filter the documents that we want to find. For example, to find all users with a specific email address, we can use the following query:

User.find({ email: 'john@doe.com' }, (error, users) => {
  if (error) {
    console.log(error);
  } else {
    console.log(users);
  }
});

Updating documents

To update a document in the database, we can use the findOneAndUpdate method of the model. This method finds a single document and updates it based on the provided data.

Here's an example of how to update a user document:

User.findOneAndUpdate(
  { email: 'john@doe.com' },
  { name: 'John Smith' },
  (error, user) => {
    if (error) {
      console.log(error);
    } else {
      console.log('User updated successfully');
    }
  }
);

In the above code, we are finding the user with the email "john@doe.com" and updating their name to "John Smith". The findOneAndUpdate method accepts three arguments: a query to find the document, the data to update, and a callback function. The callback function will be called when the update operation is complete and will be passed two arguments: an error object (if an error occurred) and the updated document.

Deleting documents

To delete a document from the database, we can use the findOneAndDelete method of the model. This method finds a single document and deletes it.

Here's an example of how to delete a user document:

User.findOneAndDelete({ email: 'john@doe.com' }, (error) => {
  if (error) {
    console.log(error);
  } else {
    console.log('User deleted successfully');
  }
});

The findOneAndDelete method accepts two arguments: a query to find the document and a callback function. The callback function will be called when the delete operation is complete and will be passed an error object (if an error occurred).

Conclusion

In this blog, we learned how to work with MongoDB and Mongoose in a Node.js application. We learned how to connect to the database, define a schema, create a model, create and save documents, find documents, update documents, and delete documents. With these basic operations, you can start building your own MongoDB-powered Node.js applications.

Guide to Yaml

Abhishek kushwaha — Sun, 11 Dec 2022 14:50:45 +0000

YAML (YAML Ain't Markup Language) is a human-readable data serialization language. It is often used for configuration files, but can be used in many other contexts as well. In this blog, we will take a look at the basics of YAML and how it can be used by developers.

First, let's define what a YAML file is. A YAML file is a text file that uses the YAML syntax to specify data structures. These data structures can be a mix of scalar values (strings, numbers, etc.), lists, and associative arrays (also known as maps or dictionaries).

Here is an example of a YAML file that defines a simple list:

- item1
- item2
- item3

This YAML file defines a list of three items: item1, item2, and item3. You can see that the list is denoted by a dash (-) followed by the item.

Now, let's take a look at how we can define a more complex data structure in YAML. Here is an example of a YAML file that defines an associative array:

key1: value1
key2: value2
key3:
  - subkey1: subvalue1
  - subkey2: subvalue2

In this example, we have defined an associative array with three keys: key1, key2, and key3. The value for key1 and key2 are simple scalar values, but the value for key3 is a list of associative arrays.

One of the benefits of using YAML is that it is very readable and easy to write. It also supports comments, which can be useful for documenting your YAML files. Here is an example of a YAML file with comments:

# This is a comment
key: value

# This is another comment
# It can span multiple lines
key2:
  - subkey1: subvalue1
  - subkey2: subvalue2

As you can see, comments in YAML are denoted by the # character and can be placed on their own line or after a value.

Another benefit of YAML is that it is versatile and can be used in many different contexts. For example, it is commonly used for configuration files in software projects. Here is an example of a YAML configuration file:

# This is a sample configuration file

# Global settings
global:
  # The name of the project
  name: My Project

# Database settings
database:
  # The type of database to use
  type: mysql
  # The database host
  host: localhost
  # The database port
  port: 3306
  # The database username
  username: root
  # The database password
  password: password

In this example, we have defined a configuration file with two sections: global and database. The global section contains a single key-value pair, while the database section contains several keys with their corresponding values.

YAML is also used in other contexts, such as for defining Kubernetes resources. Here is an example of a YAML file that defines a Kubernetes Deployment:

apiVersion: apps/v

As mentioned earlier, YAML is a versatile language and can be used in many different contexts. In addition to configuration files and Kubernetes resources, YAML is also used in other tools and frameworks, such as Ansible and Rails.

In Ansible, YAML is used to define playbooks, which are files that specify a set of tasks to be executed on one or more remote hosts. Here is an example of an Ansible playbook written in YAML:

---
- hosts: all
  tasks:
    - name: Install Apache
      apt: name=apache2 state=present
    - name: Start Apache
      service: name=apache2 state=started

In this example, we have defined a playbook that installs and starts Apache on all hosts in the all group. The playbook is written in YAML and consists of two tasks: Install Apache and Start Apache.

In Rails, YAML is used for a variety of purposes, such as defining translations and fixtures. Here is an example of a YAML file used for defining translations in Rails:

en:
  hello: "Hello"
  world: "World"

fr:
  hello: "Bonjour"
  world: "Monde"

In this example, we have defined translations for the words "hello" and "world" in English and French. The translations are organized in a YAML file, with the language code as the key and the translations as the values.

As you can see, YAML is a useful and versatile language that can be used in many different contexts by developers. It is easy to read and write, supports comments, and can be used for a variety of purposes.

In conclusion, YAML is a human-readable data serialization language that is often used for configuration files and other purposes. It is easy to read and write, supports comments, and can be used in many different contexts, such as Ansible playbooks and Rails translations. Developers can use YAML to organize and represent their data in a clear and concise way.

TypeScript

Abhishek kushwaha — Sun, 11 Dec 2022 14:48:56 +0000

When it comes to web development, JavaScript is one of the most popular and widely used programming languages. However, many developers have started using TypeScript, a programming language that is based on JavaScript, but adds additional features and capabilities.

So why choose TypeScript over JavaScript? In this blog post, we will explore the advantages of TypeScript and discuss why it can be a valuable tool for web developers.

What is TypeScript?

TypeScript is a programming language that was developed and open-sourced by Microsoft in 2012. It is a statically-typed language, which means that variables and functions have a specific type, and the TypeScript compiler checks for type errors at compile time.

TypeScript is built on top of JavaScript, and it is fully compatible with JavaScript. This means that you can use TypeScript in any JavaScript project, and any valid JavaScript code is also valid TypeScript code.

The main advantage of TypeScript over JavaScript is its strong typing system. In JavaScript, variables and functions do not have a specific type, and type errors are only caught at runtime. This can make it difficult to write and maintain large and complex JavaScript applications.

In contrast, TypeScript's strong typing system allows the compiler to catch type errors at compile time, before the code is even run. This can help prevent bugs and make it easier to refactor and maintain your code.

Object-Oriented Features

In addition to its strong typing system, TypeScript also adds object-oriented features to the language. TypeScript supports classes, interfaces, and modules, which can make it easier to structure and organize your code.

This can be particularly useful for large and complex applications, where a well-defined structure can make it easier to understand and maintain the code.

Good Integration with Popular JavaScript Libraries and Frameworks

Another advantage of TypeScript is its good integration with popular JavaScript libraries and frameworks. TypeScript has strong support for React, Angular, and Node.js, among others.

This means that you can use TypeScript in your existing JavaScript projects, and take advantage of its strong typing and object-oriented features. This can make it easier to write and maintain large and complex JavaScript applications.

Overall, TypeScript can be a valuable tool for web developers who want to write large and complex JavaScript applications. Its strong typing and object-oriented features can make it easier to write and maintain your code, and its good integration with popular JavaScript libraries and frameworks can make it a valuable addition to your toolkit.

If you are a JavaScript developer who is looking to improve the quality and maintainability of your code, consider giving TypeScript a try. It may take some time to learn the additional features and syntax of the language, but the benefits can be well worth it in the long run.

To get started with TypeScript, you will need to install the TypeScript compiler on your computer. The TypeScript compiler, or tsc, is a command-line tool that allows you to transpile TypeScript code into JavaScript code.

To install the TypeScript compiler, you will need to have Node.js and npm (the Node.js package manager) installed on your computer. If you don't have these tools installed, you can download and install them from the Node.js website.

Once you have Node.js and npm installed, you can use the following command to install the TypeScript compiler:

npm install -g typescript

This will install the TypeScript compiler globally on your system, allowing you to use it from the command line.

Once the TypeScript compiler is installed, you can create a TypeScript file with a .ts extension. For example, you might create a file called hello.ts that contains the following code:

function sayHello(name: string) {
  console.log("Hello, " + name);
}

sayHello("TypeScript");

This code defines a simple function called sayHello that takes a string argument and logs a greeting to the console. The function is annotated with a type signature, which specifies that the name argument is a string.

To transpile this TypeScript code into JavaScript code, you can use the following command:

tsc hello.ts
This will create a file called hello.js that contains the equivalent JavaScript code:

function sayHello(name) {
  console.log("Hello, " + name);
}

sayHello("TypeScript");

You can then run this JavaScript code using the Node.js runtime:

node hello.js
This will output the following message to the console:

Hello, TypeScript

And that's it! You have successfully transpiled your first TypeScript code into JavaScript, and run it using the Node.js runtime. From here, you can continue learning and experimenting with TypeScript, and explore its many features and capabilities.

Once you have the TypeScript compiler installed, you can start using it to transpile your TypeScript code into JavaScript code. In addition to the basic usage described above, there are a few other things you can do with the TypeScript compiler:

You can use the --watch flag to tell the compiler to watch for changes to your TypeScript files, and automatically transpile them whenever they are saved. This can save you time and effort, and make it easier to develop your TypeScript code.

You can use the --outFile flag to specify the name of the output JavaScript file. By default, the compiler will create a JavaScript file with the same name as the TypeScript file, but with a .js extension. However, you can use the --outFile flag to specify a different name or location for the output file.

You can use the --target flag to specify the version of JavaScript that you want your TypeScript code to be transpiled into. By default, the compiler will transpile your code into the latest version of JavaScript (ES6). However, you can use the --target flag to specify an older version of JavaScript, such as ES5, if you need to support older browsers or environments.

You can use the --sourceMap flag to generate a source map for your TypeScript code. A source map is a file that maps the generated JavaScript code back to the original TypeScript code, allowing you to debug your TypeScript code using the original source files. This can make it easier to debug and troubleshoot your TypeScript code.

Overall, the TypeScript compiler is a powerful and flexible tool that allows you to transpile your TypeScript code into JavaScript code. By using the various flags and options available, you can customize the compiler to suit your needs and preferences.

In addition to the basic usage and advanced features of the TypeScript compiler described above, there are a few other things you can do to make the most of TypeScript:

Use a TypeScript-aware code editor or IDE. Many popular code editors and IDEs, such as Visual Studio Code, WebStorm, and Sublime Text, have built-in support for TypeScript. This can make it easier to write and debug your TypeScript code, and take advantage of features such as code completion and error highlighting.

Use type definitions for popular JavaScript libraries and frameworks. TypeScript includes a large number of built-in type definitions, but you can also use third-party type definitions to add type information for popular JavaScript libraries and frameworks. This can make it easier to use these libraries and frameworks with TypeScript, and take advantage of the type checking and other features of the language.

Use a build tool or task runner. While the TypeScript compiler is a powerful tool, it can be tedious to manually run the compiler and manage your TypeScript files. To make this easier, you can use a build tool or task runner, such as Webpack or Grunt, to automate the process of transpiling your TypeScript code and managing your project files.

Use a type checker. In addition to the TypeScript compiler, you can also use a separate type checker, such as TSLint or Flow, to perform static type checking on your TypeScript code. This can help you catch and fix type errors and other issues before they become bugs in your code.

Overall, there are many ways to make the most of TypeScript and take advantage of its powerful features and capabilities. By using the right tools and techniques, you can write high-quality and maintainable TypeScript code, and build large and complex JavaScript applications.

Type annotations

Type annotations in TypeScript are used to specify the type of a variable, function, or other language construct. This allows the TypeScript compiler to check for type errors at compile time, and helps you avoid common bugs and mistakes.

To use type annotations, you simply specify the type of a variable or function after its name, using a colon (:) and the type name. For example, the following code defines a variable called name with the type string:

let name: string;

In this code, the string type annotation tells the TypeScript compiler that the name variable can only be assigned values of type string. If you try to assign a value of a different type, the compiler will raise an error.

You can also use type annotations for function arguments and return values. For example, the following code defines a function called sayHello that takes a name argument of type string, and returns a value of type string:

function sayHello(name: string): string {
  return "Hello, " + name;
}

In this code, the type annotations for the name argument and the return value tell the TypeScript compiler that the sayHello function expects a string as input, and returns a string as output. If you try to call the function with an argument of a different type, or if the function tries to return a value of a different type, the compiler will raise an error.

Type annotations are optional in TypeScript, but they are highly recommended. By using type annotations, you can take advantage of the strong typing and type checking capabilities of TypeScript, and write more reliable and maintainable code.

In TypeScript, an object type is a type that represents the structure of an object, including the names and types of its properties and methods. Object types are defined using the {} syntax, and they can be used to annotate variables, function arguments, and return values.

For example, the following code defines an object type called Person that has two properties, name and age, of type string and number, respectively:

type Person = {
  name: string;
  age: number;
}

In this code, the Person object type defines the structure of a person object, including the names and types of its name and age properties.

You can then use the Person object type to annotate a variable that holds a person object. For example:

let person: Person = {
  name: "Jane",
  age: 25
};

In this code, the person variable is annotated with the Person object type, which tells the TypeScript compiler that the person variable must be an object with name and age properties of type string and number, respectively.

You can also use object types to annotate function arguments and return values. For example:

function getPerson(id: number): Person {
  // lookup and return the person object with the given id
}

In this code, the getPerson function is annotated with the Person object type, which tells the TypeScript compiler that the getPerson function expects a number as input, and returns a Person

Interface

In TypeScript, an interface is a language construct that defines a contract for types that implement it. An interface specifies the names and types of properties and methods that a type must have, and it allows you to enforce a common structure and behavior among related types.

To define an interface, you use the interface keyword followed by the name of the interface, and a list of the properties and methods that the interface defines. For example:

interface Person {
  name: string;
  age: number;
  greet(): string;
}

In this code, the Person interface defines a type with a name property of type string, an age property of type number, and a greet method that returns a string.

Once an interface is defined, you can use it to annotate the types that implement it. For example:

class Employee implements Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): string {
    return "Hello, my name is " + this.name;
  }
}

In this code, the Employee class implements the Person interface. This means that the Employee class must have the name, age, and greet properties and methods defined by the Person interface. If the Employee class does not implement these properties and methods, or if it implements them with the wrong names or types, the TypeScript compiler will raise an error.

Interfaces are a powerful feature of TypeScript that allow you to define common structures and behaviors for related types. By using interfaces, you can enforce a consistent design and implementation among your types, and make your code more maintainable and reusable.

Class

In TypeScript, a class is a language construct that allows you to define a blueprint for an object. A class specifies the properties and methods that an object of that class will have, and it defines the structure and behavior of the object.

To define a class in TypeScript, you use the class keyword followed by the name of the class, and the body of the class enclosed in curly braces ({}). The body of the class can contain properties, methods, and other class members, which define the structure and behavior of the object.

For example, the following code defines a Person class with a name property and a greet method:

class Person {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  greet(): string {
    return "Hello, my name is " + this.name;
  }
}

In this code, the Person class has a name property of type string, and a greet method that returns a string. The class also has a constructor, which is a special method that is called when an object of the class is created. The constructor initializes the name property of the object.

Once a class is defined, you can create objects of that class using the new keyword. For example:

let person = new Person("Jane");
console.log(person.greet()); // "Hello, my name is Jane"

In this code, the person variable is assigned an object of the Person class, with the given name value. The greet method of the object is then called, which outputs the greeting message to the console.

Classes are a powerful feature of TypeScript that allow you to define reusable and extensible object types. By using classes, you can organize and structure your code in a way that is intuitive and easy to understand, and that allows for flexibility and reuse.

React + Typescript

React is a popular JavaScript library for building user interfaces, and TypeScript is a powerful typed superset of JavaScript. Together, React and TypeScript can provide a powerful and productive development experience, with the benefits of type checking and other features of TypeScript.

To use React with TypeScript, you will need to have the React and TypeScript libraries installed on your development machine. If you don't already have them installed, you can use the following commands to install them using npm, the Node.js package manager:

npm install react
npm install typescript

Once you have the React and TypeScript libraries installed, you can create a new React project using the create-react-app command-line tool. This tool will set up a new React project with TypeScript support, and create the necessary files and configuration for you.

To create a new React project with TypeScript support, run the following command:

npx create-react-app my-app --template typescript
This will create a new React project called my-app, with TypeScript support enabled. The create-react-app tool will set up the project, install the necessary dependencies, and create the initial project files.

Once the project is set up, you can start writing your React components using TypeScript. TypeScript components in React are similar to regular JavaScript components, but they have type annotations that specify the types of their props and state.

For example, the following code defines a Hello component that has a name prop of type string:

import React from "react";

type HelloProps = {
  name: string;
};

const Hello: React.FC<HelloProps> = (props: HelloProps) => {
  return <p>Hello, {props.name}!</p>;
};

export default Hello;

In this code, the HelloProps type defines the structure of the Hello component's props, with a name property of type string. The Hello component is then defined as a functional component with a type parameter that specifies the HelloProps type. This tells the TypeScript compiler that the Hello component expects a name prop of type string, and that any other props passed to the component must match the shape of the HelloProps type.

You can then use the Hello component in your React app just like any other component. For example:

import React from "react";
import Hello from "./Hello";

function App() {
  return (
    <div>
      <Hello name="TypeScript" />
    </div>
  );
}

export default App;

In addition to type checking for props and state, TypeScript can also provide type checking for event handlers and other functions in your React components. For example, the following code defines an event handler for a button click event, and uses TypeScript to specify the type of the event object:

import React from "react";

type HelloProps = {
  name: string;
};

const Hello: React.FC<HelloProps> = (props: HelloProps) => {
  const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
    console.log(event.type);
  };

  return (
    <button onClick={handleClick}>
      Click me!
    </button>
  );
};

export default Hello;

In this code, the handleClick event handler is defined with a type parameter that specifies the type of the event object. This tells the TypeScript compiler that the handleClick function expects an event object of type React.MouseEvent, and that the event.type property will be of type string. This allows the TypeScript compiler to provide type checking for the event object, and help you avoid type errors and bugs in your code.

Overall, using React and TypeScript together can provide a powerful and productive development experience, with the benefits of type checking and other features of TypeScript. By using TypeScript in your React components, you can write more reliable and maintainable code, and catch type errors and other issues early in the development process.

Here are a few tips for using React and TypeScript together:

Use type definitions for React and other libraries. TypeScript includes a large number of built-in type definitions, but you can also use third-party type definitions to add type information for popular JavaScript libraries and frameworks, such as React. This can make it easier to use these libraries with TypeScript, and take advantage of the type checking and other features of the language.
Annotate props and state with precise types. In React components, props and state are the source of truth for the component's data and behavior. By using precise and explicit types for your props and state, you can enable the TypeScript compiler to provide type checking and validation for your component data, and help you avoid type errors and bugs.
Use type parameters for functions and event handlers. In your React components, you will often need to define functions and event handlers that handle specific types of data or events. By using type parameters and type annotations, you can specify the types of these functions and event handlers, and enable the TypeScript compiler to provide type checking and validation for them.
Use interfaces to define common structures and behaviors. In complex React applications, you will often need to define common structures and behaviors that are shared among multiple components. By using interfaces, you can define these common structures and behaviors in a single place, and use them to annotate your components and enable type checking.

Overall, using React and TypeScript together can provide many benefits, including improved reliability and maintainability of your code. By following these tips and using the features of TypeScript effectively, you can build high-quality and scalable React applications.

10 Tips for Success: How to Be a Productive Developer and Student

Abhishek kushwaha — Fri, 09 Dec 2022 19:45:00 +0000

Being a developer and a student can be a challenging balancing act. On the one hand, you have the demanding work of being a developer, which requires focus, attention to detail, and the ability to solve complex problems. On the other hand, you also have the demanding work of being a student, which requires you to learn new material, complete assignments, and prepare for exams.

With time I learned that to be successful as a developer and a student, it's important to prioritize your tasks and manage your time effectively. Here are a few tips that I got from community to help you stay productive:

Create a schedule and stick to it. Having a schedule helps you organize your time and ensures that you are able to complete all of your tasks in a timely manner. Make sure to include time for your classes, studying, and your development work in your schedule.
Prioritize your tasks. Not all tasks are created equal. Some tasks are more important than others, and some tasks are more urgent than others. Make sure to prioritize your tasks so that you are focusing on the most important and urgent tasks first.
Take breaks. It's important to take breaks throughout the day to avoid burnout. Take a few minutes to stretch, grab a snack, or go for a walk. This will help you recharge and come back to your tasks with a fresh perspective.
Avoid distractions. Distractions can be a major productivity killer. When you are working on a task, make sure to minimize distractions by closing unnecessary tabs, turning off your phone, or finding a quiet place to work.
Use tools and technologies to your advantage. There are many tools and technologies available that can help you be more productive as a developer and a student. Consider using a task manager to organize your tasks, a code editor to write and edit your code, or a study app to help you prepare for exams.
By following these tips, you can be more productive as a developer and a student. Stay focused, stay organized, and keep pushing yourself to be the best that you can be.
Set specific goals and deadlines. Having specific goals and deadlines can help you stay focused and motivated. Make sure to set goals that are specific, measurable, achievable, relevant, and time-bound (SMART).
Collaborate with others. Collaborating with other developers or students can be a great way to learn new skills, share knowledge, and stay motivated. Consider joining a study group, a coding club, or an online community of developers to connect with others and learn from each other.
Seek feedback. Getting feedback from others can be a valuable way to improve your skills and learn from your mistakes. Consider asking for feedback from your peers, mentors, or instructors to help you grow as a developer and a student.
Take care of yourself. In order to be productive, you need to take care of yourself. Make sure to get enough sleep, eat well, exercise regularly, and take time for yourself. This will help you maintain a healthy balance and stay focused on your work.
Use the Pomodoro technique. The Pomodoro technique is a time management method that can help you stay focused and avoid burnout. The basic idea is to work in short bursts (usually 25 minutes) followed by a short break (usually 5 minutes). This can help you stay focused and avoid becoming overwhelmed by your tasks.
Block out time for specific tasks. In addition to creating a schedule, it can be helpful to block out specific time for specific tasks. For example, you might block out an hour in the morning to work on your development project, and an hour in the afternoon to study for an exam. This can help you stay focused and avoid distractions.
Avoid multitasking. While it may seem like multitasking can help you get more done, research has shown that it can actually decrease your productivity. Instead of trying to do multiple tasks at once, focus on one task at a time and give it your full attention. This will help you complete your tasks more efficiently and effectively.
Celebrate your successes. It's important to recognize and celebrate your successes, both big and small. This will help you stay motivated and keep pushing yourself to do your best. Take a moment to celebrate when you complete a difficult task, finish a project, or get a good grade on an exam. This will help you stay motivated and focused on your goals.

By following these tips, you can be more productive as a developer and a student. Stay focused, stay organized, and take care of yourself, and you will be well on your way to success.

GraphQL

Abhishek kushwaha — Fri, 09 Dec 2022 05:33:21 +0000

GraphQL is a powerful query language that was developed by Facebook to provide a more efficient and flexible way to query and manipulate data in APIs. Unlike traditional REST APIs, which expose a fixed set of endpoints and often require multiple round trips to the server to fetch all the necessary data, GraphQL allows the client to specify exactly what data it needs in a single request. This not only reduces the amount of data that needs to be transferred over the network, but it also allows the client to retrieve only the data that it needs, making the API more flexible and scalable.

In this blog post, we will walk through the steps for building a GraphQL API from scratch. We will start by defining the data schema, which specifies the types of data that the API will expose and the relationships between those types. Next, we will implement resolvers, which are responsible for fetching the data for each field in the schema. Then, we will create the GraphQL server, which will allow us to send queries and mutations to the API. Finally, we will test the API to ensure that it is functioning correctly.

Defining the Data Schema

The first step in building a GraphQL API is to define the data schema. This involves specifying the types of data that the API will expose and the relationships between those types. For example, if you are building an API for a to-do list application, you may have a Task type and a User type, with a one-to-many relationship between User and Task.

In GraphQL, the schema is written using the GraphQL Schema Definition Language (SDL), which is a human-readable syntax for defining the types and relationships in the schema. Here is an example of how you might define the Task and User types in the to-do list application:

type User {
  id: ID!
  name: String!
  email: String!
  tasks: [Task!]!
}

type Task {
  id: ID!
  title: String!
  description: String!
  completed: Boolean!
  user: User!
}

In this example, the User type has an id, a name, and an email, as well as a list of tasks that belong to that user. The Task type has an id, a title, a description, a completed flag, and a user who created the task.

Implementing Resolvers

Once you have defined your data schema, you will need to implement resolvers for each field in the schema. A resolver is a function that is responsible for fetching the data for a particular field. For example, if you have a Task type with a title field, you would need to implement a resolver function that fetches the title for a particular task.

In GraphQL, resolvers are typically organized into a "resolver map" where each key in the map corresponds to a field in the schema. For example, here is how you might implement the resolvers for the Task type in the to-do list application:

const resolvers = {
  Task: {
    id: (parent, args, context) => parent.id,
    title: (parent, args, context) => parent.title,
    description: (parent, args, context) => parent.description,
    completed: (parent, args, context) => parent.completed,
    user: (parent, args, context) => context.users.find(user => 
    user.id === parent.userId),
},
};

In this example, each resolver function takes three arguments: parent, args, and context. The parent argument is the parent object that contains the field being resolved, the args argument is an object containing any arguments passed to the field in the query, and the context argument is an object that contains shared data and helper functions that can be used by the resolvers.

In this case, the user resolver uses the context object to find the User object that is associated with the task being resolved. This allows the resolver to return the User object for the user field in the Task type.

Creating the GraphQL Server

The next step is to create the GraphQL server, which will allow us to send queries and mutations to the API. There are many libraries and frameworks available for creating a GraphQL server, such as Apollo Server and GraphQL-JS.

In this example, we will use Apollo Server, which is a popular GraphQL server implementation that supports many of the most commonly used GraphQL features. To create the server, we first need to define the schema and resolvers that we have implemented in the previous steps:

const schema = makeExecutableSchema({
typeDefs: [UserType, TaskType],
resolvers,
});

const server = new ApolloServer({
schema,
context: {
users: [
{
id: '1',
name: 'Alice',
email: 'alice@example.com',
},
{
id: '2',
name: 'Bob',
email: 'bob@example.com',
},
],
tasks: [
{
id: '1',
title: 'Learn GraphQL',
description: 'Learn how to build a GraphQL API',
completed: true,
userId: '1',
},
{
id: '2',
title: 'Write blog post',
description: 'Write a blog post about building a GraphQL API',
completed: false,
userId: '1',
},
{
id: '3',
title: 'Go for a run',
description: 'Go for a run to stay healthy and fit',
completed: false,
userId: '2',
},
],
},
});

In this example, we use the makeExecutableSchema function from the graphql-tools library to create the schema from the type definitions and resolvers that we have defined. We then create an instance of the ApolloServer class, passing in the schema and a context object that contains the data for the users and tasks in the to-do list application.

Testing the API

Once you have set up the GraphQL server, you can test the API by sending GraphQL queries and mutations to the server. This will allow you to verify that the API is functioning correctly and that the data is being returned as expected.

To send queries and mutations to the server, you can use a GraphQL client such as GraphiQL or Insomnia. These tools allow you to construct and send GraphQL queries and mutations and view the results in an easy-to-read format. For example, here is how you might query the API to fetch all the tasks for a particular user:

query {
  user(id: "1") {
    name
    email
    tasks {
      id
      title
      description
      completed
    }
  }
}

In this example, the query specifies that we want to fetch the name, email, and tasks fields for the user with the id of 1. The API will then use the user resolver to fetch the user with the specified id, and the tasks resolver to fetch the tasks for that user. The resulting data will be returned in the following format:


{
  "data": {
    "user": {
      "name": "Alice",
      "email": "alice@example.com",
      "tasks": [
        {
          "id": "1",
          "title": "Learn GraphQL",
          "description": "Learn how to build a GraphQL API",
          "completed": true
        },
        {
          "id": "2",
          "title": "Write blog post",
          "description": "Write a blog post about building a GraphQL API",
          "completed": false
        }
      ]
    }
  }
}

In addition to querying the API, you can also use GraphQL mutations to modify the data in the API. For example, here is how you might use a mutation to update the completed field for a particular task:

mutation {
  updateTask(id: "1", completed: true) {
    id
    title
    description
    completed
  }
}

In this example, the mutation specifies that we want to update the task with the id of 1, setting the completed field to true. The API will then use the appropriate resolver to update the task and return the updated data in the following format:

{
  "data": {
    "updateTask": {
      "id": "1",
      "title": "Learn GraphQL",
      "description": "Learn how to build a GraphQL API",
      "completed": true
    }
  }
}

Conclusion

In this blog post, we have walked through the steps for building a GraphQL API from scratch. We started by defining the data schema, which specifies the types of data that the API will expose and the relationships between those types. Next, we implemented resolvers, which are responsible for fetching the data for each field in the schema. Then, we created the GraphQL server, which allows us to send queries and mutations to the API. Finally, we tested the API to ensure that it is functioning correctly.

Overall, building a GraphQL API can be a time-consuming process, but it allows you to create a flexible and powerful API that can be used to build modern applications. By using GraphQL, you can reduce the amount of data transferred over the network and provide your clients with the ability to fetch only the data that they need, making your API more efficient and scalable.

As you continue to work on your GraphQL API, there are a few best practices that you should keep in mind. For example, you should always strive to keep your schema and resolvers as simple and modular as possible. This will make your code easier to understand and maintain, and it will also make it easier to add new features to your API in the future.

In addition, you should take advantage of the many tools and libraries that are available for working with GraphQL. For example, you can use the graphql-tools library to simplify the process of creating your schema and resolvers, and the apollo-server-express library to easily integrate your GraphQL server with an existing Express.js web application.

Finally, you should make sure to properly test and document your GraphQL API. This will ensure that your API is reliable and easy to use, and it will also make it easier for other developers to integrate with your API.

By following these best practices, you can build a high-quality GraphQL API that is efficient, flexible, and scalable.

Thanks for Reading 😊

ChatGPT: The Ultimate Tool for Natural Language Processing and Text Generation

Abhishek kushwaha — Thu, 08 Dec 2022 07:55:24 +0000

What is ChatGPT ?

ChatGpt is a large-scale language model developed by OpenAI. It is based on the GPT-3 (Generative Pretrained Transformer-3) architecture and has been trained on a massive amount of text data to generate human-like responses to natural language queries.
One of the key advantages of ChatGpt is its ability to generate text that is highly coherent and contextually relevant. This means that when you ask it a question, it is able to generate a response that flows naturally and is relevant to the conversation.
For example, if you ask ChatGpt a question about a topic it has been trained on, such as "What is the capital of France?", it will generate a response that accurately answers the question, such as "The capital of France is Paris."
In addition to its ability to generate coherent text, ChatGpt is also able to handle a wide range of natural language queries. This means that you can ask it complex questions and it will generate a response that is clear and easy to understand.
One of the applications of ChatGpt is in natural language processing (NLP) tasks, such as language translation, text summarization, and question answering. By using ChatGpt, developers can build NLP systems that are able to understand and generate human-like responses to natural language queries.
Another potential application of ChatGpt is in conversational agents, such as chatbots. By using ChatGpt as the underlying technology, developers can build chatbots that are able to engage in natural, human-like conversations with users.
Overall, ChatGpt is a powerful language model that has the ability to generate human-like text and handle a wide range of natural language queries. With its potential applications in NLP and conversational agents, ChatGpt has the potential to revolutionize the way we interact with computers and machines.
In terms of technical details, ChatGpt is based on the GPT-3 architecture, which uses a transformer-based model to generate text. This means that it uses a series of self-attention mechanisms to learn the relationships between words and generate text that is coherent and contextually relevant.
One of the key advantages of the GPT-3 architecture is its ability to handle long sequences of text, which is crucial for generating coherent responses to natural language queries. This is because natural language often involves long chains of dependencies, where the meaning of a word or phrase can depend on the context of the entire sentence or conversation.
In terms of training data, ChatGpt has been trained on a massive amount of text data, including books, articles, and websites. This allows it to generate responses that are accurate and relevant to a wide range of topics.
Another important aspect of ChatGpt is its ability to handle a wide range of natural language inputs. This means that it is able to understand and generate responses to a wide range of queries, including questions, commands, and statements.
Overall, ChatGpt is a powerful and versatile language model that has the potential to revolutionize the way we interact with machines and computers. Its ability to generate coherent and contextually relevant text, as well as handle a wide range of natural language inputs, makes it a valuable tool for developers working on natural language processing and conversational agent applications.

Use

One of the main uses of ChatGpt is in natural language processing (NLP) tasks, such as language translation, text summarization, and question answering. By using ChatGpt as the underlying technology, developers can build NLP systems that are able to understand and generate human-like responses to natural language queries.
Another potential use of ChatGpt is in conversational agents, such as chatbots. By using ChatGpt as the underlying technology, developers can build chatbots that are able to engage in natural, human-like conversations with users. This can be useful for customer service applications, where chatbots can provide answers to common questions and help users navigate complex systems.
Additionally, ChatGpt can be used to generate text for a wide range of applications, such as content creation, language translation, and data augmentation. By using ChatGpt to generate text, developers can save time and effort by automating tasks that would otherwise require manual input.
Overall, ChatGpt has many potential uses, including natural language processing, conversational agents, and text generation. Its ability to generate coherent and contextually relevant text, as well as handle a wide range of natural language inputs, makes it a valuable tool for developers working on a variety of applications.
Impact on developers
The impact of ChatGpt on developers will largely depend on how they choose to use it. However, some potential impacts on developers include:
• ChatGpt can make it easier for developers to build natural language processing (NLP) systems. By using ChatGpt as the underlying technology, developers can build NLP systems that are able to understand and generate human-like responses to natural language queries. This can save developers time and effort by reducing the need for manual input and testing.
• ChatGpt can make it easier for developers to build conversational agents, such as chatbots. By using ChatGpt as the underlying technology, developers can build chatbots that are able to engage in natural, human-like conversations with users. This can help to improve the user experience and make it easier for users to interact with complex systems.
• ChatGpt can make it easier for developers to generate text for a wide range of applications. By using ChatGpt to generate text, developers can save time and effort by automating tasks that would otherwise require manual input. This can be useful for applications such as content creation, language translation, and data augmentation.
Overall, ChatGpt has the potential to greatly impact the way developers build and work with natural language processing and conversational agent applications. By providing a powerful and versatile language model, ChatGpt can help developers to build more advanced and sophisticated systems, and save time and effort in the process.
Get Started
To get started with ChatGpt, you will need to sign up for an OpenAI API key, which will allow you to access the model and use it in your own applications. Here are the steps to get started:

Go to the OpenAI website and create an account.
Once you have created an account, visit the API keys page and generate a new API key.
Copy the API key and store it securely, as you will need it to access the ChatGpt model.
Install the OpenAI Python package, which will allow you to access the ChatGpt model from your Python code. You can install the package using the following command:

pip install openai
Once you have installed the OpenAI package, you can use the following code to access the ChatGpt model and generate a response to a natural language query:

import openai

openai.api_key = "[your API key]"

response = openai.Completion.create(
  engine="text-davinci-002",
  prompt="What is the capital of France?",
  temperature=0.5
)

print(response["choices"][0]["text"])

This code will generate a response to the query "What is the capital of France?", using the ChatGpt model with a temperature of 0.5 (which will generate text that is more creative and varied, as opposed to simply repeating the training data). The response will be printed to the console.
Overall, getting started with ChatGpt is relatively straightforward. By signing up for an OpenAI API key and installing the OpenAI Python package, you can easily access the ChatGpt model and use it to generate responses to natural language queries.

Few Tips

Here are a few tips to help you get the most out of ChatGpt:
• Use the temperature parameter to control the level of creativity and variety in the generated text. A temperature of 0 will generate text that is identical to the training data, while a higher temperature will generate more creative and varied text.
• Use the max_tokens parameter to control the length of the generated text. This can be useful if you want to generate a specific amount of text, or if you want to prevent the model from generating excessively long responses.
• Use the n parameter to generate multiple responses to the same query. This can be useful if you want to generate a variety of responses, or if you want to compare the responses generated by different temperature settings.
•Experiment with different prompt formats and query types to see how the model responds. For example, you can try asking questions, giving commands, or making statements, and see how the model generates a response.
• Use the model in combination with other NLP tools and techniques, such as keyword extraction, sentiment analysis, and entity recognition, to build more advanced and sophisticated applications.
By following these tips, you can get the most out of ChatGpt and use it to generate high-quality, human-like responses to natural language queries.

How to remove element from list Python

Abhishek kushwaha — Fri, 07 Oct 2022 05:41:03 +0000

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. There are bunch of option by which one can remove element from list in python. In this article , we would be looking into different list methods in python that remove item from list python. List values or items are placed in between square brackets [ ], separated by commas. Empty lists do not contain any values within the square brackets.

What are lists in Python?

List is the most versatile python data structure and stores an ordered sequence of elements just like your shopping list or to-do-list. In Python, Lists are mutable,meaning that the elements can be altered unlike tuples or even strings. These elements of a list are called items and can be any data type.

Lists are used to store multiple items in a single variable. These items can be objects , strings , numbers etc.

Lists are one of 4 built-in data types in Python used to store collections of data, the other 3 are Tuple, Set, and Dictionary, all with different qualities and usage.

Lists are created using square brackets as shown below:

names = [ "abhishek", "aditya", "shivam" ]
print(names) # printing the names list .

Various methods to remove elements from a list

In Python, there are various ways to remove an element from a given list. The methods are remove(), pop() and clear() .Beside these, we can also use del keyword to remove an element from a list.

One by one we would be looking at the different methods to remove an element from a list.

remove()
pop()
clear()
del Let's start with remove method and explore who it actually function.

Using remove() method+ example

The .remove() method in Python is used to remove an element from a list by passing in the value of the element to be removed as an argument. In the case where two or more elements in the list have the same value, the first occurrence of the element is removed. These state that the actual list is modified and thus it doesn't return any particular value. If we print the method call its return None.
The syntax for the same method is :

list_name.remove(element_name)

As we can see remove takes a single parameter as an argument which we want to remove from the list.
If somehow list don't contain , an exception is given stating that the element not in list.

Let's take an example where we have a list containing names of some tech stacks and one of them is stored twice.

# Create a list
tech_stack = [ "html", "javascript", "python", "java", "react" , "python" ]

# Removes the first occurance of "Chris"
tech_stack.remove("python")
print(tech_stack) # updated tech_stack list after remove method.

The Output :

[ "html", "javascript", "java", "react" , "python" ]

In the above case we can notice that python was stored twiced in tech_stack. Using the remove method over tech_stack removes the first matching element that was passed as argument. Therefore in this case python was removed from the first place it was stored and not from the last index as remove only removes the element that was found at earliest index.

Using pop() method+ example

We can remove an element from a list using the.pop() method. It also returns the element that was removed. It takes one optional input, the index of the element to be removed. If no index is provided, the method will remove the last element in the list and return that element. We modify the original list using this method.

The syntax for the same method is :

list_name.pop(element_index)

As we can see pop takes a single parameter as an argument from which index we want to remove an element.

This element_index is also optional. If not passed, the default value the pop method set is -1. That means the last element from the list is returned.

We have to make sure that the index is present in the list or its't out of range.If somehow index is not found pop() method throws an error saying IndexError:pop index

# a list
courses =  [ "Python", "Data Structures", "Video Editing", "Algorithms", "Smart Contract" ]

# Pop the last element
removed_course = courses.pop()

print(courses)
print(removed_coursev)

# Pop the element " Video Editing "
courses.pop(3)
print(courses)

The Output :

[ "Python", "Data Structures", "Video Editing", "Algorithms" ]
"Smart Contract"
[ 'Python', 'Data Structures', 'Algorithms' ]

The pop() method returns the element removed based on the index provided. The list is also modified after the removal of list element.

Using clear() method+ example

The.clear() method removes all elements from the list. It does not accept any parameters and does not return any value. Following method execution, the original list is modified with all elements removed, leaving the list with no items or elements. The Whole class is cleared. As a result, the original list is modified, and the list is left empty.

The syntax for clear() method is:

list_name.clear()

Let's have an example where clear method would empty the list.


# A list with few elements
list=[01 , "Abhishek Kushwaha" , "abhishekkushwaha@gmail.com" , "scaler"]

# using clear method over list

new_list= list.clear()
print(new_list)
print(list)

The Output:

None 
[]

Using del operator+ example

Despite of all the above methods , we also can use del operator followed by a list name in which we have to pass the index of the element to the list which we want to delete from the list. The del keyword also allow us to delete a range of elements from the list. In-order to access a range of elements from a list, you need to slice a list. Slicing a list is used when we have to deal with a smaller part of the list. When we slice , the range starts from the index to the element index we tend to remove or delete.

The syntax for del use case is :

del list_name[index]

To slice a range of elements from the list using the del keyword. One can specify where to start the slicing, where to end, and specify the step. List slicing returns a new list from the existing list.The start/ stop index from the list can be passed to del keyword as shown below:

del list_name[start:stop]

All the elements that falls in the range of start and stop is removed or deleted. How ever the stop index element is not removed as the range starts from the start index and ends one before the stop index.

Let's explore few examples that shows to remove the first element, last element, multiple elements from the list using del.

my_list = list(range(15)) # generate elements from 0 to 14.
print(" The Original list is ", my_list) 

#To remove the firstelement
del my_list[0] # list start from index 0.
print("After removing first element", my_list)

#To remove last element
del my_list[-1]
print(" After removing last element " , my_list)

# To remove element for given index : for example index:5
del my_list[5]
print(" After removing element from index:5 " , my_list)

# To remove last 2 elements from the list
del my_list[-2]
print(" After removing last 2 elements " , my_list)

#To remove multiple elements
delmy_list[1:5]
print("After removing multiple elements from start:stop index (1:5)", my_list)

#To remove multiple elements
del my_list[4:]
print("To remove elements from index 4 till the end (4:)", my_list)

The Ouput:

The Originallist is  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
After removing first element [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
After removing last element [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
After removing element from index:5 [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13]
After removing last 2 element [ 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 13 ]
After removing multiple elements from start:stop index (1:5) [ 1, 7, 8, 9, 10, 11, 13 ]
To remove elements from index 4 till the end (4:) [1, 7, 8, 9]

Examples of removing elements from a list

Let's see how we can make use of list methods to remove the elements from the list.

How to remove the first element from the list using methods like remove() , pop() and del keyword.

To remove the first element from the list using the remove() method, we must pass the first element to be removed and, in the case of pop, the index. And the index would be zero to remove the first element from the list.

In addition, as with the pop method, we can use the del keyword to remove the same first element from the list.

Let's take an example to understand how to remove first element from list using remove(), pop() and del.

alphabets = [ 'A' , 'B' , 'C' , 'D' , 'E' , 'F' ]
print(alphabets)

# Using remove() to remove first element

alphabets.remove('A') # As A is the first alphabet in the list 
print("Using remove(), the final list is ", alphabets) 

lists = ['abhishek' , 'aditya' , 'scaler']
print(lists) 

# Using pop() to remove the first element
first_item = lists.pop(0) # As the list index starts from  0.

print("The first element removed from alphabets is ", first_item)  #  abhishek
print("Using pop(), the final list is ", lists) 

# Using del to remove the first element
names = ['Abhi', 'Bipin', 'Chandan', 'Debojeet', 'Ektra', 'Faran']
del names[0] 
print(" Using del, the final list is ", names)

The Output:

['A' , 'B' , 'C' , 'D' , 'E' , 'F']
Using remove() , the final list is  ['B', 'C', 'D', 'E', 'F']
['abhishek' , 'aditya' , 'scaler']
abhishek
['aditya' , 'scaler']
[ 'Bipin', 'Chandan', 'Debojeet', 'Ektra', 'Faran' ]

How do I remove multiple elements from a list in Python?

When we tend to remove multiple elements from a list, the methods like remove() and pop() are not used as they only remove single element at a time.

Let's take an example where we are given an list ['first' , 'second' , 'third' , 'fourth'] and we want to remove multiple element from the list.

#Using del to remove the multiple elements from list

position_list= ['first' , 'second' , 'third' , 'fourth']

print("List originally is " , position_list)

del position_list[1:3] # we pass an range when we want to remove multiple element from an list.

# The range would start from the 1 index to 3rd index which don't include the 3rd index. Basicallly from 1st index to second Index.
print("Using del, the final list is ", position_list) #  ['first' , 'fourth']

As we can see that we have passed a range of elements from the list. That range slice the list and creates a new list which then by the del keyword gets removed from the original list.

How do I remove an element from a list by using index in Python?

Methods like pop() could be used to remove an element based on index. Apart from methods we can also use del keyword that can also be used to remove the element for a given index.

#Using pop to remove the multiple elements from list
lists = ['abhishek' , 'aditya' , 'scaler']
print(lists) 
element = lists.pop(2)
print("Element removed for index: 2 is ", element)
print("Using pop, the final list is ", lists) 


#Using del to remove the multiple elements from list
position_list= ['first' , 'second' , 'third' , 'fourth']
print("Originallist is ", position_list)
del position_list[2] # third is removed from the list
print("Using del, the final list is ", position_list)

The Output:

# ['abhishek' , 'aditya' , 'scaler']
Element removed for index: 2 is scaler
Using pop, the final list is ['abhishek' , 'aditya' ]
Originallist is ['first' , 'second' , 'third', 'fourth']
Using del, the final list is ['first' , 'second', 'fourth']

When we use pop method over the list we need to have a index from which element is needed to be removed. Giving the index as 2 makes the third element from the list to disappear as index starts form zero.

The pop method return that removed element and store into element variable above.

Similarly , when we are del keyword we are passing the index and that element is removed from the original list.

These were some of ways by which we can remove an element or multiple element from the list in python.

Conclusion

In Python , we have several ways or method via which we can remove an element from a given list. These methods are remove() , pop() and clear().
With these option we also have del operator which also removes an element from the list
remove() - It is used to remove the very first given element matching from the list.
pop() - The pop() method is used to remove an element from list on the basis of index that is being passes as an argument.
clear() - The clear() method removes all the elements present in the list and makes the original list empty.
del - To remove an element from list , apart from the methods we can also use del keyword and pass an index of element which we want to remove.

Python is an object-oriented programming language

Abhishek kushwaha — Mon, 05 Sep 2022 06:05:50 +0000

Is Python an object-oriented programming language?

Yes, Python is an objected oriented programming language. Everything in python is an object. Using python we can create classes and objects,for example, that functions are first-class objects. Functions, classes, strings, and even types are objects in Python: like any object, they have a type, they can be passed as function arguments, and they may have methods and properties. Therefore, Python is object oriented programming language.

Main Concepts of Object-Oriented Programming

Object-oriented programming is a method of structuring a program by bundling related properties and behavior into individual objects. These objects are related to entities. Object-oriented programming language helps us in writing reusable code. It is a popular and widely used method of solving problems by creating objects.

For example let's take human as a class.The height , weight , colour are all the attributes of a object. The biological Processes like Breathing , Walking , Eating all are considered as Methods with data and logic.

Object-oriented Programming (OOP) is a computer programming model that helps one organize their software design around data, class, and object rather than functions and logic.

Let us think of a Clothing factory where each step of the line processes some material and transform it into a finished product.

Classes and objects are the two main building blocks of object-oriented programming. A class creates a new type of object where objects are instances of the class.

Class

Class is the blueprint used to create a user-defined data structure. It holds the common attribute and behaviors of the object. For example, the class “Cloth” will hold objects “Shirt”, “Pant” and “Tshirt”.

For example, let us say that we want to store information on clothes, the general approach would be to store all the information on a list.

# name = ["category" , size , "company" , price]
shirt = [ "Shirt", 34, "xyz-company", 2000 ]
pant = [ "Pant", 34, "xyz-company", 1500 ]
tshirt = [ "Tshirt", 34, 1200 ]

There are several issues with this approach.

First, it can make larger code files more difficult to manage. If you reference pant[0] several lines away from where the pant list is declared.
There may be a case when we forget the index for the required value.

Second, it can introduce errors if not every cloth has the same number of elements in the list. In the third list above, the company is missing, so the tshirt[2] will return 1200 instead of the t-shirt's company name.

A great way to make this type of code more manageable and more maintainable is to use classes.

All class definitions start with the class keyword, which is followed by the name of the class and a colon. Any code that is indented below the class definition is considered part of the class’s body.

Here's an example of a Cloth Class :

#we define a class using the keyword class <name_of_class>:
class Cloth: 
    pass

Note: Python class names are written in CapitalizedWords notation by convention. For example, a class for a specific brand of cloth like the John Players would be written as JohnPlayers.

Currently, our class doesn't do much. We need to manage the properties like size, price, name, and company name. We define those properties using a method called .init(). Every time a new cloth object is created .init() sets the initial state of the object by assigning the values of the object's properties.

You can give .init() any number of parameters, but the first parameter will always be a variable called self. When a new class instance is created, the instance is automatically passed to the self parameter in .init() so that new attributes can be defined on the object.

Let's update the cloth class with .init() method that create .name , .size , .price , .company_name attributes:

class Cloth:
    def __init__( self, name, size , price , company_name ):
        self.name = name
        self.size = size
        self.price = price
        self.company = company_name

Using such a Class creating and managing data seems quite easy

shirt = Cloth("shirt", 25 , 1200 , "xyz")
By using such a syntax we can retrieve each value as follows :

shirt.name # returns the name 
shirt.size # returns the size
shirt.price # returns the price
shirt.company # returns the company name

Object

An object is an instance of a class. It has both a property (variables) and behavior (methods). The python object “Cloth” will have properties; “buy”, “about”, “sell” and behaviors; “discount”, and “show”.

Everything in Python is an object, and almost everything has attributes and methods. All functions have a built-in attribute doc, which returns the docstring defined in the function source code.

# Defining a class named Cloth
class Cloth:
    def __init__( self, name, size , price , company_name ):
        self.name = name
        self.size = size
        self.price = price
        self.company = company_name  

shirt = Cloth( "shirt", 25 , 1200 , "xyz" ) # creating object shirt

Method

Methods are the functions that are defined inside a class and can only be called from an instance of that class. A method includes the operation and functionality of the object. These methods are defined inside a class. These methods are the reusable piece of code that can be invoked/called at any point in the program.

# Defining a class named Cloth
class Cloth:
    def __init__( self, name, size , price , company_name ):
        self.name = name
        self.size = size
        self.price = price
        self.company = company_name

    def show( self ):  # Method 
        print( self.name, self.size, self.price, self.company )  

shirt = Cloth( "shirt", 25 , 1200 , "xyz" ) # Creating object shirt
shirt.show() # using a method over a object.

Here the show is a method or functionality to print all the data being passed at the time of object creation.

Inheritance

Inheritance is the process by which one class takes on the attributes and methods of another. Newly formed classes are called child classes, and the classes that child classes are derived from are called parent classes.

It specifies that the child object acquires all the properties and behaviours of the parent object.

Inheritance has many advantages some of them are :

It provides the reusability of the code.
It provides Transition and Readability.
Real World Relationship.

class Parent: # Parent class
    def parent_func( self ): # simple function
        print( 'This is a Parent Class' )

class Child( Parent ): # child class with Parent class as attribute
    def child_func( self ): # simple function
        print('This is Child class')


ob = Child()
ob.child_func()
ob.parent_func()

Here we can notice that despite creating an Object of child class we have access to the method from a different class. Since we know that methods are restricted to their instance, here we have access to them. This is due to inheritance as the Child class has the attribute of the Parent class.

class Parent: # Parent class
    def __init__( self,name,wish ): # init func
        self.name = name
        self.wish = wish

    def parent_func(self): # simple function
        print('This is a Parent Class')

    def show( self ):
        print( self.name , self.wish )

class Child( Parent ): # child class with Parent class as attribute
    def __init__( self,name,wish,age ):# init function
        Parent.__init__( self,name,wish ) # using Parent init method for name and wish 
        self.age = age

    def child_func( self ): # simple function
        print( 'This is Child class' )

    def show( self ):
        print( self.name , self.wish , self.age )


ob = Child( "abhishek" , "Happy Reading" , 20 ) # passing all the three arguments.
ob.show() # calling the method

Inheritance also overrides the init method. To avoid that we need to declare the Parent init function under the child init Method.

Parent.__init__(self,name,wish)

This is how we can override the Parent init function in the child function.

Polymorphism

Polymorphism contains two words "poly" and "morphs". Poly means many, and morph means shape. By polymorphism, we understand that one task can be performed in different ways. It's the ability to use a common interface for multiple forms or data.

Now in this example, we have created two classes “Cat” and “Dog”. They’re different animals and make different sounds. So, the make_sound() function should produce two different outputs based on the objects we pass through them. In this case, we have created two objects “cat1” and “dog1”.

[IMAGE {04} show that class Cat and Dog have the same method make_sound and method overload ]

class Cat:
    def __init__( self, name, age ):
        self.name = name
        self.age = age

    def info(self):
        print(f"I am a cat. My name is {self.name}. I am {self.age} years old.")

    def make_sound( self ):
        print("Meow")


class Dog:
    def __init__( self, name, age ):
        self.name = name
        self.age = age

    def info(self):
        print( f"I am a Dog. My name is {self.name}. I am {self.age} years old." )

    def make_sound( self ):
        print( "Bark" )
cat1 = Cat( "Kitty", 2.5 )
dog1 = Dog( "Fluffy", 4 )

for animal in ( cat1, cow1 ):
    animal.make_sound()
    animal.info()
    animal.make_sound()

The make-sound() function is producing two different outputs- “Meow” and “Bark”.

This concept in Object Oriented Programming is called Polymorphism. We can also consider this as Method Overloading.

Let's Create two classes and have some similar properties associated with them:

class Phone:
    def send_msg( self, x ): # send msg function
        print(f"Sending {x} as message ...")

    def switch_off( self ): # switch off function
        print("Turning it off")

class Watch:
    def send_msg( self,x ): # send msg function
        print("Cannot send the message")

    def switch_off( self ): # switch off function
        print("Removing the battery")

Here we can notice that we have two classes Phone and Watch which have two same methods send_msg and switch_off.
Now to call these methods we have to call them separately.This may look tedious to do, well we have an easy way to implement the solution of the above problem as follows:

def try_send_msg( Gadget ): # creating a common interface
    Gadget.send_msg()

Now lets create two instance of Object class

iphone = Phone()
iwatch = Watch()

Besides calling both the methods differ for different classes, we pass that into the common interface that we created above.

try_send_msg( iphone ) # passing iphone instance
try_send_msg( iwatch ) # passing iwatch instance

So the final code goes as follows:

class Phone:
    def send_msg( self ):
        print( "Sending as message ... from phone" )

    def switch_off( self ):
        print( "Turning phone off" )

class Watch:
    def send_msg( self ):
        print( "Cannot send the message from watch" )

    def switch_off( self ):
        print( "Removing the battery of watch" )

def try_send_msg( gadget ): # creating a common interface
    gadget.send_msg()


iphone = Phone() # creating instance of Phone
iwatch = Watch() # creating instance of Watch

try_send_msg(iphone) # passing iphone instance
try_send_msg(iwatch) # passing iwatch instance

With the following code the given output is as follows:

Sending as the message ... from phone
Cannot send the message from watch

So we can see that besides calling the same method to a different class that is from a different instance, we wrap those methods into a common interface and pass the instance as parameters.

Encapsulation

Encapsulation is also an essential aspect of object-oriented programming. It is used to restrict access to methods and variables.

Encapsulation refers to the wrapping up of data under a single unit. It acts as a protective shield for methods and function.

Encapsulation has some benefits, some of which are :

Data Hiding
Flexibility
Reusability

class Scaler():
    def __init__(self):
        self.blogname = "OOPS"
        self.language = "Python"

    def about(self):
        print(self.blogname , self.language)


ob = Scaler()
ob.about()

This gives the following as output :

OOPS Python
Till now everything seems working. Let's make the language attribute a private attribute by naming convention by using a double underscore at first like __attribute-name.

This makes the attribute only accessible within the scope of the class for the implementation.

Let's have a look at the code.

class Scaler(): # defining the class 
    def __init__(self):
        self.blogname = "OOPS"
        self.__language = "Python"

    def about(self):
        print(self.blogname , self.__language)


ob = Scaler() # Creating Instance 
ob.__language  # this throws Attribute Error.

__Language makes the attribute language private to its scope. Also, there are ways to recall the value stored in __language Attribute by the following code:

class Scaler(): # defining the class 
    def __init__(self):
        self.blogname = "OOPS"
        self.__language = "Python"

    def about(self):
        print(self.blogname , self.__language)


ob = Scaler() # Creating Instance 
print(ob._Scaler__language) # This works and print Python

The above code has the following output :
Python

Another use-case could be that we want to update a certain value in an attribute but we don't want to make that attribute accessible outside the scope.

Let's portray this by the following code :

class Scaler(): # defining the class 
    def __init__(self):
        self.blogname = "OOPS"
        self.__language = "Python"

    def about(self):
        print(self.blogname , self.__language)

    def set_language(self , x): # function to set a new value to language attribute
        self.__language = x

    def get_language(self): # function to get the current value of langauge attribute.
        return self.__language


ob = Scaler() # Creating Instance 
print(ob._Scaler__language) # This works and print Python
ob.set_language("py") # setting py as new language
print(ob.get_language()) # getting py as new language
print(ob._Scaler__language)

Data Abstraction

Data abstraction and encapsulation are often used as synonyms. Both are nearly synonyms because data abstraction is achieved through encapsulation.

Abstraction refers to hiding unnecessary details to focus on the whole product instead of parts of the project separately. It is a mechanism that represents the important features without including implementation details. Abstraction helps us in partitioning the program into many independent concepts so we may hide the irrelevant information in the code. It offers the greatest flexibility when using abstract data-type objects in different situations.

Let us take the example of a Mobile. It has a screen, camera, body, etc. All these things combine to form a fully functional mobile, which is an abstraction, and all the different parts are its layers of abstraction. Now a screen is composed of various parts such as a display, touch module, screen guard, etc. For these flayers, the screen is an abstraction. In simple words, abstraction can be achieved by hiding the background details and showing only the necessary ones. In programming, abstraction can not be achieved without Encapsulation.

Abstract Class - Which has one or more Abstract Methods.
Abstract Methods - Methods with the declaration but not the definition.
Abstract classes can not be instantiated, and require subclasses to provide implementations for the abstract methods.
Subclasses of an abstract class in Python are not required to implement abstract methods of the parent class.

from abc import ABC, abstractmethod # predefined abstract Abc

class Parent(ABC):   # creating a class with ABC with 

    @abstractmethod  # changing the method to abstract one 
    def display(self): # not implemented method
        None


class Child(Parent):  # creating a child class that continues Parent class
     def display(self): # defining the abstract method here.
        print("this is display method from child class")



ob = Child()
ob.display()

Here when we create an instance of Child class and call a method over that it first goes to the child class display method which is extended from Parent class. Inside the parent class, we have displayed as an abstract class means the implementation is not present in the particular class. Therefore it's overridden by the child class.

This is how we implement a large codebase where the logic is separated into different classes for more organized and readable code.

Let's understand with another example :

Below we have made an abstract class named Mobile where we have an abstract method named switch_on. The method's implementation is not given in the class. Later on Another child class of Mobile named Screen with extended Mobile class, we have switch_on method implementation.


from abc import ABC, abstractmethod

# creating a parent class
class Mobile(ABC):

    @abstractmethod  # specifing all the method as an abstract method
    def switch_on(self): # a method definition for turning the screen on.
        pass

class Screen(Mobile):
    def switch_on(self):
        print("switched on via Screen class")

power = Screen()
power.switch_on()

When the switch_on method is called over power instance, its points to the switch_on method from the Screen class where the implementation is executed.

Learn more

What is object-oriented programming ?

Object oriented programming concept in python

Conclusion

Class is the blueprint of an object. It is used to declare and create objects. Class is a logical entity. Example: Computer is a class.
Object is an instance of the class. The object is a physical entity. And we can create as many objects as we want. Example: Mouse, Keyboard, Monitor, etc are objects of class Computer.
Inheritance is an OOP concept, where existing classes can be modified or overridden by a new class. The existing class is called the base class or parent class and the new class is called the derived class or child class.
Polymorphism in OOP allows an object to take many forms. Simply, polymorphism allows us to perform the same action in many different ways. It's the ability to use a common interface for multiple forms or data.
Encapsulation in OOP is the process of restricting access to methods and variables. Encapsulation refers to the wrapping up of data under a single unit. It acts as a protective shield for methods and function.
Abstraction refers to hiding unnecessary details to focus on the whole product instead of parts of the project separately. Abstraction is done by Encapsulation.

Why and How Git ?

Abhishek kushwaha — Sun, 07 Aug 2022 06:36:16 +0000

Git is a software that tracks changes in any initialised repository or directory. It's helps for coordinating with your fellow programmers to collaborate and for tracking changes in any set of files.

Git was created by Linus Torvalds in 2005 for development of the Linux kernel, and it’s now a fundamental developing tool that’s used by almost all professional developers.

Git mainly help us in these two following terms :

Collaboration

Having A record of changes and previous state of code.

Many new developers and students have an confusion between Git and Github.
Let's understand how they are different :

Git is a version control system that keeps track and maintains a log of all the changes that are committed by the changer.

Whereas ,
Github ia a company that provide hosting services for the code and repository and let people collaborate which internally uses git for operation.

Git Installation

To get started with git and explore version control system we firstly have to install git locally in the system for that head over to Git Download and have a installation for your desired operating system.

The process is straight forward and with couple of next click and you are ready to head over to Git BASH.

The above picture shows the git bash screen which is the terminal which uses bash language for scripting. Before using some git commands and exploring the git features, let's first walk through some command cli commands which would help one getting use to terminal.

pwd command : The shell command pwddisplays the file path from the root directory to the current working directory.

mkdir Make Directory: The shell command mkdir is used to make a new directory in the filesystem according to its argument. If a file path is given, the new directory will be placed at the end. Otherwise, it creates a new directory in the current working directory.

The Directory is added to home path to view the folder one can use GUI Application , but we are developers so 😎

ls List: The shell command ls is used to list the contents of a directory. If no arguments are given, it will list the contents of the current working directory.

The above folder that We created is present in the folder can be found in the picture shown below :

cd Change Directory : The shell command cd is used to move throughout the filesystem of a computer.

cd accepts a variety of arguments:

Full file paths leading to some directory.
Name of children Directory
.. To move to parent directory of the file.

You can learn More of these basic cli commands here ➡️ Click me

Git Initialising

Before initialising lets check what version git is being installed in our system through this basic command :

$ git --version

To work with git we need some config for the user details as it manage the log associated with the changer maintaining the changes.

To set those we simply set git configs like username and email for the user. To do so follow these commands :

$ git config --global user.name "YOUR_USER_NAME"

$ git config --global user.email "YOUR_EMAIL"

After setting up you can check if they are configured well or not through these commands :

git -config --global user.name
git -config --global user.email

These would return your given values or string.

Now we are actually ready for the project so head over and create a folder and add any project you want to push over to github and keep a track of changes in git.

As we are done with creating a git repository , its time to add some files and commit the changes to log.😎 For this article am using a simple fronted site .

Now lets add these files to commit and then commit with a message "First dev commit" .

We can check all the logs for confirmation 😀

## Now lets Push this local repository to Github .

To push the code or your work to Github we first have to make a connection between the local repository and remote one for both fetching and pushing operation . For that lets first create a repository an blank one over github .

To establish the connection we would be needing the url : https://github.com/Abbhiishek/bookish-giggle.git. These url can be found over your repository or else you just add .git in the last of your repository url from browser.

To make the connection we do :

git remote add origin url_here

Also to view the connection that are established we can use :

git remote -v

Now as the connection is established we would be pushing to github all the committed stuffs from local to remote repository .
To do so we do we have the command :

git push origin <branch_name>

We can see Github is updated with the pushed code

Hurray 🥳

Though this article was not intended to give you whole idea how to work with git , I tried my best to make things understandable. If Found helpful let me know in comment section.

In the next article would share how to push it to Github Pages or other services like vercel or netlify .📍

kudos !