What is Rate Limiting?

Suppose you have a application where a user can post his picture, for this action you are calling an api endpoint running on a server and the endpoint stores the post in the database.

Now lets say the user posting the picture spams the post button and the server recieves thousands of requests per second, potentially overwhelming the server and causing it to crash or become unresponsive for other users.

To avoid the above scenario Rate Limiting is used!!

Setup

Create a boilerplate Next.js project using:

npx create-next-app@latest

Install @upstash/redis and @upstash/ratelimit using:

npm i @upstash/redis @upstash/ratelimit

docs - https://upstash.com/blog/upstash-ratelimit

Implementation of rate limiting

Since we are using nextjs the demonstration of implementation will be using server actions.

so, go ahead create a folder of actions and creates a server action which posts a picture or content to the database(Highly suggest prisma or drizzle for this).

After creating the server action follow the following steps:

• create a config folder and inside it create upstash.ts file with the following code

    import { Redis } from "@upstash/redis"
  
    export const redis = new Redis({
        // get these credentials by creating account on upstash
        url: `enter your upstash db url here` 
        token: `enter you db token here`
    });
  

• Now inside your server actions file, where the action for posting is created we'll use upstash/ratelimit by doing the following:

    "use server";
    import { Ratelimit } from '@upstash/ratelimit';
    import { redis } from './upstash'; // the file that you created above
    import { headers } from 'next/headers';
  
    const ratelimit = new Ratelimit({
        redis,
        limiter: Ratelimit.slidingWindow(5,"120s"); 
        //this means 5 requests is allowed per 120 seconds
    });
  
    export const addPost = async () => { // your server action
        const ip = headers().get('x-forwarded-for'); //getting user's ip 
        const {remaining, limit, success} = await ratelimit.limit(ip!);
        console.log(limit) // shows max limit
        console.log(remaining) // shows remaining requests in the window
        console.log(success) // returns if able to process the request
  
        // so to implement rate limit we need to use simple if condition
        if(!success){
            return "unable to process the request, limit reached wait for 2 minutes";
        }
  
        //rest of the addPost logic should be here dealing with the database
    }
  

Note: Here we are using rate limiting which uses sliding window technique and there are many more types of rate limiting to know about them check out the following link:

types of rate limiting: https://www.imperva.com/learn/application-security/rate-limiting/

There you go!! now you know how to implement rate limiting in your large scale projects very easily without any headache.

• Install Python: If you don't have Python installed on your system, you can download it from the official Python website (https://www.python.org/downloads/).

• Create a Virtual Environment: It's recommended to create a virtual environment for your FastAPI project to keep your dependencies isolated. You can use the built-in venv module in Python to create a virtual environment

    python -m venv myenv
  

• Install FastAPI: With the virtual environment activated, install FastAPI and its dependencies using pip:

    pip install fastapi uvicorn
  

• Create a FastAPI Application: Create a new Python file (e.g., main.py) and add the following code:

    from fastapi import FastAPI
    import uvicorn
    app = FastAPI()
  
    @app.get("/")
    async def root():
        return {"message": "Hello World"}
  
    if __name__ == "__main__":
        uvicorn.run(app, host="0.0.0.0", port=8000
  

• Uvicorn is an ASGI web server implementation for Python to run FastApi app on local host

Let's create an api endpoint using FastApi

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Product(BaseModel):
    id: int
    name: str
    description: str
    price: float

@app.get("/") #endpoint
async def root():
    return {"message": "Welcome to the E-commerce API!"}


# example of dynamic url
@app.get("/products/{product_id}", response_model=Product) 
async def get_product(product_id: int):
    # Fetch the product data from a database or external service
    product = {
        "id": product_id,
        "name": "Product Name",
        "description": "Product Description",
        "price": 19.99
    }
    return product

• To run the FastApi app use uvicorn main:app --reload command

    uvicorn main:app --reload
  

The api endpoint /product/{product_id} will return product based on the product_id provided in the params making it a dynamic url

Pydantic is data validation and parsing library generally used for data modelling of data that the user passes while hitting the api endpoint or when the user recieves the data when hitting the api endpoint.

HTTP methods used to create endpoints are GET,POST,PUT,DELETE

In the above example we have created get request api.

This way you can created api endpoints quickly and easily with the help of FastAPI

FastAPI also helps to document your api and you can access this docs using /docs endpoint of the FastAPI app.

Testing

Testing is the process of evaluating a software application or system to identify defects, ensure its functionality meets the desired requirements, and verify that it performs as intended. It helps in maintaining software reliability and usability.

There are two types of testing in general

• Unit Testing

• Integration Testing

Unit Testing

Unit testing is a level of software testing where individual components or units of a software application are tested in isolation. A "unit" typically refers to the smallest testable part of a program, such as a function, method, or class.

Integration Testing

Integration testing is a level of software testing that focuses on the interactions and interfaces between various units or components of a software system. The primary goal of integration testing is to ensure that these individual units when combined, work together as intended and that the interactions between them do not lead to defects or unexpected behavior.

React Testing Library & Jest

React Testing Library and Jest are two of the most popular tools used for testing React applications.

Setup

Firstly Install the react testing library package in your project using the following command

npm install --save-dev @testing-library/react

• You might also need to set up a configuration file for Jest, such as jest.config.js or package.json settings.

• Create the react components that you want to test.

In this blog, we are gonna see how to write a simple test for a component and run the tests.

Firstly, create a test file for your component the naming convention generally followed is ComponentName.test.js

Now, inside your test file import the required functions such as render and screen from the react testing library as well as the component that you want to test.

import React from 'react';
import { render, screen } from '@testing-library/react';
import MyComponent from './MyComponent';

Now let's understand how the react testing library and jest work!!

Structure of a test block

• Render a component you want to test

• Search for the element you want to interact with

• After that assert/check the results to see whether they are working as desired

The code below shows how a test block is written

test('MyComponent renders correctly', () => { // test block
  render(<MyComponent />);
  const element = screen.getByText('Hello, World!');
  expect(element).toBeInTheDocument();
});

The above test checks whether the element having the text Hello, World! is rendering properly on the screen or not.

We use render function to render the component we are supposed to test on.

The screen object is an essential utility that provides methods for querying and interacting with the rendered components.

To understand these methods refer to the below chart

The chart shows what each function returns in the case of No Match, 1 Match, 1+ Match and async calls.

A Little bit about Jest

Jest is a JavaScript testing framework maintained by Facebook. It's a powerful and developer-friendly tool for testing JavaScript code, including React applications.

It provides features like test runners, assertion libraries, mocking, and code coverage out of the box.

Use Jest's test runner to execute your tests. You can do this through the command line with npm test or yarn test (if configured).

To learn more in-depth on testing refer to the following resources

Checkout React testing library documentation here Docs

📚 Stay In the Know! Follow Our Blog

Discover a world of knowledge, inspiration, and insights right at your fingertips. Our blog is a treasure trove of valuable content that you won't want to miss. 🌟

Don't miss out! Click that "Follow" button now, and let the learning journey begin.

📖✨

Server-Side Rendering (SSR):

Definition: In SSR, the server generates the HTML for a web page and sends it to the client (usually a web browser) as a fully rendered page. This means that the initial page load includes all the content and is ready to be displayed immediately.

Static Server-Side Rendering (Static SSR):

1. Definition: In Static SSR, the server pre-generates HTML pages at build time or when content changes. Each page is pre-rendered into a static HTML file and stored on the server. These pre-rendered pages are then served to clients upon request.

2. Key Characteristics:

   • Pre-Generated Pages: All the pages are generated in advance, typically during the build process. This means that content does not change on the server at runtime.

   • Fast and Scalable: Since the HTML pages are pre-rendered, they can be served very quickly to clients. This approach is highly scalable as it doesn't require much server-side computation for each request.

   • Ideal for Content-Heavy Sites: Static SSR is well-suited for websites with mostly static content, like blogs, news sites, or e-commerce platforms with infrequent product updates.

3. Use Cases:

   • Static Websites: Websites with content that doesn't change frequently, like company homepages or personal blogs, can benefit from Static SSR to achieve fast page loads.

   • Jamstack Architecture: Static site generators like Gatsby, Next.js (with static site generation), or Hugo often use Static SSR to create efficient and performant websites.

Dynamic Server-Side Rendering (Dynamic SSR):

1. Definition: In Dynamic SSR, the server generates HTML pages for each request, and the content may change based on user interactions or data from external sources (e.g., a database). Unlike Static SSR, pages are created or modified at runtime.

2. Key Characteristics:

   • On-Demand Rendering: Each page is generated on the server when a user requests it, allowing for dynamic content and personalization.

   • Real-Time Updates: Dynamic SSR can provide real-time or near-real-time updates because it can fetch and render the latest data on each request.

   • Suitable for Content that Changes Frequently: Applications where content is frequently updated or personalized, such as social media feeds or e-commerce product listings, benefit from Dynamic SSR.

3. Use Cases:

   • Content-Intensive Applications: Dynamic SSR is suitable for applications with frequently changing content, such as news websites, forums, or social media platforms.

   • Personalized User Experiences: Websites that require user-specific content, like personalized recommendations or user profiles, can use Dynamic SSR to tailor content for each user.

Client-Side Rendering (CSR):

1. Definition: In CSR, the server sends a minimal HTML shell to the client, which includes JavaScript. The JavaScript code is responsible for fetching data from an API and rendering the content in the browser. The page is constructed dynamically on the client-side.

2. Key Characteristics:

   • Slower Initial Load: CSR typically results in a slower initial page load because the client needs to download the minimal HTML and then execute JavaScript to populate the content.

   • Interactive and Fast Navigation: Once the initial load is complete, CSR can provide a smoother and more interactive user experience as subsequent navigation and content updates can be faster.

   • Not SEO-Friendly by Default: Search engines may have difficulty indexing content initially because they might not execute JavaScript.

3. Use Cases:

   • Single-Page Applications (SPAs): Applications that require a high level of interactivity, like social media platforms or web-based productivity tools, often use CSR to provide a dynamic user experience.

   • Web Apps with Frequent Updates: Applications where content is frequently updated or needs real-time data often opt for CSR because it allows for quick updates without full page reloads.

In many real-world scenarios, a combination of SSR and CSR is used. This approach, known as "Hybrid Rendering," takes advantage of the benefits of both techniques. For example, a website may use SSR for the initial page load to optimize speed and SEO and then switch to CSR for subsequent navigation and interactions to provide a more interactive user experience. This mix allows web developers to strike a balance between performance and interactivity based on the specific needs of their application.

map, filter, and reduce These three versatile functions are not only essential tools in a JavaScript developer's arsenal but also shining examples of the functional programming paradigm.

let's learn these three very important functions in a step-by-step manner

Map

• The map function creates a new array by applying a given function to each element of an existing array.

• It does not modify the original array; instead, it returns a new array with the results.

•       const numbers = [1,2,3,4];
        const doubledNumbers = numbers.map((num) => num * 2);
  
        console.log(doubledNumbers);
        //output - [1,4,6,8]
  

Filter

• The filter function creates a new array containing all the elements that pass a test implemented by the provided function.

• It does not modify the original array; instead, it returns a new array with the results.

•       const numbers = [1, 2, 3, 4, 5];
        const evenNumbers = numbers.filter((num) => num % 2 === 0);
        console.log(evenNumbers);
        //output [2,4]
  

Reduce

• The reduce function reduces an array to a single value by applying a function to each element and accumulating the result.

• It takes a callback function that has an accumulator (the accumulated result) and the current element as arguments.

• You can also provide an initial value for the accumulator.

•       const numbers = [1, 2, 3, 4, 5];
        const sum = numbers.reduce((accumulator, current) {
                        return accumulator + current
                    }, 0);
        console.log(sum);
        //output - 15
  

• The second parameter 0 is the initial value given to the accumulator.

Conclusion

In summary, map transforms each element of an array and returns a new array, filter selects elements that meet a specific condition, and reduce accumulates the elements into a single value. These functions are powerful tools for working with arrays functionally and concisely, improving code readability and maintainability.

Understanding Objects

At the core of Javascript OOP is objects. Everything in javascript under the hood is an object, An object is a collection of key-value pairs where keys are strings (or symbols) and values can be of any data type or even functions.

Here's an example of Object in Javascript -

const person = {
  name: "John",
  age: 30,
  sayHello: function() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
};

person.sayHello(); // Output: Hello, my name is John and I am 30 years old.

Classes and Constructors in Javascript

In ES6(ECMAScript 6), Javascript introduced a more structured and general way of creating objects. A class is a blueprint for creating objects with shared properties and methods.

Example -

class Person {
  constructor(name, age) { // constructor for the class
    this.name = name;
    this.age = age;
  }

  Hello() { //no need to use function keyword in class
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person1 = new Person('John', 30);
const person2 = new Person('Jane', 25);

person1.Hello(); // Output: Hello, my name is John and I am 30 years old.
person2.Hello(); // Output: Hello, my name is Jane and I am 25 years old.

The constructor function of the class gets called whenever a new keyword is used to create the object of that class and initializes initial values for the object.

The "this" keyword helps in getting the context of the current object and setting the values.

Inheritance and Subclasses

JavaScript also supports inheritance through prototype-based inheritance. You can create a subclass (a child class) that inherits properties and methods from a parent class (a superclass).

class Student extends Person {
  constructor(name, age, grade) {
    super(name, age); // Call the parent class constructor
    this.grade = grade;
  }

  study() {
    console.log(`${this.name} is studying for their ${this.grade} grade.`);
  }
}

const student1 = new Student('Alice', 12, '6th');
student1.sayHello(); // Output: Hello, my name is Alice and I am 12 years old.
student1.study();

The super() function calls the superclass constructor function.

using extends keyword class Student inherits properties and methods of class Person and now we can use the properties of Person class in a Student object.

This phenomena is called inheritance.

Encapsulation, Abstraction, and More

OOP in JavaScript allows you to implement essential OOP principles such as encapsulation and abstraction. You can hide internal details and expose only the necessary interfaces, making your code more modular and maintainable.

Additionally, JavaScript provides tools like getters and setters to control access to object properties, further enhancing encapsulation.

To learn more in depth about these topics I'll be providing blogs on the topics soon.

Conclusion

Object-Oriented Programming in JavaScript empowers developers to create structured, reusable, and maintainable code. Understanding objects, classes, constructors, and inheritance is fundamental to harnessing the power of OOP in JavaScript. With these concepts in your toolkit, you can design elegant and efficient solutions for a wide range of applications.

In Javascript, everything is an object and the prototype serves as a blueprint for every object containing its properties and methods.

To understand it more easily let's first understand what are constructor functions

Constructor Functions -

Constructor functions are used to create objects. They act as templates for objects, defining their initial state and behavior.

Here's an example -

function myObj(name,age){ //constructor functions
    this.name = name;
    this.age = age;
}

const obj1 = new myObj("xyz","20");
const obj2 = new myObj("yzx","21");

The above constructor function takes properties "name" and "age" and sets them as properties on the newly created objects with the new keyword**.**

However, with this approach, each object created using new myObj() has its own copy of the properties and methods, leading to potential memory inefficiencies if there are many instances.

Prototypes -

JavaScript's prototype system comes into play to address above issue. Every function in JavaScript has a property called prototype, which is an object that can hold properties and methods shared among all instances created by that constructor function.

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Person.prototype.sayHello = function () {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
};

const person1 = new Person("Alice", 30);
const person2 = new Person("Bob", 25);

person1.sayHello(); // "Hello, my name is Alice and I am 30 years old."
person2.sayHello(); // "Hello, my name is Bob and I am 25 years old."

Since everything in javascript is an object we can use their prototype attribute to create our own set of properties for such objects common to all the instances of that object as the sayHello() function created above will be available to both person1 and person2 objects as both are instance of the same constructor function.

Prototypal Inheritance -

You can achieve prototypal inheritance using the __proto__ property in JavaScript. Here's an example:

// Parent object
const animal = {
  speak: function () {
    console.log(`I am an animal.`);
  },
};

// Child object inheriting from the parent
const dog = {
  __proto__: animal, // Set the prototype to 'animal'
  bark: function () {
    console.log("Woof!");
  },
};

// Create instances of 'dog'
const dog1 = Object.create(dog);
dog1.speak(); // "I am an animal."
dog1.bark();  // "Woof!"

const dog2 = Object.create(dog);
dog2.speak(); // "I am an animal."
dog2.bark();  // "Woof!"

Here, the dog object inherits the properties of the animal object with the help of __proto__ property. so all instances of the dog object will have the speak function in their prototype methods and variables.

However, __proto__ property was used in older javascript syntax in new Javascript modern syntax Object.setPrototypeOf() and Object.getPrototypeOf()

Here's an example -

// Parent object
const animal = {
  speak: function () {
    console.log(`I am an animal.`);
  },
};

// Child object
const dog = {
  bark: function () {
    console.log("Woof!");
  },
};

// Establishing prototype-based inheritance
Object.setPrototypeOf(dog, animal);

// Create instances of 'dog'
const dog1 = Object.create(dog);
dog1.speak(); // "I am an animal."
dog1.bark();  // "Woof!"

const dog2 = Object.create(dog);
dog2.speak(); // "I am an animal."
dog2.bark();  // "Woof!"

We use Object.setPrototypeOf(dog, animal) to establish prototype-based inheritance. This sets the prototype of dog to animal, creating a prototype chain where dog inherits from animal.

Conclusion -

In conclusion, JavaScript offers several mechanisms for establishing prototype-based inheritance, each with its own advantages and use cases. Whether you choose to use constructor functions, Object.create(), or Object.setPrototypeOf(), the fundamental concept remains the same: objects can inherit properties and methods from their prototypes, creating a flexible and efficient way to structure and organize your code.

Understanding prototype chains and how objects relate to each other through prototypes is crucial for writing maintainable and efficient JavaScript code.

Subscribe to our blog post to learn more about the fundamentals of web development.

In this blog post, we will explore how to combine the capabilities of React Hook Form and EmailJS to create a seamless form validation and email service integration.

What is React Hook Form?

React Hook Form is a lightweight and performant library for managing forms in React applications. It simplifies form validation, state management, and submission handling by leveraging React's hooks feature.

Setting up a React Application:

To get started, ensure that you have Node.js and npm (Node Package Manager) installed on your machine. Create a new React application using the following command in your terminal:

npx create-react-app form-validation-email-service

Installing React Hook Form and EmailJS:

Navigate into the project directory and install React Hook Form and EmailJS packages:

cd form-validation-email-service
npm install react-hook-form @emailjs/browser --save

Building a Form with React Hook Form:

In your React component file, import the necessary dependencies:

import React from 'react';
import { useForm } from 'react-hook-form';

function ContactForm() {
  const { register, handleSubmit } = useForm();

  const onSubmit = (data) => {
    console.log(data);
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      {/* Form fields */}
    </form>
  );
}

export default ContactForm;

Validating Form Inputs:

React Hook Form offers a simple way to validate form inputs using built-in validation rules or custom functions. Let's add some basic validation to our form fields:

<input
  type="text"
  {...register('name', { required: true })}
/>

<input
  type="email"
  {...register('email', 
    { 
      required: true, 
      pattern: /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i 
    }
  )}
/>

Submitting Form Data:

To handle form submission, we'll utilize the handleSubmit function provided by React Hook Form. In the onSubmit callback, we can access the form data and perform further actions:

const onSubmit = (data) => {
  console.log(data);

  // Perform additional actions like API calls or email service integration
};

Integrating EmailJS

EmailJS is a service that allows you to send emails directly from the client-side without any server-side code.

Sign up for an account on the EmailJS website and obtain your user ID and template ID. Import the EmailJS library and configure it with your credentials:

import emailjs from '@emailjs/browser';

 const onSubmit = (data) => {
    console.log(data);
    const params = {
        "user_name":data.username, //key value mustbe same as in your template in emailjs
        "user_email":data.email,
        "message": data.message,
    }
    emailjs.sendForm('YOUR_SERVICE_ID', 'YOUR_TEMPLATE_ID', params ,'YOUR_PUBLIC_KEY')
      .then((result) => {
          console.log(result.text);
      }, (error) => {
          console.log(error.text);
      });
  };

You can now test your form by filling in the required fields and submitting it. Ensure that you receive the success message and check the recipient's email inbox for the email notification.

Conclusion

In this blog post, we explored the process of implementing form validation using React Hook Form and integrating an email service using EmailJS. React Hook Form simplified form management by providing an intuitive API for validation and submission handling. By integrating EmailJS, we were able to enhance the functionality by sending automated email notifications to the desired recipient.

Remember to further explore the documentation of React Hook Form and EmailJS to unleash their full potential in your projects. Happy coding!

Here's an extensive guide to object-oriented programming (OOP) in Dart:

1. Classes and Objects:

   • Classes in Dart define the blueprint for creating objects. You can create classes using the class keyword.

   • Objects are instances of classes, and you can create objects using the new keyword or by omitting it in newer Dart versions.

    class Person {
      String name; //variables of a class
      int age; //variables of a class

      void sayHello() {
        print("Hello, my name is $name. I'm $age years old.");
      }
    }

    void main() {
      // Creating an object of the Person class
      var person = Person();
      person.name = "John";
      person.age = 30;

      // Calling the sayHello() method
      person.sayHello(); // Output: Hello, my name is John. I'm 30 years old.
    }

• Properties represent the state or data associated with an object. They are declared using variables inside a class.

• Methods define the behavior of an object. They are functions defined within a class and can manipulate the object's properties.

1. Constructors:

• Constructors are special methods used for object initialization. Dart provides default constructors if none is defined explicitly.

• You can create named constructors to provide multiple ways to create objects.

• The this keyword refers to the current instance of the class within a constructor.

• There is another type of constructor known as redirecting constructor in Dart.

class Point {
  double x;
  double y;

  // Default constructor
  Point(this.x, this.y);

  // Named constructor
  Point.origin() {
    x = 0;
    y = 0;
  }

  // redirecting Constructors
  Point.addval(double x, double y) : this(x,y);
}

void main() {
  var p1 = Point(2, 3); // Using the default constructor
  print("Point p1: (${p1.x}, ${p1.y})"); // Output: Point p1: (2.0, 3.0)

  var p2 = Point.origin(); // Using the named constructor
  print("Point p2: (${p2.x}, ${p2.y})"); // Output: Point p2: (0.0, 0.0)

  var p3 = Point.addval(4,5); // Using the redirecting constructor
  print("Point p3: (${p3.x}, ${p3.y})"); // Output: Point p3: (4.0, 5.0)
}

Important Concepts of OOP in Dart:

1. Inheritance:

   • Inheritance allows you to create new classes based on existing ones. The new class inherits the properties and methods of the parent class.

   • Dart supports single inheritance, meaning a class can only inherit from one superclass.

   • The extends keyword is used to establish inheritance relationships.

    class Animal {
      void eat() {
        print("Animal is eating.");
      }
    }

    class Dog extends Animal {
      void bark() {
        print("Dog is barking.");
      }
    }

    void main() {
      var dog = Dog();
      dog.eat(); // Output: Animal is eating.
      dog.bark(); // Output: Dog is barking.
    }

1. Polymorphism:

   • Polymorphism allows objects of different classes to be treated as objects of a common superclass.

   • Dart achieves polymorphism through method overriding. You can override methods in a subclass to provide different implementations.

    class Animal {
      void makeSound() {
        print("Animal is making a sound.");
      }
    }

    class Dog extends Animal {
      @override
      void makeSound() {
        print("Dog is barking.");
      }
    }

    class Cat extends Animal {
      @override
      void makeSound() {
        print("Cat is meowing.");
      }
    }

    void main() {
      var dog = Dog();
      var cat = Cat();

      dog.makeSound(); // Output: Dog is barking.
      cat.makeSound(); // Output: Cat is meowing.

      // Polymorphism in action
      Animal animal = dog;
      animal.makeSound(); // Output: Dog is barking.

      animal = cat;
      animal.makeSound(); // Output: Cat is meowing.
    }

1. Encapsulation:

   • Encapsulation refers to the practice of hiding internal implementation details and exposing only necessary information.

   • In Dart, you can mark properties and methods as private using the underscore (_) prefix.

   • You can provide getter and setter methods to control access to private properties.

2. Abstraction:

   • Abstraction focuses on defining interfaces or abstract classes that provide a common set of methods that subclasses must implement.

   • Dart supports abstract classes and methods using the abstract keyword.

   • Abstract classes cannot be instantiated directly; they serve as a base for subclasses.

    abstract class Animal {
      void makeSound();
    }

    class Dog extends Animal {
      @override
      void makeSound() {
        print("Dog is barking.");
      }
    }

    class Cat extends Animal {
      @override
      void makeSound() {
        print("Cat is meowing.");
      }
    }

    void main() {
      Animal dog = Dog();
      dog.makeSound(); // Output: Dog is barking.

      Animal cat = Cat();
      cat.makeSound(); // Output: Cat is meowing.
    }

1. Interfaces:

   • Dart does not have a separate interface keyword, as every class defines an interface.

   • You can implement multiple interfaces in a class using the implements keyword.

   • Classes implementing an interface must provide implementations for all the interface's methods.

2. Static Members:

   • Static members belong to the class itself rather than instances of the class.

   • You can declare static properties and methods using the static keyword.

   • Static members can be accessed without creating an object of the class.

    class Circle {
      static const double pi = 3.14159;
      static int numberOfCircles = 0;

      Circle() {
        numberOfCircles++;
      }

      static void printPi() {
        print("The value of pi is: $pi");
      }
    }

    void main() {
      Circle();
      Circle();

      print("Number of circles: ${Circle.numberOfCircles}"); // Output: Number of circles: 2

      Circle.printPi(); // Output: The value of pi is: 3.14159
    }

1. Mixins:

   • Mixins are a way to reuse a set of methods in multiple classes without using inheritance.

   • They allow you to add behavior to a class without becoming its superclass.

   • You can define a mixin using the mixin keyword and apply it to a class using the with keyword.

    mixin Swimmer {
      void swim() {
        print("Swimming...");
      }
    }

    mixin Flyer {
      void fly() {
        print("Flying...");
      }
    }

    class Animal {
      void eat() {
        print("Eating...");
      }
    }

    class Dolphin extends Animal with Swimmer {}

    class Bird extends Animal with Swimmer, Flyer {}

    void main() {
      var dolphin = Dolphin();
      dolphin.eat(); // Output: Eating...
      dolphin.swim(); // Output: Swimming...

      var bird = Bird();
      bird.eat(); // Output: Eating...
      bird.swim(); // Output: Swimming...
      bird.fly(); // Output: Flying...
    }

This guide covers the key concepts of object-oriented programming in Dart. By understanding these concepts and their implementation in Dart, you can build robust and scalable applications.

Thank you for reading! Stay connected for more valuable content. Be sure to follow us to receive regular updates, exclusive content, and special offers. Join our vibrant community of learners by visiting our website and exploring all that we have to offer. Let's continue our journey of knowledge and growth together!!

State management is the process of managing the state of your Flutter application. The state of an application is the data that changes over time, such as the current user, the current page, or the contents of a shopping cart.

Why do you need State Management?

Flutter apps are built using a declarative programming language, which means that you describe the UI of your app in terms of how it should look, rather than how it should behave. This makes it easy to create beautiful and complex UIs, but it can also make it difficult to manage the state of your app.

Without state management, you would have to manually update the state of your app whenever it changes. This would be very tedious and error-prone, especially for large and complex apps.

What is Provider?

provider is a state management package for Flutter that makes it easy to manage the state of your app. Provider uses a concept called dependency injection to manage the state of your app.

Dependency injection is a technique where you pass the dependencies of a class into the constructor of that class. This makes it easy to change the dependencies of a class without having to modify the class itself.

Provider uses dependency injection to manage the state of your app. When you create a Provider, you pass the state of your app into the constructor of the Provider. This makes it easy to change the state of your app without having to modify the code that uses the state.

How to use Provider

To use Provider, you first need to install the package. You can do this by running the following command in your terminal:

flutter pub add provider

Once the package is installed, you can start using it in your app. The following code shows how to create a simple state management solution with Provider:

import 'package:provider/provider.dart';

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Provider(
      builder: (context, child) {
        return MaterialApp(
          home: MyHomePage(),
        );
      },
    );
  }
}

class MyHomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    // Get the current count from the provider
    int count = Provider.of<Counter>(context).count;

    return Scaffold(
      appBar: AppBar(
        title: Text('My App'),
      ),
      body: Center(
        child: Text('The count is $count'),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          // Increment the count
          Provider.of<Counter>(context).increment();
        },
        child: Icon(Icons.add),
      ),
    );
  }
}

class Counter with ChangeNotifier {
  int count = 0;

  void increment() {
    count++;
    notifyListeners();
  }
}

• In this code, we create a Counter class that extends the ChangeNotifier class. The ChangeNotifier class provides a mechanism for notifying listeners when the state of the object changes.

• We then create a MyHomePage widget that uses Provider to get the current count from the Counter object. When the user clicks the floating action button, the count is incremented and the Counter object is notified.

Conclusion

Provider is a powerful state management library that can make it easy to manage the state of your Flutter apps.

With Provider, you can create a single source of truth for your app's state, and you can access the state from any widget in your app.

Provider also provides a number of features that make it easy to manage state, such as change notification,inheritance, and lazy loading.

If you are looking for a state management library for your Flutter app, I encourage you to check out Provider.

What is Hashing? Hashing is the process of mapping data of arbitrary size to a fixed-size output. This fixed-size output is called a hash or a message digest. The hash function takes input data and produces a fixed-length output, which is typically a unique representation of the input data. The resulting hash is often used for indexing, searching, and data integrity verification.

Advantages of Hashing: Hashing provides several advantages, such as:

1. Data Integrity Verification: Hashing is widely used for verifying data integrity. By comparing the hash value of the original data with the hash value of the received data, one can determine whether the data has been modified or corrupted during transmission.

2. Fast Retrieval: Hashing allows for quick retrieval of data from large datasets. Instead of searching through the entire dataset, hash functions can be used to index data and retrieve it quickly.

3. Security: Hashing is an essential tool in cryptography. It is used to store passwords securely and to authenticate data.

Types of Hash Functions: There are various types of hash functions, including:

1. Cryptographic Hash Functions: Cryptographic hash functions are designed to be secure and are commonly used in cryptography. Examples of cryptographic hash functions include SHA-256 and SHA-512.

2. Non-Cryptographic Hash Functions: Non-cryptographic hash functions are used for indexing, searching, and data integrity verification. Examples of non-cryptographic hash functions include MurmurHash and FNV.

Applications of Hashing: Hashing has several applications, including:

1. Password Storage: Hashing is used to store passwords securely. When a user enters a password, it is hashed and compared with the stored hash value. If the values match, the user is granted access.

2. Data Integrity Verification: Hashing is used to verify the integrity of data during transmission. The hash value of the original data is compared with the hash value of the received data to determine whether the data has been modified or corrupted.

3. Indexing and Searching: Hashing is used to index and search large datasets quickly. Hash functions can be used to map data to a fixed-size index, allowing for fast retrieval of data.

In Hashing Hash Tables are used but many times collision occurs when new data is being added to the Hash Table to avoid this there are many collision resolution techniques like linear probing, separate chaining and quadratic probing below there is an in-depth explanation of these techniques -

