Advanced Web Programming Winter 2022 GTU Paper Solution | 3161611

Here, We provide Advanced Web Programming GTU Paper Solution Winter 2022. Read the Full AWP GTU paper solution given below.

Advanced Web Programming GTU Old Paper Winter 2022 [Marks : 70] : Click Here

(a) What is CSS? Explain the different types of CSS.

CSS stands for Cascading Style Sheets. It is a style sheet language used for describing the presentation of a document written in HTML or XML (including XML dialects such as SVG or XHTML). CSS separates the content of a web page from its design, allowing web developers to control the appearance and layout of multiple web pages simultaneously.

There are three main types of CSS:

  1. Inline CSS: Inline CSS is applied directly to an individual HTML element using the “style” attribute. It involves specifying the style properties and their values within the HTML tag itself. For example:
<p style="color: red; font-size: 16px;">This is some text.</p>

Inline CSS has the highest specificity and will override other styles applied externally or internally.

  1. Internal CSS: Internal CSS is defined within the head section of an HTML document using the <style> tag. It allows you to define styles for multiple elements on a single page. For example:
    p {
      color: blue;
      font-size: 14px;
  <p>This is some text.</p>

Internal CSS applies to all elements that match the specified selectors within the document.

  1. External CSS: External CSS is stored in a separate file with a .css extension and linked to the HTML document using the <link> tag. This method allows you to define styles that can be shared across multiple HTML documents, promoting consistency and easier maintenance. For example:
  <link rel="stylesheet" type="text/css" href="styles.css">

The styles.css file:

p {
  color: green;
  font-size: 18px;

External CSS offers the best separation of concerns and modularity, as the styles are defined separately from the HTML structure.

(b) Write a JavaScript program to validate an Email address.

(c) What is SPA (Single page application) in AngularJS? Explain the advantages
of AngularJS.

(a) What are directives in AngularJS?

In AngularJS, directives are a core feature that allows you to extend HTML with custom behaviors and create reusable components. Directives are markers or attributes that you add to HTML elements, instructing AngularJS to attach specific behavior or manipulate the DOM (Document Object Model) in a certain way.

AngularJS provides several built-in directives, such as ng-app, ng-controller, and ng-model. Additionally, you can define your own custom directives to suit the specific needs of your application.

There are three types of directives in AngularJS:

  1. Attribute Directives: Attribute directives are applied as attributes to HTML elements. They modify the behavior or appearance of the element. Examples of built-in attribute directives include ng-model for data binding and ng-show for conditional visibility.
  2. Element Directives: Element directives create custom elements that can encapsulate complex behaviors or functionality. These directives are used as new HTML tags. For instance, you could create a custom <my-directive> element that encapsulates a specific UI component and its associated behavior.
  3. Class Directives: Class directives are applied as CSS classes to HTML elements. They typically modify the styling or provide additional visual effects. For example, AngularJS provides the ng-class directive for dynamically adding or removing CSS classes based on certain conditions.

To create a custom directive, you use the directive() function provided by AngularJS. It takes two arguments: the name of the directive and a factory function that defines the behavior of the directive. The factory function returns an object that specifies the directive’s configuration.

Here’s an example of a custom directive that highlights an element in red when clicked:

angular.module('myApp', [])
  .directive('highlightOnClick', function() {
    return {
      link: function(scope, element) {
        element.on('click', function() {
          element.css('color', 'red');

(b) Explain the data binding process in AngularJS.

(c) Explain controller in AngularJS with example.

(c) Write a syntax to send sample HTTP POST request in AngualrJS?

(a) How can you integrate AngularJS with HTML?

To integrate AngularJS with HTML, you need to follow a few steps. Here’s a basic outline of the process:

  1. Include AngularJS Library: Download the AngularJS library from the official website or include it from a content delivery network (CDN). Add the script tag to include AngularJS in your HTML file, typically in the <head> section:
<script src="path/to/angular.js"></script>
  1. Define AngularJS App: In your HTML file, create an element (usually <html> or <body>) and add the ng-app directive to define your AngularJS application. The value of the ng-app directive corresponds to the name of your AngularJS module:
<!DOCTYPE html>
<html ng-app="myApp">
<!-- ... -->
  1. Create AngularJS Module: Define an AngularJS module using the angular.module() function. The module acts as a container for controllers, services, and other components of your application. You can define it in a separate JavaScript file or within a <script> tag in your HTML file:
  angular.module('myApp', []);
  1. Create AngularJS Controller: Create a controller using the angular.module().controller() function. The controller defines the behavior and data for a specific section of your HTML. You can define it in a separate JavaScript file or within a <script> tag in your HTML file:
  angular.module('myApp', [])
    .controller('MyController', function() {
      // Controller logic here
  1. Bind Data and Behaviors: In your HTML, you can bind data and behaviors defined in your controller using AngularJS directives. For example, you can use ng-model for two-way data binding, ng-click for event handling, and ng-repeat for repeating elements. These directives are added as attributes to HTML elements:
<div ng-controller="MyController">
  <input type="text" ng-model="name">
  <button ng-click="greet()">Greet</button>
  <p>Hello, {{ name }}!</p>

In the above code, we have an input field with ng-model directive for two-way data binding, a button with ng-click directive to trigger a function in the controller, and a paragraph displaying the value of name variable.

  1. Run the Application: Finally, load the HTML file in a web browser, and AngularJS will bootstrap the application, creating the necessary connections between the HTML and the AngularJS components.

(b) Differentiate between expressions of AngularJS and JavaScript.

(c) What is $rootscope and how do we use it?


(a) Explain AngularJS MVC Architecture

AngularJS follows the MVC (Model-View-Controller) architecture pattern, which is a design pattern commonly used in web applications. The MVC architecture in AngularJS helps to separate concerns, improve code organization, and promote reusability.

Here’s a brief explanation of the three components of the MVC architecture in AngularJS:

  1. Model: The model represents the application’s data and business logic. In AngularJS, the model is typically represented by JavaScript objects or arrays. It can also include services, factories, or resources that handle data retrieval and manipulation. The model is responsible for storing and managing the application’s data, as well as implementing any necessary business rules or logic.
  2. View: The view is the user interface that the users interact with. It represents the presentation layer of the application and is responsible for displaying the data from the model and capturing user input. In AngularJS, the view is typically defined using HTML templates, which can include AngularJS directives for dynamic rendering and data binding. The view should not contain any business logic or data manipulation; it is focused on rendering and user interactions only.
  3. Controller: The controller acts as an intermediary between the model and the view. It handles user interactions, manipulates the model, and updates the view accordingly. The controller defines functions and properties that are bound to the view using AngularJS directives. It captures user input, processes it, and updates the model as needed. The controller also exposes data from the model to the view, making it available for display and interaction.

In AngularJS, the communication between the model, view, and controller happens automatically through two-way data binding. This means that changes in the model are automatically reflected in the view, and vice versa, without the need for manual DOM manipulation. AngularJS uses its digest cycle to track changes and update the view accordingly.

(b) How are validations implemented in AngularJS?

(c) Write an AngularJS code which takes number as an input and display that
number is odd or even.

(a) Explain different data types in Node.js.

In Node.js, there are several data types available, which are as follows:

  1. Number: In Node.js, a number represents a numeric value and is used to perform arithmetic operations.


let num1 = 10;
let num2 = 5;
let sum = num1 + num2; //15
  1. String: A string in Node.js represents a sequence of characters and is enclosed in either single quotes or double quotes.


let message = 'Hello, World!';
  1. Boolean: A boolean in Node.js represents a logical value, which can be either true or false.


let isTrue = true;
let isFalse = false;
  1. Array: An array in Node.js represents a collection of values of the same or different data types. The array can be created using square brackets and elements can be accessed using index.


let fruits = ['Apple', 'Banana', 'Mango'];
console.log(fruits[0]); // 'Apple'
  1. Object: An object in Node.js represents a collection of properties, which can be of different data types. The object can be created using curly braces and properties can be accessed using dot notation or bracket notation.


let person = {
  name: 'John',
  age: 30,
  isMarried: false
console.log(; // 'John'
  1. Null: Null in Node.js represents a non-existent value.


let value = null;
  1. Undefined: Undefined in Node.js represents a value that is not defined.


let value;
console.log(value); // undefined

(b) What are streams? How many types of streams are present in Node.

(c) What is Node.js? Explain the features of Node.js.


(a) How to create buffer in Node.js?

In Node.js, you can create a buffer using the Buffer class provided by the core module buffer. The Buffer class allows you to work with binary data in Node.js.

There are several ways to create a buffer in Node.js:

  1. Using the Buffer.from() method:
const buffer = Buffer.from('Hello, World!', 'utf8');

In this example, a buffer is created from a string 'Hello, World!' using the Buffer.from() method. The second parameter 'utf8' specifies the encoding of the string.

  1. Using the Buffer.alloc() method:
const buffer = Buffer.alloc(10);

Here, a buffer of size 10 bytes is created using the Buffer.alloc() method. The buffer is initialized with zeros.

  1. Using the Buffer.allocUnsafe() method:
const buffer = Buffer.allocUnsafe(10);

This method creates a buffer of size 10 bytes without initializing it. The content of the buffer is not cleared, so it may contain existing data from memory.

  1. Using the Buffer constructor:
const buffer = new Buffer('Hello, World!', 'utf8');

Note: The new Buffer() constructor is deprecated since Node.js v6.0.0. It’s recommended to use Buffer.from() or Buffer.alloc() methods instead.

Once you have created a buffer, you can perform various operations on it, such as reading from or writing to specific positions, converting it to different encodings, copying buffers, and more.

(b) What are the core modules of Node.js?

(c) How to create a simple server in Node.js that returns Hello World?

(a) Explain usage of NODE_ENV?

The NODE_ENV environment variable is commonly used in Node.js applications to determine the environment in which the application is running. It is not a built-in feature of Node.js itself, but rather a convention followed by many developers and frameworks.

The NODE_ENV variable can have different values based on the environment, such as development, production, or testing. It allows developers to customize the behavior of their application based on the environment it is running in. Here’s how NODE_ENV can be used:

  1. Configuration: The NODE_ENV variable can be used to load different configurations based on the environment. For example, you might have different database connection settings or API keys for development, production, and testing environments. By checking the value of NODE_ENV, your application can load the appropriate configuration file.
  2. Debugging: During development, you may want to enable additional debugging or logging features in your application. By checking the value of NODE_ENV, you can conditionally enable or disable debugging statements or logging based on whether it’s running in a production or development environment.
  3. Performance optimizations: In a production environment, you may want to enable certain optimizations or caching mechanisms to improve the performance of your application. With NODE_ENV, you can conditionally apply performance-related settings or optimizations specific to the production environment.
  4. Error handling: The behavior of error handling can differ between development and production environments. For example, in development, you might want to display detailed error messages and stack traces for debugging purposes, while in production, you may want to provide more generic error messages to avoid exposing sensitive information. By checking NODE_ENV, you can handle errors differently based on the current environment.

To set the value of NODE_ENV, you can either define it explicitly in your shell environment or specify it when running your Node.js application, like this:

NODE_ENV=production node app.js

The actual values used for NODE_ENV can vary based on convention or personal preference, but common values include development, production, test, staging, etc.

(b) What is REPL? What purpose it is used for?

(c) Write code to perform Insert and find operations on Student database using
Node.js and MongoDB.


(a) Explain an event-loop in Node.js.

In Node.js, the event loop is a crucial component of its runtime environment. It is responsible for handling I/O operations and executing callbacks in an efficient and non-blocking manner. Understanding the event loop is essential for writing scalable and performant Node.js applications.

The event loop follows an event-driven architecture, where I/O operations and other asynchronous tasks are handled asynchronously without blocking the execution of the program. This allows Node.js to handle a large number of concurrent connections efficiently.

Here’s a high-level overview of how the event loop works in Node.js:

  1. Event Loop Phases:
    • Timer Phase: The event loop starts by checking for expired timers and executing their associated callback functions.
    • I/O Phase: Any I/O operations that have completed are processed, and their callbacks are executed. This includes handling network requests, file system operations, and other asynchronous tasks.
    • Idle Phase: The event loop enters an idle state if there are no pending callbacks or I/O operations. It waits for new events to occur.
    • Poll Phase: The event loop checks for new I/O events and their associated callbacks. If any callbacks are ready to be executed, they are queued for execution.
    • Check Phase: Certain callbacks, such as setImmediate, are scheduled to execute immediately after the Poll phase.
    • Close Phase: Any resources (e.g., sockets) that were closed during the event loop iteration are cleaned up.
  2. Non-Blocking I/O:
    • When an asynchronous operation is initiated, Node.js does not block the execution of the program. Instead, it registers a callback for that operation and continues to process other tasks.
    • When the I/O operation is completed, the callback is pushed into the event loop’s callback queue for execution in the next event loop iteration.
  3. Execution Order:
    • The event loop continuously iterates, processing the different phases, until there are no more events or callbacks in the queue.
    • The order of executing callbacks is determined by the order in which they were added to the queue.
    • If the event loop is busy with a long-running task, it may delay the execution of other callbacks until the task completes.

The event loop enables Node.js to handle a large number of concurrent connections efficiently. It allows developers to write non-blocking, asynchronous code that can scale well. By leveraging callbacks, promises, or async/await, developers can work with I/O operations and other asynchronous tasks without blocking the execution of the program.

(b) What is an error-first callback?

(c) Write code to perform update and delete operations on Employee database
using Node.js and MongoDB.

“Do you have the answer to any of the questions provided on our website? If so, please let us know by providing the question number and your answer in the space provided below. We appreciate your contributions to helping other students succeed.”