Summer Internship Report on

School Payment Management System and Library Management System

A Summer Internship report submitted in partial fulfillment of requirements for

the award of degree of
BACHELOR OF TECHNOLOGY
IN
ELECTRONICS AND COMMUNICATION ENGINEERING
BY
KARETI VYSHNAVI
229X1A0470

Under the esteemed guidance by

Mr. M. Madan Gopal

Department of Electronics and Communication Engineering

G. PULLA REDDY ENGINEERING COLLEGE (Autonomous): KURNOOL
(Affiliated to JNTUA, ANANTAPURAMU)
2025-2026
 G. Pulla Reddy Engineering College (Autonomous)
Affiliated to JNTUA, Anantapuramu , Department of
Electronics and Communication Engineering

BONAFIDE CERTIFICATE

This is to certify that Kareti Vyshnavi, bearing the Roll Number 229X1A0470, a student of
B.Tech – ECE , has successfully completed the Summer Internship – 2025 organized by Six
Phrase / Veranda during the period [05-05-2025] to [31-05-2025].

The student has successfully solved the following two problems under this internship:

1. Title – 1: School Payment Management System

2. Title – 2: Library Management System

This work is carried out under the guidance of faculty and with due approval from
the department.

Principal Head of the Department Faculty In-Charge

(Signature with College Seal) (Signature with Seal) (Signature)
 CONTENTS
S.No Contents Page No

1. Project 1:School Payment Management System

 Introduction

 Abstract

 Input Format

 Technologies Used and Outcomes

 Models and Methods Used

 Flowcharts and Tables

 Challenges Faced

 Program Code

 Output Screenshots

 Conclusion, Advantages & Disadvantages

 References

2 Project 2:Library Management System

 Introduction

 Abstract

 Input Format

 Technologies Used and Outcomes

 Models and Methods Used

 Flowcharts and Tables

 Challenges Faced

 Program Code

 Output Screenshots

 Conclusion, Advantages & Disadvantages

 References
 PROJECT 1: SCHOOL PAYMENT MANAGEMENT SYSTEM

INTRODUCTION
In today’s educational institutions, managing student fee payments is a critical but often
complex administrative task. Traditionally, many schools still rely on manual or semi-manual
methods involving physical records, spreadsheets, or basic software tools that lack integration
and automation. This approach is prone to human errors, data inconsistencies, delays in fee
collection, and challenges in maintaining transparent financial records. These issues not only
burden the administrative staff but also affect the overall operational efficiency of the
institution.

Recognizing these challenges, this project focuses on developing a simple prototype to

simulate a digital school payment management system. The primary aim is to explore how
such a system can streamline fee collection, manage student records, and maintain fee
structures specific to different classes in a school environment. By creating a small-scale
model, we gain practical experience with core concepts such as data storage, user
authentication, role-based access, and transaction tracking.

The project uses a command-line interface (CLI) to interact with the system, which helps in
focusing on the underlying functionality without the complexity of graphical user interfaces. It
supports essential features like adding and removing student data, viewing fee payment status,
recording payments, and managing fee structures for different classes. The use of file-based
storage systems demonstrates how data can be persisted and retrieved efficiently even in basic
environments.

Beyond learning programming and software design skills, this project highlights the
importance of software solutions in improving administrative workflows in educational
institutions. It serves as a foundation for future enhancements such as online payment
integration, automated notifications, and comprehensive reporting tools. Overall, the project
provides valuable insights into the application of information technology to real- world
problems, helping bridge the gap between academic learning and practical system
development.
 ABSTRACT
The goal of this project was to study and enhance the traditional school payment management
system, which often relies on manual processes that can lead to inefficiencies, errors, and lack of
transparency. To understand the current practices and challenges involved in managing school
fees, student records, and payment tracking, we developed a basic yet functional prototype that
simulates the core functionalities of a digital school fee management system. This prototype was
not intended to be a final product, but rather a foundational model to help visualize how
digitalization could address the shortcomings of conventional methods.

In the traditional approach, fee management typically involves a great deal of paperwork, manual
calculations, and individual tracking of payments and dues. Such a system can be error-prone and
time-consuming for administrative staff, and may also lead to issues in accountability and
reporting. With increasing student strength and complexity in fee structures, the demand for a more
efficient, transparent, and organized system is evident. Our prototype aimed to address this need
by offering basic features such as adding or removing students, assigning class-wise fee structures,
recording fee payments, viewing pending dues, and displaying overall student fee status.

The system relies on structured data handling using file-based storage to keep records of students,
payments, and fee structures. By simulating real-world scenarios, such as partial payments, full
payments, and pending dues, the prototype allowed us to analyse how automation can reduce
workload, minimize manual errors, and improve overall clarity in the management process. It also
allowed us to explore how user authentication and access control (e.g., admin vs student roles) can
contribute to a more secure and organized environment.

The outcome of this project is a better understanding of how digital solutions can transform routine
school administrative tasks. Although the current version is a command-line prototype, the insights
gained lay the groundwork for developing more advanced applications in the future. These could
include user-friendly graphical interfaces, integration with online payment gateways, automated
reminders, detailed reporting, and scalable database support. Ultimately, this project serves as a
stepping stone toward building a modern, digital school fee management system that is efficient,
reliable, and user-centric.
 INPUT FORMAT

The system is designed to accept inputs through a simple command-line interface, allowing users
to interact by entering commands and providing necessary data as prompted. The input format
follows a structured approach to ensure clarity and correctness during data entry.

 User Authentication:
At the start, the system requires users to log in by entering a valid username and password. This
ensures role-based access, where different users such as administrators and students have access
to specific functionalities.
 Menu Selection:
After login, users are presented with a numeric menu displaying available options. The user
inputs an integer corresponding to the desired operation, such as viewing student fee status,
adding or removing students, or recording payments.
 Student Data Input:
When adding a student, the system prompts for several fields:
o Student ID: A unique integer identifier for each student.
o Student Name: Full name of the student, entered as a text string.
o Class Name: The name of the class or grade the student belongs to, provided as a string (e.g.,
"Class1", "Class2").
These inputs must be entered carefully to maintain data integrity.
 Payment Data Input:
When recording payments, the system expects:
o Student ID: To identify the student making the payment.
o Payment Date: The date of payment, formatted as a string (e.g., "YYYY-MM-DD").
o Amount: The numeric value of the payment made.
o Transaction ID: A unique identifier for the payment transaction, entered as a string.
 Other Inputs:
For removing a student or other administrative tasks, users enter the required identifiers (e.g.,
Student ID) as prompted.

All inputs are read as strings or integers depending on the context and validated to avoid errors
such as duplicate student IDs or invalid menu choices. The system provides feedback messages if
invalid data is entered or if operations succeed.
 TECHNOLOGIES USED AND OUTCOMES
Technologies Used:

 Java Programming Language:

The project was developed using Java due to its platform independence, robust standard libraries,
and ease of handling file operations. Java’s object-oriented features helped in designing modular
and maintainable code.
 File Handling for Data Persistence:
Instead of using complex databases, simple text files were used to store data related to students,
fee structures, and payments. This approach kept the prototype lightweight and focused on core
functionalities.
 Command-Line Interface (CLI):
The user interface is implemented through a CLI, enabling straightforward input/output
operations without requiring a graphical environment. This choice made the prototype easy to
run on any system with a Java Runtime Environment.
 Basic Data Structures:
Collections like ArrayLists were used to manage lists of students, payments, and fee structures
efficiently within the program’s runtime.

Outcomes:

 Understanding of School Fee Systems:

The project provided practical insights into how traditional school payment systems operate and
highlighted areas prone to manual errors or delays.
 Prototype Demonstration:
A working prototype was created that simulates essential operations such as adding/removing
students, viewing fee payment status, and managing fee records by class.
 Foundation for Further Development:
Although simple, this prototype serves as a foundation for future enhancements, such as
integrating a database backend, implementing a web or GUI interface, or adding automated
notification features.
 Improved Data Organization:
The system helps maintain consistent and transparent financial records, reducing the chance of
lost or mismanaged payment information.
 Skill Development:
Through this project, practical skills were gained in Java programming, file handling, basic user
interface design, and system design principles relevant to real-world applications.
 MODELS AND METHODS USED

Models Used:

To represent the core entities in the school fee management system, the project uses several data
models implemented as Java classes:

 Student Model:
Represents a student with attributes such as student ID, name, class name, and fees paid so far.
This model helps in tracking individual student fee payment status and personal details.
 FeeStructure Model:
Defines the fee amount for each class. This allows the system to calculate total fees applicable for
students based on their class, supporting flexible fee management.
 Payment Model:
Records details of each fee payment transaction, including the student ID, payment date, amount
paid, and a transaction ID. This model enables the system to maintain a payment history for each
student.

Methods Used:

The system’s functionality is implemented through a set of well-organized methods that perform
the following key operations:

 Data Loading and Saving:

Methods to load student data, payment records, and fee structures from text files on startup, and
save any changes back to these files. This ensures persistence of data between sessions.
 Student Management:
Functions to add new students, remove existing ones, and fetch student details by ID. These
methods handle updating both the student list and associated user credentials securely.
 Fee Calculation:
Methods to compute total fees for a class and calculate the outstanding amount for each student
by comparing total fees with the amount already paid.
 Payment Tracking:
Functions to view pending and completed payments by checking if the student’s paid amount
matches the total fees. This allows easy monitoring of fee payment status.
 User Interaction Methods:
Menu-driven methods that interact with the user through the command line interface, enabling
smooth navigation and operation of the system features.
 FLOWCHARTS AND TABLES

This flowchart illustrates the core workflow of the system. After starting the application, users log
in and based on their role, they get access to respective menus. Admins can manage students and
view payment data, while students can view their fee status and make payments. All changes are
saved persistently before logout.

Figure 1

Tables and File Formats:

1. students.txt

Studen Name Class Fees

t ID Name Paid
1 Aditya class1 1000
Kumar 0
2 Rohan Singh class2 1200
0
3 Shradha class3 1300
Khapra 0
4 Priya Patel class4 1500
0
5 Aman Gupta class5 1700
0
Table 1

Format: StudentID,Name,ClassName,FeesPaid Example line: 1,Aditya Kumar,class1,2000

 2. payments.txt
Student ID Date Amount Transaction ID
1 2025-05-01 2000 TXN10001
2 2025-05-03 1500 TXN10002
3 2025-05-05 2500 TXN10003
4 2025-05-07 3000 TXN10004
5 2025-05-09 1000 TXN10005

Format: Table 2
StudentID,Date,Amount,TransactionID
Example line: 1,2025-05-
01,2000,TXN10001

3. fee_structure.txt
Class Name Total Fees
class1 10000
class2 12000
class3 13000
class4 15000
class5 17000
Format:
Table 3
ClassName,TotalFees
Example line:
class1,3000

4. users.txt (Authentication file)

Username Password Role

admin admin123 admin
student1 pass1 student
student2 pass2 student
student3 pass3 student
student4 pass4 student
student5 pass5 student

Format: Table 4
Username,Password,Role
Example line:
admin,admin123,admin

Explanation of Tables:
 students.txt stores essential student details and the fees they have paid so far.
 payments.txt keeps a record of every fee payment made by students along with the date and
transaction ID.
 fee_structure.txt defines the total fee for each class, which is used to calculate pending
payments.
 users.txt manages login credentials and roles (admin or student) for system access control.
 CHALLENGES FACED
During the development of this school payment management system prototype, several
challenges were encountered that provided valuable learning experiences:

1. Understanding the Manual Workflow

Before implementing the system, one of the primary challenges was understanding how
traditional fee collection and record maintenance is performed in schools. It involved identifying
what data is recorded, how payments are tracked, how discrepancies are handled, and how
transparency is maintained—all of which needed to be translated into a digital format.

2. Designing File Structures and Formats

Since this project uses file-based storage (not databases), designing efficient and readable text
formats for storing student, payment, and fee structure data was crucial. We had to ensure the files
could store data reliably and be easily parsed by the system without causing runtime errors or
data corruption.

3. Ensuring Data Consistency Across Files

Each feature was dependent on multiple files. For example, when a student makes a payment,
both the payments.txt and students.txt files had to be updated correctly. Ensuring consistent
updates across these files without using a central database system required careful logic and
synchronization.

4. Implementing Role-Based Access

Managing different functionalities for admin and student roles required proper access control.
Implementing a user authentication mechanism that was simple, file-driven, and secure enough
for a prototype took effort and debugging.

5. Handling Invalid or Missing Data

There were several edge cases to consider:

 What if a user entered an incorrect student ID?

 What if a file was missing or empty?
 How should the system handle incorrect fee amounts?

Ensuring that the system remained stable and user-friendly even in such situations was a key
challenge during testing.
6. Time Constraints and Scope Management

Given the limited time and the nature of the internship, we had to limit the scope of the system to a
command- line interface prototype. Deciding what features to include and what to leave out
while still meeting the core objectives was a balancing act throughout the project.

7. Simulating Realistic Use Cases

Since this was not implemented in a real school environment, we had to simulate various student
actions and admin operations using dummy data. Making sure these simulations reflected real-
world challenges helped in designing better logic but also added complexity during development.
 PROGRAM CODE
This section includes the key source code files used to implement the school payment
management system prototype. The system was developed in Java and used a file-based approach
for storing student, payment, and fee structure data.

Folder Structure:

Figure 2

1. Main.java

This is the entry point of the application. It controls the main menu and allows login as either an
admin or a student.

2. Student.java

Model class to represent student data:

 3. Payment.java

Model class representing a payment record:

4. FeeStructure.java

Model for storing class-wise fee amounts:

5. FeeManager.java

Handles file I/O for all student, fee, and payment data:

6. AdminService.java and StudentService.java

Logic for role-based operations such as:

 Viewing all students

 Adding payment
 Viewing own payment history
 Checking pending dues.
7. FileAuthService.java

Handles simple username-password based login from users.txt.

Source Code Repository

The complete source code for this project is available on GitHub:

➊ https://github.com/ShaikFayaz042/school-fee-cli
3
S
 OUTPUT SCREENSHOTS
1) Student Login

2) Admin Login
 CONCLUSION

Advantages

1. Centralized Fee Tracking: Admin can view all student fee records, pending and completed
payments in one place.
2. Automation: Reduces the need for manual bookkeeping and calculations.
3. User Account Management: Automatically creates and removes student user accounts via
integration with FileAuthService.
4. Data Persistence: Student, payment, and fee structure data are saved and loaded from files,
ensuring persistence between sessions.
5. Scalability: Supports adding more students, classes, and fee structures easily.
6. Simple CLI Interface: Easy to use for admins without technical training.

Disadvantages

1. File-Based Storage Limitations: Not suitable for large-scale data or concurrent access (no real-
time database).
2. No Input Validation: Admin-side inputs (like ID and class name) lack strong validation, which
could lead to data errors.
3. Case Sensitivity Issues: Class names and usernames are case-sensitive, which may cause
mismatches.
4. No GUI: Being CLI-based, it's less user-friendly compared to a graphical interface.
5. No Authentication for Admin Menu: Anyone running the program can access admin
functionalities unless restricted externally.

Conclusion

The Admin Service component of the School Payment Management System successfully
facilitates administrative control over student records, fee status tracking, and user management.
It ensures seamless interaction between data files and the CLI-based interface. Through
functionalities like viewing fee statuses, managing payments, and controlling student records, the
system reduces manual workload, improves accuracy, and enhances transparency in fee
collection processes.
 REFERENCES

1) Design and Implementation of Automated School

https://www.projectclue.com/computer-science/project-topics-materials-for-undergraduate-students/design-
and-implementation-of-an-automated-school-fees-payment-system

2) Fee Management Project Report | PDF | Microsoft Access – Scribd

https://www.scribd.com/document/247208689/Fee-Management-Project-Report-1-1

3) School Fees Payment Management System - PHP project – kashipara

https://www.kashipara.com/project/php/3881/school-fees-payment-management-system

4) school billing system report | PDF – SlideShare

https://www.slideshare.net/slideshow/school-billing-system-report/69521945

5) School management system project Report.pdf – SlideShare

https://www.slideshare.net/slideshow/school-billing-system-report/69521945

6) School management system project report.

https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4837837

7) Design and Development of a Secondary School Payment System

https://www.academia.edu/115907527/Design_and_Development_of_a_Secondary_School_Payment_Syste
m

8) Fees management system report - A Project Report On &lt – Studocu

https://www.studocu.com/in/document/government-engineering-college-bhavnagar/computer-science-
engg/fees-management-system-report/34833744

9) Fees Management System Project in PHP – Projectworlds

https://projectworlds.in/fees-management-system-project-in-php/

10) Design And Implementation of a Payment Management System

https://www.academia.edu/19856069/Design_And_Implementation_of_a_Payment_Management_System
 PROJECT 2: LIBRARY MANAGEMENT SYSTEM
INTRODUCTION

The Library Management System is a crucial tool developed to streamline the process of
managing books and other educational resources within an academic institution. Libraries play a
significant role in the educational environment by providing students and faculty members
access to a wide range of study materials. However, manual handling of book inventories,
searching, and record-keeping can often be inefficient and error-prone, especially in large
libraries with thousands of books. This project aims to address these challenges by automating
the key operations of a library, ensuring ease of use, accuracy, and speed in managing the
resources.
This system categorizes books based on departments such as Mechanical Engineering, Civil
Engineering, Computer Science, and others, aligned with the college’s academic structure. Each
department’s books are further organized by academic year and semester, reflecting the
curriculum’s progression. Such a structured approach helps students quickly identify and access
relevant books related to their current courses or research topics. The system maintains detailed
metadata for every book, including title, author, ISBN, department, subject, and availability
status, which collectively enhance the user’s ability to search and manage the collection
effectively.
The project is designed with a user-friendly console-based interface that facilitates interaction
through simple menu options. Administrators are required to authenticate themselves using
credentials, ensuring that only authorized personnel can modify the book database. The
functionalities include viewing books by department, searching for books by title or author,
adding new books to the collection, removing obsolete entries, and listing all books available in
the library. This modular design ensures the system’s scalability and maintainability, making it
easier to incorporate new features in the future.
From a technical perspective, this project emphasizes core programming concepts such as object-
oriented programming (OOP), data structures like lists and maps, and exception handling to
ensure robust user input management. The modular code organization allows easy updates and
debugging, while the use of descriptive classes models real-world entities like books effectively.
This internship project not only provides a practical solution for library management but also
serves as a valuable learning experience in software design, implementation, and testing,
preparing students for more complex applications.
 ABSTRACT
The Library Management System project is developed as a Java-based console application
aimed at streamlining the management of library resources in a college or academic setting. The
system provides a secure login interface for administrators, ensuring that only authorized
personnel can access and manage the library’s collection. This approach enhances security and
accountability in library operations.
The system organizes books based on various engineering departments, academic years, and
semesters, reflecting the typical curriculum structure of the institution. It preloads a
comprehensive dataset of books spanning multiple departments such as Mechanical, Civil,
Computer Science, Electrical, Electronics, Chemical, and Information Technology engineering.
This categorization allows users to easily select and view books relevant to specific courses and
semesters.
Key functionalities of the system include the ability to search for books by title or author, add new
books to the collection, remove books, and view all available books. These features facilitate
efficient library management and help maintain an up-to-date catalog. The menu- driven
interface is user-friendly, enabling administrators to navigate through various options
systematically and perform tasks with minimal training.
This project demonstrates practical applications of core programming concepts like object-
oriented design, collections management using lists, and user input validation. It provides a solid
foundation for future enhancements such as incorporating borrowing and returning
functionalities, managing multiple copies of books, and integrating persistent data storage for
long-term record keeping. Overall, the system aims to reduce manual efforts, minimize errors,
and improve the overall efficiency of library management processes.
 INPUT FORMAT
Admin Login:
 The system first prompts for the admin username and password.
 The admin has 3 attempts to enter valid credentials.
 Example:
Enter admin username: admin Enter admin password: admin123
Main Menu:
 After successful login, the system displays a menu with options to perform library operations.
 The admin/user enters the number corresponding to the desired option.
 Example:
Library Menu:
1. Select Department and View Books
2. Search Book by Name/Author
3. Add Book
4. Remove Book
5. View All Books
6. Exit
Enter choice: 1
Select Department and View Books (Option 1):
 The user selects a department by entering a number (1 to 7).
 Then enters the Year (1 to 4).
 Then enters the Semester (1 or 2).
 Example:
Select Department:
1. Electronics and Communication Engineering
2. Mechanical Engineering
Enter choice: 3
Enter Year (1-4): 2
 Enter Semester (1 or 2): 1
Search Book by Name/Author (Option 2):
 User inputs a search term (can be partial or full book title or author name).
 Example:
Search by Book Name or Author: algorithms
Add Book (Option 3):
 User inputs details for the new book:
o Title
o Author
o ISBN
o Department
o Subject
 Example:
Enter title: Data Science Fundamentals Enter author: Jane Doe
Enter ISBN: CSE1011
Enter Department: Computer Science Engineering Enter Subject: Data Science
Remove Book (Option 4):
 User inputs the ISBN of the book to remove.
 Example:
Enter ISBN to remove: CSE1011
View All Books (Option 5):
 Displays all books with their details; no input required.
Exit (Option 6):
 Terminates the program; no input required.
 TECHOLOGIES USED AND OUTCOMES

Technologies Used
1. Java Programming Language:
The core of the project is developed using Java, which provides a platform- independent
environment and robust object-oriented features. Java is ideal for building console-based
applications due to its simplicity and extensive standard libraries.
2. Object-Oriented Programming (OOP):
The project is structured using OOP principles. Classes such as Book encapsulate data and
behavior, promoting modularity and ease of maintenance. Concepts like encapsulation,
inheritance (if extended), and polymorphism improve code organization.
3. Java Collections Framework:
The program uses Java Collections such as ArrayList and LinkedHashMap to store and manage
books and departments dynamically. This allows efficient addition, removal, and searching of
records.

4. Console-based User Interface:

The interaction is via the command-line interface using Scanner for input and System.out for
output. This provides a simple yet effective way for users (admins) to manage the library
resources.

Outcomes

1. Efficient Library Management:

The system provides a straightforward and efficient way for library administrators to manage
books. Admins can easily add, remove, search, and view books categorized by department, year,
and semester.

2. Department and Subject-Wise Book Organization:

The categorization of books according to departments and academic years/semesters allows users
to quickly find relevant books. This structure mirrors real academic settings, making the system
practical for educational institutions.

3. Secure Admin Access:

By implementing admin authentication, the system ensures that only authorized personnel can
modify the library’s data, preserving the integrity and security of book records.

4. Extensibility for Future Enhancements:

The use of modular code and OOP principles makes the system easily extendable. Future features
like book borrowing, returning, member management, or a graphical user interface can be added
with minimal restructuring.
 MODELS AND METHODS USED
Models Used
1. Book Model (Class):
The core data model in this system is the Book class. This class encapsulates all the essential
properties of a book, such as:

o Title

o Author

o ISBN (unique identifier)

o Department (e.g., Mechanical, Civil, CSE)

o Subject (specific course subject)

o Availability status (whether the book is available or borrowed)

This model acts as a blueprint for creating book objects and managing their attributes throughout
the program.

2. Department and Subject Categorization:

Although not explicitly a separate class, the project uses a structured collection (a nested Map and
arrays) to represent departments, years, semesters, and their corresponding subjects. This
hierarchical model organizes books efficiently and simulates the academic curriculum structure.

Methods Used

1. Admin Authentication (adminLogin):

This method handles user authentication by asking for a username and password. It limits the
number of attempts to prevent unauthorized access, ensuring only admins can manage the library.

2. Book Preloading (preloadBooks):

This method initializes the library with a predefined list of books categorized by department,
year, and semester. It generates unique ISBNs and fills the books list for initial use.

3. Menu and Navigation (menu):

This method presents the main interactive menu to the user and handles input choices to route the
user to different functionalities like viewing books, searching, adding, or removing.
4. Select Department and View Books (selectDepartment):
This method allows the admin to filter and view books based on department, year, and semester.
It uses index calculations and list filtering to extract and display the relevant subset of books.

5. Search Book (searchBook):

Enables searching for books by title or author across the entire collection. It performs case-
insensitive matching and displays matching results.

6. Add Book (addBook):

Facilitates adding new book entries to the collection by capturing details like title, author, ISBN,
department, and subject.
7. Remove Book (removeBook):
Allows removal of books from the library using the unique ISBN identifier. It confirms success or
failure of the removal operation.
8. View All Books (viewAllBooks):
Displays a complete list of all books currently in the library with their details.

9. Add Book (addBook):

Facilitates adding new book entries to the collection by capturing details like title, author, ISBN,
department, and subject.
10. Remove Book (removeBook):
Allows removal of books from the library using the unique ISBN identifier. It confirms success or
failure of the removal operation.
11. View All Books (viewAllBooks):
Displays a complete list of all books currently in the library with their details.
FLOW CHART
 TABLES

Book Table

Book Title Author

ID ISBN Department Subject Availability

C
E.Balagurusamy
1 Programming 9781234567890 CSE Programming Available
Basics
Engineering S.Timoshenko
2 9782345678901 ME Mechanics Issued
Mechanics
Digital
3 R. S. Sedha 9783456789012 ECE Electronics Available
Electronics
Database
4 C. J. Date 9784567890123 IT Database Available
Systems
Data Structures
Narasimha Data
5 in Java 9785678901234 CSE Issued
Karumanchi Structures

User Table

User ID Username Password Role

1 admin admin123 Admin
2 student1 stud123 Student

Recommendation Table

Input Department Input Subject Recommended Book Author

Title
CSE Programming C Programming Basics E. Balagurusamy
ME Mechanics Engineering Mechanics S. Timoshenko
ECE Electronics Digital Electronics R. S. Sedha
IT Database Database Systems C. J. Date
 CHALLENGES FACED
1. Data Collection and Categorization

One of the main challenges was collecting and organizing book data according to departments
and subjects. Ensuring that each book was correctly mapped to its relevant subject and
department required manual effort and domain knowledge. Mismatches or missing metadata
could affect the accuracy of recommendations.

2. User Input Handling

Designing a user-friendly way for students to input their department and subject preferences was
tricky. Preventing invalid inputs, misspellings, or case sensitivity issues required careful
validation. For example, if a student entered "cse" instead of "CSE", the system had to correctly
interpret the intent.

3. Limited Scope of Recommendations

As the recommendation logic was based on direct keyword matching (i.e., department and
subject), it lacked personalization or advanced filtering. Implementing smarter recommendations
(like ML-based or popularity-based) would require more data and complexity.

4. Maintaining Simplicity with Functionality

Balancing simplicity (as required for an internship or college-level project) with usefulness was a
constant concern. Adding too many features could complicate the code, while too few might
make the system feel basic. Choosing what to include and exclude was a design challenge.
 PROGRAM CODE

import java.util.*;

class Book {
String title;
String author;
String ISBN;
String department;
String subject;
boolean isAvailable = true;

Book(String title, String author, String ISBN, String department, String subject) {
this.title = title;
this.author = author;
this.ISBN = ISBN;
this.department = department;
this.subject = subject;
}

@Override
public String toString() {
return "Title : " + title +
"\nAuthor : " + author +
"\nISBN : " + ISBN +
"\nDepartment : " + department +
"\nSubject : " + subject +
"\nStatus : " + (isAvailable ? "Available" : "Borrowed") + "\n";
}
}

public class Main {

private static final Scanner scanner = new Scanner(System.in);
private static final List<Book> books = new ArrayList<>();
private static final String adminUsername = "admin";
private static final String adminPassword = "admin123";

public static void main(String[] args) {

adminLogin();
}

private static void adminLogin() {

int attempts = 3;
while (attempts > 0) {
System.out.print("Enter admin username: ");
String username = scanner.nextLine();
System.out.print("Enter admin password: ");
String password = scanner.nextLine();
if (username.equals(adminUsername) && password.equals(adminPassword)) {
preloadBooks();
menu();
return;
} else {
attempts--;
System.out.println("Invalid credentials. Attempts left: " + attempts);
}
}
System.out.println("Too many failed attempts. Exiting...");
}

private static void preloadBooks() {

Map<String, String[][][]> allDepartments = new LinkedHashMap<>();

allDepartments.put("Mechanical Engineering", new String[][][]{

{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Engineering
Mechanics", "Basic Electrical Engineering"},
{"Engineering Mathematics II", "Basic Electronics", "Manufacturing Processes",
"Engineering Drawing", "Environmental Science"}
},
{ // Year 2
{"Thermodynamics", "Fluid Mechanics", "Strength of Materials", "Kinematics of
Machinery", "Material Science"},
{"Heat Transfer", "Dynamics of Machines", "Machine Design", "Metrology and
Measurements", "Mechanical Vibrations"}
},
{ // Year 3
{"Design of Machine Elements", "CAD/CAM", "Control Systems", "Mechatronics",
"Refrigeration and Air Conditioning"},
{"Automobile Engineering", "Robotics", "Finite Element Analysis", "Power Plant
Engineering", "Industrial Engineering"}
},
{ // Year 4
{"Project Management", "Non-Conventional Energy Sources", "Operations
Research", "Composite Materials", "Professional Ethics"},
{"Seminar", "Major Project", "Advanced Manufacturing Processes", "Maintenance
Engineering", "Entrepreneurship"}
}
});

allDepartments.put("Civil Engineering", new String[][][]{

{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Engineering
Mechanics", "Basic Electrical Engineering"},
{"Engineering Mathematics II", "Surveying I", "Building Materials",
"Environmental Science", "Engineering Drawing"}
},
 { // Year 2
{"Surveying II", "Strength of Materials", "Fluid Mechanics", "Concrete
Technology", "Structural Analysis I"},
{"Geotechnical Engineering", "Transportation Engineering", "Environmental
Engineering", "Structural Analysis II", "Hydraulics"}
},
{ // Year 3
{"Design of Concrete Structures", "Design of Steel Structures", "Construction
Management", "Water Resources Engineering", "Remote Sensing and GIS"},
{"Estimating and Costing", "Bridge Engineering", "Construction Safety", "Urban
Planning", "Soil Mechanics"}
},
{ // Year 4
{"Project Management", "Green Building Technology", "Irrigation Engineering",
"Wastewater Engineering", "Professional Ethics"},
{"Seminar", "Major Project", "Construction Equipment", "Soil Dynamics",
"Entrepreneurship"}
}
});

allDepartments.put("Computer Science Engineering", new String[][][]{

{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Basic
Electrical Engineering", "Programming in C"},
{"Engineering Mathematics II", "Digital Logic Design", "Data Structures",
"Environmental Science", "Computer Organization"}
},
{ // Year 2
{"Discrete Mathematics", "Database Management Systems", "Operating Systems",
"Computer Networks", "Object Oriented Programming"},
{"Software Engineering", "Algorithms", "Microprocessors", "Theory of
Computation", "Compiler Design"}
},
{ // Year 3
{"Artificial Intelligence", "Machine Learning", "Cloud Computing", "Big Data
Analytics", "Information Security"},
{"Mobile Computing", "Data Mining", "Internet of Things", "Blockchain
Technology", "Cyber Security"}
},
{ // Year 4
{"Project Management", "Human Computer Interaction", "DevOps", "Ethical
Hacking", "Data Science"},
{"Seminar", "Major Project", "Entrepreneurship", "Advanced Computer
Architecture", "Wireless Networks"}
}
});
 allDepartments.put("Electrical Engineering", new String[][][]{
{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Basic
Electrical Engineering", "Engineering Mechanics"},
{"Engineering Mathematics II", "Circuit Theory", "Electronic Devices",
"Environmental Science", "Electrical Machines I"}
},
{ // Year 2
{"Electrical Machines II", "Power Systems I", "Control Systems", "Measurements
and Instrumentation", "Analog Electronics"},
{"Digital Electronics", "Microprocessors", "Power Electronics", "Renewable Energy
Systems", "Electrical Drives"}
},
{ // Year 3
{"Power Systems II", "High Voltage Engineering", "Embedded Systems",
"Switchgear and Protection", "Electrical Power Quality"},
{"HVDC Transmission", "Smart Grid", "Energy Management", "Professional
Ethics", "Industrial Electronics"}
},
{ // Year 4
{"Project Management", "Power System Operation and Control", "Electric Vehicle
Technology", "Advanced Control Systems", "Seminar"},
{"Major Project", "Entrepreneurship", "Flexible AC Transmission Systems",
"Energy Storage Systems", "Optimization Techniques"}
}
});

allDepartments.put("Electronics and Communication Engineering", new String[][][]{

{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Basic
Electrical Engineering", "Engineering Mechanics"},
{"Engineering Mathematics II", "Electronic Devices and Circuits", "Digital Logic
Design", "Environmental Science", "Signals and Systems"}
},
{ // Year 2
{"Analog Electronics", "Electromagnetic Theory", "Microprocessors",
"Communication Systems", "Data Structures"},
{"Control Systems", "Digital Signal Processing", "VLSI Design", "Microwave
Engineering", "Probability and Random Processes"}
},
{ // Year 3
{"Antenna and Wave Propagation", "Optical Communication", "Wireless
Communication", "Embedded Systems", "Information Theory"},
{"RF Engineering", "Satellite Communication", "Image Processing", "Network
Security", "Professional Ethics"}
},
 { // Year 4
{"Project Management", "Internet of Things", "Mobile Communication", "VLSI
Testing", "Seminar"},
{"Major Project", "Entrepreneurship", "Advanced Communication Systems",
"Machine Learning", "Artificial Intelligence"}
}
});

allDepartments.put("Chemical Engineering", new String[][][]{

{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Basic
Electrical Engineering", "Engineering Mechanics"},
{"Engineering Mathematics II", "Material Science", "Chemical Process
Calculations", "Environmental Science", "Fluid Mechanics"}
},
{ // Year 2
{"Thermodynamics", "Heat Transfer", "Mass Transfer", "Chemical Reaction
Engineering", "Mechanical Operations"},
{"Process Control", "Plant Design", "Instrumentation", "Process Dynamics",
"Transport Phenomena"}
},
{ // Year 3
{"Petroleum Refining", "Polymer Technology", "Biochemical Engineering",
"Process Equipment Design", "Safety and Hazard Analysis"},
{"Environmental Engineering", "Professional Ethics", "Process Simulation",
"Project Engineering", "Entrepreneurship"}
},
{ // Year 4
{"Project Management", "Advanced Chemical Engineering", "Energy Engineering",
"Waste Management", "Seminar"},
{"Major Project", "Catalysis", "Renewable Energy Technologies", "Corrosion
Engineering", "Industrial Management"}
}
});

allDepartments.put("Information Technology", new String[][][]{

{ // Year 1
{"Engineering Mathematics I", "Physics", "Engineering Chemistry", "Basic
Electrical Engineering", "Programming Fundamentals"},
{"Engineering Mathematics II", "Digital Logic Design", "Data Structures",
"Environmental Science", "Computer Organization"}
},
{ // Year 2
{"Database Management Systems", "Operating Systems", "Computer Networks",
"Object Oriented Programming", "Software Engineering"},
{"Algorithms", "Web Technologies", "Microprocessors", "Theory of Computation",
"Compiler Design"}
},
 { // Year 3
{"Cloud Computing", "Machine Learning", "Cyber Security", "Mobile Computing",
"Data Mining"},
{"Big Data Analytics", "Artificial Intelligence", "Internet of Things", "Human
Computer Interaction", "Blockchain Technology"}
},
{ // Year 4
{"Project Management", "DevOps", "Ethical Hacking", "Data Science", "Seminar"},
{"Major Project", "Entrepreneurship", "Advanced Database Systems", "Wireless
Networks", "Software Testing"}
}
});

int isbnCounter = 1000;

for (Map.Entry<String, String[][][]> entry : allDepartments.entrySet()) {

String dept = entry.getKey();
String[][][] subjectMatrix = entry.getValue();
for (int year = 0; year < subjectMatrix.length; year++) {
for (int sem = 0; sem < subjectMatrix[year].length; sem++) {
for (String subject : subjectMatrix[year][sem]) {
books.add(new Book(subject, "Author " + subject, dept.substring(0,
2).toUpperCase() + isbnCounter++, dept, subject));
}
}
}
}
}

private static void menu() {

while (true) {
System.out.println("\nLibrary Menu:");
System.out.println("1. Select Department and View Books");
System.out.println("2. Search Book by Name/Author");
System.out.println("3. Add Book");
System.out.println("4. Remove Book");
System.out.println("5. View All Books");
System.out.println("6. Exit");
System.out.print("Enter choice: ");
String choice = scanner.nextLine();
switch (choice) {
case "1" -> selectDepartment();
case "2" -> searchBook();
case "3" -> addBook();
case "4" -> removeBook();
case "5" -> viewAllBooks();
case "6" -> {
System.out.println("Exiting... Goodbye!");
return;
 }
default -> System.out.println("Invalid choice. Please select a valid option.");
}
}
}

private static void selectDepartment() {

System.out.println("Select Department:");
System.out.println("1. Mechanical Engineering");
System.out.println("2. Civil Engineering");
System.out.println("3. Computer Science Engineering");
System.out.println("4. Electrical Engineering");
System.out.println("5. Electronics and Communication Engineering");
System.out.println("6. Chemical Engineering");
System.out.println("7. Information Technology");
System.out.print("Enter choice: ");
String deptChoice = scanner.nextLine();
String dept = switch (deptChoice) {
case "1" -> "Mechanical Engineering";
case "2" -> "Civil Engineering";
case "3" -> "Computer Science Engineering";
case "4" -> "Electrical Engineering";
case "5" -> "Electronics and Communication Engineering";
case "6" -> "Chemical Engineering";
case "7" -> "Information Technology";
default -> {
System.out.println("Invalid department.");
yield null;
}
};
if (dept == null) return;

System.out.print("Enter Year (1-4): ");

int year;
try {
year = Integer.parseInt(scanner.nextLine());
if (year < 1 || year > 4) {
System.out.println("Invalid year.");
return;
}
} catch (NumberFormatException e) {
System.out.println("Invalid input for year.");
return;
}

System.out.print("Enter Semester (1 or 2): ");

int sem;
try {
sem = Integer.parseInt(scanner.nextLine());
if (sem < 1 || sem > 2) {
System.out.println("Invalid semester.");
return;
}
} catch (NumberFormatException e) {
System.out.println("Invalid input for semester.");
return;
}

// Filter books by dept, year and sem

List<Book> filtered = new ArrayList<>();
// Each semester has 5 subjects per department, so 5 books per sem per year
// Books are inserted in order by department, year, sem, subject in preloadBooks

// Calculate start index:

// For each dept, there are 4 years * 2 sem * 5 subjects = 40 books
// Get department start index
int deptIndex = 0;
List<String> depts = List.of(
"Mechanical Engineering",
"Civil Engineering",
"Computer Science Engineering",
"Electrical Engineering",
"Electronics and Communication Engineering",
"Chemical Engineering",
"Information Technology"
);

deptIndex = depts.indexOf(dept);

int booksPerDept = 4 * 2 * 5; // 40
int startIndex = deptIndex * booksPerDept;

// Calculate offset for year and sem

int offset = (year - 1) * 2 * 5 + (sem - 1) * 5;

int firstBookIndex = startIndex + offset;

for (int i = firstBookIndex; i < firstBookIndex + 5; i++) {
filtered.add(books.get(i));
}

System.out.println("\nBooks for " + dept + ", Year " + year + ", Semester " + sem + ":");
filtered.forEach(System.out::println);
}
private static void searchBook() {
System.out.print("Search by Book Name or Author: ");
String term = scanner.nextLine().toLowerCase();
boolean found = false;
for (Book book : books) {
if (book.title.toLowerCase().contains(term) || book.author.toLowerCase().contains(term)) {
System.out.println(book);
found = true;
}
}
if (!found) {
System.out.println("No books found matching your search.");
}
}

private static void addBook() {

System.out.print("Enter title: ");
String title = scanner.nextLine();
System.out.print("Enter author: ");
String author = scanner.nextLine();
System.out.print("Enter ISBN: ");
String isbn = scanner.nextLine();

System.out.print("Enter Department: ");

String department = scanner.nextLine();
System.out.print("Enter Subject: ");
String subject = scanner.nextLine();
books.add(new Book(title, author, isbn, department, subject));
System.out.println("Book added successfully.");
}

private static void removeBook() {

System.out.print("Enter ISBN to remove: ");
String isbn = scanner.nextLine();
boolean removed = books.removeIf(book -> book.ISBN.equals(isbn));
if (removed) {
System.out.println("Book removed successfully.");
} else {
System.out.println("Book not found.");
}
}

private static void viewAllBooks() {

if (books.isEmpty()) {
System.out.println("No books in the library.");
}
else {
System.out.println("\nList of all books in the library:");
for (Book book : books) {
System.out.println(book);
}
}
}
}
OUTPUT SCREENSHOTS
 CONCLUSION
The Library Book Recommendation System has proven to be a helpful tool for students and
faculty to easily access relevant books based on their department and subject needs. It simplifies
the process of searching through the library by offering quick and accurate suggestions. This not
only saves time but also ensures that students are exposed to the right study materials. The
system is designed to be user-friendly and flexible, making it easy to update and maintain as the
book database grows. Overall, this project demonstrates how a smart and efficient solution can
enhance academic support within an educational institution.

ADVANTAGES

1. Efficient Book Management – Speeds up cataloging, issuing, and returning of books.

2. User Convenience – Allows users to search and reserve books online.
3. Accurate Record Keeping – Reduces errors in tracking borrowed and returned books.
4. Time-Saving – Automates routine tasks, saving staff time.
5. Data Analytics – Provides reports on library usage, popular books, and overdue items.

DISADVANTAGES

1. High Initial Cost – Requires investment in software, hardware, and training.

2. Technical Dependence – System failure or internet issues can disrupt services.
3. Learning Curve – Staff and users need time and training to adapt.
4. Maintenance Requirements – Regular updates and support are needed.
5. Privacy Risks – User data must be securely handled to prevent breaches.
 REFRENCES
 Aggarwal, C. C. (2016). Recommender Systems: The Textbook. Springer.
→ Used for understanding recommendation system algorithms and models.
 Head First Java by Kathy Sierra
→ A beginner-friendly book for understanding core Java concepts and object-oriented
programming.
 Oracle Java Documentation
https://docs.oracle.com/en/java/
→ Official documentation for Java syntax, libraries, and best practices.
 Java: The Complete Reference by Herbert Schildt
→ Comprehensive resource for core Java libraries and advanced concepts.