DEV Community: Adarsh

This is the blog for static website hosting in the AWS S3. I assume that you have a basic knowledge of the AWS-managed console and a basic understanding of the AWS.

Create a static project locally

Get the project for the GitHub link

You can clone the GitHub repository or download the project through GitHub to the GitHub link given below.

Project Link

Manually Create your project

Create a basic HTML project locally using the basic HTML file. The main HTML file should be named index.html so that it will render the given project through the index.html. And you can add style.css and main.js depending on your need for the project. The files that you need are listed below.

index.html
styles.css
scripts.css

Create S3 bucket

Log into the AWS-managed console

Enter the login username and password for logging into the AWS console with the credentials for the IAM user or the root password.

Choose the AWS region

You can choose the region for the AWS by selecting the top right corner drop-down of the AWS managed console.

Before you create any bucket you should choose the AWS region the default is US East (N.Virginia) but you can select the AWS region depending on the distance between the server and the desired location.

Create S3 bucket

Search the S3 in the AWS search and then click on it.

Create bucket

After going to the S3 bucket click on the Create bucket so that you create a bucket and fill in the additional details. The details are documented below:

Create a bucket name

Uncheck a (Block Public access setting)

Leave everything as the default and click the create bucket button to create a S3 bucket.

Change S3 bucket properties for the static website hosting

Go to the S3 bucket click the S3 bucket link that was created and search for the properties in the S3. Under the properties click the search for the static website hosting and click on the edit button so that you enable the static website hosting.

Select the properties Tab

Select The edit button of static website hosting

Enable Static website Hosting

Upload File to S3

Upload the file that you have cloned from the previous project link or that you have manually created to S3
S3

Edit S3 Bucket Policy

Edit the bucket policy and paste the code below to give access to all s3 objects for static website hosting.

{
  "Id": "Policy1722232485407",
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "Stmt1722232483590",
      "Action": [
        "s3:GetObject"
      ],
      "Effect": "Allow",
      "Resource": "arn:aws:s3:::aws-blog-project",
      "Principal": "*"
    }
  ]
}

Edit the bucket policy

Paste the code above and save

After selecting the add enable checkbox then specify the default page for your static page.

As we have created a project using the index.html specify the index.html as a default webpage for the static website and save the changes.

After saving the changes you can see the auto-generated link below the static website hosting.

Click on the given link to visit your own S3 page.

Conclusion

You have successfully deployed your static website using AWS S3.

Integration of eslint, prettier, husky, lint-staged, commit-lint with next js

Adarsh — Fri, 19 Jan 2024 05:56:37 +0000

Eslint

ESLint is a popular open-source JavaScript linting utility. It helps developers find and fix common programming errors and enforce coding styles in their codebase. Using various plugins and rules, you can configure ESLint to suit your project's specific requirements. It's commonly used in web development to maintain code quality and consistency.

Prettier

"Prettier" is a code formatting tool that helps developers maintain a consistent coding style in their projects. It supports various programming languages like JavaScript, TypeScript, HTML, CSS, and more. It automatically formats code according to predefined rules, making it more readable and consistent.

Husky

The "husky" npm package is a Git hooks manager for Node.js projects. It helps automate tasks or checks at various points in the Git workflow. You can use it to enforce code standards, run tests, or perform other actions before commits or pushes.

Lint-staged

lint-staged is a tool commonly used in web development. It runs linters on pre-committed files in a Git repository. This helps catch and fix issues before the code is committed. It's often used in conjunction with other tools like ESLint or Prettier to maintain code quality.

Commit Lint

Commit lint is a tool to enforce commit message conventions in a Git repository. It helps maintain consistency and improves collaboration

Git Hooks

Git hooks are scripts that Git executes before or after certain key events, such as committing, merging, and pushing. They allow you to customize and automate aspects of the version control process. Common hooks include pre-commit, post-commit, pre-push, etc. You can find and configure them in the .git/hooks directory of your Git repository.

Setup

For the project, setup install the next with the help of the command below or using the next js documentation

Install vscode extensions

Install Eslint and Prettier vscode extensions from the vscode extension marketplace using a browser or using vscode editor

Next JS and Eslint Setup

npx create-next-app@latest

After executing the command below go through the recommended setup to install the eslint with the next js.

What is your project named? my-app
Would you like to use TypeScript? No / Yes
Would you like to use ESLint? No / Yes
Would you like to use Tailwind CSS? No / Yes
Would you like to use `src/` directory? No / Yes
Would you like to use App Router? (recommended) No / Yes
Would you like to customize the default import alias (@/*)? No / Yes
What import alias would you like configured? @/*

Setup Prettier with eslint in the next js project

npm i -D  prettier eslint-config-prettier

After installing, open your existing ESLint configuration file (.eslintrc.json or .eslintrc.js) and add the following line:

{
  "extends": ["next/core-web-vitals", "prettier"]
}

create .prettierrc file and add the following code to implement a prettier standard

{
  "semi": true,
  "printWidth": 120,
  "singleQuote": true,
  "arrowParens": "always",
  "proseWrap": "preserve"
}

Setup husky and lint staged

Install the husky and lint staged dependency using the following above commands

npm i -D husky lint-staged

After that execute the command below to create a script that executes during the pre-commit using the git hooks

This command will install and configure husky and lint-staged depending on the code quality tools from your project's package.json dependencies, so please make sure you install (npm install --save-dev) and configure all code quality tools like Prettier and ESLint before that.

npx mrm@2 lint-staged

after exerting the script there will be an additional script in package.json which will be similar to the below

  "lint-staged": {
    "*.js": "eslint --cache --fix",
    "*.{js,css,md}": "prettier --write"
  }

If you are using the typescript replace the code below with the code

  "**/*.{ts,js}": "eslint --cache --fix",
  "**/*.{ts,js,md}": "prettier --write"

Setup Commit lint with the next js project

Please go through this step after the installation of the husky only.

Execute the command below to install the commit lint and configure

Install

npm install -g @commitlint/cli @commitlint/config-conventional

Add hook

npx husky add .husky/commit-msg  'npx --no -- commitlint --edit ${1}'

Configure

echo "module.exports = {extends: ['@commitlint/config-conventional']}" > commitlint.config.js

Conclusion

The setup next js form eslint, prettier, husky, lint-stage and commit lint is completed and you can use this in the project to maintain maintained standardized code and commits

SOLID design principle

Adarsh — Sun, 14 Jan 2024 13:25:38 +0000

S.O.L.I.D stands for

S stands for Single responsibility principle
O stands for the open-closed principle
L stands for the Liskov substitution principle
I stands for Interface segregation principle
D stands for Dependency Inversion principle

Single Responsibility Principle

Single responsibility principle is a simple principle, and it tells us that a class should have a single primary responsibility and as a consequence, it should only have one reason to change, That reason is somehow related to its responsibility in other words it's a bat idea to add more than one responsibility to a class.

// Bad Practice
class Journal {
    constructor() {
        this.entries = []
    }
    addEntry(text) {
        //
    }
    removeEntry(index) {
        //
    }
    save(filename) {
        //
    }
    loadFromUrl(url) {
        //
    }
}

In the above code, we made a journal that is going to keep records. The bad practice signifies that you add a lot of code and give a multiple responsibility for a single class for journal management as well as file handling.

// Better Practice
class Journal {
    constructor() {
        this.entries = []
    }
    addEntry(text) {
        //
    }
    removeEntry(index) {
        //
    }
}
class PersistenceManager {
    preprocessor() {
        //
    }
    saveToFile(journal, filename) {
        //
    }
}

In the above example, it can be seen that it is easy to understand and implement the code by grouping the functionalities by the class instead of sticking all the functionality into a single class

There is an anti-pattern that shows up during a coding practice which is rather bad as opposed to a good. There is also a pattern called a god object pattern which is a huge massive class that has lots of responsibility and spaghetti code which is very difficult to figure out

And so the single responsibility is the exact opposite that basically lets us have just one responsibility and if we need additional responsibility then we just take other classes as they don't cost us anything.

Another term we used is called separation of concerns. So separation of concern is what we do when we refactor for example let's suppose you find a complicated algorithm and what we are trying to do is split it into different parts that are somehow related.

Seperation of the concern is also widely used in one of the most popular JS libraries react js. So in React, we solved this issue by creating container components that contain all the logic, which would then pass down the data via props to the presentational component. And with the introduction of React hooks, there's a new approach to this: using custom hooks.

The code is available to preview on "singleResponsibilityPrincipale.js"

Open-Closed Principle

Objects-Closed Principle(OCP) states that objects or entities should be open for extension but closed for modification which means you never jump into an existing class and start to modify it unless you have to.

class Product {
constructor(name, color, size) {
    //
    }
}
class ProductFilter {
    filterByColor(products, color) {
        //
    }
    filterBySize(products, size) {
        //
    }
    filterBySizeAndColor(products, size, color) {
        //
    }
    // state space explosion
    // 3 criteria (+weight) = 7 methods

    // OCP = open for open for extension but closed for modification
}

In the above code extending the functionality is not a good thing because if the product filter class is something that other people might have just copied your class, and then you modified it, but it doesn't they just took a copy having something that has already been tested and put into production modifying it explicitly might not be a good idea

// !Better Practice

class Product {
    constructor(name, color, size) {
        //
    }
}
class ColorSpecification {
    constructor(color) {
        //
    }
    isSatisfied(product) {
        //
    }
}
class SizeSpecification {
    constructor(size) {
        //
    }
    isSatisfied(product) {
        //
    }
}
class BetterSpecification {
    filter(items, spec) {
        //
    }
}
class AndSpecification {
    constructor(...spec) {
        //
    }
    isSatisfied(product) {
        //
    }
}

But generally, it's not such a great practice because it affects the scalability it affects maintenance ability of our code, So a better approach is to use inheritance or some sort of way of extending functionality

Now typically an object-oriented programming language these specification classes would have some sort of base class you would have sort of maybe you have some kind of abstract class called specification but in javascript, there is no abstract class, but we could just force it into the constructor by making sure that if somebody calls the constructor of the specification then they get an error.

Generally, the idea is that you use inheritance of some kind or seperation of concerns effectively to separate each criterion by which you want to filter into separate specification

The implementation can be previewed in "openClosed.js"

Liskov Substitution Principle

The third principle of solid design is the Liskov Substitution principle, and it is named after Barbra Liskov. The Liskov substitution principle states that any subclass object should be substituted for the superclass object from which it is derived.

// BAD

class Rectangle {
    constructor() {
        this.width = 0
        this.height = 0
    }

    setColor(color) {
        // ...
    }

    render(area) {
        // ...
    }

    setWidth(width) {
        this.width = width
    }

    setHeight(height) {
        this.height = height
    }

    getArea() {
        return this.width * this.height
    }
}

class Square extends Rectangle {
    setWidth(width) {
        this.width = width
        this.height = width
    }

    setHeight(height) {
        this.width = height
        this.height = height
    }
}

function renderLargeRectangles(rectangles) {
    //
}

According to the code above rectangle class should substitute for the rectangle class but in the code above it only works for rectangles not for square

class Shape {
    setColor(color) {
        // ...
    }

    render(area) {
        // ...
    }
}

class Rectangle extends Shape {
    constructor(width, height) {
        super()
        this.width = width
        this.height = height
    }

    getArea() {
        return this.width * this.height
    }
}

class Square extends Shape {
    constructor(length) {
        super()
        this.length = length
    }

    getArea() {
        return this.length * this.length
    }
}

function renderLargeShapes(shapes) {
    //
}

So we are going to create a shape class that will be extended both to a rectangle and a square. The rectangle class has the constructor both with and height, and we can get the area by multiplying width and height, while the square class has a constructor with length only, and we render the area through the renderLargeShapes function

The code implementation can be previewed in "lsp.js"

Interface Segregation Principle

Interface segregation principle states 'A client should never be forced to implement an interface that it doesn’t use, or clients shouldn’t be forced to depend on methods they do not use'.

Simple Approach

Suppose you enter a restaurant, and you are a pure vegetarian. The waiter in that restaurant gave you the menu card which includes vegetarian items, non-vegetarian items, drinks, and sweets. In this case, as a customer, you should have a menu card that includes only vegetarian items, not everything that you don’t eat in your food.

Here the menu should be different for different types of customers. The common or general menu card for everyone can be divided into multiple cards instead of just one. Using this principle helps in reducing the side effects and frequency of required changes.

In JavaScript, we don't have an interface by default. But we all would have faced situations where we want to do so many things on the constructor of a class.

class DOMTraverser {
    constructor(settings) {
        this.settings = settings
        this.setup()
    }

    setup() {
        this.rootNode = this.settings.rootNode
        this.animationModule.setup()
    }

    traverse() {
        // ...
    }
}

const $ = new DOMTraverser({
    rootNode: document.getElementsByTagName("body"),
    animationModule() {}, // Most of the time, we won't need to animate when traversing.
    // ...
})

We create a dom traverser class awe pass a settings it gets a root node and we pass an animation module always but we may not need to animate

// GOOD

class DOMTraverser {
    constructor(settings) {
        this.settings = settings
        this.options = settings.options
        this.setup()
    }

    setup() {
        this.rootNode = this.settings.rootNode
        this.setupOptions()
    }

    setupOptions() {
        if (this.options.animationModule) {
            // ...
        }
    }

    traverse() {
        // ...
    }
}

const $ = new DOMTraverser({
    rootNode: document.getElementsByTagName("body"),
    options: {
        animationModule() {},
    },
})

So in the code above we make the passing of the animation module optional by making animation module objects optional so if passed in the animation module it is implemented if not its is not implemented

The implementation of this principle can be previewed in "isp.js"

Dependency inversion principle

The dependency inversion principle states that the high-level module must not depend on the low-level module, but they should depend on abstractions states that the high-level module must not depend on the low-level module, but they should depend on abstractions

The dependency inversion principle defines a relationship that you should have between low-level modules and high-level modules.

Simple approach

You can consider a real-life example of a TV remote battery. Your remote needs a battery but it’s not dependent on the battery brand. You can use any XYZ brand that you want and it will work. So we can say that the TV remote is loosely coupled with the brand name. Dependency Inversion makes your code more reusable

// BAD

class InventoryRequester {
    constructor() {
        this.REQ_METHODS = ["HTTP"]
    }

    requestItem(item) {
        // ...
    }
}

class InventoryTracker {
    constructor(items) {
        this.items = items

        // BAD: 
        // We should just have requestItems depend on a request method: `request`
        this.requester = new InventoryRequester()
    }

    requestItems() {
        this.items.forEach((item) => {
            this.requester.requestItem(item)
        })
    }
}

const inventoryTracker = new InventoryTracker(["apples", "bananas"])
inventoryTracker.requestItems()

In the above code, we create an inventory tracker class which is always going to use an inventory requester class that is always going to use the http method. We have created a dependency on a specific request implementation.

// GOOD

class InventoryTracker {
    constructor(items, requester) {
        this.items = items
        this.requester = requester
    }

    requestItems() {
        this.items.forEach((item) => {
            this.requester.requestItem(item)
        })
    }
}

class InventoryRequesterV1 {
    constructor() {
        this.REQ_METHODS = ["HTTP"]
    }

    requestItem(item) {
        // ...
    }
}

class InventoryRequesterV2 {
    constructor() {
        this.REQ_METHODS = ["WS"]
    }

    requestItem(item) {
        // ...
    }
}


const inventoryTracker = new InventoryTracker(
    ["apples", "bananas"],
    new InventoryRequesterV2()
)
inventoryTracker.requestItems()

By constructing our dependencies externally and injecting them, we can easily
substitute our request module for a fancy new one that uses WebSockets.

Additional Content

The above content resources are in the GitHub link below

Resources

Linked list through recursion

Adarsh — Thu, 28 Jul 2022 16:13:00 +0000

#include <iostream>
using namespace std;
struct Node
{
  int data;
  struct Node *next;
};

void printList(struct Node *p)
{

  if (p == NULL)
  {
    return;
  }
  cout << p->data << " ";
  printList(p->next);
}

void recursivePrintList(struct Node *p)
{

  if (p == NULL)
  {
    return;
  }
  recursivePrintList(p->next);
  cout << p->data << " ";
}
Node *insertNode(Node *head, int data)
{
  Node *temp = new Node();
  temp->data = data;
  temp->next = head;
  head = temp;
  return head;
}
int main()
{
  Node *head = NULL;
  head = insertNode(head, 1);
  head = insertNode(head, 2);
  head = insertNode(head, 3);
  head = insertNode(head, 4);
  head = insertNode(head, 5);
  printList(head);
  cout << endl;
  recursivePrintList(head);
  cout << endl;
}

Linked list creation , deletion, insertion, and reversing of linked list

Adarsh — Sun, 24 Jul 2022 15:00:00 +0000

Linked list creation , deletion, insertion, and reversing of linked list


#include <iostream>
using namespace std;
struct Node
{
  int data;
  struct Node *next;
};
struct Node *head;
void printList()
{
  Node *temp = head;
  while (temp != NULL)
  {
    cout << temp->data << " ";
    temp = temp->next;
  }
  cout << endl;
}
void insertNode(int data, int pos)
{
  Node *temp1 = new Node();
  temp1->data = data;
  if (pos == 1)
  {
    temp1->next = head;
    head = temp1;
    return;
  }
  Node *temp2 = head;
  for (size_t i = 0; i < pos - 2; i++)
  {
    temp2 = temp2->next;
  }
  temp1->next = temp2->next;
  temp2->next = temp1;
}
void deleteNode(int pos)
{
  Node *temp1 = head;
  if (pos == 1)
  {
    head = temp1->next;
    delete temp1;
    return;
  }
  for (int i = 0; i < pos - 2; i++)
  {
    temp1 = temp1->next;
  }
  Node *temp2 = temp1->next;
  temp1->next = temp2->next;
  delete temp2;
}
void reverseList()
{
  Node *prev, *current, *next;
  current = head;
  prev = NULL;
  while (current != NULL)

  {
    next = current->next;
    current->next = prev;
    prev = current;
    current = next;
  }
  head = prev;
}
int main()
{
  head = NULL;
  for (int i = 1; i < 6; i++)
  {
    insertNode(i, i);
  }
  printList();
  deleteNode(3);
  printList();
  reverseList();
  printList();
  return 0;
}

Linked List

Adarsh — Thu, 21 Jul 2022 14:57:00 +0000

Inserting into linked list at any position

#include <stdio.h>
#include <stdlib.h>

struct Node
{
  int data;
  struct Node *next;
};
struct Node *head;
void print()
{
  Node *temp = head;
  while (temp != NULL)
  {
    printf("%d ", temp->data);
    temp = temp->next;
  }
  printf("\n");
}

void insert(int data, int n)
{
  Node *temp1 = new Node();
  temp1->data = data;
  temp1->next = NULL;
  if (n == 1)
  {
    temp1->next = head;
    head = temp1;
    print();
    return;
  }
  Node *temp2 = head;
  for (int i = 0; i < n - 2; i++)
  {
    temp2 = temp2->next;
  }

  temp1->next = temp2->next;
  temp2->next = temp1;
  print();
}

int main()
{
  head = NULL; // empty list
  insert(2, 1);
  insert(3, 2);
  insert(4, 1);
  insert(5, 2);
  return 0;
}

Deleting the node in the linked list

#include <stdio.h>
#include <stdlib.h>

struct Node
{
  int data;
  struct Node *next;
};
struct Node *head;
void printList()
{
  Node *temp = head;
  while (temp != NULL)
  {
    printf("[%d|%p]->", temp->data, (void *)&temp);
    temp = temp->next;
  }
  printf("\n");
}
void insert(int data)
{
  Node *temp = new Node();
  temp->data = data;
  temp->next = head;
  head = temp;
}
void deleteList(int n)
{
  struct Node *temp1 = head;
  if (n == 1)
  {
    head = temp1->next;
    free(temp1);
    return;
  }
  int i;
  for (i = 0; i < n - 2; i++)
  {
    temp1 = temp1->next;
  }
  printf("deleted data: %d ", temp1->next->data);

  printf("\n");
  struct Node *temp2 = temp1->next;
  temp1->next = temp2->next;
  free(temp2);
}
int main()
{
  head = NULL;
  int n;
  insert(1);
  insert(2);
  insert(3);
  insert(4);
  insert(5);
  insert(6);
  insert(7);
  printList();
  printf("Enter a position to delete \n");
  scanf("%d", &n);
  deleteList(n);
  printList();
  return 0;
}

Reversing a linked list

#include <stdio.h>
#include <stdlib.h>
struct Node
{
  int data;
  struct Node *next;
};
struct Node *head;
void reverseList()
{
  struct Node *prev, *current, *next;
  current = head;
  prev = NULL;
  while (current != NULL)
  {
    next = current->next;
    current->next = prev; // linking to prev node
    // updating for the next node
    prev = current;
    current = next;
  }
  head = prev;
}
void printList()
{
  Node *temp = head;
  while (temp != NULL)
  {
    printf("%d ", temp->data);
    temp = temp->next;
  }
  printf("\n");
}
void insertNode(int data)
{
  Node *temp = new Node();
  temp->data = data;
  temp->next = head;
  head = temp;
}
int main()
{
  struct Node *head = NULL;
  insertNode(1);
  insertNode(2);
  insertNode(3);
  insertNode(4);
  printf("Linked List : ");
  printList();
  reverseList();
  printf("Reversed list: ");
  printList();
  return 0;
}

Getting started with linked list

Adarsh — Sun, 17 Jul 2022 06:39:20 +0000

Inserting code at the begenning of the linked list

Adarsh — Sun, 17 Jul 2022 06:36:50 +0000

#include <stdlib.h>
#include <stdio.h>

struct Node
{
  int data;
  struct Node *next;
};
// struct Node *head;

Node *insertVal(Node *head, int data)
{
  Node *temp = (Node *)malloc(sizeof(struct Node));
  temp->data = data;
  temp->next = head;
  head = temp;
  return head;
};
void printData(Node *head)
{
  struct Node *temp = head;
  printf("List is : ");
  while (temp != NULL)
  {
    printf("%d ", temp->data);
    temp = temp->next;
  }
  printf("\n");
};
int main()
{
  Node *head = NULL;
  printf("How many numbers ? \n");
  int n, x, i;
  scanf("%d", &n);
  printf("The number that u have entered is %d", n);
  for (i = 0; i < n; i++)
  {
    printf("Enter the data for the list \n");
    scanf("%d", &x);
    head = insertVal(head, x);
    printData(head);
  }
  return 0;
}