PERIODICAL 1

Part A: (5x2=10)

1. Define Framework:
o A framework is a pre-built collection of libraries, tools, and components that provide structure for
building applications. It helps developers by providing a standard way to build and deploy
software applications, abstracting low-level tasks and allowing faster development.
2. What are the Components of Framework?
o The main components of a framework typically include:
 Libraries: Pre-written code that provides general functionality.
 API: Interfaces that allow the framework to interact with other software.
 Tools: Utilities that make development easier (e.g., debuggers, build tools).
 Architecture: A structured set of design principles for organizing code.
 Configuration Files: Files that specify how the framework should be set up and run.
3. Difference Between GET & POST Request:
o GET Request:
 Data is sent via the URL.
 Limited data size.
 Not secure (data is visible in the URL).
 Typically used for retrieving data.
o POST Request:
 Data is sent in the request body.
 No data size limitation.
 More secure than GET (data is not exposed in the URL).
 Typically used for submitting forms or updating data.
4. Difference Between Apache & IIS Web Server:
o Apache:
 Open-source and free.
 Cross-platform (works on Linux, Windows, etc.).
 Highly customizable with modules.
 Supports many programming languages, such as PHP.
o IIS (Internet Information Services):
 A proprietary web server by Microsoft.
 Primarily runs on Windows OS.
 Supports ASP.NET and other Microsoft technologies.
 Provides a GUI for management (compared to Apache’s command-line interface).
5. Define AJAX:
o AJAX (Asynchronous JavaScript and XML) is a web development technique that allows for
asynchronous communication between the client and server without refreshing the entire webpage.
It enables web pages to update dynamically by exchanging small amounts of data with the server
behind the scenes.
o AJAX typically uses JavaScript, XML/JSON, and XMLHttpRequest to fetch and display data
dynamically.

Part B: (5x8=40)

1. Explain Web Development Framework with Suitable Block Diagram: A web development
framework is a collection of tools and libraries that help developers create web applications. It provides
reusable components for common tasks (e.g., database interactions, authentication, routing, etc.) and
defines the structure of the web application.
o Model Layer: Handles data logic, such as database operations.
o View Layer: Represents the user interface and how the data is presented.
 o Controller Layer: Manages the user input, processes it, and interacts with the model.
2. Explain the Components of Web Development Framework in Detail: A typical web development
framework consists of the following components:
o Routing: Directs HTTP requests to the appropriate controller based on the URL.
o Controller: Contains business logic that processes user requests, manipulates data, and updates
views.
o Model: Handles data, interactions with the database, and defines the application's core entities.
o View: Represents the UI and the data presentation to the user.
o Middleware: Functions that handle the request before reaching the controller, like authentication
or logging.
o Template Engine: Used to dynamically generate HTML from data, often in MVC frameworks.
3. Explain MVC Architecture with a Suitable Example:MVC (Model-View-Controller) is a software
design pattern that separates an application into three interconnected components:
o Model: Represents the data and the business logic of the application.
o View: Displays the data to the user in a structured format (UI).
o Controller: Acts as an intermediary between the Model and the View, processing user input and
updating the View accordingly.

Example: Consider a blog application where users can create posts.

o Model: The Post class represents the blog post data and interacts with the database to save or
retrieve posts.

java
Copy code
public class Post {
privateint id;
private String title;
private String content;
}
o View: An HTML page that displays the blog posts to the user.

html
Copy code
<html>
<body>
<h1>Blog Posts</h1>
<div id="posts"></div>
</body>
</html>
o Controller: The PostController manages user requests and fetches the appropriate data from
the model, then passes it to the view.

java
Copy code
public class PostController {
public void showPosts() {
List<Post> posts = PostService.getAllPosts();
request.setAttribute("posts", posts); // Pass data to the view
view("posts.jsp"); // Render the view
}
}
4. Enlist the Features of MVC Framework:
 o Separation of Concerns: Divides the application into three parts: Model (data), View (UI), and
Controller (logic).
o Maintainability: Easier to update and manage code due to separation of concerns.
o Reusability: Model and Controller can be reused across different views.
o Testability: Easier to write unit tests for each component.
o Flexibility: Changes in one part (e.g., the UI) do not affect other parts (e.g., the business logic).
o Scalability: Supports large applications by modularizing different concerns.
5. Explain in Detail About the Understanding of Different Stacks:Technology Stacks are collections of
technologies used together to build a web application. Common technology stacks include:
o LAMP Stack:
 Linux (Operating System)
 Apache (Web Server)
 MySQL (Database)
 PHP (Programming Language)
 Usage: LAMP is widely used for dynamic websites and web applications.
