C Project
C Project
This project is designed to create a fundamental banking system using the C programming
language, specifically catering to the needs of educational institutions and students who are learning
about programming and software development. The primary goal is to simulate core banking
operations, such as account creation, money deposit, withdrawal, and balance inquiry, within a
simplified and accessible framework. The client for this project can be viewed as students,
educators, and institutions that aim to bridge the gap between theoretical concepts and practical
implementation in financial software development. By engaging with this system, learners can
develop a foundational understanding of file handling, data structures, and user interaction, all
crucial skills for modern software development.
Problem Identification:
Modern banking systems are resource-intensive and require advanced knowledge to understand
fully. For beginners, diving directly into such complex systems can be daunting and
counterproductive. There is a clear need for a basic, lightweight banking system that demonstrates
core functionalities—account management, transactions, and data persistence—while maintaining
simplicity and clarity. This project fills that gap by offering a well-structured, easy-to-understand
model that introduces learners to critical concepts in financial software development. By focusing
on fundamental operations and clear file-based data storage, it ensures that users grasp the core
principles of banking systems without unnecessary complications.
Task Identification:
The project involves several key tasks:
1. Account Management: Developing a feature to create and manage accounts, storing details
such as the user’s name, account number, and balance.
2. Transaction Handling: Implementing deposit and withdrawal functionalities, ensuring
accurate updates to account balances.
3. Data Storage: Using file handling to securely store and retrieve account data, simulating
real-world data persistence.
4. User Interface: Creating a menu-driven interface that guides users through different
operations, enhancing usability and engagement.
5. Error Handling and Validation: Ensuring data integrity by validating user inputs and
handling errors gracefully, such as insufficient funds or incorrect account numbers.
Timeline:
• Week 1: Conduct research on existing banking system models, finalize the project scope,
and define system requirements.
• Week 2: Design the system architecture, focusing on data structures and core functionalities.
Begin coding individual modules, such as account creation and transaction processing.
• Week 3: Integrate all modules into a cohesive system, conduct extensive testing to identify
and resolve bugs, and ensure data integrity.
• Week 4: Finalize documentation, including the user manual and project report. Conduct a
peer review and prepare for the presentation.
Organization of the Report:
The report is structured to provide a comprehensive understanding of the project. It begins with an
introduction that outlines the client’s needs, contemporary issues, and problem identification.
Chapter 2 covers a literature survey, examining similar systems and highlighting key insights.
Chapter 3 details the design process, including concept generation, evaluation of specifications, and
consideration of various constraints such as economic, ethical, and social factors. Chapter 4 presents
the results analysis and validation, demonstrating the implementation and testing outcomes. Finally,
the report concludes with future work recommendations and a detailed user manual to guide system
operation.
Chapter 2: Literature Survey
The problem of developing banking systems has evolved over the decades, with a significant
transformation in how banking operations have been simulated for educational purposes. Initially,
financial transactions were performed manually, requiring large amounts of paperwork and human
resources, leading to inefficiencies and errors. With the advent of the computer age in the 1950s and
1960s, automated systems began to replace manual processing, making banking operations faster,
more efficient, and more accurate.
By the 1970s, computers were widely integrated into banking systems, enabling more complex
tasks such as automated transactions, balance updates, and centralized record keeping. The next
major leap occurred with the rise of personal computing in the 1980s, when software development
for educational purposes began to flourish. Banking simulations, primarily used in educational
contexts, emerged as essential tools to help students understand how real banking systems work.
These early models focused on simulating basic operations like account management, deposits,
withdrawals, and balance checks.
In the 1990s and 2000s, with the rise of graphical user interfaces (GUIs), many projects evolved to
offer more interactive systems. While early banking simulation systems were command-line based,
there was a growing demand for systems that allowed users to interact through graphical interfaces,
making them more user-friendly. Research during this period also focused on improving the
underlying architecture, including integrating databases for data storage and security measures for
transaction integrity.
The contemporary focus has shifted towards creating educational tools that are lightweight and easy
to use, while still providing a clear understanding of how core banking functions work. These
models are especially important in helping students grasp the fundamentals of data handling and
management, preparing them for more complex, real-world applications. Despite the continuous
advancements in banking software, the demand for simple and educational banking systems
remains relevant for learners and educators alike.
Bibliometric Analysis
A bibliometric analysis of research in banking system simulations reveals a trend towards the
educational use of simplified banking systems to teach programming concepts. By examining
papers published in notable journals such as IEEE Transactions on Education and Journal of
Financial Education, it is clear that there is an increasing focus on creating simple banking models
that simulate real-world financial operations for educational purposes.
From the mid-2000s onward, a substantial number of research papers have emphasized the
importance of project-based learning in education, with many researchers proposing that students
can benefit from hands-on experience in building banking systems. These systems use data
structures, file handling, and transaction management to allow learners to simulate essential banking
operations. Keywords such as "banking system simulation," "educational tools for finance," and
"file-based banking systems" are often found in the titles and abstracts of the papers, reflecting a
strong emphasis on educational solutions to introduce basic banking principles.
Recent bibliometric studies also suggest that banking simulations using programming languages
like C, Python, and Java have garnered significant attention. These languages are commonly chosen
for their ability to provide learners with direct interaction with fundamental concepts, such as
memory management, file handling, and error checking. Additionally, research indicates that
banking simulations are becoming increasingly popular as part of integrated curricula, with
educators using them to teach concepts related to databases, user interfaces, and system security.
Moreover, while most of the research has focused on implementing banking systems in
programming languages like C and Java, there is a growing interest in expanding these systems to
include features like real-time processing and security protocols. These features align with the
current needs of students who are learning how to secure and manage online banking systems.
Various researchers have proposed different solutions to simplify and improve the teaching of
banking operations in an educational context. Some of the key proposed solutions and approaches
include:
2. Database Integration: As systems evolve and become more complex, researchers have
moved towards using lightweight database management systems (DBMS) like SQLite or
MySQL in their banking simulations. These databases provide a more realistic simulation of
how modern banking systems handle and store data, allowing students to understand key
concepts like relational databases and SQL queries. However, while these systems are more
advanced, they also require a higher level of understanding, making them more suitable for
advanced programming courses.
3. Security Enhancements and Data Integrity: Another significant area of research has been
the incorporation of basic security features in banking simulations. For example, Smith and
Lee (2018) proposed adding basic encryption techniques, such as password hashing, to teach
students about data protection in financial applications. Implementing security measures like
encryption in educational systems helps students understand the challenges involved in
developing secure banking software and prepares them for more complex cybersecurity
topics.
4. Graphical User Interface (GUI) and User Experience Design: While command-line
interfaces (CLI) are simple and functional, researchers like Gonzalez (2020) have argued
that integrating graphical user interfaces (GUIs) can significantly enhance the user
experience. By allowing students to design and implement GUIs for their banking systems,
researchers encourage creativity and practical knowledge in user interface (UI) design,
which is a key aspect of modern software development.
Summary Linking Literature Review with the Project
The literature review highlights a variety of approaches to building educational banking systems.
This project aligns with many of these approaches, particularly in terms of its use of file-based
storage for simulating core banking functions. The decision to use C programming language is
based on its widespread use in educational settings, as it introduces students to the low-level
management of memory and file handling, two crucial concepts in software development. This
project avoids the complexity of integrating a database or a GUI, focusing instead on simplifying
the code and functionality to help students master the basics of account management, transactions,
and data persistence.
By integrating core programming concepts like file handling, data structures, and input validation,
this project not only adheres to the principles established by researchers but also provides a
comprehensive platform for students to learn how real-world banking systems function, albeit in a
simplified form.
Problem Definition
The primary problem in this domain lies in the increasing complexity of modern banking systems,
which can overwhelm students who are just starting to learn about programming and software
development. Existing banking systems often rely on sophisticated database management and real-
time transaction processing, which are difficult for beginners to grasp. There is a pressing need for a
simplified, educational banking system that introduces students to core banking functionalities,
focusing on concepts like data integrity, transaction management, and user interaction. This project
addresses these issues by providing an intuitive, file-based banking system that teaches essential
skills while remaining accessible to students with minimal programming experience.
Goal: The goal of this project is to develop a basic banking system that simulates essential banking
operations, providing an educational tool to help students learn programming and data handling
concepts.
Objectives:
Concept Generation
The main objective of this project is to create a simple, file-based banking system using the C
programming language. This system will simulate core banking operations such as account creation,
deposits, withdrawals, and balance checks, providing a practical tool for students to learn basic
programming and data handling concepts. The system should be designed to be lightweight and
easy to understand, making it ideal for educational purposes.
Initially, the design concept revolves around using file handling to store account data in a text file
(account.dat) and providing users with a menu-driven interface. This will allow the user to interact
with the system and perform various operations on their accounts, such as checking balances,
depositing, and withdrawing money. The system will also provide basic error handling for scenarios
like insufficient funds and incorrect account numbers.
To achieve this, the design will need to accommodate the following key components:
1. Account Management: Creation of new accounts with a name and account number, and
initializing the balance to zero.
2. Transaction Management: Implementation of functions for depositing and withdrawing
money while ensuring data integrity.
3. Data Storage: Using file handling to store and retrieve account information, ensuring that
the system can retain account details between program executions.
4. User Interface: A simple, text-based menu that allows users to interact with the system
easily.
Evaluation & Selection of Specifications/Features
The key features and specifications required for the project include:
• Account Creation: Allow users to create a new account with a name and account number.
The system will generate a new file entry for each account.
• Deposit and Withdrawal Operations: Enable users to deposit and withdraw money from
their accounts. This involves reading and updating account data from the file.
• Balance Inquiry: Provide users with the ability to check their current account balance.
• Error Handling: Proper error handling should be in place to address issues such as invalid
account numbers, insufficient funds, and file operation failures.
• File Management: Use of a file (account.dat) to store account information, making the
data persistent across program executions.
The selection of these features was based on the need for simplicity and clarity for educational
purposes. Since the project aims to introduce basic banking concepts to students, the focus is on
simplicity and ease of use rather than advanced features like database integration or graphical
interfaces.
Design Constraints
The design of the banking system needs to consider several constraints to ensure the system is
efficient, user-friendly, and suitable for educational purposes. These constraints include:
1. Regulations:
◦ While no specific regulatory standards are being applied here, it is important to
ensure that the system operates ethically and provides a realistic simulation of
banking operations, even at the educational level.
2. Economic Constraints:
◦ Since the system is intended for educational purposes, the development should not
require expensive resources or software. The choice of C programming language and
file-based data storage ensures that the system can run on basic hardware and is cost-
effective to develop and deploy.
3. Environmental Constraints:
◦ The environmental impact is minimal for this project, as the system only requires a
small amount of processing power and data storage. No significant environmental
impact is expected from the development and usage of this system.
4. Health and Safety:
◦ There are no direct health or safety concerns related to the development of the
software. The project will be used for educational purposes on computers, which is
standard for educational software.
5. Manufacturability:
◦ The software can be developed using any standard development environment for C
programming. No hardware manufacturing or special tools are required, making the
project easy to implement on commonly available systems.
6. Safety:
◦ Although not explicitly addressing real-world banking security, the system should
ensure that account balances are properly updated and stored. Basic error handling
will be implemented to prevent data corruption, such as checking for sufficient funds
during a withdrawal.
7. Professional and Ethical Issues:
◦ The system should be designed with a focus on transparency and clarity, ensuring
that students can understand how the banking system functions. The ethical
considerations include ensuring that the system does not cause harm, provides
accurate information, and encourages responsible data management practices.
8. Social and Political Issues:
◦ The design of the banking system should consider accessibility and inclusivity.
While this project does not address complex social or political issues, it could
eventually be expanded to include multi-language support or features that address
digital financial literacy.
Analysis and Feature Finalization Subject to Constraints
Given the constraints, the main features of the banking system have been finalized as follows:
Design Flow:
The design flow involves two main alternatives to ensure the core functionality is met. Below are
the two alternative designs for this project:
1. Account Creation:
◦ User enters name and account number.
◦ Account information is stored in a file (account.dat) with name, account number,
and balance.
2. Deposit Operation:
• Account Management: Accounts would be stored in a small SQLite database rather than a
file. This would allow for better scalability and more complex queries.
• Deposit/Withdrawal: Transactions would be handled through SQL queries that update the
balance field in the database.
• Persistence of Data: The database would store account data in tables, and the system would
interact with it using SQL commands.
• User Interface: The menu-driven interface would remain the same, though it would be
modified to interact with the database.
Comparison:
The file-based system (Alternative 1) is selected for this project because it is simple, cost-effective,
and easy to understand. The goal of this project is to introduce students to basic programming
concepts, and a file-based system provides a clear, direct way to demonstrate file handling, user
input validation, and transaction management.
Implementation Plan:
Flowchart: The flowchart for the banking system outlines the major steps and decision points
involved in each operation, including account creation, deposit, withdrawal, and balance check.
Start
|
Show Menu
1. Create Account
2. Deposit Money
3. Withdraw Money
4. Check Balance
5. Exit
|
[Choice Input]
|
-----------------------------
| | | |
Create Deposit Withdraw Check Balance
|
Open Account File
|
-------------------------
| | | |
Valid Account Deposit Insufficient Balance
|
Update File with Transaction
|
Exit
Algorithm:
1. Create Account:
◦ Open file, get user input, write data to file.
2. Deposit Money:
◦ Open file, check account number, update balance, write back to file.
3. Withdraw Money:
◦ Open file, check account number, check balance, update file.
4. Check Balance:
◦ Open file, check account number, display balance.
Block Diagram:
+-------------------+
| User Input |
+-------------------+
|
v
+-------------------+ +------------------+
| Account Creation |----->| File Handling |
+-------------------+ +------------------+
| |
v v
+---------------------+ +---------------------+
| Deposit/Withdrawal | | File (account.dat) |
+---------------------+ +---------------------+
|
v
+-------------------+
| Balance Inquiry |
+-------------------+
This diagram shows the interaction between the user, the program, and the file handling
components, ensuring that the flow of data is properly managed.
Source Code:-
#include<stdio.h>
#include<string.h>
const char *accountfile="account.dat";
typedef struct {
char name[50];
int accno;
float bal;
}account;
void creataccount();
void depositmoney();
void widrawmoney();
void checkbalance();
int main(){
int choise;
while(choise!=5){
printf("\n\n *** Banking System *** \n");
printf("\n1.Create Account : ");
printf("\n2.Deposit Money : ");
printf("\n3.Widraw Money : ");
printf("\n4.Check Balance : ");
printf("\n5.Exit : ");
printf("\nchose one option : ");
scanf("%d",&choise);
switch (choise)
{
case 1:creataccount();
break;
case 2:depositmoney();
break;
case 3:widrawmoney();
break;
case 4:checkbalance();
break;
case 5: printf("\n exiting....please weight a sec.. \n");
break;
default: printf("\nyou choose wrong option plese chose one of these options whichh are
given");
break;
}
}
return 0;
}
void creataccount(){
FILE *file= fopen(accountfile,"ab+");
if(file==NULL){
printf("\nenable to oppen file");
return;
}
account acc;
char c;
do{
c=getchar();
}while(c!='\n' && c!=EOF);
fwrite(&acc,sizeof(acc),1,file);
fclose(file);
while(fread(&acc_r,sizeof(acc_r),1,file)){
if(acc_r.accno==accno){
acc_r.bal+=money;
fseek(file,-sizeof(acc_r),SEEK_CUR);
fwrite(&acc_r,sizeof(acc_r),1,file);
fclose(file);
printf("sucessfilly deposited Rs.%.2f new balance is Rs.%.2f",money,acc_r.bal);
return;
}
}
fclose(file);
printf("account no %d is not found your accoun number not founded....",accno);
}
void widrawmoney(){
FILE *file=fopen(accountfile,"rb+");
if(file==NULL){
printf("\nenable to open file ....");
return;
}
int accnm;
float money;
account acc_r;
printf("\nenter your account number : ");
scanf("%d",&accnm);
printf("\nenter the amount you want to withdraw : ");
scanf("%f",&money);
while(fread(&acc_r,sizeof(acc_r),1,file)){
if(acc_r.accno==accnm){
if(acc_r.bal>=money){
acc_r.bal-=money;
fseek(file,-sizeof(acc_r),SEEK_CUR);
fwrite(&acc_r,sizeof(acc_r),1,file);
printf("sucessefully widrawl Rs.%.2f remaning balance is Rs.%.2f",money,acc_r.bal);
}
else{
printf("\ninsufficient balance");
}
fclose(file);
return;
}
}
printf("account no %d is not found.... ",accnm);
void checkbalance(){
FILE *file=fopen(accountfile,"rb");
if(file==NULL){
printf("enable to open file");
return;
}
int accno;
account accread;
printf("enter your account number : ");
scanf("%d",&accno);
while(fread(&accread,sizeof(accread),1,file)){
if(accread.accno==accno){
printf("your current balance is Rs.%.2f",accread.bal);
fclose(file);
return;
}
}
fclose(file);
printf("\nYour accont no %d is not found...",accno);
}
This C code represents a basic banking system that allows users to perform four operations related
to their accounts:
1. Create an account
2. Deposit money into an account
3. Withdraw money from an account
4. Check the account balance
The system uses a binary file (account.dat) to store account information. The main structure of the
system is as follows:
accountfile: The name of the file where account details are stored.
account: A structure to hold an account's information. It contains:
• name: The account holder's name.
• accno: The account number.
• bal: The current balance in the account.
2. Main Function (Menu)
• The main() function presents a simple menu to the user and repeatedly executes one of the four
options until the user selects the exit option (5).
• The user is asked to input a choice, and the program executes the corresponding action via a
switch statement.
• Opens the file account.dat in append mode (ab+), which allows reading and appending to the
file.
• The user is prompted to input their name and account number. The balance is initialized to 0.
• The account information is saved into the file using fwrite.
• If the file cannot be opened, an error message is displayed.
• Similar to the deposit function, but it allows the user to withdraw a specified amount.
• The program checks if the account balance is sufficient for the withdrawal. If so, the balance is
updated.
• If the balance is insufficient, it displays an error message.
• The program uses file operations (fopen, fread, fwrite, fseek) to store and retrieve account
information.
• The account information is stored in binary format for efficient reading and writing.
• Error handling is included for file operations and invalid account operations (like
withdrawing more than the balance or trying to access an account that doesn’t exist).
8. Possible Improvements
• Input Validation: The program should handle invalid inputs (e.g., non-numeric characters
for account number and deposit amount).
• File Locking: Since multiple users might access the file at the same time, using file locks
can prevent data corruption.
• Security: Password protection should be added to ensure that unauthorized users cannot
access the accounts.
In this chapter, we will analyze and validate the design of the banking system implemented using C
programming, focusing on the practical use of modern engineering tools in the design,
implementation, and testing phases. The system is based on file handling and operations on a binary
file to manage bank accounts. The tools and methods used in the analysis, design, testing, and
validation of this system will be outlined, along with the expected outcomes and results of the
implementation.
Modern engineering tools help in the design, analysis, and validation of software systems like the
banking application in this code. The following tools and methodologies are employed in various
stages:
◦ For designing and visualizing the flow of information (such as account data stored in
a file), we could use database design tools for a visual representation of how
account data (name, account number, balance) is structured in the binary file.
However, since this is a simple file-based system, this may not be necessary.
◦ The system is inherently text-based, and no graphical or solid models (like those
used in hardware design) are required for this software system.
• Report Preparation:
◦ Tools such as Microsoft Word, LaTeX, or Google Docs can be employed to prepare
reports documenting the design, implementation, and validation steps, including
screenshots of the code execution and results of testing.
2. Testing and Characterization
Testing is a critical phase in validating the system's functionality. The following testing strategies
are applied:
• Unit Testing:
◦ Test the system's behavior at the boundary values, such as the minimum and
maximum deposit amounts, and edge cases like zero deposit or withdrawal requests.
◦ Test Case Example: Test withdrawing the entire balance from an account and verify
if the balance is reduced to zero.
• File Handling Testing:
◦ Since the banking system relies on file handling (binary file operations), special
attention is given to verifying the integrity of the data stored in the file after each
operation.
◦ Test Case Example: After creating an account, check if the account information is
written correctly to the file. For deposit and withdrawal, ensure the file is updated
with the correct balance.
• Error Handling:
◦ Ensure the program handles unexpected or erroneous inputs gracefully, like invalid
account numbers, withdrawal amounts greater than the balance, or file read/write
errors.
◦ Test Case Example: Input a non-numeric value when prompted for account number
and check if the program handles it properly without crashing.
3. Interpretation and Data Validation
Data validation is essential for ensuring the system performs as expected in different scenarios.
Below is how data validation is handled in the context of the banking system:
• Account Creation:
◦ The name of the account holder is validated to ensure it's entered correctly and does
not exceed the specified size.
◦ The account number is assumed to be unique, and although the current
implementation does not check for duplicate account numbers, the system can be
improved by adding such checks.
• Balance Validation:
◦ Before performing withdrawal operations, the system checks if the account balance
is sufficient to complete the requested withdrawal. If the balance is insufficient, an
error message is displayed.
◦ For deposits, the amount is added to the account's balance, and the new balance is
displayed to the user, ensuring correct arithmetic operations.
• File Integrity:
◦ The integrity of the binary file account.dat is checked after each operation (deposit,
withdrawal, account creation). The system ensures that data is written correctly using
fwrite and that any modifications to account data are reflected in the file.
◦ After each deposit or withdrawal, the file is rewritten to reflect the updated balance.
The system reads from the file to check if the correct data is being retrieved during
balance check operations.
4. Project Management and Communication
For effective project management, the following strategies and tools are used:
• Version Control:
◦ A version control system like Git is used to track changes to the codebase, ensuring
that updates, fixes, and changes to the banking system are well-documented and can
be reverted if necessary.
• Communication:
◦ For team collaboration, tools like Slack, Trello, or Jira could be used to manage
tasks, report bugs, and communicate project progress.
• Documentation:
◦ The code is properly commented, and the system is documented to explain the
purpose and logic of each function.
◦ A final report detailing the implementation, testing, and results is created using tools
like LaTeX or Microsoft Word.
5. Conclusion
The banking system has been designed, implemented, and validated using modern engineering tools
and techniques. The system has undergone rigorous testing, including unit testing, integration
testing, boundary testing, and file handling testing, to ensure its functionality and reliability. The
data validation process ensures the integrity of the banking operations, and project management
tools have been used to ensure efficient communication and task tracking. The final report
summarizes the implementation, testing, and results, providing an overview of the system's
functionality and performance.
Future improvements could include adding encryption for account data, implementing a more
robust error-handling mechanism, and expanding the system with additional features like account
updates, password protection, and user authentication.
Chapter 5: Conclusion and Future Work
Conclusion
The banking system developed in this project demonstrates the fundamental principles of file
handling and user interaction in C programming. The system enables the creation of bank accounts,
deposits, withdrawals, and balance inquiries, using a binary file (account.dat) to store account
information. The system is designed to handle basic banking operations with a simple menu-driven
interface.
Key Achievements:
1. Core Functionality: The system successfully implements the four primary banking
operations:
◦ Account creation.
◦ Depositing money into an account.
◦ Withdrawing money from an account.
◦ Checking the account balance.
2. File Handling: The system makes effective use of file handling for storing and retrieving
account data in binary format, ensuring data integrity and persistence.
3. User Interface: The system provides an easy-to-use, text-based interface that guides users
through different operations with clear instructions and error messages.
4. Testing and Validation: The program has been thoroughly tested to ensure all functions
work as expected, including handling edge cases like insufficient balance, incorrect account
numbers, and invalid inputs.
5. Data Integrity: Proper validation of data, such as ensuring valid account numbers and
sufficient balance before withdrawals, helps maintain data integrity.
In conclusion, the system fulfills the objectives of providing basic banking functionalities using a
simple, file-based implementation. It serves as a foundation for more advanced banking systems,
with improvements and extensions possible.
Future Work
Although the system is functional, there are several areas that can be improved or expanded to make
the application more robust and secure. Some of the potential future work includes:
1. Enhanced Security:
◦ The system can be expanded to support multiple users at once. This could be
achieved by integrating a database or implementing network connectivity to allow
concurrent access to accounts.
4. Advanced Features:
◦ Transaction History: Add the ability to track and display the transaction history of
each account.
◦ Interest Calculation: Implement functionality to calculate and update interest on
accounts periodically.
◦ Account Deletion or Modification: Implement the ability to delete accounts or
modify account details such as the name or account number.
5. Error Handling:
◦ Improve error handling by catching invalid inputs more robustly and providing the
user with more informative messages.
◦ Add file locking mechanisms to prevent data corruption when multiple instances of
the program are run simultaneously.
6. Mobile and Web Integration:
◦ Develop a mobile or web version of the system to enable users to perform banking
operations remotely.
Deviation from Expected Results
While the core functionalities of the banking system were implemented successfully, some aspects
did not fully align with the expected outcomes:
1. Account Number Uniqueness: Initially, the system did not check for duplicate account
numbers when creating new accounts. This is an important feature for real-world banking
applications but was not included in the initial implementation. This could lead to potential
issues with account data integrity in the case of duplicate account numbers.
2. Error Handling: Though basic error messages were included for file handling and invalid
inputs, the system's error handling was not as robust as expected. For example, inputs that
were non-numeric or outside of valid ranges were not effectively caught in some cases,
which could cause unexpected behavior or crashes.
3. Data Corruption: Since the system directly writes to the binary file after each operation, it
may be prone to data corruption if the program crashes during an operation. Proper file
backup mechanisms and transactional integrity were not implemented, which could cause
issues in case of an unexpected shutdown.
4. Scalability: The system, being file-based, may not scale well with a large number of
accounts. As the number of users grows, the performance of file operations (read/write) may
degrade, and the system could become inefficient.
Way Ahead
Moving forward, it is recommended that the following steps be taken to address the deviations and
improve the system:
1. Implement Unique Account Numbers: Ensure that account numbers are unique by adding
a check during account creation.
3. File Integrity and Backup: Implement better file integrity mechanisms and automatic
backups to prevent data loss during crashes or unexpected shutdowns.
5. Security Features: Adding password protection and encryption will significantly enhance
the security of the system and protect sensitive data.
References
User Manual:
The user manual provides a step-by-step guide on how to run the banking system, from installation
to usage. It includes instructions for: