What is Meteor?

Meteor is an open-source, full-stack JavaScript framework that enables developers to build web and mobile applications in a seamless, unified environment. It is designed to handle both the client-side and server-side of an application in one unified stack, making development faster, easier, and more efficient.

Meteor uses Node.js on the backend, and it integrates tightly with MongoDB, although it is agnostic to databases, allowing you to use any backend database. One of the standout features of Meteor is its real-time capabilities. Meteor makes it easier to create applications where the user interface updates dynamically in response to changes in data, without requiring the user to manually refresh the page.

Meteor was initially created in 2011 and has been widely adopted for building modern, reactive, real-time web applications. It provides a simple, intuitive API and comes with everything you need to build apps, including:

• A real-time data synchronization layer
• A build tool for managing client-side assets
• Built-in security features
• An integrated front-end framework based on Blaze (though it also supports React, Angular, and Vue)
• Full-stack reactivity through its data layer

With Meteor, you can quickly build both web and mobile applications that are fast, responsive, and modern.

What Are the Major Use Cases of Meteor?

Meteor is particularly suited for a variety of application types, especially those that require real-time interactions and a smooth, reactive user experience. Below are the major use cases for Meteor:

1. Real-time Web Applications

Meteor is an excellent choice for building applications that require live, real-time updates without the need for manual page reloads or polling.

• Example: Collaborative apps, such as Google Docs, where multiple users can see changes in real-time.
• Chat applications: Meteor’s real-time data synchronization capabilities make it a great fit for building chat applications where messages are delivered instantly.

2. Single-Page Applications (SPAs)

Single-Page Applications (SPAs) are highly dynamic web applications that load a single HTML page and update the user interface dynamically as the user interacts with the app. Meteor makes it simple to create SPAs thanks to its integrated front-end and real-time data updates.

• Example: Dashboard applications where the user sees real-time data updates and interacts with various components of the app without refreshing the page.

3. Mobile Applications (React Native)

Meteor can be used to build mobile applications in addition to web apps. It integrates well with React Native, a popular framework for building cross-platform mobile applications. The real-time capabilities of Meteor can be leveraged for mobile apps that need to sync data across multiple devices.

• Example: Mobile chat apps or apps that require live updates, such as social media apps or notification-based apps.

4. E-commerce Platforms

Meteor is well-suited for building e-commerce platforms that require dynamic updates such as product availability, user reviews, and live inventory management. The real-time data syncing feature allows for seamless interactions.

• Example: A real-time inventory tracking system for e-commerce stores where products update immediately as they are added or removed.

5. Social Media Platforms

Social media platforms benefit from Meteor’s real-time updates and its ability to handle frequent data changes efficiently.

• Example: Newsfeeds that display posts, comments, likes, and notifications in real time as users interact with the system.

How Meteor Works Along with Architecture?

Meteor’s architecture is designed to provide full-stack reactivity, meaning that changes to data are automatically reflected in the user interface without requiring any manual intervention. Here’s an overview of how Meteor works:

1. Client-Side

The client-side of a Meteor application is responsible for rendering the user interface and handling user interactions. Meteor uses a blaze template engine by default, but you can also use other popular front-end libraries like React, Vue, or Angular.

Meteor provides two-way data binding between the client and the server, which means the data in the client automatically updates when the server updates, and vice versa.

• UI updates: When the data model on the client changes (due to user actions or server-side updates), the UI automatically re-renders to reflect the changes.

2. Server-Side

Meteor uses Node.js on the server side. The server is responsible for interacting with the database (typically MongoDB) and handling HTTP requests. Meteor simplifies server-side development by providing a real-time data sync mechanism that automatically sends updates to the client as soon as the data on the server changes.

• Data publication: The server exposes data through publications, and the client subscribes to these publications to receive updates.
• Data subscription: The client subscribes to a publication to get a stream of data. Whenever the data changes on the server, the updates are automatically sent to the client without requiring the client to manually request the data.

3. Database Layer

Meteor uses MongoDB as the default database, but it can be configured to work with any database (SQL, NoSQL) by using packages. The database is tightly coupled with Meteor’s reactive data system. When data is modified, the changes are automatically reflected on the client-side UI in real-time.

• MongoDB Integration: Meteor uses a MongoDB-like API for managing the database schema on the client and server. The client-side stores a local copy of the data and synchronizes changes to the server as needed.