o MEAN Stack:
 MongoDB (Database)
 Express.js (Backend Framework)
 Angular (Frontend Framework)
 Node.js (JavaScript Runtime)
 Usage: MEAN stack is used for building single-page applications (SPAs) and scalable
web applications using JavaScript.
o MERN Stack:
 MongoDB (Database)
 Express.js (Backend Framework)
 React.js (Frontend Library)
 Node.js (JavaScript Runtime)
 Usage: Similar to MEAN, but uses React for building dynamic user interfaces.
o Django Stack:
 Django (Backend Framework, Python-based)
 PostgreSQL (Database)
 Nginx (Web Server)
 Usage: Ideal for rapid development with Python and focuses on security and scalability.
o Ruby on Rails Stack:
 Ruby on Rails (Web Framework, Ruby-based)
 PostgreSQL/MySQL (Database)
 Usage: A high-level framework that allows rapid application development in Ruby.

Choosing a Stack depends on the type of project (e.g., speed, scalability, developer preference, etc.).
PERIODICAL 2

Part A: (5x2=10)

1. What is Node.js?
o Node.js is a runtime environment that allows you to run JavaScript code on the server-side. It is
built on the V8 JavaScript engine and is designed for building scalable network applications. It is
event-driven, non-blocking, and uses an asynchronous I/O model.
2. What is NPM?
o NPM (Node Package Manager) is a package manager for Node.js. It is used to install and
manage dependencies (libraries and tools) for Node.js applications. NPM also includes a
command-line tool to interact with the NPM registry, where packages are stored.
3. What is Querystring?
o The querystring module in Node.js is used to parse and format URL query strings. It can be used
to extract data from query parameters in a URL and can also convert an object into a query string.
o Example:

javascript
Copy code
constquerystring = require('querystring');
const parsed = querystring.parse('name=John&age=30');
console.log(parsed); // { name: 'John', age: '30' }
4. What is an EventEmitter?
o EventEmitter is a core Node.js class that allows an object to emit events and listen for those
events. It facilitates the event-driven architecture in Node.js. It is used for handling events and
responding to them asynchronously.
o Example:

javascript
Copy code
constEventEmitter = require('events');
constmyEmitter = new EventEmitter();

myEmitter.on('event', () => {
console.log('An event occurred!');
});

myEmitter.emit('event'); // Output: An event occurred!

5. What is Pipe Operation in Node.js?
o The pipe() operation in Node.js allows the output of one stream to be passed as input to another
stream. It is commonly used in file I/O operations to transfer data between readable and writable
streams.
o Example:

javascript
Copy code
constfs = require('fs');
constreadStream = fs.createReadStream('source.txt');
constwriteStream = fs.createWriteStream('destination.txt');
 readStream.pipe(writeStream); // Piping data from source.txt to
destination.txt

Part B: (5x8=40)

1. What is Node Package Manager? Also Explain the Command Line Options of NPM.
o Node Package Manager (NPM) is a tool for managing JavaScript packages (modules) that are
used in Node.js applications. It allows you to install, update, and uninstall packages, and also
manages project dependencies through the package.json file.

Common NPM Command Line Options:

o npminit: Initializes a new Node.js project and creates a package.json file.

o npm install <package>: Installs a package.
 Example: npm install express
o npm install <package> --save: Installs a package and adds it as a dependency in
package.json.
o npm install <package> --global: Installs a package globally.
o npm uninstall <package>: Removes a package.
o npm update: Updates all the installed packages.
o npm list: Displays all the installed packages.
o npm start: Starts a Node.js application using the script defined in package.json.
2. How Event Listener is Handled in Node.js? Explain with a Suitable Example.
o In Node.js, event listeners are used to listen for and handle events emitted by objects, such as
EventEmitter. An event listener can be added using the .on() method, and it gets triggered
when the event is emitted using .emit().

Example:

javascript
Copy code
constEventEmitter = require('events');
constmyEmitter = new EventEmitter();

// Add an event listener

myEmitter.on('greet', (name) => {
console.log(`Hello, ${name}!`);
});

// Emit an event
myEmitter.emit('greet', 'John'); // Output: Hello, John!
In this example:

o The greet event is emitted with the name "John".

o The listener function is executed, logging "Hello, John!" to the console.
3. What is an Event? Explain the Concept of Event Loop with a Suitable Diagram.
o Event: An event in Node.js refers to a signal or notification emitted when something happens,
such as a user action or an I/O operation completing. Node.js uses the EventEmitter class to
manage and handle events.

Event Loop: Node.js operates in a non-blocking, asynchronous manner using an event loop. The event
loop continually checks if there are events to be processed, such as I/O operations, and executes the
 corresponding callbacks. It allows Node.js to handle multiple requests simultaneously without blocking the
execution of the application.

o Process: The event loop goes through the various phases such as timers, I/O handling, and
callbacks until there are no more events to process.
4. Explain Timers and Its Types.
o Timers in Node.js allow you to schedule functions to run after a certain period or repeatedly.
They are used for deferred execution.

Types of Timers:

o setTimeout(): Executes a function once after a specified delay (in milliseconds).

javascript
Copy code
setTimeout(() => {
console.log('Executed after 2 seconds');
}, 2000);
o setInterval(): Executes a function repeatedly at a specified interval (in milliseconds).

javascript
Copy code
setInterval(() => {
console.log('Executed every 2 seconds');
}, 2000);
o clearTimeout(): Stops a setTimeout() before it executes.

javascript
Copy code
let timeout = setTimeout(() => {
console.log('This will not be logged');
}, 2000);

clearTimeout(timeout); // Cancels the timeout

o clearInterval(): Stops a setInterval() from repeating.

javascript
Copy code
let interval = setInterval(() => {
console.log('This will not be logged');
}, 2000);

clearInterval(interval); // Cancels the interval

5. Handling Data I/O (Any 2):
o i) Buffers: A Buffer is a temporary storage area in memory for binary data. In Node.js, buffers are
used to handle raw binary data (e.g., file I/O). Buffers are especially useful when working with
streams or binary file formats.

Example:

javascript
Copy code
const buffer = Buffer.from('Hello World');
console.log(buffer.toString()); // Output: Hello World
o ii) Streams: Streams are objects that allow you to read or write data in chunks, making them
suitable for handling large amounts of data (e.g., files). Streams in Node.js are classified into:
 Readable Streams (e.g., fs.createReadStream())
 Writable Streams (e.g., fs.createWriteStream())

Example (Readable Stream):

javascript
Copy code
constfs = require('fs');
constreadStream = fs.createReadStream('file.txt', 'utf8');
readStream.on('data', (chunk) => {
console.log(chunk);
});
o iii) File System (fs): The File System (fs) module allows interaction with the file system. It
provides methods for reading, writing, and manipulating files.

Example:

javascript
Copy code
constfs = require('fs');

// Reading a file
fs.readFile('example.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log(data); // Output the file content
});

// Writing to a file
fs.writeFile('output.txt', 'Hello, World!', (err) => {
if (err) throw err;
console.log('File has been saved!');
});
PERIODICAL 3

Part A: (5x2=10)

1. What is NoSQL?
o NoSQL (Not Only SQL) refers to a class of database management systems designed to handle
large amounts of unstructured or semi-structured data. Unlike traditional relational databases
(SQL), NoSQL databases do not use fixed schemas and tables. They are highly scalable and
flexible, making them suitable for big data and real-time web applications.
o Examples of NoSQL databases include MongoDB, Cassandra, and CouchDB.
2. How to Insert Multiple Documents in a MongoDB Database?
o In MongoDB, you can insert multiple documents into a collection using the insertMany()
method. This method allows you to insert an array of documents in a single operation.

Example:

javascript
Copy code
constMongoClient = require('mongodb').MongoClient;
consturl = 'mongodb://localhost:27017';
constdbName = 'mydatabase';

