ASSIGNMENT 1 FRONT SHEET

Qualification Pearson BTEC Level 5 Higher National Diploma in Computing

Unit number and title Unit 22: Application Development

Submission date Date Received 1st submission

Re-submission Date Date Received 2nd submission

Student Name Student ID

Class Assessor name

Student declaration

I certify that the assignment submission is entirely my own work and I fully understand the consequences of plagiarism. I understand that
making a false declaration is a form of malpractice.

Student’s signature

Grading grid

P1 P2 M1 M2 D1

Page | 1
 Summative Feedback:  Resubmission Feedback:

Grade: Assessor Signature: Date:

Internal Verifier’s Comments:

Signature & Date:

Page | 2
Contents
I. INTRODUCTION..................................................................................................................................... 4
II. Produce a well-defined problem definition statement, supported by a set of user and system
requirements for a business problem (P1)..................................................................................................4
A. Problem Definition.......................................................................................................................4
B. User Requirements...................................................................................................................... 5
C. System Requirements.................................................................................................................. 6
III. Review areas of risk related to the successful development of a proposed application (P2)........9
A. Technical Risks............................................................................................................................. 9
B. Security Risks..............................................................................................................................12
C. User-related Risks...................................................................................................................... 15
D. Development Process Risks....................................................................................................... 16
IV. Research the use of software development tools and techniques for the development of a
proposed application (P3)..........................................................................................................................17
A. Software Development Tools.................................................................................................... 17
V. CONCLUSION....................................................................................................................................... 24
VI. REFERENCES (Harvard Style)..........................................................................................................24

I. INTRODUCTION

II. Produce a well-defined problem

definition statement, supported by a set
of user and system requirements for a
business problem (P1)
A. Problem Definition
o The challenge that university students face is managing their finances while staying within
their budgets. Many students have difficulty tracking their daily expenses, especially with
the various costs of living on or off-campus, such as rent, groceries, transportation, and
entertainment. Without a simple and efficient way to monitor their spending, students often
end up overspending or failing to allocate their funds properly.

Page | 3
 o Key Problems to Address:
 Lack of Budgeting Awareness: Students may not have experience managing personal
finances, leading to overspending and financial stress.
 Difficulty in Tracking Expenses: Students typically have multiple sources of income
(scholarships, part-time jobs, family support) and various types of expenses. Tracking
these manually can be confusing and time-consuming.
 Need for Simple, User-Friendly Tools: Most existing financial management apps are
either too complex or not tailored to the specific needs of students, making them less
accessible or relevant.
o By addressing these issues, the CampusExpense Manager application will provide a platform
where students can easily track their expenses, monitor their budgets, and ultimately
develop better financial habits during their academic journey.
o For users (students):
 Increased financial stress: Students who do not keep track of their spending may end up
spending more than they can afford, which can lead to financial stress. This can affect
their quality of life while studying.
 Lack of initiative in managing personal finances: Failure to manage spending effectively
can leave students with no clear picture of their financial situation. They may have
difficulty saving or budgeting for necessities such as rent, tuition, and living expenses.
 Wasted resources: Many students have limited income from scholarships, family grants,
or part-time jobs. Failure to manage these resources well can lead to them wasting
money on unnecessary expenses, leading to a lack of funds for important expenses.
o For businesses (BudgetWise Solutions):
 Missed business opportunity: If BudgetWise Solutions fails to provide a suitable solution
to help students manage their expenses, they may miss out on a business opportunity in
a large potential market. Students have a large customer base and have an urgent need
for financial management.
 Reputation impact: Developing an ineffective expense management application can
negatively impact BudgetWise Solutions' reputation, reducing its ability to attract future
customers and partners.
 Difficult to scale: If BudgetWise Solutions does not thoroughly solve students' financial
problems through the application, it will be difficult to scale the product to other
markets or attract more users.

B. User Requirements
o List the user's functional requirements.

 User Registration and Authentication

 Expense Tracking
 Budget Setting
 Expense Overview
 Recurring Expenses
 Expense Reports

Page | 4
  Notifications and Alerts
 Feedback and Support
o Mention the key features that users want.
 User Registration and Authentication:
 Users can create an account using a username and password.
 Secure login and authentication allow access to personal expense data.
 Password recovery option for users who forget their credentials

 Expense Tracking
 Users can add, edit, and delete expenses, providing details such as the amount, date,
description, and category (e.g., rent, groceries, transportation).
 Categorization helps users organize their expenses effectively.

 Budget Setting
 Users can set a monthly budget for different categories like food, entertainment, or
education.
 The budget can be adjusted over time to accommodate changing financial needs

Page | 5
 Expense Overview
 The app provides a clear overview of total monthly expenses, remaining budget, and
a breakdown by category.
 Users can view trends over time to analyze spending patterns and adjust their budget

 Recurring Expenses
 Users can add recurring expenses (e.g., rent, subscription services), and the app will
automatically log these expenses in the budget at the specified intervals.

Page | 6
  Expense Reports
 Users can generate detailed reports of their expenses for a specific time period (e.g.,
monthly or yearly), broken down by category
 Notifications and Alerts
 The app sends notifications to alert users when they are approaching or exceeding
their budget for certain categories.
 Reminders for upcoming or overdue expenses
 Feedback and Support
 An in-app feedback form allows users to report issues or provide suggestions.
 Quick access to support for resolving any app-related concerns

C. System Requirements
1. Functional Requirements

 User Account Management:

 New User Registration: The system allows students to register an account using email
or social network accounts (Google, Facebook).
 Login: Supports login via username/password and optional two-factor authentication
(2FA) for enhanced security.
 Forgot Password: The system allows users to recover their password if they forget it
via email or phone number.
 Update Account Information: Users can edit personal information such as name,
email, and profile picture.

Page | 7
 Budget Management:
 Setting Budget: Users can set an overall budget or individual budgets for each
category (such as food, tuition, entertainment).
 Edit Budget: The system allows users to adjust the budget at any time during the
month.
 Over-Budget Notification: When spending exceeds the set budget, the system will
send a warning notification.
 Spending Tracking:
 Expense Recording: Users can add, edit or delete expenses manually or automatically
(via bank integration or QR code scanning).
 Expense Classification: The system automatically classifies expenses into categories
such as food, tuition, entertainment, etc.
 Expense Report: Provides daily, weekly, monthly expense reports in the form of
visual tables or charts.
 Income Management:
 Record Income: Allows users to enter income from various sources (salary,
scholarship, family allowance).
 Edit and delete income: Users can change or delete income when necessary.
 Plan and track savings goals:
 Set savings goals: Helps users set financial goals (e.g. save for books, save for a
vacation).
 Track progress: The system tracks savings progress and reports progress against
goals.
 Sharing and Collaboration Features:

Page | 8
  Share Expenses: Users can share common expenses with roommates or relatives and
calculate the split of expenses.
 Invite Users: Support sending invitations via email or link to share budget plans and