1. Linear Probing: Linear probing is a simple method for resolving collisions. When a collision occurs, the algorithm checks the next available slot in the table and places the item there. This process continues until an empty slot is found. The main disadvantage of linear probing is that it can result in clustering, where items are stored in adjacent slots, making it more difficult to search the table efficiently.

   

2. Separate Chaining: Separate chaining is a technique where each slot in the hash table contains a linked list of items that hash to that location. When a collision occurs, the item is added to the linked list. This method avoids clustering and is more efficient for large datasets. However, it requires additional memory to store the linked lists and may result in slower search times if the lists become too long.

   

Quadratic Probing: Quadratic probing is a variation of linear probing that tries to distribute items more evenly across the table. Instead of checking the next available slot, the algorithm searches for the next available slot using a quadratic function. This method reduces clustering and provides better search efficiency than linear probing. However, it may result in longer search times for some inputs.

In conclusion, hashing is an essential concept in computer science, providing several benefits such as data integrity verification, fast retrieval, and security. Understanding the different types of hash functions and their applications can help developers make informed decisions when implementing hashing in their applications.

ChatGPT API helps developers to integrate ChatGPT features into their projects which can be either chat-based or voice assistant ie - using your commands as input and the API will generate a response based on that command.

DALL-E API is used for image generation based on user prompts

Pre-requisites before integration

• Create an account on Open AI by going to their documentation page

• Generate your API Key which will be used to make an API call to the ChatGPT API and DALL-E API by clicking on Create new secret key

• Make sure to store the API Key somewhere like the .env file as you will only be able to see it on the website only once.

Integrate APIs in your Flutter Project

• Create a dart file which will contain all the functions regarding the API calls to

  ChatGPT and DALL-E and name it for example openai_service.dart

• We are gonna use the HTTP package for the API call but you can also use the dart_openai package for the API calls(dart_openai)

• Now we are gonna use chat API(chat completions) which supports two open AI models: GPT-4 and GPT-3.5-turbo

• Now as we are also using DALL-E API together we need some way to distinguish whether the user is asking to generate an image or not for that we will be using an async function named as isArtPrompt() and use Chat completions for it.

  This function returns a yes or no based on which API call is made either to ChatGPT API or DALL-E API.

  

•   Future<String> isArtPrompt(String prompt) async {
        try {
          final res = await http.post(
              Uri.parse("https://api.openai.com/v1/chat/completions"),
              headers: {
                'Content-Type': 'application/json',
                'Authorization': 'Bearer $OpenAIApiKey'
              },
              body: jsonEncode({
                'model': "gpt-3.5-turbo",
                'messages': [
                  {
                    "role": "user",
                    "content":
                        "Does this message want to generate an AI picture, image, art or anything similar? $prompt . Simply answer with a yes or no."
    //this content asks chatGPT and retrieves answer in yes or no 
                  }
                ],
              }));
          print(res.body);
          if (res.statusCode == 200) {
            String content =
                jsonDecode(res.body)['choices'][0]['message']["content"];
            content = content.trim(); //trimming all space from output
            switch (content) {
              case 'yes':
              case 'Yes':
              case 'Yes.':
              case 'yes.':
                   final res = await dallEAPI(prompt); 
                   // dalle api call if yes
                return res;
              default:
                final res = await chatGPTAPI(prompt);
                // ChatGPT api call if no
                return res;
            }
          }
          return "An internal error!!";
        } catch (e) {
          return e.toString();
        }
      }
  

  Now the functions chatGPT API and DALL-E are as follows

•   final List<Map<String, String>> messages = [];
    // Chat Completetion API call
    Future<String> chatGPTAPI(String prompt) async {
        messages.add({'role': 'user', 'content': prompt});
        try {
          final res = await http.post(
              Uri.parse("https://api.openai.com/v1/chat/completions"),
              headers: {
                'Content-Type': 'application/json',
                'Authorization': 'Bearer $OpenAIApiKey'
              },
              body: jsonEncode({
                'model': "gpt-3.5-turbo",
                'messages': messages,
              }));
          print(res.body);
          if (res.statusCode == 200) {
            String content =
                jsonDecode(res.body)['choices'][0]['message']["content"];
            content = content.trim();
            messages.add({'role': 'assistant', 'content': content});
            return content;
          }
          return "An internal error!!";
        } catch (e) {
          return e.toString();
        }
      }
  
    // image generation API call
    Future<String> dallEAPI(String prompt) async {
        messages.add({'role': 'user', 'content': prompt});
        try {
          final res = await http.post(
              Uri.parse("https://api.openai.com/v1/images/generations"),
              headers: {
                'Content-Type': 'application/json',
                'Authorization': 'Bearer $OpenAIApiKey'
              },
              body: jsonEncode({
                'prompt': prompt,
                'n': 1, // number of images to be generated
              }));
          print(res.body);
          if (res.statusCode == 200) {
            String imgUrl = jsonDecode(res.body)['data'][0]['url'];
            imgUrl = imgUrl.trim();
            messages.add({'role': 'assistant', 'content': imgUrl});
            return imgUrl;
          }
          return "An internal error!!";
        } catch (e) {
          return e.toString();
        }
      }
  

  Thats it !! Now you can use the isArtPrompt() function and pass it your desired prompt, the function will call either of the APIs and give a response which you can use in your Flutter app to showcase the user.

You can check out my Voice assistant Flutter App using ChatGPT API and DALL-E API for text response and image generation based on user prompts(Voice Assistant App).

Make sure to follow me and subscribe to this blog for more tech blogs like this on daily basis, P.S. - your support is much appreciated!!!

Create: The Create operation allows users to create new data entries in the database. This can be done using a web form or an API endpoint. When the user submits the data, it is sent to the server and stored in the database. The data is validated to ensure that it meets the required criteria before it is stored in the database.

Read: The Read operation allows users to retrieve data from the database. This can be done by querying the database using specific criteria. For example, a user might search for all the products in a specific category or all the users who have signed up in the last week. The data is returned in a format that can be easily understood by the user, such as a table or a list.

Update: The Update operation allows users to modify existing data in the database. This can be done using a web form or an API endpoint. When the user submits the updated data, it is sent to the server and stored in the database. The data is validated to ensure that it meets the required criteria before it is updated in the database.

Delete: The Delete operation allows users to remove data from the database. This can be done using a web form or an API endpoint. When the user confirms the deletion, the data is removed from the database. It is important to note that this operation should be used with caution, as it can result in the loss of important data.

