mirror of https://github.com/sabazadam/Se302.git synced 2025-12-31 20:31:22 +00:00

Files

sabazadam a8dd7154dd Preparation and Planing Documents added to the github

2025-11-30 17:56:12 +03:00

31 KiB

Raw Blame History

TEAM ASSIGNMENTS - EXAM SCHEDULING SYSTEM

Project: Exam Planner Desktop Application Course: SE302 - Software Engineering Team: Team 3, Section 1 Date: November 26, 2025

TEAM ROSTER

Name	Student ID	Primary Role	Secondary Responsibilities
Kerem Bozdag	20200602012	Database & Data Layer Lead	Data validation, CSV import/export
Milena Larissa Ünal	20230602107	Algorithm Specialist	CSP solver, constraint validation, optimization
Rabia Tülay Gokdag	20210602029	UI/FXML Specialist	JavaFX views, FXML layouts, Scene Builder
Mehmet Sefa Keskin	20230602047	Controller Layer Lead	MVC controllers, UI-business integration
Feyza Gereme	20230602028	Testing & QA Lead	JUnit tests, integration testing, CI/CD
Emin Arslan	20230602007	Documentation & Integration Lead	JavaDoc, user manual, code reviews

DETAILED ROLE RESPONSIBILITIES

1. Kerem Bozdag - Database & Data Layer Lead

Primary Responsibilities

Database Design & Implementation:

Design and implement SQLite database schema
Create ER diagrams for all entities and relationships
Write SQL schema creation script (schema.sql)
Define all tables with proper constraints (foreign keys, uniqueness, indexes)
Optimize database performance with appropriate indexes

DAO Layer (Data Access Objects):

Implement all DAO classes:
- StudentDAO - CRUD operations for students
- CourseDAO - CRUD operations for courses
- ClassroomDAO - CRUD operations for classrooms
- EnrollmentDAO - Manage student-course relationships
- ScheduleDAO - Save, load, list, delete schedules
- ExamAssignmentDAO - Manage exam assignments
Implement batch operations for performance (bulk inserts)
Write transaction management utility (TransactionManager)
Create database connection pool/singleton (DatabaseConnection)

CSV Import/Export:

Implement CSVParser utility class
Create ImportService for all 4 CSV file types:
1. Student IDs
2. Course codes
3. Classroom capacities (format: ClassroomID;Capacity)
4. Enrollment/attendance lists
Implement data validation during import:
- Duplicate detection
- Format validation
- Referential integrity checks
Create detailed error reporting with line numbers
Implement CSV export functionality for schedule views

Data Validation:

Validate all user inputs before database insertion
Ensure referential integrity (enrollments reference valid students/courses)
Implement constraint checks at database level (CHECK constraints)
Create validation utility methods used by service layer

Testing Responsibilities

Write unit tests for all DAO methods (target: >90% coverage)
Test batch operations for correctness and performance
Test transaction rollback on errors
Test duplicate detection
Create test CSV files (valid and invalid cases)
Integration testing for CSV import workflow

Collaboration Points

With Milena: Provide efficient query methods for CSP solver (enrollment lookups, student-course mappings)
With Sefa: Design clean DAO interfaces for controller layer to use
With Feyza: Create testable DAO methods, support integration testing
With Emin: Document database schema, DAO API, CSV formats

Deliverables

Week 1: Database schema script and ER diagram
Week 2: All DAO classes with unit tests, CSV import working
Week 3: Schedule and exam assignment persistence
Week 7: CSV export functionality
Week 9: Database optimization and performance tuning

2. Milena Larissa Ünal - Algorithm Specialist

Primary Responsibilities

Domain Model Design:

Create all POJO (Plain Old Java Object) classes:
- Student - Student entity
- Course - Course entity
- Classroom - Classroom entity with capacity
- Enrollment - Student-course relationship
- Schedule - Schedule metadata
- ExamAssignment - Course assignment to {classroom, day, slot}
- ScheduleConfiguration - Exam period configuration (days, slots, strategy)
Ensure proper encapsulation, getters/setters, equals/hashCode, toString

Constraint Validation:

Implement ConstraintValidator class with methods for each hard constraint:
1. No consecutive exams: checkNoConsecutiveExams(student, day, slot, assignment)
2. Max 2 exams per day: checkMaxTwoExamsPerDay(student, day, assignment)
3. Classroom capacity: checkClassroomCapacity(course, classroom)
Create detailed constraint violation messages
Implement ValidationResult class with error details
Handle edge cases (day boundaries for consecutive constraint)

CSP Solver Implementation:

Implement backtracking algorithm with constraint propagation

Core algorithm in CSPSolver class:

public Map<Course, ExamAssignment> solve(
    List<Course> courses,
    List<Classroom> classrooms,
    List<Enrollment> enrollments,
    ScheduleConfiguration config,
    OptimizationStrategy strategy,
    ProgressTracker progressTracker
) throws NoSolutionException, CancelledException

Implement variable ordering heuristic (Minimum Remaining Values - MRV)
Implement value ordering heuristic (Least Constraining Value)
Implement forward checking for constraint propagation
Add progress tracking callback mechanism
Implement cancellation support (check flag during backtracking)

Optimization Strategies:

Create OptimizationStrategy interface
Implement 4 concrete strategies:
1. MinimizeDaysStrategy - Pack exams into fewest days
2. BalanceDistributionStrategy - Spread exams evenly across days
3. MinimizeClassroomsStrategy - Use fewest classrooms
4. BalanceClassroomsStrategy - Balance classroom usage per day
Integrate strategies with value ordering heuristic
Document when to use each strategy

Conflict Detection:

Implement ConflictDetector class
Analyze why no solution exists when solver fails:
- Students with too many courses for available slots
- Courses with more students than max classroom capacity
- Overlapping enrollment patterns creating conflicts
Generate ConflictReport with:
- List of students causing conflicts
- List of courses causing conflicts
- Specific recommendations (extend period, add classrooms, reduce enrollments)

Performance Optimization:

Pre-compute enrollment mappings (student→courses, course→students)
Implement domain pre-filtering (eliminate impossible assignments)
Add memoization for repeated constraint checks
Use efficient data structures (HashSet, HashMap for fast lookups)
Optimize for small-medium datasets (20-50 courses, 250-500 students)

Testing Responsibilities

Write unit tests for each constraint validator (>95% coverage target)
Create test cases with known solutions (3-5 courses with obvious valid schedule)
Create test cases with known conflicts (unsolvable scenarios)
Test all 4 optimization strategies produce different results
Performance testing:
- Small dataset (50 courses, 500 students): <10 seconds ✓
- Sample dataset (20 courses, 250 students): <5 seconds ✓
Test edge cases:
- Single course
- All students in one course
- Consecutive slots at day boundaries
- Maximum enrollments per student

Collaboration Points

With Kerem: Use DAO queries efficiently, understand data structure
With Sefa: Design ScheduleService API for controllers to call
With Feyza: Make algorithm testable, provide test data generators
With Emin: Document algorithm design, create flowcharts

Deliverables

Week 1: Algorithm design document and pseudocode
Week 3: Domain models and constraint validators (fully tested)
Week 4: Working CSP solver for simple cases (3-5 courses)
Week 5: All optimization strategies, solver handles sample data (<10 sec)
Week 5: Conflict detector for unsolvable cases
Week 9: Performance optimization and final algorithm polish

3. Rabia Tülay Gokdag - UI/FXML Specialist

Primary Responsibilities

UI Design & Wireframing:

Design wireframes for all application screens
Create color scheme and visual design guidelines
Design application icon and branding
Ensure consistent UI/UX across all views
Plan responsive layouts (different screen resolutions)

FXML Layout Creation: Create FXML files for all views using Scene Builder:

MainWindow.fxml - Main application window with navigation
ImportView.fxml - CSV file import screen
ConfigurationView.fxml - Exam period configuration
ScheduleView.fxml - Schedule generation with progress
ClassroomView.fxml - Classroom schedule view (table)
StudentView.fxml - Student schedule view (table with search)
CourseView.fxml - Course schedule view (sortable table)
DayView.fxml - Day-by-day grid view
ExportView.fxml - Export options screen
HistoryView.fxml - Schedule history list
Dialogs: Edit dialog, Conflict report dialog, Error dialogs

UI Components:

