A Report on

Demonstration of DevOps with Library

Management Program
Submitted to Manipal University, Jaipur
Towards the partial fulfillment for the Award of the Degree of

BACHELOR OF TECHNOLOGY
In Information Technology
2024-2025
By

Rohit Dabas
219302076
Prakhar Gupta
219302223
Adarsh Devashish
2193202385

Under the guidance of

Aditya Hati, Rajender Choudhary and Praveen Shukla

Department of Information Technology

School of Co Information Technology
Manipal University Jaipur
Jaipur, Rajasthan
1. Introduction

The project titled “Demonstration of DevOps with Library Management Program” showcases the
implementation of DevOps practices in building a functional Library Management System (LMS).
DevOps, a combination of development and operations, aims to streamline the software
development lifecycle by integrating automation, collaboration, testing, and deployment
processes. This project serves as an example of how modern development methodologies can
enhance software quality, reduce development time, and create efficient workflows.

The Library Management System, a core application often used in educational institutions, public
libraries, and private organizations, was selected to demonstrate these principles. The LMS
includes fundamental features such as managing book inventories, adding and searching books,
and retrieving book details. By incorporating DevOps practices, this system illustrates the benefits
of automated testing, version control, and continuous integration and deployment (CI/CD).

The development of this system utilized several key tools and technologies that align with the
objectives of DevOps. Maven was used as the build tool to manage dependencies, automate the
compilation of the program, and streamline the testing and packaging processes. Java, a robust and
widely used programming language, was chosen to implement the core functionalities of the LMS.
JUnit, a framework for unit testing in Java, ensured that the system performed as expected by
validating individual components of the program. Git, a version control system, provided a
collaborative platform for managing code changes and maintaining a history of the project. Finally,
Jenkins, a popular CI/CD tool, was employed to automate builds and testing, enabling continuous
delivery of the application.

The project followed a structured methodology beginning with setting up a Maven project and
defining dependencies. The core functionality of the LMS was implemented in Java, followed by
rigorous testing with JUnit. Git was used for version control, while Jenkins automated the build
and testing processes. These steps culminated in the creation of a `.jar` file, signifying a successful
build and deployable application.

The significance of this project lies in its ability to demonstrate how DevOps practices can
transform traditional software development. By automating repetitive tasks, ensuring reliability
through testing, and maintaining code integrity with version control, the project highlights the
advantages of integrating DevOps into real-world applications. This report delves into the project's
implementation, challenges, results, and future enhancements, providing insights into the effective
application of DevOps in software engineering.
2. Literature Review

The table below summarizes similar studies or projects.

Source Methodology Main Problems/

Topic Relevance
reference Used Findings disadvantages
Automated Agile and Complexity of
Improved Demonstrates
Study 1 Library CI/CD integration
deployment automation benefits
Systems pipelines efficiency

Java- Requires
based Java with Reliable test additional Validates JUnit
Study 2
Inventory JUnit testing outcomes deployment application in DevOps
Systems tools
Git for Git branches Learning
Enhanced Highlights Git's role in
Study 3 Version and version curve for
collaboration our project
Control histories beginners
Steep learning
Maven Dependency Streamlined
curve for Aligns with our use of
Study 4 Build management builds and
beginners Maven
Tools and testing
automation
Automated Maintenance
Jenkins for builds and Reduced of pipelines Supports Jenkins
Study 5
CI/CD GitHub manual errors implementation
linkage
3. Problem Definition and Methodology
Problem Definition:

The primary challenge was to design and develop a functional Library Management System (LMS)
while adhering to DevOps principles to ensure automation, reliability, and efficiency. Traditional
software development often involves manual testing, deployment, and version tracking, leading to
inefficiencies and increased chances of errors. The objective of this project was to overcome these
challenges by integrating modern DevOps practices, such as automated testing, build automation,
and continuous integration and delivery (CI/CD), into the development lifecycle of the LMS.

Proposed Methodology:

The project followed a structured methodology, beginning with project initialization and setup. A
Maven project was created using the mvn archetype:generate command, defining dependencies
and configurations in the pom.xml file. Git was employed to manage code versions and enable
collaborative development, ensuring changes were tracked and easily reversible.

The core functionalities of the LMS, such as adding books, searching for books, and managing
inventory, were implemented in Java. Unit tests were developed using JUnit to validate each
function and ensure the system’s correctness. Maven automated the compilation, testing, and
packaging processes, generating a .jar file for deployment.

Jenkins was integrated for CI/CD, automating the build and testing processes and linking the
project with a GitHub repository. Scheduled builds ensured that the system remained updated with
each change committed to the repository.
This methodology not only facilitated the development of a reliable and functional LMS but also
exemplified the practical application of DevOps to streamline workflows and enhance software
quality.