track common expenses.
 Notifications and reminders:
 Expense recording reminder: The system automatically sends daily reminders for
users to update their spending.
 Large spending notification: When there is a large spending, the system will send a
notification to let users know and adjust if necessary.
 Low budget warning: Send a notification when spending is about to exceed the set
budget.
 Data Integration:
 Synchronization with Bank Accounts: The system is capable of connecting and
synchronizing with users' bank accounts to automatically record financial
transactions.
 Integration with Other Services: The application can connect with other financial
management tools to retrieve data or share data between applications.
 Security and Privacy:
 Data Encryption: Users' financial and personal data is encrypted to ensure safety.
 Privacy Management: Users can set privacy settings, choose what information will be
shared and what information will be kept private.
 Multi-language support:
 The system provides multi-language support so that users from different cultures can
easily use the application
2. Non-functional Requirements

 Performance:
 Response time: The application must respond to all user actions within 2-3 seconds.
Complex tasks such as generating reports or financial analysis must be processed
within 5 seconds.
 Application size: The application must be optimized so that the installation size does
not exceed 100 MB, making it easy for users to download and install on devices with
limited capacity.
 Scalability:
 The application must be able to scale to serve many users without affecting
performance. The system must be able to handle thousands of requests at the same
time when the number of users increases suddenly, especially at the beginning or
end of each semester.
 Compatibility:
 Multi-platform compatibility: The application must support smooth operation on
both popular operating systems, Android (version 8.0 and above) and iOS (version
12.0 and above).
 Compatibility with multiple screen sizes: The application interface must be
compatible with different screen sizes, from smartphones to tablets.
Page | 9
  Security:
 User information security: User personal and financial data must be encrypted both
when stored in the application and when transmitted over the network. Security
protocols such as HTTPS and TLS must be used to protect user information.
 Authentication and authorization: The system must support two-factor
authentication (2FA) and authorization management to ensure the security of user
accounts.
 Privacy: The application must comply with personal data protection standards and
regulations such as GDPR (General Data Protection Regulation) where applicable.
 Maintainability:
 The source code must be clearly written and organized and be easily extendable and
maintainable in the future.
 There must be adequate documentation of the system and source code to support
updates and bug fixes when necessary.
 New features can be easily integrated without affecting existing features.
 Availability and Reliability:
 Availability: The application must operate stably 24/7 with at least 99.9% uptime, to
ensure users can always access and use it.
 Data recovery: In case of application failure or interruption, the system must be able
to automatically backup and restore data without losing user data
 Usability:
 Ease of use: The application should have a user-friendly interface, features and
functions should be easy to understand and operate without complicated
instructions.
 User experience: The application should provide a smooth experience, clear and
logical interface, and be suitable for the student audience.
 Maintainability and Upgradeability:
 The application should be easy to update with new features without having to
reinstall the entire application. Updates should be quick and should not affect user
data.

III. Review areas of risk related to the

successful development of a proposed
application (P2)
A. Technical Risks
1. Performance on different devices

 Poor performance on low-end devices:

 Risks: Low-end devices (low RAM, weak processors) may experience slowness,
lagging, or sudden app exits.

Page | 10
  Impact: This directly affects the user experience, reduces satisfaction, and can lead to
user abandonment.
 Solution: Optimize the source code and design the interface to be lighter, minimizing
the use of system resources.
 Differences between operating system versions:
 Risks: The app may not run smoothly or have errors on older versions of Android or
iOS due to differences in APIs and operating system features.
 Impact: Users with older devices will encounter problems, causing an inconsistent
experience and affecting the adoption of the app.
 Solution: Develop and test on multiple operating system versions, and provide
alternative features or reduce dependencies on new APIs.
 Displaying the interface on different screen sizes:
 Risk: The application interface may be broken, scaled incorrectly or displayed
incorrectly on devices with different screen resolutions.
 Impact: Affects the consistency and professionalism of the application, leading to
user discomfort.
 Solution: Use responsive design and test the display on a variety of devices and
screen sizes.
 Excessive consumption of system resources and battery:
 Risk: The application consumes too much energy and resources (RAM, CPU),
reducing battery life and causing the device to heat up.
 Impact: Causes poor user experience, making them use the application less.
 Solution: Optimize system resource management, limit unnecessary background
tasks and use reasonable data compression methods.
 Data Access Speed:
 Risks: The app may take a long time to access and process data on devices with low
storage speeds or weak network connections.
 Impact: Users are frustrated by long waits, leading to abandonment or deletion of
the app.
 Solution: Use caching and data loading optimization techniques such as
asynchronous data loading.
 Memory Management Issues:
 Risks: On devices with limited memory, the app may run out of memory or be forced
to shut down due to excessive RAM usage.
 Impact: App stability and user experience are affected, causing frustration when the
app frequently closes unexpectedly.
 Solution: Optimize memory usage, use memory cleaning techniques, and compress
large objects such as images.
 App Loading Time:
 Risk: On older devices or slow networks, the initial data loading or app startup time
may be too long, frustrating users.
 Impact: Users may abandon the app due to long waits during startup or loading.
 Solution: Use lazy loading strategies and optimize startup time.
2. Ability to integrate with external services
Page | 11
 Incompatibility with APIs of external services:
 Risk: External services such as banks, e-wallets, or other financial systems may
change their APIs or data structures without prior notice. This may prevent the
application from integrating or processing data properly.
 Impact: User transaction or financial data is not updated in a timely manner, making
it difficult to manage spending and reducing the reliability of the application.
 Solution: Continuously monitor APIs from external services, use versioning
mechanisms to ensure long-term compatibility, and design flexible systems to easily
update changes.
 Authentication & Authorization Challenges:
 Risks: Integrating with external services, especially financial services, requires
complex authentication and authorization processes, such as OAuth, SSO (Single
Sign-On), or other security mechanisms.
 Impact: If not properly integrated, users may have difficulty logging in or authorizing
the application, affecting their ability to connect to bank accounts or e-wallets.
 Solution: Use standard authentication methods such as OAuth2 and ensure the
integration process complies with international security standards. Detailed
documentation is required for users when granting access to external services.
 Dependence on network connection and stability of external services:
 Risk: The integration depends on external services, if the service is interrupted or the
network connection is poor, the application may not work as expected, causing
delays or complete failure in some functions.
 Impact: Users may not be able to sync data or perform financial transactions, causing
frustration and loss of trust in the application.
 Solution: Integrate temporary storage mechanism (local caching) and automatic data
synchronization options when the network is stable. Monitor the operating status of
external services to take timely corrective measures.
 Changes in security policies and regulations of external services:
 Risk: Financial services or e-wallets often have strict security policies and regulations
on personal data and privacy. Changes in regulations or security policies may affect
the integration.
 Impact: If these policies and regulations are not followed, the application may be
denied connection to external services or users may not be able to grant access,
causing service disruption.
 Solution: Ensure that the application complies with current security regulations such
