Convene

Convene is a campus event management system built entirely with vanilla Java. It was built as a 3rd year semester 1 project to demonstrate OOP principles, multithreading, and file-based data persistence - all without relying on any frameworks or external libraries.

The system allows students to browse, register for, and manage campus events, while staff can create, update, and cancel events. When an event reaches capacity, students are automatically waitlisted, and a background thread handles promotion when spots open up.

Why I Built Convene

University event management is a problem that maps cleanly onto object-oriented design. There are clear roles (students, staff), well-defined entities (events, registrations), and real constraints (capacity limits, waitlists). It is complex enough to require proper architecture but focused enough to build from scratch in pure Java.

I wanted to demonstrate that strong software engineering does not require heavyweight frameworks. Convene proves that:

1. Clean architecture can be achieved with vanilla Java.
2. Multithreading can solve real problems (automated waitlist promotion).
3. Data persistence can work without a database (file-based save/load).
4. Input validation and error handling can make a console application feel polished.

System Architecture

Convene follows an MVC-inspired architecture with clean package separation. Every layer has a clear responsibility.

Models - The Domain Layer

The domain is built on a proper class hierarchy:

• User is an abstract base class with userId, name, role, and a showMenu() contract
• Student extends User with view, register, and cancel capabilities
• Staff extends User with create, update, and cancel event capabilities
• Event holds all event data: ID, name, schedule, location, capacity, registered students, and a waitlist queue
• Role enum defines STUDENT and STAFF constants

Controllers - The Interaction Layer

Controllers handle user interaction and menu flow:

• MenuController manages role selection and routing at startup
• StudentMenuController drives the student menu loop and dispatches actions
• StaffMenuController drives the staff menu loop and dispatches actions

Services - The Business Logic Layer

• EventManager is the core service that handles event CRUD, registration, search, waitlist management, and the background promotion thread

Utils - The Support Layer

• InputValidator provides strict validation for dates, times, IDs, and menu selections
• ConsoleUtils handles console formatting, banners, dividers, and prompts
• DataPersistence manages file-based save/load for events and registrations

Key Features

Role-Based Access Control

Users select their role at startup (Student or Staff) and enter a User ID and name. Each role has a completely separate menu with distinct capabilities:

Student Menu:

1. View Available Events
2. Register for Event
3. Cancel Registration
4. View Registration Status
5. Search Events
6. Exit

Staff Menu:

1. Create Event
2. Update Event
3. Cancel Event
4. View Participants & Waitlists
5. Search Events
6. Exit

Capacity Management and Automatic Waitlisting

When a student registers for an event that has reached its capacity, they are automatically placed on a waitlist queue. This is not a workaround - it is a designed feature:

• The waitlist uses a Queue data structure for fair, first-come-first-served ordering
• When a registered student cancels, the next waitlisted student is promoted automatically
• Promotion happens via a background thread that monitors for available spots

This is one of the most interesting parts of Convene: real Java multithreading solving a practical problem.

Search and Filter

Both students and staff can search events by:

• Event name - partial match search
• Date - find events on a specific date

Results are sortable, making it easy to find relevant events in a growing list.

Data Persistence

Convene uses file-based persistence to ensure data survives between sessions. Events, registrations, and waitlists are serialised to files in the data/ directory and loaded on startup.

This was a deliberate choice to demonstrate file I/O concepts without introducing database complexity.

Input Validation and Error Handling

Every user input is validated:

• Dates and times must follow correct formats
• IDs must match expected patterns
• Menu selections must be within range
• Invalid input triggers graceful recovery with clear error messages

The application never crashes on bad input. Every exception is caught and handled with a user-friendly message.

OOP Principles in Practice

Convene was designed to demonstrate core OOP concepts in a meaningful context:

Beyond the four pillars, Convene also demonstrates:

• Collections: ArrayList, Queue, HashMap for managing events, waitlists, and registrations
• Multithreading: Background thread for waitlist promotion
• File I/O: Persistent save/load for all application data
• Exception Handling: Graceful recovery for all error conditions

Technical Stack

• Language: Java 17+
• Architecture: MVC-inspired with clean package separation
• Concurrency: Java threads for background waitlist promotion
• Persistence: File-based data storage (no database required)
• Build: Pure javac compilation - no build tools required

What I Learned

Building Convene from scratch in vanilla Java reinforced several important lessons:

• Frameworks are not always necessary. A well-structured vanilla Java project can be clean, maintainable, and feature-rich. Understanding the fundamentals matters more than knowing the latest framework.
• Multithreading requires discipline. The background waitlist promotion thread needed careful coordination to avoid race conditions. This was a practical introduction to Java concurrency.
• File I/O is underappreciated. Building persistence without a database forced me to think carefully about data serialisation, file formatting, and error recovery during read/write operations.
• Console UIs deserve design attention. Formatted menus, dividers, and clear prompts make the difference between a tool that feels rough and one that feels intentional.

Where Can I Learn More?

• Repository: GitHub Repo
• Documentation: Full developer docs in the docs/ folder