Suppose, you are on Instagram and you create a post, this is called create functionality and now in that post after uploading you are trying to change the caption of the post, this is update functionality similarly you delete a post triggering delete functionality and while you are searching for an account to follow you are triggering read functionality as you are trying to search the account which Instagram will provide by reading from its database.

The above example, tells you that CRUD functionality is most crucial for big tech companies to maintain their product.

The importance of CRUD functionality: CRUD functionality is important for several reasons. First, it allows users to interact with data simply and intuitively. This makes it easier for users to manage their data and reduces the likelihood of errors.

Second, CRUD functionality ensures that data is consistent and accurate. When users create, read, update, and delete data using a standardized set of operations, the data remains consistent across the entire system.

Finally, CRUD functionality helps to ensure the security of the system. By controlling access to the Create, Read, Update, and Delete operations, the system can prevent unauthorized access to sensitive data.

In conclusion, CRUD functionality is an essential feature of any application that deals with data. It provides users with a simple and intuitive way to manage their data, ensures the consistency and accuracy of the data, and helps to ensure the security of the system.

To Learn More about what is an API checkout my Blog

APIs are an essential part of software development and they are becoming highly important for businesses around the world as they are moving their operations to the cloud. APIs allow applications to access data and interact with other applications seamlessly and efficiently.

For example, suppose you are building an app which allows users to search for weather conditions across countries and states for this you can use a Weather API which has all the data and integrates it into your application making it very efficient and easy to build. Moreover, you can also add more features to your app by using multiple APIs.

Without APIs, most of your favourite software wouldn't exist today such as Google Maps API lets you integrate Google Maps on your mobile which is allowing many tech startups like Ola, Uber etc. to provide location service.

Why should you use APIs in your application?

• It extends application capabilities.

• Allows developers to reuse certain application logic.

• APIs are platform-independent, they deliver data without being affected by the requesting platform.

• Enables the app to access outside resources.

So How Does an API Work?

Imagine you are trying to order an item from an online e-commerce store now when you click on buy item your request gets transferred to the backend web server of the e-commerce store via an API request.

Now, the backend server will respond to the API request and pass on your order request to the delivery partner and the delivery partner will deliver the requested item to you.

This process of sending a request is called an API request and the response to the API request is called an API response.

So API helps in providing a secured layer between applications and the data they access, protecting sensitive information from unauthorized access.

Types of APIs

• Open/Public APIs -

  These APIs are available to everyone as a result, open APIs typically have relatively low authentication and authorization measures and are often restricted in the assets they share. These are either free to access or have a subscription fee.

• Partner APIs -

  Partner APIs are shared externally, but only among those with a business relationship with the API company. Access is limited to authorized clients with official licenses

• Internal APIs -

  internal APIs (also called private APIs) are not intended for use by third parties. Internal APIs are only made available for use inside a company and are meant to streamline data transfers between teams and systems.

• Composite APIs -

  Composite APIs combine multiple APIs allowing developers to bundle calls or requests and receive one unified response from different servers.

10 APIs you can use in your Applications -

• Google Maps API (Checkout)

• Omdb API (Checkout)

• Open Weather Map API (Checkout)

• Spotify API (Checkout)

• Coinbase API (Checkout)

• Fake Store API (Checkout)

• Novu API (Checkout)

• Zenserp API (Checkout)

• Number verification API (Checkout)

• Stripe API (Checkout)

The process in which a function calls itself either directly or indirectly is called recursion and the corresponding function is called a recursive function with recursion you can solve some complex problems quite easily examples of such problems are tower of hanoi, tree traversals, DFS of graph etc.

properties of recursion -

• performing the same operation multiple times with different inputs

• At every step, the input is reduced to make the problem smaller

• A base condition is required to stop the recursion process otherwise infinite loop will occur

Many people when try to solve a problem using recursion they try to trace each recursive call to determine what each function call is doing but this is a trap of endless confusion to avoid this trap you need not need to know what each function call is doing rather you just need to pick a subproblem and believe that your function will solve the rest of the problem, you need to take a leap of faith and believe in your function.

Steps to approach a problem and think recursively

• Step 1) Know what your function is supposed to do.

• Step 2) Determine a subproblem from the main problem.

• Step 3) Find out the answer to the subproblem and use it to solve the main problem.

• Step 4) Last step is to determine the base condition of the problem

Let's take a simple problem such as finding the sum of 1 to n numbers and follow the 4 steps mentioned above to solve the problem.

Know what your function is supposed to do

This is the most basic and general step but a very important one. Now in the question above, we know that we need to calculate the sum of numbers from 1 to n

So our function needs to take a value n and return the sum from 1 up to n so our inputs of the function cant exceed n.

let's say the function is sumTo().

int sumTo(int n){

}

Determine the subproblem from the main problem

A subproblem is any problem that is smaller than the main problem and it is important to find the appropriate subproblem

In the above case, the subproblem can be solving the sum of all numbers less than n.

so the appropriate subproblem will be solving for the sum of (n-1) numbers.

Finding out the answer to the subproblem and using it to solve the main problem

The solution for the sum of n-1 numbers will be

sumToSubProblem = 1+2+3 ...... + n-1

Now to find the solution to the main problem we just need to add the nth number -

mainProblem = subProblem + n

So the code will be

int sumTo(int n){
     int subProblem = sumTo(n-1);
     return subProblem + n;
}

The last step is to find the base case for the recursion process -

A base case condition is any condition that stops the recursion process and is necessary to avoid the infinite loop.

So to find the base condition we need to find at what input the function becomes irrelevant in the above case we know if n = 0 the function will become irrelevant as 0+0 will give 0 only.

so on applying this base condition we will have a complete solution to the main problem

int sumTo(n-1){
    if(n == 0) return 0;
    int subProblem = sumTo(n-1);
    return subProblem + n;
}

More examples -

Reversing a string using recursion

As per the first step, we know that we need a function that takes a string as input and return a reversed string.

string reverseString(string s){

}

Now we need to determine a subproblem which in this case will be leaving the first character and solving for the rest of the characters.

ie - string s = "hello";

so the subproblem will be reversing "ello" to "olle" and adding the first character 'h' in the end.

string reverseString(string s){
     string substring = s.substr(1,s.length());
     string reversedSubProblem = reverseString(substring);
     return reversedSubProblem + s[0];
}

Now the last step will be finding the base case condition which in this case will be if string s become empty string because that is the most basic string a user can provide.

so,

string reverseString(string s){
     if(s == "") return "";
     string substring = s.substr(1,s.length());
     string reversedSubProblem = reverseString(substring);
     return reversedSubProblem + s[0];
}

Similarly to find the nth Fibonacci number the subproblems will be finding the Fibonacci terms (n-1) and (n-2) and the addition of these two terms will give the solution for the nth Fibonacci term.

and the base condition, in this case, will be for n = 0 and n = 1 as there are no two previous terms for these values

int fibonacci(int n){
    if(n == 0) return 0;
    if(n == 1) return 1;
    int term1 = fibonacci(n-1);
    int term2 = fibonacci(n-2);
    return term1+term2;
}

Branches are used within the development process of the project which involves creating a new feature, and fixing bugs it acts as a copy of your main work but changes in a branch do not reflect on your main work and you can use it for trial and testing and after getting the desired output you can open a pull request to merge the changes on your branch to the main branch ie - update your main branch with the changes.

Steps for pushing your project to GitHub-

First thing first you'll need to create an empty GitHub repository inside where you would put your project files.

After creating the repo you will be displayed the following screen

• The first step is initialising git inside your project folder.

• The second step is creating a remote to your GitHub repo.

• The third step is to add your project files in the staging area using the command

  " git add . " This will add the project files from your local directory to the staging area.