as GDPR, PCI-DSS. It is necessary to set up a system to monitor and update policies
from external services to quickly adjust when needed.
 Latency in communication with external services:
 Risk: Communication between the application and external services may experience
high latency due to network speed or performance of external APIs.
 Impact: Data is not updated in a timely manner, leaving users without the latest
spending information, affecting their budget management.
 Solution: Use asynchronous communication techniques to load data from external
services without affecting the user experience. It is necessary to set reasonable

Page | 12
 timeout thresholds and measures to reduce the load when external services have
problems.
 Data security when integrating with external services:
 Risk: When applications send and receive data from external services, especially
sensitive financial data, if proper encryption and security are not ensured, the data
can be stolen or leaked.
 Impact: Users' personal and financial data can be exposed, causing loss of trust and
damage to both users and developers.
 Solution: Use security protocols such as HTTPS, SSL/TLS to ensure data is encrypted
during transmission. At the same time, encrypt data at the application level and
perform regular security checks.
 Ability to integrate with multiple external services simultaneously:
 Risk: Integrating multiple external services can be complicated due to differences in
APIs, data formats, and authentication processes of each service.
 Impact: Without proper integration, applications can fail when interacting with these
services or encounter inconsistent data management issues. Solution: Use tools and
frameworks that support multi-service integration (middleware) to manage APIs and
data from multiple sources. Establish common standards for integration to minimize
incompatibilities

B. Security Risks
1. Personal financial data leak.

 Unencrypted data transmission:

 Risk: If a user's personal financial data is not encrypted when transmitted between
the application and the server or between the application and external services,
hackers can easily intercept and collect sensitive information through man-in-the-
middle attacks.
 Impact: A user's financial data, such as banking information, e-wallets, or transaction
history, can be stolen, leading to financial fraud.
 Solution: All financial data should be encrypted through secure protocols such as
SSL/TLS during transmission. Ensure all connections use HTTPS instead of HTTP.
 Unsecure data storage:
 Risk: If an application stores personal financial information in a database or local
storage without using encryption or proper security mechanisms, hackers can access
and steal the data through system attacks.
 Impact: Sensitive information such as bank account details or credit card numbers
can be exposed, causing damage to users and the reputation of the application.
 Solution: Use encryption-at-rest methods in databases and local storage. Do not
store sensitive information without strong encryption mechanisms.
 Weak user authentication:

Page | 13
  Risk: If an application uses weak user authentication methods such as simple
passwords or does not have multi-factor authentication, hackers can easily break into
users' accounts and steal financial information.
 Impact: Users can lose control of their accounts, leading to exposure of personal
financial information and financial fraud.
 Solution: Apply two-factor authentication (2FA) or multi-factor authentication to
protect user accounts. Encourage or require users to set complex passwords and
change them periodically.
 Handling financial data insecurely on mobile devices:
 Risk: Apps may not properly handle the storage or access of financial information on
mobile devices, leaving them vulnerable to hackers using device attacks or malware.
 Impact: Financial data may be stolen from users' devices, leading to personal
financial loss.
 Resolution: Ensure apps do not store sensitive financial information in easily
accessible memory, use sandboxing and operating system security mechanisms.
Encrypt local storage and use built-in operating system security features (such as iOS
Keychain or Android Keystore).
 Integrating with insecure external services:
 Risk: If the application integrates with insecure external services (e-wallets, banks) or
does not have adequate security measures during data exchange, hackers can exploit
vulnerabilities to steal users' financial information.
 Impact: Risks from third parties can cause loss of users' financial information, causing
widespread attacks from outside the application.
 Solution: Use standard security mechanisms such as OAuth2 to manage
authentication and authorization. Ensure that external services comply with security
regulations and safety checks.
 The application does not properly validate input:
 Risk: Security vulnerabilities such as SQL injection or cross-site scripting (XSS) can
occur if the application does not properly validate and filter user input. Hackers can
exploit these vulnerabilities to penetrate the system and steal financial data.
 Impact: Hackers can access the database and steal or change financial information,
causing financial and reputational loss.
 Solution: Implement strict input checks, including using input validation methods and
checking for common security vulnerabilities. Use robust security libraries to prevent
injection attacks.
 Uncontrolled system access:
 Risk: Without strict system access control and authorization, hackers can exploit
high-level accounts to steal or change financial data.
 Impact: Hackers' intrusion into administrative accounts or accounts with special
access rights can lead to the loss of financial data for many users.
 Solution: Apply a strict authorization model, ensuring that only authorized accounts
have access to important areas of the system. Use regular audits and logs to detect
unusual activities.
2. Data loss due to hardware or software failure.
Page | 14
 Server hardware failure:
 Risk: Servers that store personal financial data may experience hardware failures
such as hard drive failures, power failures, or network failures, resulting in data loss
or inaccessibility.
 Impact: Users may lose important financial data, affecting their personal spending
and budget management. This failure may also reduce user confidence in the
application.
 Solution: Implement a mechanism for automatic and periodic data backup on
redundant servers. Use distributed storage solutions and RAID (Redundant Array of
Independent Disks) systems to minimize the risk of data loss due to hardware failure.
 Application software failure:
 Risk: Software failures in the application or data management system may cause
database corruption, data write errors, or loss of user financial data.
 Impact: Users may not be able to access previous spending information or lose
important financial transaction information, affecting the use of the application.
 Solution: Perform regular application testing and maintenance to detect and fix
potential software errors. Use logging and monitoring mechanisms to detect errors
and quickly restore data if problems arise.
 Data loss due to software upgrades or updates:
 Risk: During system updates or upgrades, unforeseen errors can cause data loss,
especially when there is no proper data backup plan before performing the update.
 Impact: Users may lose all personal data related to spending or budgeting if the
upgrade fails and there is no recovery method.
 Solution: Always ensure that data is fully backed up before performing system or
software updates. Thoroughly test updates on a test environment before deploying
to production.
 Database Disconnection Issues:
 Risks: Problems with the connection between the application and the database (e.g.,
lost network connection, database server failure) can disrupt data retrieval or
writing, resulting in loss or corruption of personal financial data.
 Impact: Users are unable to synchronize financial data or lose financial transactions
made during the outage.
 Resolution: Use automatic connection recovery mechanisms and data integrity
techniques such as transaction validation and caching when there is a connection
failure.
 Lack of reliable data backup mechanism:
 Risk: If the application does not have a regular data backup mechanism or does not
backup properly, users' personal financial data may be lost in the event of a
hardware or software failure.
 Impact: Users will lose all their financial data, unable to recover or manage their
spending and budget, causing them loss and inconvenience.
 Solution: Set up and maintain a regular backup system, ensuring that backups are
stored in multiple locations and can be quickly restored when needed.
 Data conflicts during synchronization:

Page | 15
  Risk: When the application needs to synchronize data between the mobile device
and the server, data conflicts or overwrite errors may occur, resulting in loss or
corruption of personal financial data.
 Impact: Users may lose recent changes or important transaction information,
reducing the accuracy of spending management.
 Solution: Implement conflict resolution mechanisms during synchronization. Use
version tracking systems to ensure data is recorded accurately and fully
synchronized.
 Malware or viruses:
 Risk: Malware or viruses can attack users' devices or data storage servers, causing
loss or destruction of personal financial data.
 Impact: Users may lose all their data or financial data may be improperly modified,
leading to poor financial decisions.
 Solution: Use robust security software such as firewalls, antivirus programs, and
malware detection tools to protect data and systems. Ensure devices and servers are
always updated with the latest security patches.

C. User-related Risks
1. User forgets to enter spending data

 Risks:
 Users may forget or skip entering daily expenses due to being busy or forgetting to
use the app. This leads to inaccurate spending tracking, reducing the effectiveness of
the app in helping users manage their personal finances.
 Impact:
 Without complete data entry, users will not have an accurate view of their actual
spending situation, leading to ineffective budget management, inability to control
spending, and the risk of spending over budget without realizing it.
 In the long run, this can make users lose interest in the app, reduce usage rates, and
may lead to users abandoning the app altogether.
 Solution:
 Automatic reminders: Integrate a feature to send daily or periodic reminders to
remind users to enter expenses. Reminder times can be personalized based on user
habits.
 Fast Data Entry: Provide fast and convenient data entry, allowing users to easily
record spending in seconds. For example, use a simple interface with automatic
spending category suggestions.
 Automated data entry from external services: Integrate with e-wallets, banks, or
credit cards to automatically collect and enter users' spending transactions without
having to manually enter them.
 Spending habit tracking: Analyze and predict spending based on usage history and
suggest expenses that may have been missed.

Page | 16
  Statistics and reporting: Provide weekly or monthly reports that highlight days when
users have not entered data so they are aware and can fill in missing data.
 Gamification: Use gamification to encourage users to maintain data entry habits, for
example, offering reward points or trophies for consecutive data entry over multiple
days.
2. Users are not familiar with the interface
 Risks:
 Users, especially those who are not familiar with technology or have never used
financial management applications, may have difficulty getting used to the interface
of the "CampusExpense Manager" application. This may lead to confusion, incorrect
usage, or missing out on important features.
 Impact:
 Users may feel confused, uncomfortable, and abandon the application after a short
period of use. This reduces the effectiveness of the application and may result in low
user retention rates.
 Without understanding how to use the interface, users may enter incorrect data or
fail to optimize the financial management tools in the application, reducing the
accuracy of information and the usefulness of the application.
 Solution:
 Design a simple and intuitive interface: Use a friendly, intuitive user interface (UI)
design with recognizable icons and a clean layout, making it easy for users to learn
the main functions without much guidance.
 Onboarding: Provide a quick tutorial when users first start using the app. This can
help them get familiar with basic functions and how to enter expenses easily.
 In-app hints and instructions: Add brief notes or instructions right in the interface
when users interact with features for the first time. For example, when users click on
the add expense section, a short tutorial on how to choose a category or note can be
displayed.
 Customize the interface based on usage habits: Provide options that allow users to
personalize the interface based on usage habits. For example, allow them to hide or
show functions that they rarely use to avoid confusion.
 Multilingual support: Make sure the app supports multiple languages, so users feel
comfortable using the interface in their preferred language.
 Quick feedback: Provide immediate feedback when users complete an action (e.g.,
successful data entry, saved information, or when an error occurs) to let them know
that the app is working properly.
 Help features: Add detailed help or FAQs that are easily accessible from the main
interface so users can quickly look up issues they encounter.
 Survey and improve the interface:
 Gather feedback from users through surveys or interface experience evaluation
boards to identify areas for improvement. Use this data to refine the interface to
better suit users’ needs and habits.

Page | 17
D. Development Process Risks
1. Changing requirements during development

 Risks:
 During the development of an application, changes in requirements may occur from
customers, users, or stakeholders. These changes may include adding, removing, or
modifying features, new requirements for the interface, security, or operation of the
application.
 Impacts:
 Increased costs and time: Changing requirements may require modifying or rewriting
large parts of the application, which is time-consuming and resource intensive. This
can lead to overspending on the original budget and missing the release schedule.
 Disrupting the development process: If requirements change frequently or are not
well managed, the development team may have difficulty maintaining the progress
and quality of the product. The project may become chaotic, with constant design
changes, code rewrites, or feature adjustments.
 Impact on product quality: Changing requirements mid-way can lead to skipping full
testing or applying temporary solutions, reducing the final quality of the product,
thereby affecting the user experience and reliability of the application.
 Difficulty in managing scope: Changing requirements too often can lead to "scope
creep" (uncontrolled scope expansion), making the project more complex than it was
originally.
 Solution:
 Strictly manage requirements: Establish a clear process for managing requirements
changes. Any requirement changes need to be carefully reviewed, analyzing the
impact on time, cost and quality before being implemented.
 Use agile development methods: Agile allows for better management of
requirement changes through iteration development and continuous feedback from
customers or users. Requirements changes can be flexibly adjusted within iterations
without significantly impacting the overall schedule.
 Clear Agreements: Make sure that the agreement with the customer or stakeholders
clearly states the level of acceptance of changes and the conditions associated with
adding new requirements (such as additional costs and time).
 Prioritize requirements: When requirements change, they should be categorized and
prioritized according to their importance. Only make changes that are truly necessary
and have a major impact on the application's goals.
 Document changes: Any requirement changes should be clearly documented and
communicated to the entire development team, to ensure everyone understands
and follows the same adjusted plan.
 Continuous testing: When requirements change, additional testing should be
performed to ensure that new or adjusted features work properly and do not impact
other parts of the application.

Page | 18
IV. Research the use of software
development tools and techniques for
the development of a proposed
application (P3)
A. Software Development Tools
1. Android Studio
 Android Studio Overview:
 Android Studio is Google's official integrated development environment (IDE) for
Android application development. It is a powerful tool based on IntelliJ IDEA,
providing specialized features and tools for developing, testing, and deploying mobile
applications on the Android operating system. Android Studio supports multiple
programming languages, including Java and Kotlin, and provides features such as the
Android Emulator and Gradle build system to make development easier and more
efficient.

 Main Features of Android Studio:

 Intelligent Code Editor: Supports auto-completion of code, syntax checking and code
hinting when programming in Java, Kotlin and C++. It helps reduce errors and speed
up the application development process.
 Android Emulator: Helps developers test apps on different device configurations and
Android versions without having to have all the physical devices. This emulator
supports testing interface, features, and performance

Page | 19
  Gradle-based build system: Gradle is a powerful build tool that automates the
process of compiling, testing, and packaging applications. This allows for easy
dependency management and integration with CI/CD tools.
 Layout Editor: Android Studio provides a visual interface design tool that makes it