Methodology:
• Step 1: Initialize a Maven project with appropriate dependencies.
• Step 2: Utilize Git for version control to manage code changes.
• Step 3: Write Java code for core functionalities such as adding, searching, and managing
books.
• Step 4: Implement JUnit tests to ensure software reliability.
• Step 5: Use Jenkins to automate builds and link with GitHub for CI/CD.
4. Design and Implementation
The design and implementation of the Library Management System (LMS) were carried out with
a focus on integrating DevOps practices into every stage of development. The system's architecture
and workflow were meticulously planned to ensure smooth functionality and scalability.

Design
The project was structured as a Maven-based application to benefit from its build automation and
dependency management features. The project followed a modular design to enhance
maintainability and scalability. Key design components included:

1. Core Application Modules:

App.java: The main application driver containing entry points and overall control.
Library.java: A separate module managing book-related functionalities, including adding
and searching for books.

2. Testing Modules:
AppTest.java: Tests the primary application flow.
LibraryTest.java: Tests the correctness of library operations, such as adding books and
searching by attributes.

3. Configuration Files:
pom.xml: Defined project dependencies, plugins, and build configurations.

Implementation

1. Maven Setup:
The project was initialized using the Maven archetype generation tool. This setup created a
standard folder structure, including directories for source code and tests. Dependencies such as
JUnit for testing were specified in pom.xml.

2. Coding:
The LMS core functionalities were implemented in Java. Methods for adding books, searching by
attributes, and managing inventory were developed. Object-oriented principles were adhered to
for better organization.

3. Testing:
Unit tests were implemented using JUnit. Test cases validated functionalities like adding a new
book, retrieving book details, and searching for specific books. Each test case was executed, and
the results ensured the reliability of the system.

4. Version Control with Git:

Git was utilized to manage the codebase, enabling tracking of changes and seamless collaboration.
Branching and merging strategies were applied to ensure code integrity and avoid conflicts.
5. Build and Deployment:
The Maven clean install command automated the cleaning, compiling, and packaging of the
project. A .jar file was generated and stored in the target directory, ready for execution or
deployment.

6. CI/CD Integration with Jenkins:

Jenkins was set up to automate the build and testing processes. The GitHub repository was linked
to Jenkins to trigger builds upon code commits. This ensured continuous integration and delivery,
reducing manual intervention.

This systematic design and implementation approach resulted in a fully functional LMS
demonstrating the effectiveness of DevOps practices in modern software development.

5. Results

• System Functionality: The Library Management System (LMS) was successfully

developed with core functionalities such as adding, searching, and managing books, all
implemented in Java.

• Testing: All JUnit test cases were executed and passed successfully, confirming the
reliability of the system’s key features. The testing process ensured that functions like
book retrieval and inventory management were error-free.

• Build Automation: The Maven build process was fully automated. The mvn clean install
command successfully compiled and packaged the project into a .jar file, ready for
deployment.

• CI/CD Pipeline: Jenkins was integrated with GitHub for continuous integration. Builds
were automatically triggered with each code commit, ensuring up-to-date deployment
and consistent system performance.

• Outcome: The project resulted in a robust, reliable, and fully functional LMS,
demonstrating the effectiveness of DevOps practices in streamlining development and
deployment workflows.
6. Conclusion

The Library Management System project successfully demonstrated the integration of DevOps
practices in the software development lifecycle. By incorporating tools such as Maven, Git, JUnit,
and Jenkins, the project not only achieved its functional goals but also highlighted the benefits of
DevOps in improving efficiency, collaboration, and automation. The core features of the LMS,
such as adding books, searching for books, and managing the library’s inventory, were seamlessly
implemented using Java.

Through the use of JUnit, the system’s functionality was thoroughly tested, ensuring that it met
the required standards. The integration of Git for version control and Jenkins for continuous
integration ensured that code was consistently up-to-date and properly tested with each change.
The Maven automation ensured smooth and error-free builds.

This project serves as a proof of concept for the power of DevOps in modern software
development. Future enhancements for the LMS could include additional functionalities such as
borrowing and returning books, as well as deploying the application on a server to improve
accessibility. Overall, the project successfully showcased the efficiency and reliability of a
DevOps-driven development process.

Bibliography
[1] J. Hai, Q. Zeng, and Y. Zhuang, "Design and Application of High Fidelity IPTV CDN Test-
bed Based on User Viewing Behavior Model," *2023 International Wireless Communications and
Mobile Computing (IWCMC)*, Marrakesh, Morocco, 2023, pp. 182-187, doi:
10.1109/IWCMC58020.2023.10182644.

[2] M. Fowler, "Continuous Integration: Improving Software Quality and Reducing Risk,"
Addison-Wesley Professional, 2006.

[3] K. Beck, "Test-Driven Development: By Example," *Addison-Wesley*, 2002.

[4] J. Kim, M. Kim, and S. Lee, "DevOps Adoption in Software Development: An Empirical
Study," *Journal of Software Engineering and Applications*, vol. 14, no. 5, 2021, pp. 85-100.

[5] M. T. N. Nguyen, T. T. Nguyen, and H. T. Tran, "Integration of DevOps in the Software

Development Process: A Case Study," 2019 International Conference on Information and
Computer Technologies (ICICT), Hanoi, Vietnam, 2019, pp. 231-236.