4. Data Synchronization and Reactivity

One of the key features of Meteor is its real-time data synchronization. As soon as data changes on the server, the client is notified, and the UI is updated in real-time. This allows Meteor to build highly reactive and dynamic applications.

• Pub/Sub (Publish-Subscribe Model): The publish-subscribe model allows the server to send only the data that the client has subscribed to, ensuring efficient data transmission and minimizing unnecessary data transfers.

5. DDP (Distributed Data Protocol)

Meteor uses DDP to communicate between the client and server. DDP is a protocol that allows the client to subscribe to specific pieces of data on the server and receive updates when that data changes. This protocol helps Meteor provide real-time reactivity by synchronizing data changes automatically.

What Are the Basic Workflow of Meteor?

The basic workflow in a Meteor application typically involves the following steps:

1. Defining the Data Model:
   • Use collections (similar to tables in a database) to define the data model. Collections hold the data that is used by the app and can be accessed or modified by both the client and server.
2. Creating Publications on the Server:
   • On the server side, define publications that expose certain data to the client. A publication might send data from a MongoDB collection or any other data source.
3. Subscribing to Data on the Client:
   • On the client side, use subscriptions to request data from the server. Once the subscription is established, any changes to the data are automatically pushed to the client.
4. Real-Time Data Synchronization:
   • Meteor’s real-time data synchronization ensures that changes in the data (on the server) are immediately reflected in the UI (on the client) without the need for the user to refresh the page.
5. Updating the UI:
   • When the data model changes, Meteor automatically triggers a UI update through its reactivity system. The UI reacts to changes in the underlying data and re-renders accordingly.
6. Handling User Input:
   • The client side can capture user input (e.g., button clicks, form submissions) and update the server-side data accordingly. Meteor’s full-stack reactivity ensures that the updates are synchronized and reflected in real-time.

Step-by-Step Getting Started Guide for Meteor

Here’s a step-by-step guide for getting started with Meteor:

Step 1: Install Meteor

Start by installing Meteor on your machine. Meteor can be installed via a simple command in the terminal:

curl https://install.meteor.com/ | sh

Step 2: Create a New Meteor Project

Once Meteor is installed, you can create a new Meteor project using the following command:

meteor create myapp

This creates a new directory (myapp) with the basic structure of a Meteor app.

Step 3: Run Your Application

Navigate into the newly created app directory and run the application:

cd myapp
meteor

Your app should now be running on http://localhost:3000.

Step 4: Define Collections

Meteor uses collections to store data. You can define a collection on both the client and server.

// In a file named collections.js
import { Mongo } from 'meteor/mongo';

export const Tasks = new Mongo.Collection('tasks');

Step 5: Define Publications and Subscriptions

On the server, create a publication that sends data to the client. On the client, subscribe to this data.

// On the server (in server/main.js)
import { Meteor } from 'meteor/meteor';
import { Tasks } from '/imports/collections';

Meteor.publish('tasks', function() {
  return Tasks.find();
});

// On the client (in client/main.js)
import { Meteor } from 'meteor/meteor';
import { Tasks } from '/imports/collections';

Meteor.subscribe('tasks');

Step 6: Display Data in the UI

Use templates to display data from collections. For example:

<!-- In the HTML file (client/main.html) -->
<template name="taskList">
  <ul>
    {{#each tasks}}
      <li>{{name}}</li>
    {{/each}}
  </ul>
</template>

Step 7: Modify Data on the Server

To add or modify data, you can use Meteor’s simple API to interact with collections.

// On the server
Meteor.methods({
  'tasks.insert'(name) {
    Tasks.insert({ name });
  },
});

The post Mastering Meteor: Use Cases, Architecture, Workflow, and Getting Started appeared first on scmGalaxy.

What is Mongoose?

Mongoose is an elegant, robust Object Data Modeling (ODM) library for MongoDB and Node.js. It provides developers with powerful tools to interact with MongoDB using object-oriented paradigms and schema-based data modeling. While MongoDB natively stores data in a schema-less, JSON-like format (BSON), Mongoose allows you to impose schemas on your data models, enforce validations, and build complex queries effortlessly.

Mongoose enhances developer productivity and data reliability through:

• Schema validation and enforcement
• Built-in data type casting
• Middleware support (pre/post hooks)
• Plugin ecosystem
• Built-in query building and population

Whether you’re building RESTful APIs, real-time applications, or complex enterprise systems, Mongoose bridges the flexibility of NoSQL with the discipline of structured programming.

Major Use Cases of Mongoose

Mongoose is incredibly versatile and is commonly used in the following development scenarios:

1. Structured Backend for Node.js Applications

In applications where data structure consistency is essential (e.g., e-commerce platforms, content management systems), Mongoose ensures schema enforcement on MongoDB documents.

2. CRUD API Development

Mongoose pairs seamlessly with Express.js to handle Create, Read, Update, and Delete operations. Its syntax simplifies working with MongoDB queries in a readable, chainable format.

3. Form Validation

User input from forms can be validated using Mongoose’s schema-level validations, such as:

• Required fields
• Min/max value limits
• Regex pattern matching
• Custom validation functions

4. Modeling Relationships

Although MongoDB is document-oriented and not relational, Mongoose allows you to reference documents across collections using ObjectId and the populate() method, enabling SQL-like data joins.

5. Plugins and Middleware

Use or create plugins like pagination, timestamps, soft delete, etc. Middleware (hooks) like pre('save') or post('find') make it easy to inject custom logic at lifecycle events.

6. Rapid Prototyping

For startups and hackathons, Mongoose’s ease of use and flexibility make it a top choice for quickly building and iterating full-stack applications with MongoDB.

How Mongoose Works (with Architecture)

At a high level, Mongoose sits between the Node.js server application and the MongoDB database, offering a structured interface to interact with otherwise schemaless data.

Architecture and Flow:

1. MongoDB Connection Layer

Mongoose establishes a connection to a MongoDB database using a connection URI. The connection is managed via mongoose.connect().

2. Schema Definition Layer

A schema defines the structure and rules of documents in a collection:

• Field types (String, Number, Date, etc.)
• Constraints (required, unique)
• Defaults
• Getters/setters
• Custom validators

3. Model Layer

Schemas are compiled into models, which act as constructors and query interfaces for MongoDB collections. They expose methods like .find(), .save(), .updateOne(), etc.

4. Middleware and Hooks

Developers can register middleware to run logic before or after operations:

• Pre-save: Hash passwords before saving
• Post-remove: Cleanup references or logs
• Pre-find: Auto-populate fields

5. Plugins and Ecosystem

Mongoose has a rich plugin ecosystem allowing reuse of functionality like:

• Auto-timestamps
• Authentication (e.g., via passport-local-mongoose)
• Slug generation
• Virtual fields

Basic Workflow of Mongoose

Here is the typical workflow for using Mongoose in a Node.js project:

1. Connect to the Database

Establish a connection to MongoDB using Mongoose.

2. Define a Schema

Create a schema that outlines your data structure and includes validations and defaults.

3. Create a Model

Compile the schema into a model using mongoose.model().

4. Use the Model to Interact with Data

Leverage methods like .create(), .find(), .findById(), .updateOne(), and .deleteOne() to manipulate data.

5. Handle Middleware

Add hooks for additional logic at specific stages of data processing.

6. Scale with Plugins

Add reusable plugins for features like pagination, auditing, and authorization.

Step-by-Step Getting Started Guide for Mongoose

Here’s a comprehensive walkthrough to help you start using Mongoose with MongoDB and Node.js:

Step 1: Install Node.js and MongoDB

Ensure you have Node.js and MongoDB installed on your system. You can use MongoDB locally or connect to a cloud instance (like MongoDB Atlas).

Step 2: Initialize a Node.js Project

mkdir mongoose-demo && cd mongoose-demo
npm init -y
npm install mongoose express

Step 3: Connect Mongoose to MongoDB

// db.js
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mongoose_demo', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
}).then(() => {
  console.log("MongoDB Connected");
}).catch(err => console.error(err));

Step 4: Define a Schema and Model

// models/User.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, min: 0 },
}, { timestamps: true });

module.exports = mongoose.model('User', userSchema);

Step 5: Perform CRUD Operations

// app.js
const express = require('express');
const mongoose = require('./db');
const User = require('./models/User');
const app = express();

app.use(express.json());