easy for developers to create and customize user interfaces (UIs) without manually
writing XML code.
 Debugger and Profiler: Powerful debugging tools help detect logic errors and
performance bugs. Profiler provides detailed information about your application's
CPU, memory, and network usage in real time, helping to optimize performance.
 APK Analyzer: Allows analysis of APK file size and optimization of app size, thus
helping the app perform better on devices with limited resources.
 Benefits of using Android Studio in developing "CampusExpense Manager" application:
 Android Cross-Platform Development: Android Studio allows for optimized
application development for a variety of Android devices, from smartphones to
tablets, ensuring that the "CampusExpense Manager" application will be compatible
with a variety of student devices.
 Rapid application testing: With the Android Emulator, developers can test
applications on multiple device configurations without having to invest in multiple
physical devices, saving costs and time.
 Efficient programming with Kotlin: Android Studio has strong support for the Kotlin
programming language, a modern language that helps develop applications faster
and more securely. This will help projects take advantage of advanced features and
minimize errors in the source code.
 Easy project management with Gradle: The Gradle build system helps manage
dependent libraries and automates the application building process, ensuring stable
and consistent releases.
 Challenges of using Android Studio:
 High resource requirements: Android Studio consumes a lot of system resources
such as CPU and RAM, especially when using Android Emulator. Therefore, it is
necessary to use a computer with high configuration to ensure working performance.
 Complexity: With so many powerful features, Android Studio can become
complicated for new developers, requiring time to learn and get used to use
effectively.
2. Git, Github
 Git Overview:
 Git is a distributed version control system widely used in software development. Git
allows developers to track the history of source code changes, collaborate effectively

Page | 20
 within a team, and manage different versions of a project. Git was created by Linus
Torvalds in 2005, primarily to manage the source code of the Linux project.

 Main features of Git:

 Version Control: Git allows you to track all changes in the project's source code, save
commits so you can go back to the old version when needed. This helps manage
change history, detect and fix errors easily.
 Distributed work: With Git, each programmer has a full copy of the entire project on
their personal computer, which helps them work offline and push changes when
there is a network connection.
 Branching and Merging: Git supports creating branches to develop new features,
testing without affecting the main source code (main branch). Once completed, that
branch can be safely merged into the main branch.
 Staging Area: Before committing, Git provides a staging area so that programmers
can review changes and choose which parts of the code to save.
 GitHub Overview:
 GitHub is a web-based platform built on Git that allows developers to host source
code online, collaborate on projects, and manage software development.
Additionally, GitHub provides a variety of additional tools to help make software
development more efficient, such as issue tracking, CI/CD integration, and pull
request management.

Page | 21
 GitHub Key Features:
 Source Code Hosting: GitHub provides a repository for public and private software
projects. Developers can easily clone, push, and pull source code through Git.
 Pull Requests: GitHub provides a pull request feature that allows developers to
submit code for review before it is merged into the main branch. Project managers
can review the code, discuss it, and request revisions before accepting changes.
 Issue Tracking: GitHub has an issue tracker that helps developers track issues, bugs,
or features that need to be developed. Each issue can be discussed and assigned to
team members.
 Actions (CI/CD): GitHub Actions allows for automation of the application testing and
deployment process. Whenever there is a change in the source code, GitHub Actions
can run test scripts, build the application, and deploy it to production automatically.
 Collaboration Tools: GitHub supports a variety of collaboration features like Wikis,
Discussions, and Project Boards, helping development teams communicate, manage
progress, and share knowledge efficiently.
 Benefits of Git and GitHub in "CampusExpense Manager" project:
 Efficient source code management: Git and GitHub make it easy for development
teams to track changes in the source code and roll back to previous versions if
problems arise. Each commit saves history, helping to control the development
process in a detailed and clear way.
 Easy team collaboration: With GitHub, team members can work together, develop
features on different branches and merge them when completed. This minimizes
conflicts and enhances effective collaboration.

Page | 22
  Bug and new feature management: Issue tracker on GitHub helps track bugs or
features that need to be developed. Each issue can be assigned to specific developers
and progress is tracked transparently.
 Automate testing and deployment processes: GitHub Actions allows you to set up
CI/CD processes to automatically test code every time there is a change and deploy
applications to production, helping to speed up development and minimize the risk
of errors when releasing.
 Challenges when using Git and GitHub:
 Git Knowledge Required: While Git is powerful, it can be difficult for new
programmers to use. Understanding the commands and how Git works takes time to
learn.
 Source Code Conflicts: When multiple programmers work on the same source code
file, merge conflicts can occur. This requires the programmer to know how to resolve
conflicts safely and effectively.
3. Junit
 Junit Overview:
 JUnit is a popular testing framework for the Java programming language. Designed to
help programmers easily write and run automated tests, JUnit ensures that code is
working as expected. It is one of the important tools in the Test-Driven Development
(TDD) software development process.

 Main Features of Junit:

 Unit Testing: JUnit allows programmers to write unit tests, which test individual code
or functions for correctness. These tests are executed automatically and provide
quick feedback on whether the code is working correctly.

Page | 23
  Annotations: JUnit uses annotations such as @Test, @Before, @After,
@BeforeClass, and @AfterClass to mark test methods, as well as setup or cleanup
before/after testing.
- @Test: Marks a method as a test.
- @Before: Runs before each test, usually to initialize data or objects.
- @After: Runs after each test, usually to clean up data.
- @BeforeClass: Runs before all tests in the class, usually to set up resources that
only need to be set up once.
- @AfterClass: Runs after all tests in the class, usually to clean up common
resources.
 Assertions: JUnit provides assert methods (like assertEquals, assertTrue, assertFalse,
assertNotNull, etc.) to compare expected and actual results. If the results do not
match, the test fails, providing details about the reason.
 Test Suites: JUnit allows multiple tests to be grouped into a test suite, helping to
organize and run tests in groups, thus testing multiple components of the application
at the same time.
 Easy integration with other tools: JUnit easily integrates with build tools like Maven,
Gradle and CI/CD systems like Jenkins, GitHub Actions. It also integrates well with
IDEs like IntelliJ IDEA and Eclipse, allowing to run tests directly from the IDE.
 Benefits of JUnit in software development:
 Ensure code quality: JUnit helps ensure that individual components of an application
work as expected, reducing errors and improving code quality.
 Test-Driven Development: JUnit supports TDD, where tests are written before the
actual code is written. This gives the programmer a clearer direction on how to
design methods and test them from the start.
 Fast feedback: JUnit's automated tests run very quickly, providing immediate
feedback on potential errors in the code, helping to detect and fix errors earlier in
the development process.
 Save time on manual testing: By automating testing, JUnit reduces the time and
effort required to manually test code, especially as the project grows larger.
 Detect errors when changing code: JUnit helps detect new errors that arise when
making code changes (regression errors). When unit tests run frequently, any
changes that cause problems will be detected immediately.
 Application of JUnit in the project "CampusExpense Manager":
 Expense Management Feature Testing: With JUnit, the development team can test