Design table layouts (columns, headers, alternating rows)
Create form inputs (text fields, spinners, combo boxes)
Design buttons with consistent styling
Add icons and visual feedback (success checkmarks, error icons)
Implement progress indicators (progress bar, spinner)
Design filter controls (dropdowns, search boxes)

Styling (CSS):

Create styles.css with consistent theme
Define color palette:
- Primary: Blue (#2196F3)
- Success: Green (#4CAF50)
- Error: Red (#F44336)
- Neutral: Gray (#9E9E9E)
Style all UI components (buttons, tables, inputs, labels)
Add hover effects and focus states
Ensure accessibility (sufficient color contrast, clear focus indicators)

Visual Polish:

Add icons for all buttons and actions
Design loading spinners and progress animations
Create success/error message displays
Add tooltips for user guidance
Ensure proper alignment and spacing
Test on different screen sizes

Testing Responsibilities

Test UI layouts on different screen resolutions
Verify all FXML files load correctly
Test keyboard navigation (tab order)
Verify CSS styling is consistent
Test accessibility features
Ensure no UI elements overlap or clip

Collaboration Points

With Sefa: Provide FXML files with proper fx:id for controller binding
With Emin: Provide screenshots for documentation, create visual guide
With Feyza: Support TestFX UI testing
With all: Get feedback on UI designs, iterate based on usability

Deliverables

Week 1: Wireframes and visual design guidelines
Week 2: Import View FXML
Week 3: Configuration View FXML
Week 4: Schedule generation view with progress UI
Week 6: All 4 schedule views (Classroom, Student, Course, Day)
Week 7: Export View and edit dialog
Week 8: History View and conflict report display
Week 9: Final UI polish and consistency check

4. Mehmet Sefa Keskin - Controller Layer Lead

Primary Responsibilities

Application Setup:

Create Main.java - JavaFX application entry point
Set up application lifecycle (start, stop)
Load main window FXML
Initialize application resources

Main Controller:

Implement MainController for main window
Handle navigation between views
Manage view switching logic
Implement menu bar actions (File, Edit, View, Help)

Feature Controllers: Implement controllers for all views:

ImportController - CSV file import workflow
- File browse dialogs (4 file choosers for each CSV type)
- Call ImportService to process files
- Display import results (success/error messages with line numbers)
- Handle import errors gracefully
ConfigurationController - Exam period setup
- Input validation (positive integers only)
- Calculate total slots (days × slots per day)
- Validate sufficient slots for courses
- Save configuration to database
ScheduleController - Schedule generation
- Create JavaFX Task for background solver execution
- Update progress bar in real-time
- Handle cancellation (interrupt solver)
- Display success or failure results
- Show conflict report on failure
ClassroomViewController, StudentViewController, CourseViewController, DayViewController - Schedule display
- Populate tables/grids with schedule data
- Implement filtering (dropdown filters, search boxes)
- Implement sorting (sortable table columns)
- Handle view switching
ExportController - Export workflow
- Format selection (CSV or Excel radio buttons)
- View selection (checkboxes for which views to export)
- File save dialog
- Call export service
- Display export success/error messages
HistoryController - Schedule history
- Load schedule list from database
- Display schedule metadata (date, strategy, counts)
- Load selected schedule
- Delete schedules with confirmation dialog

Business Logic Integration:

Connect controllers to service layer (ImportService, ScheduleService, ExportService)
Handle service exceptions and display user-friendly errors
Manage application state (current schedule, configuration)
Implement proper resource cleanup (close database connections)

Error Handling:

Catch all exceptions from service/DAO layers
Convert technical errors to user-friendly messages
Display errors in dialog boxes or status labels
Log errors for debugging

Threading:

Use JavaFX Task for long-running operations (solver, import, export)
Keep UI responsive during background tasks
Update UI from background threads safely (Platform.runLater)
Handle task cancellation properly

Testing Responsibilities

Write unit tests for controller logic (mock service layer)
Test error handling for all exception cases
Test threading (background tasks update UI correctly)
Ensure no memory leaks (resources cleaned up)
Test with TestFX for UI integration

Collaboration Points

With Rabia: Get FXML files with fx:id set, provide feedback on UI design
With Kerem/Milena: Use service layer APIs, handle exceptions
With Feyza: Make controllers testable, support TestFX testing
With Emin: Document controller architecture and event flows

Deliverables

Week 1: Main controller with navigation
Week 2: Import controller (integrate with ImportService)
Week 3: Configuration controller
Week 4: Schedule controller with background task and progress
Week 6: All 4 view controllers (Classroom, Student, Course, Day)
Week 7: Export controller and edit dialog controller
Week 8: History controller
Week 9: Final controller polish and error handling improvements

5. Feyza Gereme - Testing & QA Lead

Primary Responsibilities

Test Infrastructure Setup:

Configure JUnit 5 in Maven/Gradle
Set up test directory structure (src/test/java)
Create test utility classes (TestDataBuilder, TestDatabase)
Configure test coverage reporting (JaCoCo)
Set up CI/CD pipeline (GitHub Actions)

Unit Testing: Write comprehensive unit tests for all layers:

DAO Layer Tests:
- Test CRUD operations (insert, update, delete, select)
- Test batch operations
- Test transaction rollback on error
- Test uniqueness constraints
- Test foreign key constraints
- Target: >90% coverage for DAO layer
Algorithm Layer Tests:
- Test each constraint validator individually
- Test CSP solver with known solutions (3-5 courses)
- Test unsolvable cases (known conflicts)
- Test all 4 optimization strategies
- Test edge cases (single course, max enrollments, day boundaries)
- Target: >95% coverage for algorithm layer
Service Layer Tests:
- Test business logic validation
- Test error propagation (DAO → Service → Controller)
- Mock DAO and algorithm layers using Mockito
- Test transaction handling
- Target: >80% coverage for service layer
Controller Layer Tests:
- Mock service layer
- Test error handling in controllers
- Test state management
- Target: >70% coverage for controller layer

Integration Testing:

Database Integration:
- Test end-to-end import (CSV → Database → Verify)
- Test schedule save → load round-trip
- Test manual edit → validation → save
UI Integration (TestFX):
- Test navigation workflow
- Test import workflow (select files → import → verify results)
- Test generation workflow (configure → generate → view schedule)
- Test export workflow (select format → export → verify file)
End-to-End Testing:
- Complete user workflows from start to finish
- Test with sample data (20 courses, 250 students, 10 classrooms)

Performance Testing:

Create benchmark tests for solver performance:
- Small dataset (50 courses, 500 students): Must complete <10 seconds
- Sample dataset (20 courses, 250 students): Must complete <5 seconds
Test database query performance (all queries <100ms)
Profile application memory usage
Identify and report performance bottlenecks

Test Data Management:

Create test CSV files:
- test_students_10.csv - 10 students
- test_students_100.csv - 100 students
- test_students_250.csv - 250 students (matches sample)
- test_courses_5.csv - 5 courses
- test_courses_20.csv - 20 courses (matches sample)
- test_classrooms_small.csv - 3 classrooms, capacity 20
- test_classrooms_medium.csv - 10 classrooms, capacity 40
- test_enrollments_simple.csv - Simple enrollment pattern
- test_enrollments_complex.csv - Complex pattern for stress testing
Create test data builders for easy test object creation
Maintain test fixtures (consistent test data for repeatable tests)

CI/CD Pipeline:

Set up GitHub Actions workflow:
- Run all tests on every commit
- Generate coverage report
- Upload coverage to Codecov (or similar)
- Fail build if coverage drops below 70%
- Fail build if any test fails
Configure test execution in Maven/Gradle
Set up test reporting (JUnit XML reports, HTML reports)

Bug Tracking & Quality Assurance:

Create bug report template
Track all bugs found (use GitHub Issues or similar)
Prioritize bugs (critical, major, minor)
Verify bug fixes (regression tests)
Monitor code quality metrics (coverage, complexity)

Testing Responsibilities

All testing tasks are primary responsibility!
Coordinate with other team members to ensure testable code
Review all PRs for test coverage before approval
Generate weekly test coverage reports
Identify untested code paths and create tests

Collaboration Points

With Kerem: Get testable DAO interfaces, create database test utilities
With Milena: Get test data generators for algorithm, create solvable/unsolvable test cases
With Rabia/Sefa: Write TestFX UI tests, verify UI behavior
With Emin: Document testing strategy, contribute to quality assurance documentation

Deliverables

Week 1: CI/CD pipeline setup, test infrastructure
Week 2: DAO layer tests (>90% coverage)
Week 3: Constraint validation tests
Week 4: Solver unit tests, performance benchmarks
Week 5: All optimization strategy tests
Week 6: View controller TestFX tests
Week 7: Export functionality tests
Week 8: Integration tests, end-to-end tests
Week 9: Full test suite complete, coverage report >70%
Week 10: Final QA report

6. Emin Arslan - Documentation & Integration Lead

Primary Responsibilities

Memory Bank Maintenance:

Maintain and update MEMORY_BANK.md as project evolves
Document all design decisions and rationale
Track assumptions and open questions
Update API contracts when interfaces change
Add discovered edge cases and solutions

Code Documentation:

Ensure all public methods have JavaDoc comments
Review JavaDoc for clarity and completeness
Set up JavaDoc generation in Maven/Gradle
Generate JavaDoc HTML documentation
Create package-level documentation (package-info.java)
Document complex algorithms with explanatory comments

Technical Documentation:

Create/maintain technical documents:
- DATABASE_SCHEMA.md - Database documentation with ER diagrams
- ALGORITHM_DESIGN.md - Algorithm pseudocode and flowcharts
- GIT_WORKFLOW.md - Git branching strategy and PR process
- API_DOCUMENTATION.md - Service layer API reference
- UI_COMPONENT_GUIDE.md - FXML components and styling guide
- TESTING_GUIDE.md - How to run tests, write tests, interpret coverage
Create architecture diagrams (use draw.io, PlantUML, or similar):
- System architecture (MVC layers)
- Class diagrams (domain models, DAO, services)
- Sequence diagrams (import workflow, generation workflow)
- ER diagram (database schema)

User Documentation:

Write comprehensive User Manual (15-25 pages) with:
- Introduction and overview
- Installation guide (step-by-step with screenshots)
- Getting started tutorial
- Feature reference (all features explained with screenshots)
- Troubleshooting guide (common issues and solutions)
- FAQ (frequently asked questions)
- Appendix (sample CSV formats, configuration options)
Create Quick Start Guide (1-2 pages)
Write Installation Guide (standalone document)
Write Troubleshooting Guide with common errors and fixes

Code Review & Integration:

Review all Pull Requests for:
- Code quality and style
- Documentation completeness (JavaDoc, comments)
- Adherence to architecture (MVC separation)
- Naming conventions
- No obvious bugs
Coordinate integration of features from different team members
Resolve merge conflicts when needed
Ensure clean Git history (meaningful commit messages)
Conduct weekly integration review meetings

Presentation & Delivery:

Create presentation slides for final demo (15-20 slides)
Prepare demo script for presentation
Coordinate demo video recording (optional but recommended)
Compile final deliverable package:
- Source code (clean, organized)
- User manual (PDF)
- Developer documentation (JavaDoc + technical docs)
- Executable JAR
- Sample database
- Sample CSV files
- Installation guide
- README

Git Workflow Management:

Enforce Git branching strategy (main, develop, feature branches)
Review commit messages for clarity
Create and maintain Pull Request template
Manage release tagging (v1.0.0, etc.)
Coordinate merges to develop and main

Quality Assurance Support:

Work with Feyza on quality standards
Review test coverage reports
Identify documentation gaps
Ensure consistency across all documentation
Create checklists (final delivery checklist, PR review checklist)

Testing Responsibilities

Review test documentation
Ensure tests have clear descriptions
Document test execution procedures
Create user acceptance test scenarios

Collaboration Points

With ALL: Review all code, provide feedback, coordinate integration
With Kerem: Document database schema and DAO APIs
With Milena: Document algorithm design and optimization strategies
With Rabia: Take screenshots for user manual, document UI components
With Sefa: Document controller architecture and event flows
With Feyza: Document testing strategy and procedures

Deliverables

Week 1: MEMORY_BANK.md, ROADMAP.md, TEAM_ASSIGNMENTS.md, GIT_WORKFLOW.md
Week 2: DATABASE_SCHEMA.md with ER diagram
Week 3: Domain model documentation
Week 4: ALGORITHM_DESIGN.md with pseudocode and flowcharts
Week 5: API documentation for service layer
Week 6: UI component guide with screenshots
Week 8: Architecture diagrams (system, class, sequence)
Week 9: Testing guide and quality assurance documentation
Week 10: User Manual (complete), Installation Guide, Final deliverable package, Presentation slides

TEAM COLLABORATION GUIDELINES

Weekly Meetings

Monday Sprint Planning (30 min):

Each person reports: What did you complete last week?
Discuss blockers and issues
Assign tasks for current week from roadmap
Set weekly goals

Wednesday Mid-Week Sync (15-30 min):

Quick round-robin status update
Identify anyone who is blocked
Schedule pair programming sessions if needed
Adjust week's plan if necessary

Friday Demo & Retrospective (30-45 min):

Each person demos their work for the week
Celebrate completed features
Retrospective: What went well? What to improve?
Brief planning for next week

Pair Programming Sessions

Recommended pairings for integration:

Kerem + Sefa: Integrate DAO with controllers
Milena + Sefa: Integrate CSP solver with UI
Rabia + Sefa: Connect FXML views with controllers
Kerem + Milena: Optimize database queries for solver
Feyza + [anyone]: Write tests together (test-driven development)

Schedule: As needed, typically 1-2 hours, Wednesday or Thursday

Code Review Process

Every Pull Request Must:

Have at least 1 approval (from someone other than author)
Pass all CI/CD checks (tests, coverage)
Have no merge conflicts
Follow PR template (description, changes made, testing done)

Review Turnaround Time:

PRs should be reviewed within 24 hours
Small PRs preferred (easier to review)
Urgent PRs can be flagged in WhatsApp/Discord

Who Reviews:

Emin reviews all PRs for documentation and code quality
Feature-specific specialist reviews related PRs (e.g., Kerem reviews DB changes)
Feyza reviews for test coverage

Communication Channels

Synchronous (Real-time):

Weekly meetings (Monday, Wednesday, Friday)
Pair programming sessions
Emergency sync if someone is blocked

Asynchronous:

WhatsApp/Discord - Daily updates, quick questions, coordination
GitHub - Code reviews, PR discussions, issue tracking
Email - Formal communication with professor

Conflict Resolution

If technical disagreement arises:

Discuss in team meeting (not in PR comments)
Each person presents their approach and rationale
Team votes (majority wins)
Emin documents decision in MEMORY_BANK.md with rationale

If someone is blocked:

Post in group chat immediately (don't wait)
If not resolved in 2 hours, schedule sync call
Pair programming session to unblock

If someone is behind schedule:

Notify team in Monday meeting
Other team members offer to help
Re-distribute tasks if necessary
Update roadmap if needed

ACCOUNTABILITY & EXPECTATIONS

Individual Commitments

Each team member commits to:

Attend all weekly meetings (or send written update if absent)
Complete assigned tasks by Friday demo
Review assigned PRs within 24 hours
Write tests for their own code
Document their own code (JavaDoc, comments)
Communicate blockers early
Help teammates when they're stuck

Quality Standards

All code must:

Follow Java naming conventions
Have JavaDoc for public methods
Have meaningful variable/method names
Have no compiler warnings
Pass all tests
Have test coverage (per layer targets)

Definition of "Done"

A task is only "done" when:

Code is written and works correctly
Tests are written and passing
JavaDoc is complete
Code is reviewed and approved
Merged to develop branch
Documentation is updated (if needed)

ESCALATION & SUPPORT

When to Ask for Help

Ask your teammate for help if:

Stuck for >2 hours on a technical problem
Unsure about design decision
Need code review or feedback
Want to pair program

Ask Emin (Integration Lead) if:

Merge conflicts arise
Architecture question (which layer should this code go in?)
Documentation question
Git workflow question

Ask the whole team if:

Major technical decision needed
Significant roadmap change proposed
Need to reprioritize tasks

Ask the professor if:

Requirements are unclear
Need clarification on constraints
Considering major scope change
Need project extension

SUCCESS METRICS

Individual Performance

Each team member will be evaluated on:

Completion of assigned tasks (on time)
Code quality (clean, documented, tested)
Collaboration (helping teammates, pair programming)
Communication (attending meetings, timely updates)
Testing (writing tests, achieving coverage targets)
Documentation (JavaDoc, comments, technical docs)

Team Performance

Team success measured by:

Meeting weekly milestones from roadmap
Passing all tests (>70% coverage overall)
All functional requirements implemented (FR1-FR12)
All non-functional requirements met (NFR1-NFR6)
Complete and polished deliverable package
Successful final presentation

APPENDICES

Appendix A: Tools & Technologies

Required Tools (All Team Members):

Java JDK 17+
IntelliJ IDEA (recommended) or Eclipse
Git (for version control)
Maven or Gradle (build tool)
SQLite Browser (for database inspection)

Role-Specific Tools:

Kerem: DB Browser for SQLite
Milena: Profiling tools (JProfiler or VisualVM)
Rabia: Scene Builder (for FXML editing)
Sefa: JavaFX Scene Builder
Feyza: JaCoCo (coverage), TestFX (UI testing)
Emin: Draw.io (diagrams), Markdown editor

Appendix B: Learning Resources

JavaFX:

Official docs: https://openjfx.io/javadoc/17/
Tutorial: https://openjfx.io/openjfx-docs/
Scene Builder: https://gluonhq.com/products/scene-builder/

SQLite:

Tutorial: https://www.sqlitetutorial.net/
JDBC: https://www.sqlitetutorial.net/sqlite-java/

CSP Algorithms:

Russell & Norvig "Artificial Intelligence: A Modern Approach" - Chapter 6
Online: https://artint.info/2e/html/ArtInt2e.Ch4.html

Testing:

JUnit 5: https://junit.org/junit5/docs/current/user-guide/
Mockito: https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html
TestFX: https://github.com/TestFX/TestFX

Appendix C: Contact Information Template

Team Member	Email	Phone	Preferred Contact Method
Kerem Bozdag	[fill in]	[fill in]	WhatsApp / Discord
Milena Larissa Ünal	[fill in]	[fill in]	WhatsApp / Discord
Rabia Tülay Gokdag	[fill in]	[fill in]	WhatsApp / Discord
Mehmet Sefa Keskin	[fill in]	[fill in]	WhatsApp / Discord
Feyza Gereme	[fill in]	[fill in]	WhatsApp / Discord
Emin Arslan	[fill in]	[fill in]	WhatsApp / Discord

Group Chat: [WhatsApp/Discord link] Repository: [GitHub URL] Professor: [Name, Email, Office Hours]

CHANGELOG

Version	Date	Author	Changes
1.0	2025-11-26	Claude Code	Initial team assignments document

END OF TEAM ASSIGNMENTS

Note: This document defines roles but emphasizes collaboration. While each person has a specialty, everyone helps each other to ensure project success. Cross-functional collaboration is encouraged and expected.

31 KiB Raw Blame History Unescape Escape

TEAM ASSIGNMENTS - EXAM SCHEDULING SYSTEM

TEAM ROSTER

DETAILED ROLE RESPONSIBILITIES

1. Kerem Bozdag - Database & Data Layer Lead

Primary Responsibilities

Testing Responsibilities

Collaboration Points

Deliverables

2. Milena Larissa Ünal - Algorithm Specialist

Primary Responsibilities

Testing Responsibilities

Collaboration Points

Deliverables

3. Rabia Tülay Gokdag - UI/FXML Specialist

Primary Responsibilities

Testing Responsibilities

Collaboration Points

Deliverables

4. Mehmet Sefa Keskin - Controller Layer Lead

Primary Responsibilities

Testing Responsibilities

Collaboration Points

Deliverables

5. Feyza Gereme - Testing & QA Lead

Primary Responsibilities

Testing Responsibilities

Collaboration Points

Deliverables

6. Emin Arslan - Documentation & Integration Lead

Primary Responsibilities

Testing Responsibilities

Collaboration Points

Deliverables

TEAM COLLABORATION GUIDELINES

Weekly Meetings

Pair Programming Sessions

Code Review Process

Communication Channels

Conflict Resolution

ACCOUNTABILITY & EXPECTATIONS

Individual Commitments

Quality Standards

Definition of "Done"

ESCALATION & SUPPORT

When to Ask for Help

SUCCESS METRICS

Individual Performance

Team Performance

APPENDICES

Appendix A: Tools & Technologies

Appendix B: Learning Resources

Appendix C: Contact Information Template

CHANGELOG

31 KiB

Raw Blame History