FEL205 · Mini Project Documentation

✦ Axiom

Intelligence & Attendance Control System

Institution: SIES Graduate School of Technology, Nerul, Navi Mumbai

Branch: Electronics & Computer Science Engineering

Subject: FEL205 — Object Oriented Programming Methodology Lab

Academic Year: 2025–26 | Semester II

Students: Sharvin Mhatre · Sharvani Jorwekar · Kashvi Kurkute

Section 01

Project Overview

Axiom is a production-grade web application that replaces manual attendance calculations with an intelligent, real-time simulation engine. Students can simulate future attendance decisions, check ISE exam schedules, and receive smart notifications about their academic standing — all through a premium dark-mode interface.

The system consists of two layers:

LayerTechnologyPurpose
Java Backend CoreOOP-based Java with Swing GUIOriginal attendance logic engine — the foundation of all calculations
Web ApplicationVite + Vanilla JS + CSS3Live-deployed SPA translating Java OOP into a globally accessible browser experience
Section 02

OOP Concepts — FEL205 Syllabus Mapping

Module 1 — Introduction to OOP

OOP ConceptImplementation in Axiom
Class & ObjectAttendanceLogic class; objects hold subject attendance state per instance
EncapsulationPrivate fields attended, total accessed only via public methods
AbstractionAttendanceLogic abstracts raw math — GUI calls calculatePercentage() without knowing the formula
InheritanceAttendanceGUI extends JFrame — inherits entire Window framework
Polymorphismcalculate() behaves differently for leave buffer vs recovery calculations
Message PassingActionListener.actionPerformed() — button object sends message to logic layer

Module 2 — Class, Object, Packages & I/O

// Encapsulation — private fields with public methods
private int attended;
private int total;

public double calculatePercentage() {
    return (attended / (double) total) * 100;
}

Additional patterns: this keyword in constructors, static mark bracket constants, private/public/protected access modifiers throughout.

Module 3 — Arrays, Strings & Vectors

// All 13 subjects stored in an array of objects
SubjectData[] subjects = new SubjectData[13];
subjects[0] = new SubjectData("AM-II", 39, 35);
// String manipulation for notification messages
String msg = String.format("Attend %d more classes to reach 75%%", recovery);

Module 4 — Inheritance, Polymorphism & Abstraction

// Inheritance from JFrame
public class AttendanceGUI extends JFrame {
    public AttendanceGUI() {
        super("Axiom — Attendance Dashboard");
        setLayout(new GridBagLayout());
    }
}
// Method Overriding — ActionListener interface
calculateBtn.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        performCalculation(); // polymorphic dispatch
    }
});

Module 5 — Exception Handling

try {
    int attended = Integer.parseInt(attendedField.getText());
    int total    = Integer.parseInt(totalField.getText());
    if (total == 0) throw new ArithmeticException("Total cannot be zero");
    if (attended > total) throw new IllegalArgumentException("Attended > Total");
} catch (NumberFormatException e) {
    JOptionPane.showMessageDialog(this, "Please enter valid numbers.");
} catch (ArithmeticException | IllegalArgumentException e) {
    JOptionPane.showMessageDialog(this, e.getMessage());
}

Module 6 — GUI Programming in Java (Swing)

ComponentUsed For
JFrameMain application window
JPanelSubject card containers
JLabelSubject names, percentage display
JTextFieldAttended / Total class inputs
JButtonCalculate trigger with ActionListener
JScrollPaneScrollable multi-subject dashboard
GridBagLayoutResponsive card-based layout
Font, ColorDark mode UI styling equivalent
Section 03

Core Formulae

Attendance %= ( Attended ÷ Total ) × 100
Leave Buffer= ⌊ ( 100 × Attended ÷ TargetPct ) − Total ⌋
Recovery Needed= ⌈ ( TargetPct × Total − 100 × Attended ) ÷ ( 100 − TargetPct ) ⌉

Internal Marks Bracket System

Attendance %Internal MarksStatus
≥ 95%5 / 5Maximum
≥ 90%4 / 5Excellent
≥ 85%3 / 5Good
≥ 80%2 / 5Average
≥ 75%1 / 5Minimum Safe
< 75%0 / 5 ⚠️Red Alert
Section 04

Key Features & Uniqueness

⭐
Examiner tip: These features go significantly beyond a standard mini-project. Emphasize the production-grade quality and the breadth of technologies used.
🌊

