DEV Community: Nipu Chakraborty

nginx default configuration file understand

Nipu Chakraborty — Fri, 22 Sep 2023 06:55:35 +0000

Where you will find default conf file and what will be it's name in linux?

Ans: /etc/nginx/nginx.conf

Explanation of file

Ans:
let's see what has in this file
run this command
nano /etc/nginx/nginx.conf

You will get this output

user  nginx;
worker_processes  auto;

error_log  /var/log/nginx/error.log notice;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

let's explain line by line

user nginx; : This sets the user under which the Nginx worker processes will run. In this case, it's set to the "Nginx" user, it's enhance security by limiting the processes and permissions

worker_processes auto; : This will determine the number of worker process that Nginx will be handling for the incoming request. It will choose an automatic number of worker processes based on CPU.

error_log /var/log/nginx/error.log notice; : This will store your error log in the indicated location you can check here if you face any error during the run of the server.

pid /var/run/nginx.pid;: This file contains the master process ID. in a defined location.

events { ... }: In this section Nginx handle events like how Nginx handle connections and events like incoming request by default it has 1024 worker connections but you can change it as per your need.

http { ... }: This section actually handles all HTTP configurations for the server here we can include
include /etc/nginx/mime.types; which actually contain all types of file extensions like .jpg .png .txt .html ... etc. and
default_type application/octet-stream; this section set default MIME type that doesn't have an explicitly defined type.
log_format main here you can define the log format for every request.
access_log /var/log/nginx/access.log main; In this section, you can set the location and format for the access log file. It will keep every single request log with details.

sendfile on; by doing this you are giving permission to send file system calls so that static files can be served efficiently.