// Create
app.post('/users', async (req, res) => {
  try {
    const user = await User.create(req.body);
    res.json(user);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// Read
app.get('/users', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

// Update
app.put('/users/:id', async (req, res) => {
  const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
  res.json(user);
});

// Delete
app.delete('/users/:id', async (req, res) => {
  await User.findByIdAndDelete(req.params.id);
  res.json({ message: 'User deleted' });
});

app.listen(3000, () => console.log('Server running on port 3000'));

Step 6: Add Middleware Example (Hash Password)

const bcrypt = require('bcrypt');

userSchema.pre('save', async function (next) {
  if (this.isModified('password')) {
    this.password = await bcrypt.hash(this.password, 10);
  }
  next();
});

Step 7: Try It Out

Run your server:

node app.js

Test with a tool like Postman or cURL:

• POST /users → Create a user
• GET /users → Get all users
• PUT /users/:id → Update user
• DELETE /users/:id → Delete user

The post Mastering Mongoose: A Developer’s Guide to MongoDB Modeling appeared first on scmGalaxy.

What is Express.js?

Express.js, commonly referred to as Express, is a fast, unopinionated, and minimalist web framework for Node.js. It simplifies the process of building web applications and APIs by providing a robust set of features, such as routing, middleware support, template rendering, and much more. Express is one of the most popular and widely used frameworks in the Node.js ecosystem because it enhances the core capabilities of Node.js by making the web application development process more efficient and organized.

Express.js works on top of Node.js, utilizing the non-blocking, event-driven nature of Node.js for handling asynchronous requests. By offering a minimalistic yet highly extensible structure, Express allows developers to create scalable and high-performance web applications. Express is particularly well-suited for building APIs, handling HTTP requests and responses, and managing the back-end of web applications.

Some key features of Express.js include:

• Routing: It provides an elegant and powerful way to define routes for handling different HTTP requests (GET, POST, PUT, DELETE).
• Middleware: Express allows you to add custom functions to handle requests before the route handler is called, allowing for things like authentication, logging, and error handling.
• Templating: Express supports various templating engines (like Pug, EJS, and Handlebars) for rendering dynamic content.
• Static Files: It can serve static files, such as images, CSS, and JavaScript, directly from the server.
• Extensibility: Express is lightweight, and developers can extend its functionality using middleware or plugins to fit their needs.

Express.js is an essential tool for developers working with Node.js, especially for building RESTful APIs, single-page applications, and server-side rendered websites.

What are the Major Use Cases of Express.js?

Express.js is a versatile framework used in various web application and API development scenarios. Some of the major use cases include:

1. Building RESTful APIs:
   Express.js is widely used for developing RESTful APIs. Its straightforward routing system and support for JSON responses make it ideal for handling API requests and interacting with databases. You can use Express to easily create endpoints for CRUD operations (Create, Read, Update, Delete).
2. Web Application Development:
   Express is perfect for building traditional web applications that need a backend to serve HTML, CSS, and JavaScript files. The framework also supports templating engines, which allows dynamic content to be rendered on the server and sent to the client.
3. Single Page Applications (SPA):
   Express.js can be used to serve data and handle requests for single-page applications. By integrating Express with front-end frameworks like React, Vue, or Angular, you can create dynamic user interfaces with API-driven backends.
4. Middleware for Handling Requests:
   Express excels in handling middleware, which are functions that process requests before they reach the route handlers. Middleware functions can handle tasks such as logging, authentication, request validation, and error handling. This makes Express particularly useful in creating modular and scalable server-side architectures.
5. Real-Time Web Applications:
   Express can be used in conjunction with WebSocket libraries (like Socket.io) to develop real-time applications like chat apps, notification systems, or live data dashboards, allowing clients and servers to communicate instantly.
6. Server-Side Rendering (SSR):
   Express.js is frequently used for server-side rendering (SSR) applications. By utilizing templating engines such as Pug or EJS, developers can render HTML on the server before sending it to the browser, improving SEO and reducing initial load time.
7. Microservices:
   Express is lightweight and modular, making it an excellent choice for building microservices. Developers can create individual microservices, each responsible for specific functionality, and then use Express to build APIs to facilitate communication between them.

How Express.js Works Along with Architecture?

Express.js follows the typical architecture of a web application built with Node.js but adds an additional layer of routing and middleware functionality to simplify the development process.

Basic Architecture of Express.js

1. Request Handling: Express handles HTTP requests by defining routes and associating them with specific HTTP methods (GET, POST, PUT, DELETE). When a request is made to the server, Express will evaluate the incoming request and match it to the appropriate route.
2. Routing: The routing system in Express is at the heart of its architecture. Routes are defined to handle specific HTTP requests, and each route can be linked to one or more middleware functions. Routes define the logic that processes the request and sends back the response to the client.
3. Middleware: Middleware functions are a central component of Express applications. They sit between the request and the response, allowing you to add functionality to requests before they reach the route handler. Middleware can handle authentication, logging, input validation, or simply pass control to the next middleware or route handler. Middleware functions can be global or route-specific.
4. Server and Listener: Express creates an HTTP server that listens for incoming requests on a specified port. The server is created using the express() function, and the listener is started using the app.listen() method.
5. Request-Response Cycle: The cycle begins when a client sends an HTTP request to the server. The server processes the request, executes the relevant route handler, and responds to the client with data (usually in JSON format) or HTML.
6. Template Rendering: If the application uses server-side rendering (SSR), Express uses templating engines to render HTML on the server. The engine compiles dynamic data into an HTML template, which is then sent to the client.
7. Static File Serving: Express can serve static assets like images, stylesheets, and JavaScript files directly using the express.static() middleware, improving performance by offloading static content from the application logic.

What are the Basic Workflows of Express.js?

The workflow in an Express.js application typically follows these steps:

1. Initialization:
   • First, you initialize an Express application by importing the express module and creating an app instance.
   • You then configure any middleware (for handling requests) and routes (for handling specific HTTP requests).
2. Routing and Middleware Handling:
   • When a request is made to the server, Express evaluates the URL and HTTP method, matching the request to the appropriate route.
   • Middleware functions are executed before the route handler, allowing for pre-processing tasks (e.g., authentication, logging, or data validation).
   • Once the middleware completes its work, the request reaches the relevant route handler.
3. Request Processing:
   • In the route handler, the application processes the request (e.g., querying a database, applying business logic, or rendering a page) and sends back a response.
   • If the route is designed to handle an API request, the response might include JSON data.
4. Response:
   • The server sends the response back to the client. This could include rendered HTML pages, JSON data, or status messages.
   • Express also supports sending status codes, headers, and other information as part of the response.
5. Error Handling:
   • If an error occurs, Express provides a centralized way to handle errors using middleware. This ensures that your application can gracefully handle failures and provide useful feedback to the client.

Step-by-Step Getting Started Guide for Express.js

1. Install Node.js:
   • Before you can use Express.js, you need to install Node.js on your machine. You can download and install it from nodejs.org.
2. Set Up a New Project:
   • Create a new directory for your project and navigate to it in your terminal.
   • Initialize a new Node.js project by running the command: npm init -y
3. Install Express.js:
   • Use npm (Node Package Manager) to install Express.js: npm install express
4. Create Your First Express Application:
   • In your project directory, create a new file named app.js and write the following code: const express = require('express'); const app = express(); const port = 3000; // Basic route app.get('/', (req, res) => { res.send('Hello World!'); }); app.listen(port, () => { console.log(`App is listening at http://localhost:${port}`); });
5. Run Your Application:
   • Start your application by running the following command in the terminal: node app.js
6. Test the Application:
   • Open a web browser and navigate to http://localhost:3000. You should see “Hello World!” displayed in your browser.
7. Expand the Application:
   • You can add more routes, middleware, and even integrate a database like MongoDB or MySQL to expand the functionality of your application.

The post Getting Started with Express.js: The Fast and Minimalist Web Framework appeared first on scmGalaxy.

• Data
• Length

Methods

• appendData(String)
• deleteData(start, length)
• insertData(start, string)
• replaceData(start, length, string)
• splitText(start)
• substringData(start, length)

Length

Length property is used to access the length of Text which indicates the number of characters it contains.

Syntax:- TextNode.length

Data

Data property is used to set or return the value of a text node and comment node objects.

Syntax: –
Sets
TextNode.data = value
Returns
TextNode.data

Ex:- TextNode.data = “Hello DevOpsSchool”;

appendData(String)

This method is used to append the passed string to the end of the text node and comment node.

Syntax: –
TextNode.appendData(String);

Ex: –
TextNode.appendData(“Hello DevOpsSchool”);

deleteData(start, length)

This method is used to delete or remove text content from a text node and comment node. It deletes the specified length of characters starting from index defined in start.

Syntax:-
TextNode.deleteData(start, length);

Ex: –
TextNode.deleteData(0, 5);

insertData(start, string)

This method is used to insert text content to text node and comment node. It inserts the value in string, starting at the character index specified in start.

Syntax:-
TextNode.insertData(start, string)

Ex: –
TextNode.insertData(3, “Hello”)

replaceData(start, length, string)

This method is used to replace text content of text node and comment node. It inserts the value in string, starting at the character index specified in start.

Syntax:-
TextNode.replaceData(start, length, string)

Ex: –
TextNode.replaceData(0, 4, “Hello”)

splitText(start)

The splitText(start) method breaks the Text node into two nodes at the specified start index, keeping both nodes in the tree as siblings. It returns right side of the split in a new text node and leaves the left side in the original.

Syntax: –
var rightSide = TextNode.splitText(start)

Ex: –
var rightSide = TextNode.splitText(5)

substringData(start, length)

It returns the part of the current element’s (TextNode and CommentNode) text content from the specified position with the specified length.

Syntax:-
TextNode.substringData(start, length)

Ex: –
TextNode.substringData(2, 5);

The post Modifying Text Nodes in JavaScript appeared first on scmGalaxy.

Error:-

Many of you get this error when you did not change anything in app.scss, but when I run npm run watch I get the following errors:

 error  in ./resources/sass/app.scss                                                                      

Module build failed (from ./node_modules/sass-loader/lib/loader.js):                                      
Unsupported operation: Cannot extract a file path from a URI with a fragment component                    

@ ./resources/sass/app.scss 2:14-254                                                                     

    Asset      Size   Chunks             Chunk Names                                                     
/js/app.js  2.46 MiB  /js/app  [emitted]  /js/app                                                         

ERROR in ./resources/sass/app.scss                                                                        
Module build failed (from ./node_modules/css-loader/index.js):                                            
ModuleBuildError: Module build failed (from ./node_modules/sass-loader/lib/loader.js):                    

undefined                                                                                                 
      ^                                                                                                  
      Join(null, "variables"): part 0 was null, but part 1 was not.                                       
@import 'variables';                                                                                      
        ^^^^^^^^^^^                                                                                       
  stdin 2:9  root stylesheet                                                                              
      in C:\Users\TAQI VAHEED\Desktop\#Coding\resPro\resources\sass\app.scss (line 2, column 9)           
    at runLoaders (C:\Users\TAQI VAHEED\Desktop\#Coding\resPro\node_modules\webpack\lib\NormalModule.js:30
    at C:\Users\TAQI VAHEED\Desktop\#Coding\resPro\node_modules\loader-runner\lib\LoaderRunner.js:364:11  
    at C:\Users\TAQI VAHEED\Desktop\#Coding\resPro\node_modules\loader-runner\lib\LoaderRunner.js:230:18  
    at context.callback (C:\Users\TAQI VAHEED\Desktop\#Coding\resPro\node_modules\loader-runner\lib\Loader
13)

Solution:-

The main issue which we have found that is related to dart-sass being used instead of node-sass with laravel

You have to just follow one step:-

Step 1:- You have to run this Command and all the things will solve .

npm install node-sass

The post error in ./resources/assets/sass/app.scss appeared first on scmGalaxy.

You need to make cross-env working globally instead of having it in the project.

Step 1:- remove node_modules folder

Step 2:-  run this Command so that you cross-env work globally.

npm install --global cross-env

Step 3:- Remove “cross-env”: “5.0.1” from the devDependencies section of the package.json file. You may actually skip this step and keep package.json. If you’d want.

Step 4:- Then run this command.

npm install --no-bin-links

Step 5:- After this finally you can run your main command

npm run dev

The post ‘cross-env’ is not recognized as an internal or external command, operable program or batch file. appeared first on scmGalaxy.

Node.js untangles concurrency by replacing the Java platform’s standard, multithreaded approach with single-threaded, event-driven I/O.

Node.js (Node) is an I/O environment built on top of Google Chrome’s JavaScript runtime — essentially, a server-side implementation of JavaScript. Node’s asynchronous, event-driven I/O model makes it easy for developers with JavaScript knowledge to build high-performing, scalable, and highly concurrent web applications rapidly and run them in the cloud.

The post Know about nodejs? appeared first on scmGalaxy.