core functionality such as adding, editing, and deleting expenses, ensuring that these
functions work correctly and are not affected by other changes in the application.

Page | 24
  Financial Data Testing: JUnit can be used to test the accuracy of financial
calculations, such as total income, total expenses, or remaining budget. This is
especially important for a financial application like "CampusExpense Manager".
 Performance Testing: JUnit can be combined with performance testing tools to test
whether critical functions can handle large volumes of user data while maintaining
stable performance.
 Challenges when using JUnit:
 Test writing time: Writing tests can be time-consuming, especially for large projects,
as each method or feature requires its own test.
 Test maintenance: When the source code changes, the tests also need to be updated
to reflect the new changes. This can create additional maintenance work.
 Testing complex components: Some components such as user interfaces (UI) or
integrations with external systems can be difficult to test with JUnit and require
additional testing tools or mocking.

4. Espresso
 Espresso Overview:
 Espresso is a UI testing framework for Android applications, developed by Google. It
helps developers create automated tests for their application's user interface,
ensuring that UI components work as expected and are error-free when interacting
with users.

 Main features of Espresso:

 Automated UI Testing: Espresso allows you to write automated tests to interact with
UI elements such as clicking buttons, entering text, scrolling pages, and checking the
states of the interface (show, hide, or state of a widget).
 Synchronization: One of the most powerful features of Espresso is its ability to
automatically synchronize with the main thread of the application, which helps to
minimize potential errors due to asynchrony between threads. When actions in a test
are executed, Espresso waits until the UI is idle before performing the next action.
 Fluent API: Espresso provides an easy-to-use API with intuitive syntax, allowing
developers to write tests with methods like onView() to find UI elements and
perform() to perform actions on them. This makes the test concise and easy to read.
 Assertions: Espresso supports checking the state of UI components using assertions
like check(). For example, a developer can check if a component is displayed correctly,
if the text is correct, or if a checkbox is checked.

Page | 25
  Integration with JUnit: Espresso easily integrates with JUnit, allowing UI tests to be
run alongside unit tests and other types of tests. This creates a more comprehensive
testing system for the application.
 RecyclerView support: Espresso is capable of testing dynamic components like lists or
repeaters like RecyclerView, allowing easy interaction with each item in the list.
 Benefits of Espresso in Software Development:
 Ensure UI Correctness: Espresso helps ensure that the application's user interface
works as expected. Automated tests can check that the interface responds correctly to
user actions and that state changes are handled correctly.
 Early Bug Detection: With Espresso, errors related to the interface and user
interactions can be detected early in the development phase, before the application is
released, minimizing the risk of bugs in the production version.
 Efficient Automated Testing: Instead of manual testing that is time-consuming and
prone to errors, Espresso automates the entire UI testing process, saving time and
ensuring that testing is performed consistently.
 Application of Espresso in the project "CampusExpense Manager":
 Expense Manager UI Testing: Espresso can test the important features of the
"CampusExpense Manager" app, such as the expense entry interface, transaction list
display, and navigation between screens. This ensures that the interface functions
properly and does not confuse users.
 UI Compatibility Testing on Different Devices: By automating testing on multiple
Android devices, Espresso helps ensure that the app's interface displays properly and
functions consistently across different screen sizes and resolutions, from smartphones
to tablets.
 User Interaction Testing: Espresso can simulate user actions such as typing, scrolling,
and pressing buttons, to ensure that the app's features work exactly as expected.
 Challenges of using Espresso:
 Time required to write tests: While test automation saves time in the long run, writing
initial tests for an interface can be time-consuming, especially for complex interfaces.
 Environment configuration: Setting up a test environment and configuring Espresso to
run smoothly on multiple devices or emulators can be difficult, especially when
running on CI/CD pipelines.
 Testing on dynamic interfaces: Dynamic interfaces with complex interactions or
dependencies on external services can be difficult to test and require mocking or test
tuning.
5. Android Profiler
 Android Profiler Overview:

Page | 26
  Android Profiler is a set of tools built into Android Studio that helps developers
monitor and analyze the performance of Android applications. It provides detailed
information about CPU, memory (RAM), battery, and network usage, thereby helping
to detect performance issues and optimize the application.

 Main features of Android Profiler:

 CPU Profiler: Helps monitor CPU activity in real time and records information about
how the application's threads use CPU resources. This tool allows analyzing how
methods, threads, or processes put heavy load on the CPU.
- Displays real-time graphs of CPU usage.
- Record and analyze stack traces of methods to identify the code segments that
consume the most CPU resources.
 Memory Profiler: Helps monitor the application's memory usage, thereby detecting
memory leaks and memory management issues.
- Real-time display of how much RAM the application is using.
- Record memory allocation and release events.
- Analyze heap and allocated objects to look for issues such as memory leaks.
 Network Profiler: Helps analyze and optimize the network traffic used by the
application, including monitoring the amount of data sent and received in real time.
- Shows graphs of network activity, with details on the size of data sent and
received.
- Allows analyzing HTTP/HTTPS traffic to see requests and responses from servers,
helping to detect unnecessary or suboptimal requests.

Page | 27
  Energy Profiler: Allows monitoring of application battery consumption and analyzing
power-draining factors such as CPU, screen, or sensor usage.
- Shows information about power-related events, such as CPU wake locks,
sensors, and GPS.
- Helps analyze energy consumption to optimize and extend battery life for
applications.
 Benefits of Android Profiler in software development:
 Optimize performance: Android Profiler provides detailed data on CPU, memory,
network, and power, helping to detect performance bottlenecks in your app. This
helps improve speed and user experience.
 Detect and fix memory leaks: Memory leaks can slow down your app and cause "Out
of Memory." With Memory Profiler, developers can easily detect and fix memory
management issues.
 Reduce battery consumption: Energy Profiler helps identify code or components that
are consuming unnecessary power, thereby optimizing your app to save battery.
 Analyze network traffic: Network Profiler helps optimize network resource usage,
reduce unnecessary data consumption, and improve app response speed.
 Application of Android Profiler in the project "CampusExpense Manager":
 Optimize data management: The "CampusExpense Manager" application can
continuously retrieve or store users' financial data. Using the Network Profiler to
analyze and optimize network requests will help reduce the amount of data
transmitted, improve performance and user experience when accessing data over the
network.
 Optimize memory and performance: By using the Memory Profiler and CPU Profiler,
the development team can detect memory issues, such as memory leaks when
processing many financial transactions or when using large data tables. This helps the
application run smoothly even when handling large volumes of user spending data.
 Save battery: With the Energy Profiler, the development team can test and optimize
features that require GPS or background services, helping the application consume
less energy, which is very important for mobile users.
 Challenges when using Android Profiler:
 Complex Data Analysis: Data from Android Profiler can be very detailed and complex,
requiring programmers to have the skills and time to understand and optimize code
based on this data.
 Real-world testing performance: Some performance issues only appear when running