keepalive_timeout 65; In this section, you can set a timeout for keep-alive client connections. by default, it has 65 sec but you can set your own time.
include /etc/nginx/conf.d/*.conf; by doing this you can include additional configuration files from the /etc/nginx/conf.d/ directory. Basically, when you think your configuration script going too big you can separate by doing this.

Thank you
You can find me on linkedin connect with me to get more information like this.

Solve Cross Browser Compatibility Issues

Nipu Chakraborty — Fri, 08 Sep 2023 05:24:46 +0000

STEP-1: After write code validate HTML and css

Write well know and and align code
Insert comment for better understand
Indentation match and ensure open-closing tag
Use Jigsaw css validator
Use Js formatter for javascript code and HTML
Use Css lint and eslint
validate with w3school html validator and solve the issue.
Before/after write code always check with browser support I mentioned here some tools [BrowserStack(paid),Browserling(free+paid), IE NetRenderer(free)]

STEP 2: Use css reset and html reset

You can use Normalize.css
HTML5 Reset and
Eric Meyer’s Reset CSS

STEP 3: Maintain Layout structure.

Always use HTML viewport metatag
CSS Multiple Columns click here to know more
CSS Flexbox and Grid click to know more

STEP 4: Detect feature so during development

Here I mentioned some tools

STEP 5:

Test on real device you can also use some tools like browserstack but I will recomend real device always better.

STEP 6:

Always keep update you libaray and packages
Use modern frontend frameworks as like reactJs, VueJs or AngularJs and keep up to date it's a good practice
Always use big comunity support frameworks so that you get better support for feature.

Thanks for your time:
You can reach me at : https://www.linkedin.com/in/nipuchakraborty

JavaScript Function Closures

Nipu Chakraborty — Wed, 06 Sep 2023 10:13:31 +0000

What closure actully do?

Suppose you have a simple pice of code like this.

let value = 1
function multiply(){
   value = value * 2;
   console.log(value)
}  
multiply() // output: 2
multiply() // output: 4
multiply() // output: 8
console.log(value) // 8

if you see here we have a variable in global scope and a function what multiply value*2 and assign it to value variable and console it.
Now take another code

function multiply(){
   let value = 1
   value = value * 2;
   console.log(value)
}  
multiply() // output : 2
multiply() // output : 2
console.log(value) // output: ReferenceError: value is not defined

if you see here we have a variable in functional scope and a function what multiply value*2 and assign it to value variable and console it.

let's discuss what is the difference in this two codes ?

Now discuss about variable life time

In first code variable has life time util close the window or nevigate another page as it is in global scope
In second code variable has life time util function execution. After complete the execution of this it will be destroy all variable. for this reason when I console value in 2nd code get ReferenceError: value is not defined

I think you identify the problem already if you are clever.

In First code when I am trying to get updated value and it happend because it update in global scope variable and we know global scope exist util nevigate or close window that's why we are getting expected result.

But when I created a function after execution it will delete all variable and execution steps that's why when I try to get value it will always getting 2. Now what is the solutions the solutions is I need something what will do this in innerscope and throw it after execute in global scope so that we can get updated value.
let's do this.

function multiply() {
  let value = 1;
  function mul() {
     value = value * 2;
  }
  mul();  
  return value; 
}
const mul1 = multiply()
const mul2 = multiply()
console.log(mul1, mul2) //output 2 2

Still problem not solved expected 4 but getting 2 let's solve this by return insted of value variable let's return the the inner/nested function

function multiply () {
  let value = 1;
  function mul() {
      value = value * 2; 
      return value
  }
 return mul
};

const mul = multiply()
console.log(mul()) // 2
console.log(mul()) // 4
console.log(mul()) // 8

So finally define what is Closures?

A closure is a feature of JavaScript that allows inner functions to access the outer scope of a function. Closure helps in binding a function to its outer boundary and is created automatically whenever a function is created.

Docker Best Practices for Production

Nipu Chakraborty — Sat, 02 Sep 2023 18:59:48 +0000

1. Always use specific version

❌ Don't do this

FROM node

✅ Do this because it will ensure your container image version

FROM node:20.0.0

2. Try to use alpine version

❌ Don't do this because It can be use large

FROM node:20.0.0

✅ Do this for small official image

FROM node:20.0.0-alpine

3. Dont install all dependencies

❌ Don't do this

RUN npm install

✅ Do this because you don't need dev dependencies in your production server

RUN npm install --production

4. Mantain versioning

❌ Don't do this

docker build -t myapp .

✅ Do this it will help you to track version of your container images.

docker build -t myapp:1.0 .

Automating the installation of Docker on Linux using a shell script

Nipu Chakraborty — Sun, 27 Aug 2023 07:44:01 +0000

Create a .sh file file by opening your terminal

touch docker-auto-install.sh

after that open the file

nano docker-auto-install.sh

and Write this code

#!/bin/bash

echo "Updating linux...."
sudo apt-get update
echo "Installing ca-certificates curl and gnupg..."
sudo apt-get install ca-certificates curl gnupg
echo "Add Docker's official GPG key:"
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add Docker repository
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

echo "Update package index again to include Docker repository"
apt update

echo "Installing Docker Engine..."
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

echo "Starting and enabling Docker service"
systemctl start docker
systemctl enable docker

echo "Docker installed and started successfully."

After complete save this file by ctrl+s
and for exit press ctrl + x

Make the script executable: chmod +x docker-auto-install.sh
Run the script with root privileges: sudo ./docker-auto-install.sh

fiverr

Database Transactions

Nipu Chakraborty — Wed, 05 Jul 2023 06:43:20 +0000

What is Transaction?

A database transaction is a unit of work performed on a database that consists of multiple steps or operations. It is a fundamental concept in database systems and ensures the consistency and reliability of data.

In a transaction, a set of database operations is grouped together to form a single logical unit. These operations can include inserting, updating, deleting, or retrieving data from one or multiple database tables. The transaction can involve changes to multiple records or tables, and it represents a specific task or business operation.

Transactions follow the ACID properties, which stands for:

Atomicity: A transaction is atomic, meaning that it is treated as a single indivisible unit of work. It either executes in its entirety, or none of its operations are applied to the database. If any operation fails within the transaction, the entire transaction is rolled back, and the database is restored to its state before the transaction started.
Consistency: A transaction brings the database from one consistent state to another consistent state. It ensures that all integrity constraints, rules, and relationships defined in the database schema are maintained during the transaction. If a transaction violates any constraints, the database reverts to its original state.
Isolation: Transactions execute in isolation from each other, as if they were the only ones operating on the database. This property ensures that concurrent transactions do not interfere with each other's intermediate results. It prevents issues such as dirty reads (reading uncommitted data), non-repeatable reads (reading different data in subsequent reads), and phantom reads (reading new rows that appear during a transaction).
Durability: Once a transaction is committed and changes are applied to the database, they are permanent and survive any subsequent system failures. The committed data is stored securely and can be recovered in case of a crash, power outage, or any other catastrophic event.

Database transactions are crucial for maintaining data integrity, ensuring data consistency, and providing concurrency control in multi-user environments. They allow complex operations and modifications to be performed reliably and accurately on a database, even in the presence of concurrent access by multiple users or applications.

Let see an example with typescript and TypeORM

before start make a User entity with username, email and password

import { createConnection, getConnection } from "typeorm";
import { User } from "./entities/User";

async function performTransaction(): Promise<void> {
  // Create a new database connection
  const connection = await createConnection();

  // Start a transaction
  await connection.transaction(async (entityManager) => {
    try {
      // Create a new user
      const newUser = new User();
      newUser.username = "JohnDoe";
      newUser.email = "johndoe@example.com";
      newUser.password = "password123";

      // Save the user in the transaction
      await entityManager.save(newUser);

      // Update the user's email
      newUser.email = "john.doe@example.com";

      // Save the updated user in the transaction
      await entityManager.save(newUser);

      // Commit the transaction
      await entityManager.commit();

      console.log("Transaction committed successfully.");
    } catch (error) {
      // Rollback the transaction if an error occurs
      await entityManager.rollback();
      console.error("Transaction rolled back due to an error:", error);
    }
  });

  // Close the connection
  await getConnection().close();
}

// Call the transaction function
performTransaction().catch((error) => {
  console.error("Error occurred:", error);
});

How Javascript works? (Bangla)

Nipu Chakraborty — Thu, 18 May 2023 08:26:59 +0000

Single Thread JavaScript

Nipu Chakraborty — Thu, 18 May 2023 08:25:40 +0000

How JavaScript call stack works?(Bangla)

Nipu Chakraborty — Thu, 18 May 2023 08:24:37 +0000

JavaScript Event loop (Bangla)

Nipu Chakraborty — Thu, 18 May 2023 08:23:20 +0000

JavaScript Founder & history (Bangla language)

Nipu Chakraborty — Thu, 18 May 2023 08:20:58 +0000

.js, .cjs and .mjs defference

Nipu Chakraborty — Mon, 15 May 2023 10:24:15 +0000

CJS, MJS, and .JS are file extensions used to denote different types of JavaScript files. Here's the difference between them:

.JS (JavaScript):
The .js extension is the most common file extension for JavaScript files. It is used to indicate that a file contains JavaScript code. .js files can be executed in different JavaScript environments, such as web browsers, servers, and other JavaScript runtime environments.
CJS (CommonJS):
CommonJS is a module system for JavaScript used in server-side environments like Node.js. The CJS module format allows you to define modules using the require and module.exports syntax. In CommonJS, each file is treated as a separate module, and you can import/export functionality between modules using require and module.exports.

CommonJS modules are typically used in Node.js applications and other server-side JavaScript environments. You will often find files with the .js extension using the CommonJS module format.

MJS (ECMAScript Modules): MJS is an extension used for JavaScript files that adhere to the ECMAScript Modules (ESM) specification. ECMAScript modules are part of the JavaScript language standard and provide a more modern and standardized way to define modules.

ECMAScript modules use the import and export keywords to define dependencies and expose functionality between modules. Unlike CommonJS, which is primarily used in server-side environments, ECMAScript modules can be used both in browsers and server-side environments that support them.

The MJS extension is often used to indicate that a JavaScript file uses the ECMAScript module format, making it easier to differentiate between files that use CommonJS and ECMAScript modules.

In summary, .js files are the general extension for JavaScript files, while CJS and MJS are extensions used to specify the module formats (CommonJS and ECMAScript Modules) used in JavaScript files for different environments and purposes.
Here are some examples to illustrate the usage of each file extension:

.JS (JavaScript):

// script.js
function sayHello() {
  console.log("Hello, world!");
}

sayHello();

CJS (CommonJS):

// moduleA.js
const message = "Hello, from Module A!";
module.exports = message;

// moduleB.js
const messageA = require("./moduleA");
console.log(messageA);

MJS (ECMAScript Modules):

// moduleA.mjs
const message = "Hello, from Module A!";
export default message;

// moduleB.mjs
import messageA from "./moduleA";
console.log(messageA);

In the first example, the .js file contains regular JavaScript code that can be executed in any JavaScript environment.

The second example demonstrates the use of CommonJS modules. Each file is treated as a separate module, and the module.exports statement is used to expose functionality from one module to another. The require statement is used to import the exported functionality.

The third example showcases ECMAScript modules. The MJS extension is used to indicate that the JavaScript file adheres to the ECMAScript module format. The export statement is used to expose functionality, and the import statement is used to import the exported functionality from other modules.

Please note that the usage of CJS or MJS modules depends on the specific JavaScript runtime or environment being used.

ref