144Hz Liquid Glassmorphism Intro

CSS @keyframes + backdrop-filter blobs swirl at hardware-accelerated frame rates. Zoom locks onto the "i" in Axiom using precise DOM coordinate math.

🔐

Secure Multi-User Authentication

PRN-based login with real-time username recognition. Dynamic "Welcome Sharvin" heading animates with blur-to-focus spring easing the instant credentials are recognized.

🎮

Simulation Engine

[ + Attend ] and [ − Bunk ] buttons simulate future classes and instantly recalculate percentage, marks, and leave buffer without touching historical data.

🔔

Smart Notification System

Toast alerts fire on login with iOS audio for RED ALERT (<75%), MANDATORY (0 buffer), and UPGRADE POTENTIAL (within 2% of bracket jump) states.

📅

ISE Exam Calendar

Live countdown cards with red/amber urgency glow for upcoming Internal Exams. Reminder toasts fire automatically on login if exam is within 3 days.

🌍

Global Deployment

Deployed on Vercel's global CDN — accessible worldwide from any browser with zero installation. Production build completed in 248ms via Vite 8.

Section 05

Viva Q&A Preparation

What OOP concept does AttendanceGUI extends JFrame demonstrate?
Inheritance. AttendanceGUI inherits all properties and methods of JFrame — such as setTitle(), setSize(), setVisible() — without re-implementing them. This is single inheritance in Java.
How is Encapsulation achieved in your project?
The attended and total fields in AttendanceLogic are declared private. External classes access them only through public methods like getPercentage(), protecting internal state integrity — the core principle of encapsulation.
Where is Polymorphism demonstrated?
The ActionListener interface's actionPerformed() method is overridden for each button (Calculate, Bunk, Attend). Same method signature — different runtime behaviour depending on which button fired. This is runtime polymorphism via method overriding.
Why deploy a web app in addition to a Java application?
The Java application requires a local JDK installation. The web app is globally accessible from any browser with zero installation, proving the portability of OOP logic across languages and platforms. Both layers share identical mathematical formulae.
What design pattern does the Simulation Engine use?
The State Pattern. Each subject card maintains its own currentTotal and currentAttended state — analogous to Java instance variables. Clicking Bunk/Attend mutates private state and triggers a re-render, exactly like a Java setter mutating encapsulated fields.
How does the notification system relate to Java's event model?
JavaScript's addEventListener('click', handler) is functionally identical to Java's addActionListener(new ActionListener(){...}). Both register a callback invoked when a user interaction fires — this is the Observer / Event-Driven programming pattern, directly from Module 6.
Section 06

ISE Exam Schedule

SubjectTypeDateStatus
EGISE08-Apr-2026✅ Completed
DSDISE09-Apr-2026✅ Completed
ACISE-I09-Apr-2026✅ Completed
ACPPT16-Apr-2026🔴 Urgent
AM-IIISE-II17-Apr-2026🔴 Urgent
Section 07

Team

SM

Sharvin Mhatre · 125BT041016

Architect & Lead Developer

Conceptualized the entire project and built the full web application — SPA routing, 144Hz liquid animations, secure PRN-based authentication, real-time simulation engine, smart notification system, ISE calendar, Web Audio API integration, and Vercel deployment.

SJ

Sharvani Jorwekar · 125BT041007

Feature Contributor

Provided real SIES ERP attendance data, contributed feature requirements and real-world use-case scenarios that shaped the leave simulation and notification alert systems.

KK

Kashvi Kurkute

Implementation Planner

Contributed to the project roadmap, implementation planning, and the structural design of the attendance calculation logic flow and module architecture.

Conclusion

Summary

Axiom successfully demonstrates all six modules of the FEL205 OOP syllabus through a dual-layer implementation.

💡
The project goes significantly beyond a standard mini-project by incorporating real-world engineering concerns: secure authentication, multi-user data isolation, hardware-accelerated animations, Web Audio API, ISE date reminders, and global CDN deployment — making it a production-grade application rather than an academic prototype.
LayerKey OOP Concepts Demonstrated
Java (Swing)Classes, Objects, Encapsulation, Inheritance (JFrame), Polymorphism (ActionListener), Exception Handling, GUI with AWT/Swing
Web App (JS)Module pattern (Encapsulation), Closures (State), Event-driven programming (Observer), DOM abstraction, Deployment engineering