the application on real devices or in a production environment. Therefore, testing only
in a development environment may not detect all issues.

Page | 28
  Time-consuming optimization: Performance optimization can be time-consuming,
especially when analyzing and tuning many different components of the application.

B. Software Development Techniques

1. Test-Driven Development (TDD)
 Test-Driven Development (TDD) Overview:
 Test-Driven Development (TDD) is a software development technique in which tests
are written before the actual application code is written. At its core, TDD is an iterative
process in which a developer first creates automated tests for a feature or method,
and then writes code to make these tests pass. TDD helps ensure that the code written
not only meets the requirements, but also functions correctly.

 TDD Process: TDD typically follows a "Red-Green-Refactor" cycle consisting of three main
steps:
 Red (Write a Failing Test): A developer first writes a test for a new feature or method,
even though no code has been implemented yet. This test is guaranteed to fail
because the main code has not been written.
 Green (Write code to make the test pass): After the test fails, the developer writes
the actual code to make the test pass. In this step, the focus is on writing the minimum
code to pass the test.
 Refactor (Improve the code): Once the test has passed, the developer can go back and
improve the source code by optimizing it without affecting the test results. This is a
fine-tuning step to ensure the code is cleaner and more efficient.
 Benefits of Test-Driven Development:

Page | 29
  Early error detection: Since the tests are written before the main code is written, TDD
helps detect errors early in the development process, even before the code is
integrated into the main system.
 Ensure the code meets the requirements: TDD helps ensure that every feature or
function has a test, thereby ensuring that the code is developed according to the
requirements and specifications.
 Reduce post-deployment errors: With a full suite of automated tests, developers can
be more confident when editing, adding, or optimizing code, as they can immediately
run tests to ensure no new errors are introduced.
 Encourage clean code design: TDD encourages developers to write code that is easy to
test, resulting in clean and maintainable code design.
 TDD application in the "CampusExpense Manager" project:
 Testing financial transaction management: In the "CampusExpense Manager"
application, processing users' financial transactions requires a high degree of accuracy.
With TDD, the development team can write tests in advance for features such as
recording expenses, calculating balances, and categorizing transactions. This ensures
that important financial features always work correctly.
 Ensure Collaboration: If the application has features that involve synchronizing data or
sharing information between multiple devices, TDD can help ensure that data is
processed and synchronized correctly.
 Improved Code Reliability: TDD helps create automated test suites for each new
feature of the application. This not only helps detect bugs early, but also makes it
easier for the development team to upgrade or add new features without worrying
about affecting other parts of the application.
 Challenges of TDD:
 Time-consuming upfront: Although TDD has many long-term benefits, writing tests
before writing code can make the initial project take longer.
 Testing Skills Required: TDD requires developers to have good test writing skills. If the
tests are written incorrectly or too poorly, it can lead to missed bugs.
 Difficult to apply to user interfaces (UI): TDD is often more suitable for business logic
and backend components. Complex UI testing may require other testing techniques
such as a UI testing framework (e.g. Espresso).
2. Behavior-Driven Development (BDD)
 Behavior-Driven Development (BDD) Overview:
 Behavior-Driven Development (BDD) is a software development technique that
extends Test-Driven Development (TDD) and focuses on describing the behavior of a
system based on user requirements in natural language. BDD helps stakeholders
(including developers, testers, and customers) better understand how an application

Page | 30
 will work through examples and scenarios written in user-friendly language. By writing
scenarios that describe the desired behavior of the system, BDD helps ensure that the
system meets the requirements from the user's perspective.

 How BDD Works:

 BDD relies on the use of user stories and scenarios to describe the behavior of the
system. A BDD scenario is typically written in a "Given-When-Then" structure, focusing
on a specific user behavior.
 Given: The initial condition or context.
 When: The action or event that occurs.
 Then: The desired result after the action.
 BDD support tools:
 Cucumber: This is a popular tool in BDD, allowing to write test scenarios in natural
language such as Gherkin. Cucumber converts these scenarios into real test code to
run and check the behavior of the system.
 JBehave: This is a BDD tool for Java, providing a framework for defining and executing
BDD scenarios.
 SpecFlow: Used in the .NET environment, SpecFlow is a tool that allows to integrate
BDD into the .NET software development process.
 Benefits of Behavior-Driven Development:
 Engagement between stakeholders: BDD helps improve communication between
development, testing, and customer teams by using natural language to describe
requirements and behaviors. This helps avoid misunderstandings about requirements.
 User-centric: BDD focuses on the behavior of the system from the user's perspective,
ensuring that the features developed are true to the user's actual needs.

Page | 31
  Easy to maintain and extend: BDD scenarios are written clearly and easily understood,
making it easy for team members to understand how the system will work without
having to read the detailed source code. This makes the system easy to maintain and
extend.
 Integrated with automated testing: BDD works closely with automated testing,
ensuring that each new feature has test scenarios that describe the correct behavior.
When the code changes, these tests ensure that the system still functions correctly.
 Application of BDD in the "CampusExpense Manager" project:
 Describing key behaviors: In the "CampusExpense Manager" project, BDD can be used
to describe key behaviors such as managing expenses, tracking account balances, and
categorizing transactions. Scenarios such as adding expenses, editing transactions, or
receiving alerts about over-budgets can be written in natural language to ensure that
all project members understand the functionality to be developed.
 Optimize testing: With BDD, the development team can create a comprehensive set of
test scenarios for the application's key behaviors. When the application is updated,
automated tests will ensure that important features continue to function properly.
 Improve customer communication: By writing understandable BDD scenarios,
customers or end users can be directly involved in reviewing and adjusting functional
requirements. This helps ensure that the application meets the real needs of students.
 Challenges of applying BDD:
 Time and skill requirements: BDD requires time to write detailed scenarios and
describe system behavior. To write effective scenarios, the development team needs
to have good scripting skills and a good understanding of business requirements.
 Complexity for large projects: When the application is complex, maintaining and
organizing BDD scenarios can become difficult, especially when there are too many
scenarios to control.
 Stakeholder alignment: BDD requires active participation of stakeholders (such as
customers, testers, developers). Without alignment, the BDD process can be
ineffective.
3. Continuous Integration/Continuous Deployment (CI/CD)
 Continuous Integration/Continuous Deployment (CI/CD) Overview:
 Continuous Integration (CI) and Continuous Deployment (CD) are two important
methodologies in modern software development that help automate and improve the
process of developing, testing, and deploying applications. CI/CD is used to speed up
development and ensure that new source code is thoroughly tested before
deployment, while also helping to deploy quickly and reliably.

Page | 32
  CI is the process where developers integrate (merge) their code into the main branch
regularly, usually daily. Each merge automatically triggers a build process and runs
tests to ensure that the new code does not break the system.
 CD is the next step of CI, where the automatically tested code is automatically
deployed to the production or staging environment. Continuous Delivery (CD) ensures
that the application is always ready to deploy, and Continuous Deployment (CD) is the
process of automatically deploying the application to the production environment as
soon as the code passes the tests.

 CI/CD process:
 Continuous Integration (CI):
- Commit code regularly: Developers regularly commit their code to the main
branch of the source code repository.
- Automatic build and test: Each commit automatically triggers the build (compile)
process and runs unit tests, integration tests to ensure the code does not
introduce new errors.
- Fast feedback: If an error occurs during the build or test process, the programmer
will receive immediate feedback to fix the error quickly.
 Continuous Deployment (CD):
- Automatic deployment: When the code has passed all the automated tests, the
system will automatically deploy the application to the staging or production
environment.
- Post-Deployment Testing: After the application is deployed, further tests can be
run on production (e.g. smoke tests) to ensure everything is working properly.
- Feedback from real users: New features are quickly put into the hands of real
users, allowing for early feedback and rapid product improvements.
 CI/CD tools:
 Jenkins: One of the most popular CI/CD tools, Jenkins is an open-source platform that
automates the process of building, testing, and deploying applications.

Page | 33
  GitLab CI/CD: A CI/CD platform that integrates directly into GitLab, supporting
automated pipeline-based builds, testing, and deployments.
 CircleCI: A CI/CD tool that enables rapid build and test processes, and can be easily
integrated with many services such as GitHub and Docker.
 Travis CI: A popular open-source CI/CD platform, especially for open-source projects
on GitHub.
 Benefits of CI/CD:
 Automation of the process: CI/CD helps automate the build, test, and deployment
process, reducing manual work and human errors.
 Early error detection: CI helps detect errors early in the development process through
automated testing after each commit, helping developers fix errors as they arise.
 Shorten time to market: CD allows new features to be deployed quickly to users,
thereby helping to receive quick feedback and timely product adjustments.
 Improve product quality: With continuous automated testing, CI/CD helps ensure
code is always stable and high quality before being released to the production
environment.
 Application of CI/CD in the "CampusExpense Manager" project:
 Continuous Integration (CI): In the "CampusExpense Manager" project, CI can be
applied by automatically running unit and integration tests every time there is a code
change from programmers. This ensures that features like expense recording, balance
calculations, and transaction categorization work correctly even as the code is
continually updated and extended.
 Continuous Deployment (CD): Once the code passes all automated tests, the system
can automatically deploy the application to the staging or production environment.
This ensures that new features of the "CampusExpense Manager" application are
quickly updated to users without service interruption issues.
 Challenges in adopting CI/CD:
 Complex configuration: Setting up and maintaining a CI/CD pipeline can require a lot
of configuration and tuning to ensure that it runs smoothly and reliably.
 Full testing requirements: For CI/CD to work effectively, the project needs a complete
and robust automated testing suite, including unit testing, integration testing, and
functional testing. Lack of testing can reduce the reliability of automated
deployments.
 Control the deployment environment: When an application is deployed
automatically, there can be risks if the production environment is not ready or there
are unforeseen issues. There should be a backup and recovery plan in place if errors
arise after deployment.
4. Agile/Scrum

Page | 34
 Overview of Agile and Scrum
 Agile is a flexible software development method that focuses on collaboration, rapid
customer feedback, and small (iterative) development. Agile emphasizes continuous
change and improvement throughout the product development process.
 Scrum is one of the most popular Agile frameworks, often used in software
development projects. Scrum provides a set of rules, roles, and events that help the
development team implement the project in Sprints (short development cycles),
usually lasting from 1 to 4 weeks. Scrum emphasizes collaboration between team
members and customer feedback.

 Main components of Scrum:

 Roles:
- Product Owner: A representative of the customer, responsible for defining and
prioritizing features (Product Backlog). The product owner ensures that the
development team is working according to user requirements.
- Scrum Master: A person who helps the development team follow the Scrum
process, removes impediments (obstacles) and ensures that the team can
complete the Sprint as planned.
- Development Team: A group of technical members responsible for developing
and delivering features during each Sprint. This group usually includes
programmers, testers and other specialists.
 Artifacts:
- Product Backlog: A list of all requirements, features, and enhancements for the
product. The Product Owner is responsible for maintaining and prioritizing the
Product Backlog.
- Sprint Backlog: A collection of tasks and features selected from the Product
Backlog to be successfully completed in a Sprint.

Page | 35
 - Increment: A complete and usable version of the product after each Sprint.
Increments must meet the previously defined "Definition of Done" criteria.
 Events (Main Events):
- Sprint Planning: The first meeting of the Sprint, where the development team and
the Product Owner discuss and select the goals and features to be completed in
the Sprint.
- Daily Scrum: A short (usually 15-minute) daily meeting where the development
team updates on progress, plans, and impediments.
- Sprint Review: The final Sprint meeting, where the development team presents
the completed work to the Product Owner and stakeholders for feedback.
- Sprint Retrospective: The final meeting of the Sprint, where the development
team and the Scrum Master review the workflow, finding areas for improvement
in the next Sprint.
 Benefits of Agile/Scrum:
 Increase development speed: Agile/Scrum helps software development teams release
small but complete product versions after each Sprint, helping users and customers
receive new features quickly.
 Early feedback from customers: Scrum allows Product Owners and customers to
directly participate in the development process through Sprint Review meetings,
helping the development team receive early feedback and adjust the product
promptly according to needs.
 Adapt to change: Agile encourages flexibility, allowing the team to easily change
requirements and goals when there are changes from the business environment or
customer needs.
 Enhance collaboration and transparency: With Scrum, all team members know about
progress and goals through Daily Scrum, Sprint Review and Sprint Planning meetings,
helping to improve coordination and transparency within the team.
 Application of Agile/Scrum in the "CampusExpense Manager" project:
 Flexibility in development: In the "CampusExpense Manager" project, Agile/Scrum
helps the development team easily adapt to changes from customers or students, the
end users of the application. This is especially important when the application's
expense management feature may need to be adjusted based on real-world feedback.
 Development in Sprints: The development team can work in short Sprints, focusing on
features such as expense tracking, generating personal financial reports, or classifying
transactions. After each Sprint, the team can review and present the completed
features to get feedback from the Product Owner.

Page | 36
  Early feedback from users: Using Scrum, the team can collect feedback from students
right after each Sprint Review, ensuring that the expense management features meet
user requirements before developing new features.
 Challenges of Agile/Scrum:
 Lack of collaboration: Agile/Scrum requires close collaboration between team
members and the customer. If the Product Owner or stakeholders are not actively
involved, the development process can be delayed or go off track.
 Difficulty in time management: Each Sprint usually lasts from 1 to 4 weeks, so work
needs to be divided appropriately. Failure to meet the Sprint goal can affect the
overall progress of the project.
 Continuous change: Although Agile encourages flexibility, frequent changes in
requirements can be difficult for the development team, especially when the
requirements are conflicting or unclear.

V. CONCLUSION

VI. REFERENCES (Harvard Style)

Page | 37