• The fourth step is to commit your changes with a message using the command

  git commit -m "message"

• Create a main branch using the command,

  git branch -M main and push your staged files to the main using the command

  git push -u origin main

Collaborate on an existing GitHub project using branches and pull requests

Now to collaborate on an existing project first you'll need to clone the project on your local directory using the command git clone project_url

After, it is a great practice to create your branch for modifications, to create a branch use the command git checkout -b <branch-name>

Now inside your branch, you can add your feature and after finishing the feature you can add the changes to the staging area using the command

git add .

After adding, commit the changes with an appropriate message describing the feature you have changed or updated to do so use the command

git commit -m "message"

The above steps keep on repeating while changes are done.

Now the final step is to push the changes on your branch and open a pull request for the reviewer to review it and merge it with the main to do so following sets of commands are used -

• git push origin <branch name>

• Now to open a pull request for your changes do the following steps

• Navigate to your GitHub Repo and select your branch which consists of your commits -

  

• Above the list of files, click Pull request.

  

• Type a title and description for your pull request.

  

• Click on create pull request button

  

After creating the pull request the owner of the project will review your code and merge it to the master branch if there are no conflicts.

Note - before doing any changes on your branch you must pull the changes done on the main so that there are no merge conflicts or issues to do so -

• Before pulling changes switch to your branch using get checkout <branch-name>

• fetch the current origin using git fetch origin

• use git merge origin/main to pull changes from the main branch to your local branch another way to do this is to use the command git rebase origin/main

• You can check whether you are behind commits or not using the git status

• Now you can simply pull the changes from the master branch to the local branch.

Congrats!! now you can collaborate easily on projects with your team mates without disturbing the existing work flow and also create your own projects and push it to github to collaborate with others or work on a open source project.

A Linked List is a data structure which can change during the execution it consists of a set of nodes linked together each node is divided into two parts one part consists of the data to be stored and the other part stores the address of the next node.

Some key points for a linked list -

• Successive elements are connected by pointers.

• last elements point to NULL in case of singly linked list and doubly linked list

• It can grow or shrink in size during the execution of the program.

• It does not waste memory space.

Types of Linked Lists -

• Singly Linked List -

  

• Doubly Linked List -

  

  pointers exist between adjacent nodes in both directions, the list can be traversed either forward or backward, and two pointers are maintained to track known as head and tail.

• Circular Linked List -

  

  the pointer of the last element in the list points back to the first element.

Basic operations of Linked Lists -

• Insert a node in Linked List.

• Delete a node in Linked List.

• Traverse a Linked List.

Implementation of a Linked List -

Singly Linked List

// node structure
class Node {
public:
  int data; // data element
  Node *next;//stores address of next element in a list

  Node()
  {
    data = 0;
    next = NULL;
  }
  Node(int x)
  {
    this->data = x;
    this->next = NULL;
  }
}

class ll {
Node *head;
public:
  ll(){head = NULL}

  Node *insert(int pos, int x) {
    Node *temp = new node(x);
    Node *curr;
    curr = head;
    if (pos == 1) // insert at first position
    {
      temp->next = head;
      head = temp;
      return head;
    }
    for (int i = 1; i <= pos - 2 && curr != NULL; i++) 
    // insert anywhere
    {
      curr = curr->next;
    }
    temp->next = curr->next;
    curr->next = temp;
    return head;
  }

  Node *del(int pos) {
    Node *curr;
    curr = head;
    if (pos == 1) // delete first node
    {
      head = head->next;
      return head;
    }
    for (int i = 1; i <= pos - 2 && curr != NULL; i++)
    // delete any node
    {
      curr = curr->next;
    }
    curr->next = curr->next->next;
    return head;
  }

  void display() { // traversing the list
    Node *curr = head;
    while (curr != NULL){
      cout << curr->data << " ";
      curr = curr->next;
    }
  }
}

Doubly Linked List -

class Node{
public:
    int data;
    Node *prev;
    Node *next;

    Node()
    {
        prev = NULL;
        next = NULL;
        data = 0;
    }
    Node(int x)
    {
        data = x;
        prev = NULL;
        next = NULL;
    }
}

class dll{
    Node *head;
public:
    dll() { head = NULL }

    void insertFront(int x)
    {
        Node *newNode = new Node(x);
        NewNode->next = head;
        newNode->prev = NULL;
        if (head != NULL){
            head->prev = newNode;
        }
        head = newNode;
    }

    void insertAfter(Node *prevNode, int x){
        if (prevNode == NULL){
            cout << "previous cant be null";
            return;
        }
        Node *newNode = new Node(x);
        newNode->prev = prevNode;
        newNode->next = prevNode->next;
        prevNode->next = newNode;
        if (newNode->next != NULL){
            newNode->next->prev = newNode;
        }
    }
    void insertEnd(int x){
        Node *newNode = new Node(x);
        newNode->next = NULL;
        Node *last = head;
        if (head == NULL){
            newNode->prev = NULL;
            head = newNode;
            return;
        }
        while (last->next != NULL){
            last = last->next;
        }
        last->next = newNode;
        newNode->prev = last;
    }
    void deleteNode(Node *delNode){
        if(head == NULL || delNode == NULL){
            return;
        }
        if(head == delNode){ // del first node;
            head = delNode->next;
        }
        if(delNode->next!=NULL){ 
            delNode->next->prev = delNode->prev;
        }
        if(delNode->prev!=NULL){
            delNode->prev->next = delNode->next;
        }
        delete delNode;
    }

    void display(Node *node) { // displays a list after a given node
        Node *last;

        // forward direction
        while (node != NULL){
            cout << node->data << "<==>";
            last = node;
            node = node->next;
        }
        // backward direction
        while (last != NULL){
            cout << last->data << "<==>";
            last = last->prev;
        }
    }
}

Circular Linked List -

class Node{
public:
    int data;
    Node *next;
    Node(){
        this->data = 0;
        this->next = NULL;
    }
    Node(int x){
        this->data = x;
        this->next = NULL;
    }
}

class cll{
    Node *head;
    Node *tail;

public:
    cll(){
        this->head = NULL;
        this->tail = NULL;
    }
    void insert(int x)
    {
        Node *newNode = newNode(x);
        if (head == NULL){
            head = newNode;
            tail = newNode;
            return;
        }
        tail->next = newNode;
        newNode->next = head;
        tail = newNode;
    }

    void delNode(int x)
    {
        Node *temp = head;
        if (head == tail){
            head = NULL;
            tail = NULL;
            return;
        }
        if (temp->data == x){
            head = head->next;
            tail->next = head;
            return;
        }
        do{
            Node *n = temp->next;
            if (n->data == x){
                temp->next = n->next;
                break;
            }
            temp = temp->next;
        } while (temp != head);
    }

    void display(){
        Node *temp = head;
        if (head != NULL){
            do{
                cout << temp->data << "-->";
                if (temp->next != NULL){
                    temp = temp->next;
                }
            } while (temp != head);
        }
    }
}

Interview Questions on Linked Lists -

Check out all the questions about linked lists that have been asked in the FAANG interviews frequently in this GitHub repository also make sure to follow me on GitHub to stay updated on such content, also you can too contribute to this repo.

Other related blogs -

Congrats! you have learned the fundamentals of Linked List Data-Structure, make sure to subscribe to my blog to follow this series and follow me on Hashnode, where I'll be uploading content on Data Structures and Algorithms every weekend.

It is generally of two types -

• Max-heap - where the root node must be greatest among all its child nodes and the same goes for its right subtree and left subtree.

• Min-heap - where the root node must be smallest among all its child nodes and the same goes for its right subtree and left subtree.

  

Operations on a Heap -

• insert() - Inserts data into Heap.

• extract min() - Extracts and deletes the smallest element in the Heap while maintaining its properties.

• decreaseKey() - Changes an element at an index in the Heap while maintaining its properties.

• deleteKey() - Deletes an element at an index in the Heap while maintaining its properties.

• heapify() - The process of creating a heap data structure from a binary tree represented using an array.

• buildHeap() - converts an array into a Heap using the help of heapify function.

• getMin()/getMax() - Returns the minimum/maximum element of the Heap.

Implementation of Heap -

Heap is represented using arrays where the element at the 0-th index is greatest in the case of a Max-heap and minimum in the case of a Min-heap.

We find the right and left child using the formula -

• left child = 2*i+1

• right child = 2*i+2

• parent = (i-1)/2

• Here, i is the index of the node.

#include <iostream>
using namespace std;

class Heap
{
    int size;
    int capacity;
    int arr[];
    Heap(int c)
    {
        size = 0;
        capacity = c;
        arr = new int[c];
    }
    int leftChild(int i) // extracts left child Index
    {
        return (2 * i + 1);
    }
    int rightChild(int i) // extracts right child index
    {
        return (2 * i + 2);
    }
    int parent(int i) // extracts parent index of a node
    {
        return (i - 1) / 2;
    }
    insert(int x) // Time Complexity o(logn) // inserts in Heap
    {
        if (size == capacity)
            return;
        size++;
        arr[size - 1] = x;
        int i = size - 1;
        while (i != 0 && arr[parent(i)] > arr[i])
        {
            swap(arr[parent(i)], arr[i]);
            i = parent(i);
        }
    }
    void minHeapify(int i) { // Time Complexity O(logN)
        int li = leftChild(i), ri = rightChild(i);
        int smallest = i;
        if (li < size && arr[li] < arr[smallest])
        {
            smallest = li;
        }
        if (ri < size && arr[ri] < arr[smallest])
        {
            smallest = ri;
        }
        if (smallest != i)
        {
            swap(arr[i], arr[smallest]);
            minHeapify(smallest);
        }
    }
    int getMin() // extracts minimum element from heap
    {
        return arr[0];
    }

    int extractMin()//removes minimum element from heap and returns it
    {
        if (size == 0)
            return INT_MAX;
        if (size == 1)
        {
            size--;
            return arr[0];
        }
        swap(arr[0], arr[size - 1]);
        size--;
        minHeapify(0);
        return arr[size];
    }
    void decreaseKey(int i, int x) //changes a heap element at index i
    {
        arr[i] = x;
        while (i != 0 && arr[parent(i)] > arr[i])
        {
            swap(arr[parent(i)], arr[i]);
            i = parent(i);
        }
    }

    void deleteKey(int i) // deletes a element at i index
    {
        decreaseKey(i, INT_MIN);
        extractMin();
    }

    void buildHeap() // T.C. O(N) //builds the heap using heapify()
    {
        for (int i = (size - 2) / 2; i >= 0; i--)
        {
            minHeapify(i);
        }
    }
}

Applications of Heap -

• Heap is used to constructing a priority_queue

• Heap sort is the fastest sorting algorithm with time complexity O(N*logN) and is easy to implement.

priority_queue -

In c++, the STL priority_queue provides the functionality of the priority queue which is internally created using Heap Data-Structure.

To solve questions related to Heap priority_queue will be used in c++, it is of two types ascending priority queue and descending priority queue.

To create a min heap the syntax is -

• priority_queue<int,vector<int>,greater<int>> pq;

To create a max heap the syntax is -

• priority_queue<int> pq;

priority_queue functions -

• size() - returns the size of the queue

• push() - pushes an element inside the queue

• pop() - deletes the first element of the queue

• empty() - checks whether the queue is empty or not

• top() - returns a topmost element of the queue

Heap Interview Questions -

• Heap implementation

• Check if an array is a heap or not

• Convert a min-heap to max-heap

• Heap sort

• K-closest

• K-frequent numbers

• K-th largest/smallest element

• Merge-k-sorted arrays

• The minimum cost of the rope

• Sort k-sorted array(nearly sorted)

A resource to get in-depth knowledge -

Congrats! you have learned the fundamentals of Heap Data-Structure, make sure to subscribe to my blog to follow this series and follow me on Hashnode, where I'll be uploading content on Data Structures and Algorithms every weekend.

Operations on a Stack -

• push() - pushes an element in the stack.

• pop() - removes an element from the top of the stack.

• peek()/top() - returns the top element of the stack.

• isEmpty() - checks if the stack is empty or not.

• isFull() - checks if the stack is full or not

Ways of implementing Stack -

• Using Arrays

• Using Linked list

Using Arrays -

#include <iostream>
using namespace std;

class Stack{
private:
  int top;
  int cap;
  int *arr;

public:

  Stack(int c){
    top = -1;
    cap = c;
    arr = new int[c];
  }

  void push(int x){ //pushes element in the stack
    if(isFull()){
      cout<<"Stack overflow";
    }
    top++;
    arr[top] = x;
  }

  int pop(){ //removes element from the top of stack
    if(isEmpty()){
      cout<<"Stack underflow";
    }
    int p = arr[top];
    top--;
    return p;
  }

  int peek(){ //returns top elements of the stack
    return arr[top];
  }

  bool isFull(){
       if(top == cap-1){
          return true;
       }
    return false; 
  }

  bool isEmpty(){ //checks if stack is empty or not
    if(top == -1){
      return true;
    }
    return false;
  }
};

Using Linked List -

class Node
{
public:
    int data;
    Node *next;
    Node(int d)
    {
        this->data = d;
        this->next = NULL;
    }
};

class myStack
{
private:
    Node *top;
    int size = 0;
    int capacity = 5;

public:
    myStack()
    {
        top = NULL;
    }
    void push(int x)
    {
        if (size >= capacity)
        {
            cout << "stack overflow";
            return;
        }
        Node *newNode;
        newNode = (Node *)malloc(sizeof(Node));
        newNode->data = x;
        newNode->next = top;
        top = newNode;
        size++;
    }

    int pop()
    {
        Node *temp;
        int data;
        if (size <= 0)
        {
            cout << "stack underflow";
            return;
        }
        temp = top;
        data = top->data;
        top = top->next;
        free(temp);
        size--;
        return data;
    }

    bool isEmpty()
    {
        return size <= 0;
    }

    int peek()
    {
        if (!isEmpty())
        {
            return top->data;
        }
        else
        {
            cout << "Stack is empty.";
        }
    }
    void display()
    {
        Node *temp = top;
        while (top != NULL)
        {
            cout << temp->data << " ";
            temp = temp->next;
        }
    }
};

Stack Overflow and Stack Underflow -

Stack Overflow - It is a situation in which the stack is full and no elements can be pushed ie. when we try to push more items in a stack than it can hold.

Stack Underflow - this happens when we try to pop an element from an empty stack.

Top Interview Questions -

• Balanced-parenthesis problem

• Astroid-collision problem

• Celebrity-problem

• Largest-Rectangle-histogram problem

• Maximal-Rectangle problem

• Stock-Span Problem

• Next-greater-element problem

• Next-greater-element-2(Circular)

• remove-k-digits problem

• delete the middle element of the stack

• sort the stack

• reverse the stack

• Implement stack using a queue

• Implement stack using two queue

Resources to get in-depth knowledge -

Aditya Verma Stack playlist -

Love Babbar Stack playlist -

Congrats! you have learned the fundamentals of Stack Data-Structure, make sure to subscribe to my blog to follow this series and follow me on Hashnode, where I'll be uploading content on Data Structures and Algorithms every weekend.