Acropolis Institute of Technology and Research, Indore

Dept. of Computer Science and Engineering

Subject Name: Departmental Elective (S/W. Subject Code: CS - 701

Architecture)

Semester: VII Branch: CSE

List of Experiments:

1. Describe your major project architecture.

2. Define a use case most suitable for data flow, design and describe its architecture using
the data flow architecture.
3. Define a use case most suitable for pipe and filter, design and describe its architecture
using the pipe and filter architecture.
4. Describe the J2EE technology stack.
5. Document some part of your major project architecture using one of the Architecture
Description Languages
6. Document ADLs. Show how and where you will use ADLs in your project.
7. Apply CBAM, ATAM, ARID and ADD to your project and compare each of them with the
former.
8. Draw basic UML diagrams of your project like: Use case, Class, Activity, and Sequence
diagram.
9. Draw Use case diagrams for Bus tracking App.
10. Draw Use Case diagram for MMT App.
11. Write a program to demonstrate transaction operations in Hibernate.
12. Make a simple web page using AngularJS.
13. Write a simple program to demonstrate the use of Servlets and JSP.

Ayush choudhary cs-01 0827CS201052

 1. Describe your major project architecture

If you are using React, Flask, and SVM for your Diabetes Management System, the architecture
will be more streamlined. Here's an overview of the architecture using these technologies:

1. User Interface (UI):

- Create a web-based user interface using React for patients to interact with the system.
- Implement user authentication and authorization for patients to access their data securely.

2. Front-End (React):
- Develop the user interface in React, allowing patients to input and view their diabetes-related
data.
- Use React Router for managing different views and React state management libraries like
Redux or React Context to handle state.

3. Back-End (Flask):
- Implement a Flask-based back-end to handle data processing and model integration.
- Set up RESTful APIs to communicate between the front-end and back-end.
- Handle user authentication and data validation on the back-end.
- Implement Flask extensions for tasks like API development and database connectivity.

4. Data Management:
- Store patient data in a relational database (e.g., PostgreSQL) within Flask. Create database
schemas to store user profiles and diabetes-related data.

5. SVM Model:
- Train an SVM model using diabetes-related data for prediction. You can use libraries like Scikit-
learn for building and training the SVM model.

6. Integration:
- Connect the SVM model with Flask to make predictions based on user data input.

7. Security:
- Implement security measures to protect sensitive patient data, including encryption, secure
authentication, and access control.

8. User Interaction:
- Design the UI to allow patients to input relevant diabetes data, such as blood glucose levels
and medication intake.

9. Prediction and Feedback:

- Upon user data input, send the data to the SVM model for prediction.
- Display the prediction results and provide feedback to patients regarding their diabetes status.

Ayush choudhary cs-01 0827CS201052

10. *Data Storage*:
- Store prediction results and historical patient data in the database for future reference and
analysis.

11. *Testing and Quality Assurance*:

- Implement thorough testing of the entire system, including unit tests, integration tests, and
end-to-end testing to ensure its reliability.

12. *Deployment*:
- Deploy the system on a web server, and configure it for production use. Use tools like Nginx or
Gunicorn to serve the Flask app.

13. *Monitoring and Logging*:

- Set up monitoring and logging to track the performance and health of the system.

14. *Documentation*:
- Provide documentation for administrators and users on how to use the system effectively.

15. *Maintenance and Updates*:

- Plan for regular maintenance, updates, and improvements based on user feedback and
evolving medical standards.

This architecture focuses on the integration of React for the user interface, Flask as the back-end
for data processing and prediction, and an SVM model for diabetes prediction. It simplifies the
system by using a minimal technology stack, making it easier to develop and maintain while still
providing valuable functionality for diabetes management.

2. Define a use case most suitable for data flow, design and describe its
architecture using the data flow architecture.

Data Flow architecture is a software architectural pattern that emphasizes the flow of data
between processing components. It's particularly suitable for systems that process data in a
parallel and distributed manner. One common use case for Data Flow architecture is in real-time
data processing and transformation. Let's define a use case and design its architecture:

A use case that can be implemented using the data flow architecture is Real-Time Analytics
Dashboard . In this scenario, an organization has decided to use a Real-Time Analytics
Dashboard to process and display various real-time metrics, such as website traffic, sales, and
user behavior.

Ayush choudhary cs-01 0827CS201052

Architecture:

Data Sources: In this use case, data sources include user interactions, logs, and database
updates. These sources continuously generate data. The architecture should support
ingesting and handling this data.

Data Processing Components (Data Flow Nodes): These components are responsible for
processing the incoming data streams. Each type of data processing, such as aggregating
page views, calculating conversion rates, or identifying anomalies, is performed by a
specific data processing component. These components act as nodes in the data flow.

Data Flow Channels (Edges): Data Flow architecture requires channels that connect data
processing components. These channels facilitate the transfer of data from one
processing step to the next. They should be scalable and support parallelism, allowing
multiple instances of processing components to work in parallel.

Data Flow Controller: A central control component manages the overall flow of data and
orchestrates the execution of data processing tasks. It decides when and where to route
data and can scale processing components based on demand.

Ayush choudhary cs-01 0827CS201052

Real-Time Dashboard: Processed data is then fed into the real-time dashboard, where it's
displayed to users. This could include various visualizations, charts, and metrics thatprovide
insights into the e-commerce website's performance.

Key Characteristics:

● Parallelism and distributed processing are key features. Data processing components can
run concurrently to handle the high volume of real-time data.

● Data Flow architecture supports a high level of modularity, making it easy to add,
modify, or replace processing components as requirements change.

● The system can dynamically adjust the number of processing components based on data
volume and processing demands, ensuring scalability.

● Fault tolerance and data reliability are critical aspects to handle potential failures or data
loss.

Scalability Considerations:

To ensure scalability, you can use technologies like Apache Kafka for data streaming and Apache
Flink for data processing. These technologies support distributed data processing and can
handle large data volumes efficiently.

In this use case, the Data Flow architecture allows you to handle and analyze a continuous
stream of data from multiple sources in real-time, providing up-to-date insights for the
e-c ommerce website's performance. It also offers the flexibility to adapt to changing
requirements and to scale the system as data volume grows.
In this representation:

● "Data Sources" represent the various sources of data, which continuously provide
incoming data streams.

● "Data Flow Controller" manages the flow of data and orchestrates the execution of data
processing tasks.

● "Data Flow Nodes" (Node 1, Node 2, Node 3, Node 4) represent the data processing
components responsible for performing specific tasks on the incoming data streams.

● "Data Flow Channels" (the lines between nodes) facilitate the transfer of data from one
processing step to the next.

● "Real-Time Dashboard" is where the processed data is displayed in a user-friendly

format, such as visualizations, charts, and metrics.

3. Define a use case most suitable for pipe and filter, design and describe its
architecture using the pipe and filter architecture.

Pipe and filter architecture is a software architectural pattern where data flows through a series
of processing steps (filters) connected by pipes. Each filter performs a specific, isolated task on
the data, and the architecture is designed to facilitate modularity and reusability. This
architecture is particularly useful when you have a large amount of data that needs to be
processed in stages, and each processing step can be executed independently and concurrently.

A use case that can be implemented using the pipe and filter architecture is Image Processing
Pipeline . In this scenario, an unprocessed image undergoes a series of transformations to
become a processed image that can serve a more useful purpose. The pipe and filter
architecture can be used to break down the image processing task into smaller independent
components or filters that can be chained together in a pipeline. Each filter performs a single
task on the imagestream, such as removing background noise or converting the data to a
different format

Imagine you have a system that processes images. You need to apply a series of operations to
an input image, such as resizing, color correction, and applying filters. This use case is suitable

Ayush choudhary cs-01 0827CS201052

for a pipe and filter architecture as each image processing operation can be treated as a filter,
and the data (the image) flows through this series of filters.

Architecture:

Input Data Source (Pipe): This is the entry point of your pipeline. It could be a
user-uploaded image or an image fetched from a database. The input image is passed
into the pipeline.

Filter 1 - Image Resizing (Filter): The first filter in the pipeline is responsible for resizing
the input image to a specific resolution. It takes the input image and produces a resized
image as output. This filter only performs resizing and passes the resized image to the
next filter.

