DEV Community: kamesh

Nodemon is not for production!

kamesh — Fri, 14 Jun 2024 12:32:42 +0000

What is Nodemon?

Nodemon is a utility that automatically restarts your Node.js application when file changes in the directory are detected. It is very useful during development because it allows developers to see the effects of their changes immediately without having to manually stop and restart the server.

Why Not Use Nodemon in Production?

Performance Overhead: Nodemon constantly watches files for changes, which can consume additional system resources. In a production environment, minimizing resource usage is crucial for optimal performance.

Unnecessary Restarts: In production, the application code is not supposed to change frequently. Automatically restarting the server can lead to unnecessary downtime and disruptions.

Security Risks: Allowing automatic restarts based on file changes can be risky. For example, if an unauthorized person gains access and makes changes to files, Nodemon will restart the application with those potentially malicious changes.

Lack of Control: Automated restarts can lead to unintended consequences, such as temporary service outages or state inconsistencies. In production, it is important to have controlled and predictable deployments.

Best Practices for Production

Use a Process Manager: Tools like PM2 or Forever are better suited for production environments. They can handle process monitoring, restarts, load balancing, and other management tasks.

Manual Deployments: Adopt a deployment process that includes manual checks, testing, and controlled rollouts. Automation tools like CI/CD pipelines can help streamline this process.

Monitoring and Alerts: Implement robust monitoring and alerting systems to detect issues and trigger manual interventions when necessary.

let vs var vs Const

kamesh — Sun, 02 Jun 2024 04:23:32 +0000

Let’s dive into the differences between var, let, and const in JavaScript. These three keywords are used for variable declaration, but they behave differently. Here’s a breakdown:

var:

Scope: Variables declared with var are either globally scoped or function/locally scoped.
Globally scoped: If a var variable is declared outside a function, it’s available for use throughout the entire window.
Function scoped: If declared within a function, it’s accessible only within that function.
Hoisting: var variables are hoisted to the top of their scope and initialized with a value of undefined.
Re-declaration and Updates: You can re-declare and update var variables within the same scope without errors.



var greeter = "hey hi";
var times = 4;
if (times > 3) {
    var greeter = "say Hello instead";
}
// greeter is now "say Hello instead"

let:

Scope: Variables declared with let have block-level scope. They’re limited to the block they’re declared in (e.g., within loops or conditionals).
Hoisting: Like var, let variables are hoisted but not initialized until the actual declaration.
Reassignment: You can reassign let variables, making them useful when you need to change a value over time.



let greeting = "hello";
if (true) {
    let greeting = "hi"; // Different scope
}
// greeting is still "hello"

const:

Scope: Like let, const also has block-level scope.
Reassignment: Variables declared with const cannot be reassigned after their initial assignment.
Use Case: Use const for values that should remain constant (e.g., mathematical constants, configuration settings).



const pi = 3.14;
// pi cannot be reassigned

Advantage: It improves code readability by clearly indicating immutability.

In summary:

Use let when you need to reassign variables within a block.
Use const for constants that shouldn’t change.
Minimize the use of var due to its function scope and potential issues

Hate the fact that semicolon is called colon😒 and vice versa.

kamesh — Sun, 07 Apr 2024 05:27:26 +0000

Hate the fact that semicolon is called colon and vice versa.