ITA ImporTAnT QuesTIons :

1.

a. Tree Structure of XML Schema :

WeatherData
└── City [1..*]
├── Name
├── State
├── WeatherStationCode
├── Wind
│ ├── Speed
│ ├── Direction
│ └── Gusts
├── Humidity
├── Temperature
│ ├── Min
│ └── Max
├── AtmosphericPressure
├── Rainfall
└── AQI
b. XML File for 3 Cities :
<?xml version="1.0" encoding="UTF-8"?>
<WeatherData>
<City>
<Name>Delhi</Name>
<State>Delhi</State>
<WeatherStationCode>DEL001</WeatherStationCode>
<Wind>
<Speed>12.5</Speed>
<Direction>NW</Direction>
 <Gusts>18.3</Gusts>
</Wind>
<Humidity>45.0</Humidity>
<Temperature>
<Min>24.0</Min>
<Max>38.0</Max>
</Temperature>
<AtmosphericPressure>1012.3</AtmosphericPressure>
<Rainfall>2.5</Rainfall>
<AQI>172</AQI>
</City>

<City>
<Name>Mumbai</Name>
<State>Maharashtra</State>
<WeatherStationCode>MUM101</WeatherStationCode>
<Wind>
<Speed>9.2</Speed>
<Direction>SW</Direction>
<Gusts>14.1</Gusts>
</Wind>
<Humidity>72.0</Humidity>
<Temperature>
<Min>26.0</Min>
<Max>34.0</Max>
</Temperature>
<AtmosphericPressure>1008.7</AtmosphericPressure>
<Rainfall>15.0</Rainfall>
<AQI>95</AQI>
</City>

<City>
<Name>Bangalore</Name>
<State>Karnataka</State>
<WeatherStationCode>BLR202</WeatherStationCode>
<Wind>
<Speed>6.0</Speed>
<Direction>NE</Direction>
<Gusts>10.0</Gusts>
</Wind>
<Humidity>60.0</Humidity>
 <Temperature>
<Min>20.0</Min>
<Max>30.0</Max>
</Temperature>
<AtmosphericPressure>1015.0</AtmosphericPressure>
<Rainfall>0.0</Rainfall>
<AQI>42</AQI>
</City>
</WeatherData>

c. XML Schema Design :

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="WeatherData">
<xs:complexType>
<xs:sequence>
<xs:element name="City" maxOccurs="unbounded">
<xs:complexType>
<xs:sequence>
<xs:element name="Name" type="xs:string"/>
<xs:element name="State" type="xs:string"/>
<xs:element name="WeatherStationCode" type="xs:string"/>
<xs:element name="Wind">
<xs:complexType>
<xs:sequence>
<xs:element name="Speed" type="xs:float"/>
<xs:element name="Direction" type="xs:string"/>
<xs:element name="Gusts" type="xs:float"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="Humidity" type="xs:float"/>
<xs:element name="Temperature">
<xs:complexType>
<xs:sequence>
<xs:element name="Min" type="xs:float"/>
<xs:element name="Max" type="xs:float"/>
</xs:sequence>
</xs:complexType>
</xs:element>
 <xs:element name="AtmosphericPressure" type="xs:float"/>
<xs:element name="Rainfall" type="xs:float"/>
<xs:element name="AQI" type="xs:int"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>

</xs:schema>

2. What is DTD? How it is used to define the elements and their attributes for an XML file?
Explain with help of an example .

DTD (Document Type Definition) is a way to define the structure and rules for an XML
document. It tells what elements, attributes, and data types can appear, how they nest, and
in what order — just like a grammar for the XML file.

It helps:

• Validate XML files (i.e., check if they follow the correct format).

• Define the allowed structure (like a blueprint).

Types of DTD

1. Internal DTD – Defined inside the XML file.

2. External DTD – Defined in a separate .dtd file and linked.

Defining Elements :

<!ELEMENT element-name category>

Defining Attributes

<!ATTLIST element-name attribute-name attribute-type attribute-value>

Example :

<?xml version="1.0"?>

<!DOCTYPE WeatherData [

<!ELEMENT WeatherData (City+)>

 <!ELEMENT City (Name, State, Code, Wind, Humidity, Temperature, Pressure, Rainfall,
AQI)>

<!ELEMENT Name (#PCDATA)>

<!ELEMENT State (#PCDATA)>

<!ELEMENT Code (#PCDATA)>

<!ELEMENT Wind (Speed, Direction, Gusts)>

<!ELEMENT Speed (#PCDATA)>

<!ELEMENT Direction (#PCDATA)>

<!ELEMENT Gusts (#PCDATA)>

<!ELEMENT Humidity (#PCDATA)>

<!ELEMENT Temperature (Min, Max)>

<!ELEMENT Min (#PCDATA)>

<!ELEMENT Max (#PCDATA)>

<!ELEMENT Pressure (#PCDATA)>

<!ELEMENT Rainfall (#PCDATA)>

<!ELEMENT AQI (#PCDATA)>

<!-- Attributes (optional example) -->

<!ATTLIST City id ID #REQUIRED>

]>

<WeatherData>

<City id="c1">

<Name>Delhi</Name>

<State>Delhi</State>

<Code>DL001</Code>

<Wind>

<Speed>15</Speed>

<Direction>NW</Direction>
 <Gusts>20</Gusts>

</Wind>

<Humidity>40</Humidity>

<Temperature>

<Min>25</Min>

<Max>38</Max>

</Temperature>

<Pressure>1012</Pressure>

<Rainfall>2.5</Rainfall>

<AQI>150</AQI>

</City>

</WeatherData>

3. What is AJAX. How an AJAX operation sends a GET request to the server and displays
the response in the browser .

AJAX stands for Asynchronous JavaScript and XML. It's a technique used in web
development to send and receive data from a server asynchronously — without
having to reload the entire web page.

Key Points:
• Uses JavaScript (often with XMLHttpRequest or fetch) to communicate with the
server.
• Data can be in various formats — XML, JSON, HTML, or plain text.
• Allows smoother, faster, and more interactive user experiences.

🛠️ How AJAX Works (Basic Flow) :

1. A user action triggers a JavaScript function.
2. The function creates an AJAX request (e.g., GET or POST).
3. The browser sends the request in the background to a server.
4. The server processes it and sends back a response.
5. JavaScript updates part of the web page using the response.
Example: AJAX GET Request Using XMLHttpRequest :

HMTL + JAVASCRIPT CODE :

<!DOCTYPE html>
<html>
<head>
<title>AJAX Example</title>
</head>
<body>

<h2>Get Weather Info</h2>

<button onclick="loadData()">Click to Get Data</button>

<div id="result"></div>

<script>
function loadData() {
// Step 1: Create an XMLHttpRequest object
var xhttp = new XMLHttpRequest();

// Step 2: Define what happens when response is ready

xhttp.onreadystatechange = function() {
if (this.readyState === 4 && this.status === 200) {
// Step 3: Update part of the page with server response
document.getElementById("result").innerHTML = this.responseText;
}
};

// Step 4: Open a GET request to a sample file (or server endpoint)

xhttp.open("GET", "weather-info.txt", true); // could also be .php, .json, etc.

// Step 5: Send the request

xhttp.send();
}
</script>

</body>
</html>
 Sample Server File: weather-info.txt :
Weather in Mumbai: 33°C, Humidity: 60%, Wind: 18 km/h NW

✅ Output (When Button Is Clicked)

The text Weather in Mumbai: 33°C, Humidity: 60%, Wind: 18 km/h NW will appear
inside the <div id="result">.

4. What is XML? Advantages of XML over HTML. What are the rules to create a well-
formed XML file?

XML (eXtensible Markup Language) is a markup language used to store, structure,

and transport data. It is self-descriptive, meaning the tags describe the data clearly.
Unlike HTML, XML is not concerned with how data looks, but what it is.

Example :
<Student>
<Name>Ravi Kumar</Name>
<RollNo>101</RollNo>
<Course>Computer Science</Course>
</Student>

Advantages of XML over HTML :

Feature XML HTML

Purpose Stores and transports data Displays data

Custom Tags Yes, user-defined No, predefined

Data and presentation

Data Separation Data and structure only mixed

Yes (well-formed, case- Loose syntax

Strict Syntax
sensitive)

Extensible Fully extensible Not extensible

Machine- Not suitable for data

Easily parsed by software transport
readable
Rules to Create a Well-Formed XML File :

1. Single Root Element : There must be one and only one root element.
Ex : <Students> ... </Students>
2. Properly Nested Elements : Elements must be properly closed and not
overlap.
Ex : <Name><First>John</First><Last>Doe</Last></Name>
<Name><First>John</Name></First> Invalid
3. Every Tag Must Be Closed : All opening tags must have matching closing tags.
Ex: <RollNo>101</RollNo>
<RollNo>101
4. Tags are Case-Sensitive : <Name> and <name> are different.
5. Attribute Values Must Be Quoted :
Ex: <student id="101">
<student id=101>
6. No Reserved Characters in Data :
Characters like <, >, &, " must be replaced with entities:
< → &lt;
> → &gt;
& → &amp;
" → &quot;

7. No Spaces in Tag Names :

Ex: <StudentName>
<Student Name>

5. Explain the life cycle of a JSP page with a suitable diagram. Explain each phase of the
life cycle and the functions calls.

JSP File (.jsp)

↓
[1] Translation Phase (JSP → Servlet)
↓
[2] Compilation Phase (Servlet.java → Servlet.class)
↓
[3] Class Loading & Instantiation
 ↓
[4] Initialization (jspInit())
↓
[5] Request Handling (service())
↓
[6] Destruction (jspDestroy())

JSP Life Cycle Phases Explained

1. Translation Phase
• The JSP engine translates the .jsp file into a Java servlet (a .java file).
• Example: index.jsp → index_jsp.java
• This step happens only once when the page is first requested or updated.
2. Compilation Phase
• The generated .java servlet file is compiled into a .class file.
• Example: index_jsp.java → index_jsp.class
3. Class Loading & Instantiation
• The compiled servlet class is loaded into memory and instantiated using the class
loader.
4. Initialization – jspInit()
• The container calls the jspInit() method only once during the JSP’s lifecycle.
• Used for initial setup such as database connection setup or variable initialization.
5. Request Processing – _jspService(HttpServletRequest, HttpServletResponse)
• For every client request, the container calls the _jspService() method.
• This method handles:
o Generating dynamic content (HTML)
o Reading request parameters
o Writing response

Note: You should not override _jspService() — it's automatically generated and
handled.

6. Destruction – jspDestroy()
• Called only once when the JSP is removed or the server shuts down.
• Used to release resources like closing DB connections, cleaning up, etc

6. Explain the different types of tags used in JSP and their purpose. Give an example for
each type of tag.

In JSP (JavaServer Pages), different types of tags are used to insert Java code, control
the behavior of the page, and interact with clients. These tags help mix HTML with
Java logic effectively.

Types of Tags in JSP with Examples :

1. Directive Tags :
Purpose: Provide global information about the JSP page to the container (e.g.,
import packages, define page encoding, error handling, etc.)
Common Directives:
page: Defines page-level instructions (e.g., imports, error page).
include: Includes a static file during translation.
taglib: Declares a tag library.
Syntax : <%@ directive attribute="value" %>
Example :
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<%@ include file="header.jsp" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

2. Scriptlet Tags :
Purpose: Embeds Java code that is executed every time the page is requested.
Syntax : <% java_code %>
 Example :
<%
int x = 10;
out.println("Value of x: " + x);
%>
3. Expression Tags :

Purpose: Evaluates a Java expression and outputs the result directly to the client.

Syntax: <%= expression %>

Example:

<%= "Welcome, " + request.getParameter("name") %>

4. Declaration Tags :
Purpose: Declare methods or variables at the class level of the servlet
generated from the JSP.
Syntax : <%! declaration %>
Example:
<%!
int counter = 0;
public int getCounter() {
return ++counter;
}
%>
<p>Counter: <%= getCounter() %></p>

5. Action Tags :
Purpose : Used to control the behavior of the JSP engine (includes, forwards,
etc.) — use XML syntax.
Syntax : <jsp:action attribute="value" />
Examples
Include another resource:
jsp
CopyEdit
<jsp:include page="footer.jsp" />
Forward to another resource:
jsp
CopyEdit
<jsp:forward page="home.jsp" />
Use JavaBeans:
 jsp
CopyEdit
<jsp:useBean id="user" class="com.example.User" scope="session" />
<jsp:setProperty name="user" property="name" value="John" />
<jsp:getProperty name="user" property="name" />

6. Custom Tags :
Purpose : Reusable components defined using JSP Tag Libraries (JSTL) or your
own tags.
Example using JSTL Core Library:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<c:if test="${param.age > 18}">
<p>You are eligible.</p>
</c:if>

7. What do you understand by a JSP Element? Describe the different types of

tags used for the JSP elements with suitable examples.

A JSP Element is a construct in JavaServer Pages (JSP) used to embed Java code or
JSP-specific instructions into HTML pages. These elements allow the server to
dynamically generate web content based on logic written in Java.

***********same tags explained above are the nswers for thi question *********

8. What is SOAP? Explain with suitable examples a SOAP Request and its
Response in XML.
SOAP (Simple Object Access Protocol) is a protocol used for exchanging
structured information in the implementation of web services. It allows
programs running on different operating systems to communicate using HTTP
and XML.
Key Features of SOAP:
Platform and language independent
Uses XML to encode messages
Typically sent via HTTP or SMTP
Supports request/response model
Well-defined SOAP envelope structure
SOAP Message Structure:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
 <soap:Header> <!-- Optional --></soap:Header>
<soap:Body> <!-- Required -->
<!-- Application-specific data -->
</soap:Body>
</soap:Envelope>

Example: SOAP Request (for a simple calculator service) :

Suppose we want to call a Add method in a web service that adds two numbers.

POST /calculator HTTP/1.1

Host: www.example.com
Content-Type: text/xml; charset=utf-8
Content-Length: length
SOAPAction: "http://tempuri.org/Add"

SOAP Request Body :

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<Add xmlns="http://tempuri.org/">
<intA>5</intA>
<intB>10</intB>
</Add>
</soap:Body>
</soap:Envelope>

SOAP Response : If the service successfully processes the request, it may respond
with:

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Body>
<AddResponse xmlns="http://tempuri.org/">
<AddResult>15</AddResult>
</AddResponse>
</soap:Body>
</soap:Envelope>

9. Briefly explain the following :

 i. Web Services , WSDL ,UDDI
ii. Service Oriented Architecture
iii. SOAP
iv. REST
v. Digital Signature

i. Web Service, WSDL, UDDI

• Web Service:
A web service is a software application that provides functionality over the web using
standard protocols like HTTP. It allows communication between different
applications, often across platforms and languages.
A Web Service is a standardized way of integrating web-based applications using
open standards like HTTP, XML, SOAP, and WSDL.

It allows different applications (written in different languages and running on

different platforms) to communicate and exchange data.

Web services are self-describing, platform-independent, and can be discovered

using UDDI.
Example: A currency converter API or weather forecast service.

• WSDL (Web Services Description Language):

An XML-based language used to describe the functionality offered by a web service.
It defines the service interface, data types, operations, and communication protocols.
• UDDI (Universal Description, Discovery, and Integration):
A directory service where businesses can register and search for web services. It acts
like a "yellow pages" for services on the web.

ii. Service Oriented Architecture (SOA)

SOA is a software design approach where services are provided to other components
through a communication protocol, usually over a network. Services are loosely
coupled, reusable, and interoperable, which makes SOA ideal for integrating different
systems.
Service-Oriented Architecture (SOA) is a design pattern in which services are
provided to other components by application components, through a
communication protocol over a network.
• Each service is independent, loosely coupled, and reusable.
• Promotes interoperability, scalability, and flexibility.
Example: An e-commerce application where:
• Inventory service,
• Payment service,
• Shipping service
…all run as independent web services but work together.

iii. SOAP (Simple Object Access Protocol)

SOAP is a protocol used for exchanging structured information in web services using
XML. It typically runs over HTTP and allows programs on different platforms to
communicate. SOAP is known for being rigid but secure and extensible.

iv. REST (Representational State Transfer)

REST is an architectural style for designing networked applications. It uses HTTP
methods (GET, POST, PUT, DELETE) for communication and is widely used due to its
simplicity, performance, and scalability. Unlike SOAP, REST typically uses JSON or
XML.

v. Digital Signature
A Digital Signature is a cryptographic technique used to validate the authenticity
and integrity of a digital message or document.
• It uses public key encryption.
• Ensures that the message:
o Comes from a verified sender
o Has not been tampered with
Process:
1. Sender generates a hash of the message.
2. Encrypts it using their private key.
3. Receiver uses sender’s public key to verify the signature.
Example: Used in secure emails, e-invoices, e-governance documents.

10. What is REST API and how it works ?

REST API stands for Representational State Transfer Application Programming

Interface. It is a set of rules that allows programs to communicate with each
other over HTTP, just like web browsers and servers do.

Key Concepts of REST:

1. Stateless: Each request from a client contains all the information needed to process
the request. No session is stored on the server.
2. Resources: Everything is treated as a resource (like a user, image, product), and
identified by a URL.
3. HTTP Methods are used to perform actions on resources:

Method Action Description

GET Read Retrieves data from the server

POST Create Sends data to create a new resource

PUT Update Updates an existing resource

DELETE Delete Removes a resource

How a REST API Works – Example

Imagine a REST API for managing users at:
arduino
CopyEdit
https://api.example.com/users
1. GET Request – Retrieve Users
http :
GET /users HTTP/1.1
Host: api.example.com
Response:
Json :
[
{ "id": 1, "name": "Alice" },
{ "id": 2, "name": "Bob" }
]

2. POST Request – Create a User

http :
POST /users HTTP/1.1
Host: api.example.com
Content-Type: application/json

{
"name": "Charlie"
}
Response:
Json :
{ "id": 3, "name": "Charlie" }
 3. PUT Request – Update a User
http :
PUT /users/3 HTTP/1.1
Host: api.example.com
Content-Type: application/json

{
"name": "Charles"
}

4. DELETE Request – Delete a User

http :
DELETE /users/3 HTTP/1.1
Host: api.example.com
Response:
Json :
{ "message": "User deleted successfully" }

11. What do you understand by a Web Service? What is Service Oriented

Architecture?

A Web Service is a software application that provides communication between two

electronic devices (systems or applications) over a network using standard web
protocols, such as HTTP, XML, SOAP, or REST.

🔹 Key Features:
i. Platform-independent (e.g., Java can talk to .NET)
ii. Uses standard data formats like XML or JSON
iii. Can be accessed via URL
iv. Interoperable – works across different systems
🔹 Example Use Case:
A weather web service provides current temperature data. Your app can call this
service, receive the response, and display it to the user.
 Service-Oriented Architecture (SOA) is a design pattern or architectural style where
applications are structured as a collection of independent, reusable services that
communicate over a network.
🔹 Key Characteristics:
I. Loose coupling – services are independent
II. Reusability – services can be reused across different apps
III. Interoperability – services built in different languages/platforms can work together
IV. Standard interfaces – often use WSDL for SOAP or OpenAPI for REST

🔹 Example:
An e-commerce system built using SOA might have:
i. A User Service for handling user authentication
ii. An Order Service for managing customer orders
iii. A Payment Service to process payments
Each service runs independently but works together to form the full system.

12. Write at least six differences between SOAP and REST.

SOAP (Simple Object REST (Representational

Aspect State Transfer)
Access Protocol)

Architectural style using

1. Protocol Strict protocol (SOAP) standard HTTP methods

Supports XML, JSON, HTML,

2. Data Format Uses only XML plain text, etc.

Can use HTTP, SMTP, Uses only HTTP/HTTPS

3. Transport
TCP

Slower due to heavy Faster and lightweight

4. Performance (especially with JSON)
XML and overhead

Built-in support for Requires custom

5. Standards implementation for security
WS-Security, ACID,
Support etc.
WSDL
 SOAP (Simple Object REST (Representational
Aspect State Transfer)
Access Protocol)

Complex to Easy to use and more

6. Simplicity suitable for web applications
implement and parse

7. Caching | Not supported | Fully supports caching with HTTP methods |

8. Statefulness | Can be stateful or stateless | Typically stateless |
9. Interface | Uses a fixed XML contract (WSDL) | Uses URIs for accessing resources
|
10. Flexibility | Less flexible due to rigid structure | More flexible and widely used in
modern APIs |

13. Explain the three types of JSP Directive tag with suitable examples.

1. Page Directive
Purpose:
• Defines page-level instructions like importing packages, defining content type, error
page, etc.
Syntax:
jsp
CopyEdit
<%@ page attribute="value" %>
Common Attributes:
• import: Import Java packages
• contentType: Define MIME type
• errorPage: Set error handler page
• isErrorPage: Specify if the page handles errors
Example:
jsp
CopyEdit
<%@ page import="java.util.*, java.sql.*" %>
<%@ page contentType="text/html" %>
<%@ page errorPage="error.jsp" %>

2. Include Directive
Purpose:
• Includes a static file (HTML, JSP, etc.) during translation time (before the JSP is
compiled).
Syntax:
jsp
CopyEdit
<%@ include file="filename.jsp" %>
Example:
jsp
CopyEdit
<%@ include file="header.jsp" %>
<p>Main content of the page here</p>
<%@ include file="footer.jsp" %>
Includes are useful for common page parts like headers and footers.

3. Taglib Directive
Purpose:
• Declares a tag library to use custom tags in the JSP using JSTL or other tag libraries.
Syntax:
jsp
CopyEdit
<%@ taglib uri="uri" prefix="prefixName" %>
Example (JSTL Core Tags):
jsp
CopyEdit
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<c:if test="${score > 50}">

<p>You passed!</p>
</c:if>

14. Explain the values of the readyState property of XMLHttpRequest object and
their significance.

The readyState property of the XMLHttpRequest object in AJAX indicates the current
state of the request. It holds an integer value from 0 to 4, each representing a
different phase of the request–response cycle.
 XMLHttpRequest.readyState Values :

Value State Meaning

Request not initialized. open() has not

0 UNSENT been called yet.

open() has been called. Request is ready

1 OPENED to be sent using send().

send() has been called, and headers are

2 HEADERS_RECEIVED available.

Response is being received. Partial data is

3 LOADING available.

Request completed. Full response

4 DONE received. Ready to process.

EXAMPLE : Handling readyState :

var xhr = new XMLHttpRequest();

xhr.onreadystatechange = function() {
if (xhr.readyState === 4 && xhr.status === 200) {
document.getElementById("output").innerHTML = xhr.responseText;
}
};
xhr.open("GET", "data.txt", true);
xhr.send();

Explanation:
• onreadystatechange is triggered every time readyState changes.
• When readyState is 4 and status is 200 (OK), the request is successful, and the
response is processed.

15.
 SOAP Request :

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:web="http://example.com/webservice">
<soapenv:Header/>
<soapenv:Body>
<web:ConvertCurrency>
<web:SourceCurrency>INR</web:SourceCurrency>
<web:TargetCurrency>USD</web:TargetCurrency>
<web:FromAmount>1000</web:FromAmount>
</web:ConvertCurrency>
</soapenv:Body>
</soapenv:Envelope>

SOAP Response :

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:web="http://example.com/webservice">
<soapenv:Header/>
<soapenv:Body>
<web:ConversionResponse>
<web:SourceCurrency>INR</web:SourceCurrency>
<web:TargetCurrency>USD</web:TargetCurrency>
<web:SourceAmount>1000</web:SourceAmount>
<web:ConvertedAmount>12.15</web:ConvertedAmount>
</web:ConversionResponse>
</soapenv:Body>
</soapenv:Envelope>

16.
 XML with Internal DTD :

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE showroom [
<!ELEMENT showroom (twoWheeler+)>
<!ELEMENT twoWheeler (type, brandName, modelNumber, category, price,
mileage, manufacturer)>
<!ELEMENT type (#PCDATA)>
<!ELEMENT brandName (#PCDATA)>
<!ELEMENT modelNumber (#PCDATA)>
<!ELEMENT category (#PCDATA)>
<!ELEMENT price (#PCDATA)>
<!ELEMENT mileage (#PCDATA)>
<!ELEMENT manufacturer (name, address)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT address (addressLine1, addressLine2, street, city, state, pincode,
customerCare)>
<!ELEMENT addressLine1 (#PCDATA)>
<!ELEMENT addressLine2 (#PCDATA)>
<!ELEMENT street (#PCDATA)>
<!ELEMENT city (#PCDATA)>
<!ELEMENT state (#PCDATA)>
<!ELEMENT pincode (#PCDATA)>
<!ELEMENT customerCare (#PCDATA)>
]>

<showroom>
<twoWheeler>
<type>scooter</type>
<brandName>Honda Activa</brandName>
<modelNumber>ACT123</modelNumber>
<category>utility</category>
<price>75000</price>
<mileage>50</mileage>
<manufacturer>
<name>Honda Motors</name>
<address>
<addressLine1>Plot No. 12</addressLine1>
 <addressLine2>Industrial Area</addressLine2>
<street>MG Road</street>
<city>Gurgaon</city>
<state>Haryana</state>
<pincode>122001</pincode>
<customerCare>18001031031</customerCare>
</address>
</manufacturer>
</twoWheeler>

<twoWheeler>
<type>bike</type>
<brandName>Yamaha FZ</brandName>
<modelNumber>FZV2</modelNumber>
<category>sports</category>
<price>95000</price>
<mileage>45</mileage>
<manufacturer>
<name>Yamaha India</name>
<address>
<addressLine1>No. 21</addressLine1>
<addressLine2>Main Road</addressLine2>
<street>Bannerghatta Road</street>
<city>Bangalore</city>
<state>Karnataka</state>
<pincode>560076</pincode>
<customerCare>18004201600</customerCare>
</address>
</manufacturer>
</twoWheeler>
</showroom>

Key Points:
i. The root element is <showroom>.
ii. Each <twoWheeler> holds:
o Basic info: <type>, <brandName>, <modelNumber>, <category>, <price>,
<mileage>.
o Nested <manufacturer> element which includes <name> and an <address>
block.
 17.

SOAP Request :

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:tem="http://example.com/temperature">
<soapenv:Header/>
<soapenv:Body>
<tem:ConvertTemp>
<tem:FromUnit>DEG</tem:FromUnit>
<tem:ToUnit>FRN</tem:ToUnit>
<tem:Temperature>100</tem:Temperature>
</tem:ConvertTemp>
</soapenv:Body>
</soapenv:Envelope>

SOAP Response :

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:tem="http://example.com/temperature">
<soapenv:Header/>
<soapenv:Body>
<tem:TempConvResponse>
<tem:FromUnit>DEG</tem:FromUnit>
<tem:ToUnit>FRN</tem:ToUnit>
<tem:FromTemp>100</tem:FromTemp>
<tem:ConvertedTemp>212</tem:ConvertedTemp>
</tem:TempConvResponse>
</soapenv:Body>
</soapenv:Envelope>

Notes:
i. The namespaces (like http://example.com/temperature) should be replaced with the
actual namespace URI used by your web service.
ii. The units (DEG, FRN, KVN, etc.) are custom 3-letter codes for degrees Celsius,
Fahrenheit, Kelvin, etc.
iii. SOAP uses XML format to structure the request and response.

Javascript validation questions :

18.

HTML + CSS + JavaScript Code :

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Place Order</title>
<style>
body {
font-family: Arial, sans-serif;
padding: 20px;
}
form {
max-width: 600px;
margin: auto;
background: #f9f9f9;
padding: 20px;
 border-radius: 8px;
}
h2 {
text-align: center;
}
label {
display: block;
margin-top: 10px;
font-weight: bold;
}
input {
width: 100%;
padding: 8px;
margin-top: 5px;
}
.section-title {
margin-top: 20px;
font-size: 18px;
color: #333;
}
button {
margin-top: 20px;
width: 100%;
padding: 10px;
background: #28a745;
color: white;
border: none;
border-radius: 4px;
font-size: 16px;
}
.error {
color: red;
font-size: 14px;
}
</style>
</head>
<body>

<form id="orderForm">
<h2>Place Order</h2>
 <label for="name">Name:</label>
<input type="text" id="name" name="name" required>

<label for="email">Email:</label>
<input type="email" id="email" name="email" required>

<label for="phone">Phone Number:</label>

<input type="tel" id="phone" name="phone" required pattern="[0-9]{10}"
placeholder="10 digits only">

<div class="section-title">Billing Address</div>

<label for="b_house">House No:</label>

<input type="text" id="b_house" name="b_house" required>

<label for="b_street">Street:</label>
<input type="text" id="b_street" name="b_street" required>

<label for="b_city">City:</label>
<input type="text" id="b_city" name="b_city" required>

<label for="b_state">State:</label>
<input type="text" id="b_state" name="b_state" required>

<label for="b_pin">Pin Code:</label>

<input type="text" id="b_pin" name="b_pin" required pattern="[0-9]{6}"
placeholder="6 digit PIN">

<div class="section-title">Shipping Address</div>

<label for="s_house">House No:</label>

<input type="text" id="s_house" name="s_house" required>

<label for="s_street">Street:</label>
<input type="text" id="s_street" name="s_street" required>

<label for="s_city">City:</label>
<input type="text" id="s_city" name="s_city" required>

<label for="s_state">State:</label>
<input type="text" id="s_state" name="s_state" required>
 <label for="s_pin">Pin Code:</label>
<input type="text" id="s_pin" name="s_pin" required pattern="[0-9]{6}"
placeholder="6 digit PIN">

<button type="submit">Submit Order</button>

</form>

<script>
document.getElementById('orderForm').addEventListener('submit', function (e) {
const phone = document.getElementById('phone').value;
const b_pin = document.getElementById('b_pin').value;
const s_pin = document.getElementById('s_pin').value;
let error = '';

if (!/^\d{10}$/.test(phone)) {
error += 'Phone number must be exactly 10 digits.\\n';
}

if (!/^\d{6}$/.test(b_pin)) {
error += 'Billing PIN must be exactly 6 digits.\\n';
}

if (!/^\d{6}$/.test(s_pin)) {
error += 'Shipping PIN must be exactly 6 digits.\\n';
}

if (error) {
e.preventDefault();
alert(error);
}
});
</script>

</body>
</html>
 19.

HTML + JavaScript Form Validation Code :

<!DOCTYPE html>
<html>
<head>
<title>Quick Apply Form</title>
<style>
form {
max-width: 500px;
margin: auto;
padding: 20px;
background: #f9f9f9;
border-radius: 10px;
font-family: Arial, sans-serif;
}
label {
display: block;
margin-top: 10px;
}
input, select, textarea {
width: 100%;
padding: 8px;
margin-top: 5px;
}
button {
margin-top: 15px;
padding: 10px;
width: 100%;
background: #007bff;
color: white;
border: none;
border-radius: 5px;
 font-size: 16px;
}
</style>
</head>
<body>

<form id="quickApplyForm">
<h2>Quick Apply</h2>

<label for="name">Name:</label>
<input type="text" id="name" required>

<label for="email">Email:</label>
<input type="email" id="email" required>

<label for="age">Age:</label>
<input type="number" id="age" required>

<label for="mobile">Mobile No:</label>

<input type="text" id="mobile" required placeholder="10-digit number">

<label for="qualification">Highest Qualification:</label>

<select id="qualification" required>
<option value="">--Select--</option>
<option value="High School">High School</option>
<option value="Diploma">Diploma</option>
<option value="Undergraduate">Undergraduate</option>
<option value="Postgraduate">Postgraduate</option>
</select>

<label for="bio">Short Bio:</label>

<textarea id="bio" rows="5" maxlength="1000" required></textarea>

<button type="submit">Apply</button>
</form>

<script>
document.getElementById('quickApplyForm').addEventListener('submit', function
(e) {
const name = document.getElementById('name').value.trim();
const email = document.getElementById('email').value.trim();
 const age = parseInt(document.getElementById('age').value);
const mobile = document.getElementById('mobile').value.trim();
const qualification = document.getElementById('qualification').value;
const bio = document.getElementById('bio').value.trim();

let errorMsg = '';

if (!name || !email || isNaN(age) || !mobile || !qualification || !bio) {

errorMsg += 'All fields are mandatory.\n';
}

if (age < 18 || age > 35) {

errorMsg += 'Age must be between 18 and 35.\n';
}

if (!/^\d{10}$/.test(mobile)) {
errorMsg += 'Mobile number must be exactly 10 digits.\n';
}

if (bio.length > 1000) {

errorMsg += 'Short Bio must not exceed 1000 characters.\n';
}

if (errorMsg) {
e.preventDefault();
alert(errorMsg);
}
});
</script>

</body>
</html>

20. What are the benefits of using AJAX over conventional web development?

1. Faster User Experience (No Full Page Reloads)

• AJAX allows updating parts of a web page without reloading the entire page.
• Traditional web apps reload the entire page for every interaction.

Example: Submitting a comment without refreshing the whole post page.

2. Reduced Server Load and Bandwidth Usage

• Only the required data (usually small JSON/XML snippets) is sent/received.

• Unlike conventional methods, entire HTML pages aren't sent each time.

This means less data transfer, saving server resources and bandwidth.

3. Improved Interactivity & Responsiveness

• AJAX enables real-time updates and dynamic content loading.

• User actions get quicker feedback, improving usability.

Example: Auto-suggestions while typing in a search bar.

4. Better User Experience

• By avoiding flickers and page reloads, users enjoy a smoother interaction.

• Makes web apps behave more like desktop applications.

5. Seamless Background Data Fetching

• AJAX can fetch or send data in the background, allowing the user to continue using
the page uninterrupted.

6. Supports Asynchronous Operations

• Asynchronous behavior means the page doesn't get blocked while waiting for server
response.

• Multiple requests can happen simultaneously.

7. Modular Code and Easier Maintenance

 • AJAX promotes writing modular, component-based logic where each part of the UI is
independent.

• Easier to test, debug, and maintain.

Feature AJAX Conventional Web Dev

Page reload on actions No Yes

Speed Fast (partial update) Slower (full reload)

Bandwidth usage Lower Higher

Interactivity High Low

User experience Modern/Fluent Disruptive reloads

21. Explain the concept of AJAX. Describe an AJAX operation step by step that
sends a GET request to the server and displays the response in a designated
space on a web page with a suitable example.

*****already explained above just for reference******

Answer:

AJAX (Asynchronous JavaScript and XML) allows web pages to be updated without reloading
the entire page, making them more dynamic and user-friendly. It achieves this by using
JavaScript to send and receive data from a server in the background, using a special object
called XMLHttpRequest.

Here's a step-by-step breakdown of an AJAX operation sending a GET request and displaying
the response:

1. HTML Setup Code

<div id="myDiv"></div>

<button onclick="sendRequest()">Get Data</button>

This HTML sets up a div element (myDiv) where the data will be displayed, and a button that
triggers the AJAX request.

2. JavaScript Code:
JavaScript

function sendRequest() {

// 3. Create an XMLHttpRequest object

var xhttp = new XMLHttpRequest();

// 4. Define the callback function

xhttp.onload = function() {

if (this.status == 200) {

// 5. Update the div with the server response

document.getElementById("myDiv").innerHTML = this.responseText;

} else {

document.getElementById("myDiv").innerHTML = "Error: " + this.status;

};

// 6. Open the request

xhttp.open("GET", "get_data.php"); // Replace "get_data.php" with your server endpoint

// 7. Send the request

xhttp.send();

Step 3:

An XMLHttpRequest object (xhttp) is created. This object handles the communication with
the server.

Step 4:

An onload function is defined. This function is executed when the server responds to the
request. The this.status property indicates the HTTP status code of the response (e.g., 200
for success).

Step 5:

Inside the onload function, the response text (this.responseText) is retrieved and used to
update the content of the myDiv element.

Step 6:
The open() method is used to configure the request:

GET: Specifies the HTTP method (GET in this case).

get_data.php: The URL of the server-side script that will handle the request.

Step 7:

The send() method initiates the request.

3. Server-Side Script (get\_data.php):

Code

<?php

$data = "This data was sent from the server!";

echo $data;

?>

This PHP script (or any other language) receives the request, processes it, and returns the
data as a response. In this example, it simply echoes a string.

In summary: A button click triggers the JavaScript code. The JavaScript creates an AJAX
request, sends it to the server, receives the server's response, and then updates the web
page without a full page reload.

22. Describe the three dialog boxes provided by the window object with code
examples, output and their use.

1. alert() – Display a Message

Description:
• Displays a simple message to the user.
• Only an OK button is available.
• Useful for notifications or warnings.

Code Example:
Javascript:
alert("This is an alert box!");
Output:
A pop-up box with the message:
This is an alert box!
[OK]
Use:
• Show important messages.
• Notify about form validation errors.
• Debugging (simple alerts during development).

2. confirm() – Ask for Confirmation

Description:
• Displays a dialog with OK and Cancel buttons.
• Returns true if OK is clicked, false if Cancel is clicked.
Code Example:
Javascript:
var result = confirm("Do you want to proceed?");
if (result) {
alert("You clicked OK.");
} else {
alert("You clicked Cancel.");
}
Output:
A pop-up box:
Do you want to proceed?
[OK] [Cancel]
Then another box:
You clicked OK. (if OK is clicked)
— OR —
You clicked Cancel. (if Cancel is clicked)
Use:
• Confirm user actions like deletion, submission, or navigation.
• Avoid accidental operations.

3. prompt() – Get User Input

Description:
• Displays a dialog with a message and a text input field.
• Returns the input string or null if Cancel is pressed.
Code Example:
Javascript:
var name = prompt("What is your name?");
if (name !== null) {
alert("Hello, " + name + "!");
}
Output:
What is your name?
[___________]
[OK] [Cancel]
Then:
Hello, John! (if "John" is typed)
Use:
• Collect quick input from the user.
• Prompt for values like names, emails, etc. (in simple apps).