1. Introduction
2. Core Processes of the System Development Life Cycle
3. Functional and Non-Functional Requirements
4. Stakeholders and Contributions to Requirements Definition
5. Domain Model Diagram
6. Use Case Descriptions
7. Security Methods and Controls
8. Impact of Visibility and Affordance on Usability
9. Conclusion
1. Introduction
Introduction
The purpose of this report is to provide a solution for the development of an application for the campus
canteen that will allow a student to place an order and schedule delivery of that order to a specified venue
on campus. The application will also accept payments via credit card. In order to develop this application, it
is important to follow the core processes of the System Development Life Cycle (SDLC), which include
planning, analysis, design, implementation, and maintenance.
The planning phase involves identifying the problem, determining the feasibility of the project, and defining
the project scope. In this case, the problem is the lack of an efficient system for ordering and delivering
food on campus. The feasibility of the project will be determined by assessing the resources available, such
as time, budget, and personnel. The project scope will be defined by identifying the features and
functionalities of the application.
The analysis phase involves gathering and analyzing requirements for the application. This includes
identifying functional and non-functional requirements, as well as stakeholders and their contributions to
requirements definition. Functional requirements are the features and functionalities that the application
must have, such as the ability to place an order and schedule delivery. Non-functional requirements are the
qualities that the application must possess, such as security and usability. Stakeholders are the individuals
or groups that have an interest in the application, such as students, canteen staff, and IT personnel.
The design phase involves creating a domain model diagram to show the relationship between the classes in
the application, as well as developing use case descriptions to describe the interactions between the user
and the application. The domain model diagram will show the classes ‘Student’, ‘Order’, and ‘OrderItem’, and
their relationships. The use case descriptions will describe the steps involved in placing an order and
scheduling delivery.
The implementation phase involves coding and testing the application. This includes developing security
methods and controls to protect the data that will be processed by the application. It is important to ensure
that the security controls do not impede on the usability of the application.
The maintenance phase involves maintaining and updating the application to ensure that it continues to
meet the needs of the users. This includes fixing bugs, adding new features, and improving the usability and
security of the application.
In conclusion, the development of an application for the campus canteen requires following the core
processes of the System Development Life Cycle, which include planning, analysis, design, implementation,
and maintenance. By following these processes, the application can be developed efficiently and effectively,
while ensuring that it meets the needs of the users and is secure and usable.
2. Core Processes of the System Development Life
Cycle
The System Development Life Cycle (SDLC) is a process used by software developers to design, develop,
and maintain software systems. The core processes of the SDLC are as follows:
1. Planning: In this phase, the project team defines the scope of the project, identifies the
stakeholders, and creates a project plan.
2. Analysis: In this phase, the project team analyzes the requirements of the system and creates a
detailed specification document.
3. Design: In this phase, the project team designs the system architecture, creates a detailed design
document, and develops a prototype.
4. Implementation: In this phase, the project team develops the software system, tests it, and deploys
it.
5. Maintenance: In this phase, the project team maintains the software system, fixes any bugs, and
makes any necessary updates.
(Source: SDLC - System Development Life Cycle)
For the campus canteen application, the planning phase would involve defining the scope of the project,
identifying the stakeholders (such as students, canteen staff, and IT support), and creating a project plan.
The analysis phase would involve analyzing the requirements of the system, such as the ability to place an
order and schedule delivery, and creating a detailed specification document. The design phase would
involve designing the system architecture, such as the database structure and user interface, creating a
detailed design document, and developing a prototype. The implementation phase would involve developing
the software system, testing it, and deploying it. Finally, the maintenance phase would involve maintaining
the software system, fixing any bugs, and making any necessary updates.
3. Functional and Non-Functional Requirements
Functional requirements are the features and capabilities that a system must have in order to meet the
needs of its users. Non-functional requirements are the characteristics that a system must have in order to
be considered usable, reliable, and efficient. In the case of the campus canteen application, some examples
of functional requirements are:
1. The ability for a student to place an order for food items from the canteen.
2. The ability for a student to schedule delivery of the order to a specified venue on campus.
3. The ability for the application to accept payments via credit card.
Non-functional requirements for the campus canteen application may include:
1. Security: The application must be secure and protect sensitive information such as credit card
details.
2. Usability: The application must be easy to use and navigate for students.
3. Reliability: The application must be available and functional at all times during the canteen’s
operating hours.
4. Stakeholders and Contributions to Requirements
Definition
Stakeholders are individuals or groups who have an interest in the development of a system. They can be
internal or external to the organization. In the case of the campus canteen application, the stakeholders can
be identified as follows:
1. Students: They are the primary users of the application and will be placing orders and making
payments.
2. Canteen staff: They will be responsible for preparing and delivering the orders.
3. IT department: They will be responsible for developing and maintaining the application.
4. Campus security: They will be responsible for ensuring the security of the application and the data
it processes.
5. Finance department: They will be responsible for managing the financial transactions processed by
the application.
Each stakeholder has a unique perspective and set of requirements that must be taken into consideration
during the requirements definition phase. For example, students may prioritize ease of use and
convenience, while the IT department may prioritize security and scalability.
To ensure that all stakeholders’ requirements are captured, it is important to involve them in the
requirements definition process. This can be done through interviews, surveys, and focus groups. By
involving stakeholders, the development team can gain a better understanding of their needs and
expectations, and can develop a system that meets those needs.
Source: Sommerville, I. (2016). Software engineering. Pearson Education Limited.
5. Domain Model Diagram
To create a domain model diagram for the campus canteen application, we need to identify the classes and
their relationships. The three classes we will be using are ‘Student’, ‘Order’, and ‘OrderItem’.
Student Class
Attributes: StudentID, Name, Email
Relationships: One student can place many orders
Order Class
Attributes: OrderID, OrderDate, DeliveryVenue
Relationships: One order can have many order items, one order belongs to one student
OrderItem Class
Attributes: ItemID, ItemName, Quantity, Price
Relationships: One order item belongs to one order
The domain model diagram for the campus canteen application would look like this:
+----------------+
+----------------+
+----------------+
|
|
|
Student
|
Order
|
OrderItem
|
+----------------+
+----------------+
+----------------+
| - StudentID
|
| - OrderID
|
| - ItemID
|
| - Name
|
| - OrderDate
|
| - ItemName
|
| - Email
|
| - DeliveryVenue|
| - Quantity
|
|
|
|
|
| - Price
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
+----------------+
+----------------+
6. Use Case Descriptions
+----------------+
Use Case Name: Placing an Order and Scheduling Delivery
Brief Description:
The use case involves a student placing an order for food from the campus canteen and scheduling the
delivery of the order to a specified venue on campus. The student will be able to select the items they want
to order, specify the delivery location and time, and make payment via credit card.
Actor(s):
Student
Flow of Activities:
1. The student opens the canteen application and logs in.
2. The student selects the option to place an order.
3. The student browses the menu and selects the items they want to order.
4. The student specifies the delivery location and time.
5. The student confirms the order and is directed to the payment page.
6. The student enters their credit card details and confirms the payment.
7. The system confirms the order and displays the estimated delivery time.
8. The student receives a notification when the order is ready for delivery.
9. The student receives the order at the specified location and time.
Source:
Satzinger, J. W., Jackson, R. B., & Burd, S. D. (2016). Systems analysis and design in a changing
world. Cengage Learning.
7. Security Methods and Controls
When developing an application that accepts and processes payments, it is important to implement security
methods and controls to protect the data being processed. Here are three security controls that can be
implemented in the campus canteen application:
1. Encryption: All sensitive data, such as credit card information, should be encrypted to prevent
unauthorized access. This can be achieved by using SSL/TLS protocols to encrypt data in transit,
and by using strong encryption algorithms to encrypt data at rest.
2. Access Control: Access to the application and its data should be restricted to authorized users
only. This can be achieved by implementing user authentication and authorization mechanisms,
such as username and password authentication, two-factor authentication, and role-based access
control.
3. Auditing and Logging: All user activities and system events should be logged and audited to
detect and prevent security breaches. This can be achieved by implementing logging mechanisms
that record all user activities and system events, and by using auditing tools to analyze the logs and
detect any suspicious activities.
In addition to implementing security controls, it is also important to ensure that the application remains
usable and user-friendly. Here are two ways in which usability can be ensured:
1. Simplicity: The application should be designed to be simple and easy to use, with clear and
concise instructions and minimal user input required.
2. Feedback: The application should provide feedback to the user at every step of the process, to
ensure that the user is aware of what is happening and what is expected of them. This can be
achieved by using clear and concise error messages, progress indicators, and confirmation
messages.
8. Impact of Visibility and Affordance on Usability
Visibility and affordance are two important factors that impact the usability of a system. Visibility refers to
the ability of a user to see and understand the available options and actions within a system. Affordance
refers to the ability of a user to understand what actions are possible within a system based on its design
and layout.
According to a study by Nielsen Norman Group, visibility and affordance are critical to the success of a
system. The study found that users are more likely to use a system that is easy to understand and navigate.
In order to achieve this, designers must ensure that the system provides clear and concise feedback to
users, and that the system’s layout and design are intuitive and easy to use.
One way to improve visibility and affordance is to use consistent design patterns throughout the system.
This includes using consistent colors, fonts, and icons, as well as ensuring that the layout of the system is
consistent across all pages and screens. Additionally, designers should ensure that the system provides
clear and concise feedback to users, such as error messages and confirmation messages.
Another way to improve visibility and affordance is to conduct user testing throughout the design process.
This allows designers to gather feedback from users and make changes to the system based on their
feedback. By involving users in the design process, designers can ensure that the system is easy to use and
meets the needs of its users.
In conclusion, visibility and affordance are critical to the success of a system. By using consistent design
patterns, providing clear and concise feedback, and conducting user testing, designers can improve the
usability of a system and ensure that it meets the needs of its users.
9. Conclusion
Conclusion
In conclusion, the development of the campus canteen application requires a thorough understanding of the
System Development Life Cycle (SDLC) and the different processes involved. It is important to identify and
understand the functional and non-functional requirements of the application, as well as the stakeholders
and their contributions to the requirements definition. The domain model diagram and use case descriptions
are crucial in the development of the application, as they provide a clear understanding of the relationships
between classes and the flow of activities.
Security methods and controls are also important considerations in the development of the application, as
cyber security is becoming a big concern. It is important to implement security controls such as encryption,
access control, and authentication to ensure the security of the data being processed. However, it is equally
important to ensure that these controls do not impede on the usability of the application.
Finally, the impact of visibility and affordance on usability should also be considered in the development of
the application. The application should be designed in such a way that it is easy to use and understand, with
clear and concise instructions.
Overall, the development of the campus canteen application requires a holistic approach that takes into
consideration the different aspects of software development, from requirements definition to security and
usability. By following the SDLC and implementing the necessary controls and considerations, the
application can be developed to meet the needs of the stakeholders and provide a seamless user
experience.
10 References
S. Bennett and K. McRobb, Object-Oriented Systems Analysis and Design Using UML, 2nd ed.
Maidenhead, UK: McGraw-Hill Education, 2010.
“Functional vs. Non-Functional Requirements: What’s the Difference?” ReQtest, 2019. [Online].
Available: https://reqtest.com/requirements-blog/functional-vs-non-functional-requirements-whats
-the-difference/. [Accessed: 10-Jun-2021].
Satzinger, J. W., Jackson, R. B., & Burd, S. D. (2016). Systems analysis and design in a changing
world. Cengage Learning.
Kendall, K. E., & Kendall, J. E. (2011). Systems analysis and design. Pearson Education.
Pressman, R. S. (2014). Software engineering: a practitioner’s approach. McGraw-Hill Education.
Sommerville, I. (2016). Software engineering. Pearson Education Limited.