Building a Library Management System in Go

In this article, let's explore a Library Management System (LMS) implemented in Go, highlighting its core features, design decisions, and key code snippets.

Core Features of the Library Management System

• Book Management

The system supports multiple copies of each book, allowing for efficient tracking and management of inventory. Each book has properties such as ID, title, author, publication year, and a slice of BookItem, which represents the individual copies.

type Book struct {
    ID            int
    BookItem      []BookItem
    Title         string
    Author        string
    PublishedYear string
    mu            sync.RWMutex
}

• Member Management

Members can borrow books, and the system tracks their borrowing history. Each member has a borrowing quota, ensuring they can borrow a limited number of books at any given time.

type Member struct {
    ID              int
    Name            string
    ContactInfo     string
    CurrentBorrowed []*BookItem
    BorrowHistory   []*BookItem
}

• Borrowing and Returning Books

The borrowing mechanism checks for available copies and updates their status accordingly. The system allows members to return books, updating the book's status and tracking the transaction in the member's borrowing history.

func (m *Member) AddBorrowedBook(bookItem *BookItem) {
    m.CurrentBorrowed = append(m.CurrentBorrowed, bookItem)
}

func (l *Library) BorrowBookByMember(memberID int, bookID int) *BookItem {
    // Logic to borrow a book
}

• Concurrency Control

Utilizing Go's concurrency features, the system handles multiple borrowing and returning requests simultaneously. The use of sync.RWMutex ensures that book availability checks and updates are thread-safe, preventing race conditions.

func (b *Book) IsBookAvailable() bool {
    b.mu.RLock()
    defer b.mu.RUnlock()
    for _, bookCopy := range b.BookItem {
        if bookCopy.Status == Available {
            return true
        }
    }
    return false
}

• Overdue Book Management

The system checks if borrowed books are overdue, implementing business rules to notify members and possibly charge fines.

func (bi *BookItem) IsOverdue() bool {
    if bi.Status != Borrowed {
        return false
    }
    return time.Since(bi.LastBorrowed) > time.Hour*24*7
}

Design Decisions

Why Go?
Go was chosen for its simplicity, efficiency, and built-in support for concurrency, which is crucial for handling multiple requests in a library setting. Its strong typing and compile-time checks help reduce bugs and improve code maintainability.

Singleton Pattern for Library Instance
The system uses a singleton pattern to manage a single instance of the library. This design ensures that all operations (adding books, managing members) are centralized, simplifying resource management.

var (
   libraryInstance *Library
   once            sync.Once
)

func GetLibraryInstance() *Library {
   once.Do(func() {
       libraryInstance = &Library{books: make(map[int]*Book), members: make(map[int]*Member)}
   })
   return libraryInstance
}

Encapsulation and Data Protection
The use of mutexes (sync.RWMutex) protects shared resources and ensures that concurrent access does not lead to inconsistent states. This encapsulation is crucial in a multi-user environment where multiple members may be interacting with the system simultaneously.

Please explore the complete code and contribute to further enhancements in the following repository: