Preparation and Planing Documents added to the github

2025-12-31 20:31:22 +00:00 · 2025-11-30 17:56:12 +03:00
parent 720188328b
commit a8dd7154dd
19 changed files with 10240 additions and 61 deletions
--- a/TEAM_ASSIGNMENTS.md
+++ b/TEAM_ASSIGNMENTS.md
@@ -0,0 +1,836 @@
+# 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:
+  ```java
+  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:
+1. `MainWindow.fxml` - Main application window with navigation
+2. `ImportView.fxml` - CSV file import screen
+3. `ConfigurationView.fxml` - Exam period configuration
+4. `ScheduleView.fxml` - Schedule generation with progress
+5. `ClassroomView.fxml` - Classroom schedule view (table)
+6. `StudentView.fxml` - Student schedule view (table with search)
+7. `CourseView.fxml` - Course schedule view (sortable table)
+8. `DayView.fxml` - Day-by-day grid view
+9. `ExportView.fxml` - Export options screen
+10. `HistoryView.fxml` - Schedule history list
+11. 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:
+1. `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
+2. `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
+3. `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
+4. `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
+5. `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
+6. `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:**
+1. Discuss in team meeting (not in PR comments)
+2. Each person presents their approach and rationale
+3. Team votes (majority wins)
+4. Emin documents decision in MEMORY_BANK.md with rationale
+
+**If someone is blocked:**
+1. Post in group chat immediately (don't wait)
+2. If not resolved in 2 hours, schedule sync call
+3. Pair programming session to unblock
+
+**If someone is behind schedule:**
+1. Notify team in Monday meeting
+2. Other team members offer to help
+3. Re-distribute tasks if necessary
+4. 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.