Filter 2 - Color Correction (Filter): The second filter in the pipeline is responsible for
applying color correction to the resized image. It might adjust brightness, contrast, and
color balance. The output is a color-corrected image.

Filter 3 - Image Filtering (Filter): The third filter in the pipeline applies various filters to
the color-corrected image. Filters could include effects like blurring, sharpening, or
applying artistic filters. The output is the filtered image.

Output Data Sink (Pipe): The final output is the processed image, which can be stored in
a database, displayed to the user, or used for various purposes.

Key Characteristics:

● Each filter is a self-contained module responsible for a specific operation.

● Filters are connected in a linear sequence where data flows from one filter to the next.

● The data (the image) is immutable; each filter takes an input and produces an output
without modifying the original data.

● Filters can be developed independently, and new filters can be added or existing ones
can be modified without affecting the entire pipeline.

Ayush choudhary cs-01 0827CS201052

 ● Parallelism and concurrency can be leveraged to improve the processing speed, as each
filter can run on a separate thread or process.

This architecture is flexible and allows for the easy addition or removal of filters, making it
suitable for scenarios where you have a series of data processing tasks that can be executed in a
modular and scalable manner.

4. Describe the J2EE technology stack.

The J2EE technology stack is a set of specifications and technologies for building and deploying
enterprise-level, distributed, and scalable Java applications. It provides a robust platform for
developing and running enterprise applications, including web applications, EJB (Enterprise
JavaBeans) components, and more. The main components of the J2EE technology stack include:

Servlets: Servlets are Java classes that handle HTTP requests and responses. They are
commonly used to build web applications. Servlets provide a way to extend web servers
to generate dynamic content, process form data, and perform other server-side tasks.

JSP (JavaServer Pages): JSP is a technology that simplifies the creation of dynamic web
content. JSP pages are essentially HTML templates with embedded Java code. They are
compiled into servlets and executed on the server to generate dynamic web pages.

EJB (Enterprise JavaBeans): EJB is a server-side component model that simplifies the
development of scalable and transactional business logic. There are three types of EJBs:

● Session Beans: Implement business logic and are stateless or stateful.

● Entity Beans: Represent data stored in a database and provide a high-level

interface to interact with the database.

Ayush choudhary cs-01 0827CS201052

 ● Message-Driven Beans: Handle asynchronous processing of messages, typically
using JMS (Java Messaging Service).

JDBC (Java Database Connectivity): JDBC is a Java API for connecting to relational
databases. It provides a standardized way to interact with databases, enabling data
storage and retrieval.

JNDI (Java Naming and Directory Interface): JNDI is used for naming and directory
services, enabling the location and retrieval of resources and services in a distributed
environment. It's commonly used for EJB and database connection management.

JMS (Java Messaging Service): JMS is a messaging API for sending and receiving
messages asynchronously. It's used for building scalable and loosely coupled systems,
and it's often integrated with EJBs.

JTA (Java Transaction API): JTA is an API for managing distributed transactions. It provides
the ability to coordinate transactions across multiple resources, such as databases and
message queues.

JCA (Java Connector Architecture): JCA provides a standard architecture for connecting
enterprise systems to EIS (Enterprise Information Systems), like ERP and CRM systems. It
allows for the development of resource adapters that facilitate communication between
Java applications and EIS.

JavaMail API: The JavaMail API is used for sending and receiving email messages. It
allows Java applications to send email through standard SMTP, POP3, and IMAP mail
servers.

JSP Tag Libraries: J2EE provides custom tag libraries for JSP, such as JSTL (JavaServer
Pages Standard Tag Library) and custom tag libraries for various purposes, like form
handling, database access, and more.

The J2EE technology stack provided a comprehensive set of tools and APIs for building
enterprise-grade applications, promoting modularity, reusability, and scalability. Over time, J2EE
evolved into Java EE and then Jakarta EE, with various improvements and changes, but many of
the core concepts and technologies have remained relevant in the development of Java-based
enterprise applications.

Ayush choudhary cs-01 0827CS201052

 5. Document some part of your major project architecture using one of the
Architecture Description Languages

Document some part of your major project architecture using one of the Architecture Description
Languages

Documenting a part of the diabetes detection system architecture using an Architecture

Description Language (ADL) can be a structured and standardized way to convey architectural
details. One widely used ADL is the Unified Modeling Language (UML). Here's an example of how
you might document part of the system using UML:

Use Case Diagram:

A Use Case Diagram in UML can help you represent the interactions between the system and
external actors, highlighting the main functionalities or use cases. In the context of a diabetes
detection system, you might have actors such as "Patient," "Healthcare Professional," and
"External Data Source."

plaintext
Copy code
+----------------+ +------------------------+
| Patient | | Healthcare Professional |
+----------------+ +------------------------+
| |
| |
| |
+--------------------- --+ +--------------------------+
| Diabetes Detection| | External Data Source |
| System | | |
+---------------- --+ +--------------------------+
| |
| |
| |
| |
+-----------------------------------------------------------------------+
| Diabetes Detection Use Cases |
+----------------------------------------------------------- ------------+
In the above diagram:
"Patient" and "Healthcare Professional" are external actors who interact with the system.
"External Data Source" represents external data input, such as data from wearable devices or
patient records.
"Diabetes Detection System" is the main system under consideration.
"Diabetes Detection Use Cases" represents the primary functionalities or use cases of the system,
Ayush choudhary cs-01 0827CS201052
like "Perform Diabetes Risk Assessment," "Display Recommendations," "Input Patient Data," etc.
This Use Case Diagram provides a high-level overview of how different actors interact with the
diabetes detection system and the primary use cases it supports. You can further expand on each
use case with more detailed UML diagrams, such as Activity Diagrams, Sequence Diagrams, or
Class Diagrams, depending on the level of detail you need to convey. These diagrams would
provide a more in-depth view of the system's architecture, components, and interactions.

6. Document ADLs. Show how and where you will use ADLs in your project.

An Architecture Description Language (ADL) is a formal language used to represent and

document the architecture of a system. ADLs provide a structured and standardized way to
describe the components, relationships, and behavior of a complex system. They are especially
valuable in software and systems engineering for conveying high-level architectural concepts,
facilitating communication, and supporting design and analysis. Here, I'll discuss how and where
you might use ADLs in a project.

Usage of ADLs in a Project:

Project Initiation and Planning:

● At the outset of a project, you can use an ADL to create an architectural vision
and outline high-level design decisions.

● An ADL can help identify architectural requirements, constraints, and quality

attributes that guide the system's design.

Design and Development:

Ayush choudhary cs-01 0827CS201052

 ● During the design phase, you can create detailed architectural models using an
ADL to document the system's structure, components, and interactions.

● ADLs can be used to specify architectural patterns, components, connectors,

interfaces, and their relationships.

● They support the creation of diagrams and documentation that provide a clear
understanding of the system's architecture to stakeholders.

Collaboration and Communication:

● ADLs serve as a common language for architects, developers, and stakeholders,

improving collaboration and communication among project teams.

● They help ensure that everyone has a shared understanding of the system's
architecture.

Analysis and Evaluation:

● ADLs can facilitate architectural analysis, including performance, security, and

scalability assessments.

● You can use the formal notation of ADLs to perform model-based analysis and
validation of architectural decisions.

Documentation and Maintenance:

● ADLs are valuable for creating comprehensive architectural documentation that

aids in system maintenance and future enhancements.

● They help preserve institutional knowledge about the system's design and
rationale.

Compliance and Standards:

● In regulated industries, ADLs may be required to demonstrate compliance with

architectural standards and best practices.

● ADLs support the creation of architecture artifacts that align with industry
standards and guidelines.

Examples of ADLs:

Ayush choudhary cs-01 0827CS201052

 ● ArchiMate: A widely used ADL for enterprise architecture, focusing on representing the
structural and behavioral aspects of systems, including their relationships with the
business and technology environments.

● UML (Unified Modeling Language): UML is a general-purpose modeling language that

includes architectural modeling components. It's frequently used for system and
software architecture documentation.

● ADML (Architecture Description Markup Language): ADML is an XML-based language

used for representing and exchanging architecture descriptions, suitable for both
software and systems engineering.

Document ADLs. Show how and where you will use ADLs in your project.
Where to Use ADLs in Your Project:

ADLs (Attribute-Driven Design) is an architectural design approach that focuses on achieving

specific quality attributes in a software system. In the context of a diabetes detection system
project, you can use ADLs to ensure that the system is designed to meet the desired quality
attributes. Here are some areas where you can apply ADLs in a diabetes detection system project:

Scalability:Use ADLs to design the system's architecture to be scalable, allowing it to handle a

growing number of users, data, and devices. This is particularly important if the system is
expected to expand over time.

Reliability:Apply ADLs to design the system with redundancy, fault tolerance, and robust error-
handling mechanisms to ensure that it operates reliably. For a diabetes detection system,
ensuring data accuracy and system uptime is crucial.

Performance:Use ADLs to optimize the system's performance. This includes designing efficient
algorithms and data structures for data analysis, minimizing response times, and managing system
resource utilization.

Security:Employ ADLs to build security measures into the system's architecture. This includes
encryption of sensitive data, access control, authentication, and authorization mechanisms. Given
the sensitivity of health data in a diabetes detection system, security is paramount.

Usability:Apply ADLs to design a user-friendly interface that ensures ease of use for patients and
healthcare professionals. Usability includes features like clear navigation, informative feedback,
and accessibility for all users.

Ayush choudhary cs-01 0827CS201052

Maintainability:Use ADLs to structure the codebase and system components in a way that
facilitates future maintenance and updates. A well-organized architecture simplifies the addition
of new features and the resolution of issues.

Interoperability:Design the system to be interoperable with other healthcare systems and

standards, ensuring seamless data exchange and compatibility with external devices and data
sources.

Compliance:Ensure that the system architecture is designed to comply with relevant healthcare
regulations and standards, such as HIPAA (Health Insurance Portability and Accountability Act) for
data privacy and security.

Data Management:Utilize ADLs to establish data storage and retrieval mechanisms that meet data
management requirements, including data consistency, data integrity, and data access
performance.

Analytics and Decision Support:Apply ADLs to the design of analytics and decision support
components to ensure that the system can provide valuable insights and recommendations based
on data analysis and machine learning models.

Integration:Ensure that the system architecture is designed to seamlessly integrate with other
healthcare systems, electronic health records (EHRs), and wearable devices to enhance the overall
ecosystem.

Cost-Efficiency:Consider the cost-effectiveness of the system's architecture, optimizing resource

utilization and minimizing operational expenses while meeting the desired quality attributes.

By integrating ADLs into these aspects of the diabetes detection system project, you can ensure
that the architectural design aligns with the specific quality attributes required for the system's
success. This approach helps you make informed decisions about the system's design, prioritize
architectural elements, and guide the development process to meet the project's goals.

Ayush choudhary cs-01 0827CS201052

 7. Apply CBAM, ATAM, ARID and ADD to your project and compare each of them
with the former.

Cost-Benefit Analysis (CBA) is a valuable method to assess the financial viability and overall
feasibility of implementing a diabetes detection system. In this context, a CBA can help you
determine whether the benefits of the system outweigh the costs associated with its
development, deployment, and maintenance.

ATAM (Architecture Tradeoff Analysis Method):

ATAM is primarily used for evaluating the architecture of a software system and identifying trade-
offs between different architectural attributes.
It can be applied to assess the trade-offs in a diabetes detection system, considering factors like
accuracy, computational efficiency, scalability, and maintainability.
ATAM can help in making architectural decisions based on well-defined quality attributes.
ARID (Architecture Representation for Infomediary Design):

ARID is designed to represent architectures of infomediaries, which are systems that provide
information services. It might not be directly applicable to a diabetes detection system, as it's
tailored for a different domain.
However, if your diabetes detection system includes information services or data exchange, you
could adapt ARID principles for that specific part of the architecture.
ADD (Attribute-Driven Design):

ADD is an approach to software design that focuses on achieving specific quality attributes or
characteristics (such as performance, security, and reliability).
It can be used to design the diabetes detection system's software components with an emphasis
on attributes like accuracy, usability, and reliability.
You can use ADD to guide the design process by prioritizing the most critical quality attributes for
your system.
To compare these methods, consider the following aspects:

Relevance: Evaluate how well each method aligns with the goals and needs of your diabetes
detection system. Some methods might be more suitable for certain aspects of the system.

Complexity: Assess the complexity and effort required to apply each method. Some methods may
be more time-consuming or resource-intensive than others.

Precision: Consider how accurately each method can capture and address the specific
Ayush choudhary cs-01 0827CS201052
requirements and challenges of diabetes detection.

Flexibility: Determine how adaptable each method is to changes in the system's requirements or
design constraints.

Integration: Examine how easily each method can be integrated into your development process
and workflow.

Ultimately, the choice of which method to use or combine will depend on the specific context of
your diabetes detection system, your project's goals, and the expertise of your development
team. You may even find it beneficial to use a combination of these methods to address different
aspects of the system's architecture and design.

Ayush choudhary cs-01 0827CS201052

8. Draw basic UML diagrams of your project like: Use case, Class, Activity, and
Sequence diagram.

Sequence diagram:

Ayush choudhary cs-01 0827CS201052

Activity Diagram:

Ayush choudhary cs-01 0827CS201052

9. Draw Use case diagrams for Bus tracking App.

Ayush choudhary cs-01 0827CS201052

10. Draw Use Case diagram for MMT App.

11. Write a program to demonstrate transaction operations in Hibernate.

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

public class HibernateTransactionDemo {

public static void main(String[] args) {

Configuration configuration = new Configuration();

Ayush choudhary cs-01 0827CS201052

 configuration.configure("hibernate.cfg.xml");

SessionFactory sessionFactory = configuration.buildSessionFactory();

Session session = sessionFactory.openSession();

Transaction transaction = session.beginTransaction();

try {

YourEntity entity = new YourEntity();

entity.setSomeProperty("Some Value");

session.save(entity);

transaction.commit();

} catch (Exception e) {

e.printStackTrace();

transaction.rollback();

} finally {

session.close();

sessionFactory.close();

Ayush choudhary cs-01 0827CS201052

12. Make a simple web page using AngularJS.

<!DOCTYPE html>
<html>
<head>
<title>Simple Web Page with AngularJS</title>
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.8.2/angular.min.js"></script>
</head>
<body ng-app="myApp" ng-controller="myCtrl">

<h1>Simple Web Page with AngularJS</h1>

<div>
<input type="text" ng-model="newItem" placeholder="Add a new item">
<button ng-click="addItem()">Add</button>
</div>

<ul>
<li ng-repeat="item in items">
{{ item }}
<button ng-click="removeItem($index)">Remove</button>
</li>
</ul>

<script>
var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope) {
$scope.items = ["Item 1", "Item 2", "Item 3"];

$scope.addItem = function() {
if ($scope.newItem) {
$scope.items.push($scope.newItem);
$scope.newItem = "";
}
};

Ayush choudhary cs-01 0827CS201052

 $scope.removeItem = function(index) {
$scope.items.splice(index, 1);
};
});
</script>
</body>
</html>

13. Write a simple program to demonstrate the use of Servlets and JSP.

Create a Servlet:

import java.io.*;

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

@WebServlet("/HelloServlet")

public class HelloServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

String name = request.getParameter("name");

request.setAttribute("name", name);

RequestDispatcher dispatcher = request.getRequestDispatcher("greeting.jsp");

dispatcher.forward(request, response);

Ayush choudhary cs-01 0827CS201052

Create a JSP Page:

<!DOCTYPE html>

<html>

<head>

<title>Greeting Page</title>

</head>

<body>

<h1>Greetings, <%= request.getAttribute("name") %>!</h1>

</body>

</html>

Create a Web Deployment Descriptor (web.xml):

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

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">

<servlet>

<servlet-name>HelloServlet</servlet-name>

<servlet-class>HelloServlet</servlet-class>

Ayush choudhary cs-01 0827CS201052

 </servlet>

<servlet-mapping>

<servlet-name>HelloServlet</servlet-name>

<url-pattern>/HelloServlet</url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

</welcome-file-list>

</web-app>

Ayush choudhary cs-01 0827CS201052