MongoClient.connect(url, { useUnifiedTopology: true }, (err, client) =>

{
if (err) throw err;
constdb = client.db(dbName);
const collection = db.collection('mycollection');

const documents = [
{ name: 'John', age: 30 },
{ name: 'Jane', age: 25 },
{ name: 'Doe', age: 35 }
];

collection.insertMany(documents, (err, res) => {

if (err) throw err;
console.log(`${res.insertedCount} documents inserted`);
client.close();
});
});
3. Enlist Any Four Data Types in MongoDB:MongoDB supports a variety of data types. Four common
ones are:
o String: Stores text.
o Integer: Stores numeric values.
o Boolean: Stores true or false values.
o Object: Stores documents within documents (similar to objects in JavaScript).
4. Enlist the Features of MongoDB: Some key features of MongoDB are:
 o Schema-less Data Model: Allows for flexible and dynamic schema design.
o Scalability: Horizontal scaling through sharding (distributing data across multiple machines).
o High Availability: Replica sets for automatic failover and data redundancy.
o Document-Oriented: Stores data in BSON (Binary JSON) format, which is easy to work with and
maps directly to objects in programming languages like JavaScript.
o Aggregation: Powerful aggregation framework for complex data processing.
5. What is MapReduce?
o MapReduce is a data processing technique used for performing parallel processing of large
datasets. In MongoDB, MapReduce allows you to process data and aggregate it across multiple
nodes.
o Map function: Processes input data and produces key-value pairs.
o Reduce function: Merges all values associated with a specific key to produce a result.

Part B: (4x10=40)

1. What are the Steps to Connect Node.js with MongoDB? To connect Node.js with MongoDB, you can
use the mongoose library or the native MongoDB Node.js driver. Here's how to do it:

Steps:

1. Install MongoDB driver or Mongoose:

bash
Copy code
npm install mongoose
2. Import and Set Up Mongoose:

javascript
Copy code
const mongoose = require('mongoose');
consturl = 'mongodb://localhost:27017/mydatabase';

mongoose.connect(url, { useNewUrlParser: true, useUnifiedTopology:

true })
.then(() => {
console.log('Connected to MongoDB');
})
.catch(err => {
console.log('Error connecting to MongoDB: ', err);
});
3. Define a Schema (optional but recommended):

javascript
Copy code
const schema = new mongoose.Schema({
name: String,
age: Number
});

const User = mongoose.model('User', schema);

4. Perform Operations (e.g., create, read, update, delete).
2. What is CRUD? Explain the CRUD Operation in Node.js.CRUD stands for Create, Read, Update,
and Delete. These are the basic operations used in most web applications to interact with databases.
In Node.js, you can perform these operations on MongoDB using Mongoose or the native MongoDB
driver.

CRUD Operations:

o Create: Insert a new document into a collection.

javascript
Copy code
const user = new User({ name: 'John', age: 30 });
user.save((err, user) => {
if (err) console.log(err);
console.log('User created:', user);
});
o Read: Find documents in a collection.

javascript
Copy code
User.find({ name: 'John' }, (err, users) => {
if (err) console.log(err);
console.log('Users found:', users);
});
o Update: Modify an existing document.

javascript
Copy code
User.updateOne({ name: 'John' }, { $set: { age: 35 } }, (err, res)
=> {
if (err) console.log(err);
console.log('User updated:', res);
});
o Delete: Remove a document from a collection.

javascript
Copy code
User.deleteOne({ name: 'John' }, (err) => {
if (err) console.log(err);
console.log('User deleted');
});
Explain How to Create User Account and Database Administrator Account in MongoDB. In
MongoDB, you can create users and assign roles (like database admin or read/write permissions) to those
users.

Steps to Create a User Account:

1. Start MongoDB Shell:

bash
Copy code
mongo
2. Switch to the Admin Database:

javascript
Copy code
 use admin
3. Create a New User:

javascript
Copy code
db.createUser({
user: 'myuser',
pwd: 'mypassword',
roles: [{ role: 'readWrite', db: 'mydatabase' }]
});
o This creates a user with readWrite permission on mydatabase.

Steps to Create a Database Administrator Account:

javascript
Copy code
db.createUser({
user: 'admin',
pwd: 'adminpassword',
roles: [{ role: 'dbAdmin', db: 'mydatabase' }]
});
o This creates a database administrator (dbAdmin) account for managing the database.
List and Explain the Features of Advanced MongoDB.Advanced Features of MongoDB:
o Sharding: Allows horizontal scaling by distributing data across multiple servers. It helps in
handling large-scale applications with massive amounts of data.
 Sharding involves breaking data into smaller chunks and distributing them across
different machines to balance the load.
o Replica Sets: A set of MongoDB instances that maintain the same data set. They provide high
availability and data redundancy. If one node goes down, another can take over.
o Aggregation Framework: MongoDB provides a powerful aggregation framework for querying
and transforming data. It supports operations like filtering, grouping, and sorting to process data in
a pipeline.
o Full-text Search: MongoDB offers built-in full-text search capabilities, allowing efficient
searching for documents based on text content. This is useful for applications with search
functionalities.
o Transactions: MongoDB supports multi-document ACID transactions, allowing you to execute
multiple operations as a single unit of work. This feature is useful when you need atomicity for
multiple documents or collections.
CYCLIC TEST

Define Framework.

 A framework is a pre-built collection of libraries, tools, and components that developers use to build
applications more efficiently. It provides a structured environment and set of conventions for developing
software, promoting reusability and reducing redundancy. Examples include Django (Python), Angular
(JavaScript), and Spring (Java).

What are the Roles of Web Browser?

 A web browser serves as a client-side application that enables users to access and interact with websites.
Its key roles include:
o Sending requests to web servers.
o Rendering HTML, CSS, and JavaScript into readable pages.
o Handling user interactions (clicks, inputs, etc.).
o Managing cookies, caching, and local storage.
o Displaying multimedia content (images, videos, etc.).

Define IIS Web Server.

 IIS (Internet Information Services) is a web server developed by Microsoft for Windows Server
operating systems. It supports HTTP, HTTPS, FTP, and other protocols, and allows hosting websites and
web applications. IIS provides security features, scalability, and performance optimization for hosting
dynamic content.

Define Apache Server.

 Apache HTTP Server, commonly known as Apache, is one of the most widely used open-source web
servers. It supports various protocols like HTTP, HTTPS, and FTP, and is highly configurable with a
modular architecture. Apache is commonly used to serve static and dynamic content, often in conjunction
with PHP, MySQL, and other web technologies.

Define AJAX.

 AJAX (Asynchronous JavaScript and XML) is a technique used in web development to create dynamic
and interactive web pages. It allows web pages to fetch data asynchronously from a server without
reloading the entire page. AJAX uses JavaScript to send requests to the server and update parts of a page
with the response, improving user experience by making applications faster and more responsive.

Define Node.js.

 Node.js is a runtime environment that allows developers to run JavaScript on the server side. It is built on
the V8 JavaScript engine and is designed for building scalable, high-performance network applications.
 Node.js is event-driven, non-blocking, and uses a single-threaded event loop to handle multiple connections
concurrently.

Define NPM.

 NPM (Node Package Manager) is a package manager for the Node.js runtime environment. It is used to
install, manage, and share JavaScript libraries (called packages) and dependencies in a Node.js application.
NPM also provides a command-line interface to interact with the registry, where packages are stored.

What are the Types of Request?

 Common types of HTTP requests include:

o GET: Requests data from a specified resource.
o POST: Sends data to the server to create or update a resource.
o PUT: Replaces a current resource with new data.
o DELETE: Deletes a specified resource.
o PATCH: Partially updates a resource.
o HEAD: Requests the headers of a resource, without the body.
o OPTIONS: Describes the communication options for the target resource.

Define MVC Architecture.

 MVC (Model-View-Controller) is an architectural pattern used in web and software development to

separate an application into three main components:
o Model: Represents the data and business logic of the application.
o View: Represents the user interface (UI), displaying data from the model.
o Controller: Acts as an intermediary between the model and the view, processing user input and
updating the model or view accordingly.

What are the Components of Full Stack Web Development?

 Full Stack Web Development involves both front-end and back-end development. Its components include:
o Front-end (Client-side): HTML, CSS, JavaScript, frameworks like React, Angular, or Vue.js.
o Back-end (Server-side): Server-side languages and frameworks like Node.js, Express.js, Python
(Django/Flask), Ruby (Rails), or PHP.
o Database: Relational (MySQL, PostgreSQL) or NoSQL (MongoDB, Cassandra) databases to
store and manage data.
o Version Control: Git, GitHub, or GitLab for managing code and collaboration.
o Deployment: Tools like Docker, Kubernetes, AWS, or Heroku for deploying applications.
o API Integration: RESTful APIs or GraphQL to facilitate communication between the front-end
and back-end.