Con-Map-Track

Project Overview

The Convention Map Tracker is a web app that helps people find media or anime or furry conventions around the country and plan their trips easily. Instead of having to check multiple websites for details, prices, and directions, this app puts everything together in one place to make it easy for the user. Users can see how far a convention is from them, how many attendees were there last year (to get an idea of how many might go), and even get rough cost estimates for gas, plane tickets, and nearby hotels. The goal is to make it simple for anyone who likes going to conventions like anime, gaming, or comic cons to see what’s happening and decide if they can afford the trip.

The app’s main purpose is to take the stress out of travel planning, give an easier alternative to encourage you to go to the convention. Most con attendees have to check different sites for info on tickets, hotels, and transportation, and that can be time-consuming and discouraging. With this tracker, they’ll be able to type in their location and see all upcoming conventions, travel distances, and estimated costs that is around them. The data will pull from simple sources at first, probably stored in JSON or a basic database, or possibly install a web scraper to pull data from sites to constantly update. The project will also use location-based data to calculate travel distance and cost, a different version of Google Maps.

The key stakeholders for this project include convention attendees, event organizers to fund these. If the app were ever made public, travel agencies and advertisers could also become stakeholders since it would be an app for everyone. The main focus right now is to show I can design and build a working app using solid software planning and Agile methods. This means breaking the work into clear sprints, following a backlog, and keeping things organized in GitHub and on each desktop.

There are a few risks I already know about. The first is the limited time for development, since this project only spans eight weeks. Gathering real data could also take longer than expected, especially for accurate pricing and such (Thus my web scraper idea could be implemented). Another challenge will be making sure the app looks good and runs well on both desktop and mobile. I plan to manage these risks by keeping the features realistic focusing first on convention lookup, map display, and simple cost estimation before adding anything fancy. I’ll also make sure to test often, and update based on what works best.

For the success criteria, I’ll know I’ve met my goals when the app can show conventions with distance, cost, and attendance info (Probably when you hover your mouse over the location or distance line). The travel estimate feature should give users a general idea of what it would cost to drive or fly to that event. The interface should load fast and show accurate data. Each feature will match a user story from the backlog, and the whole app will be managed through version control on GitHub with proper commits, branches, and documentation. If all those parts work together smoothly by the end, I’ll consider it a success.

I’m keeping this project ambitious enough to show real-world application. By the end, I’ll have something useful that ties together data, mapping, and cost estimation all while following the Agile process. I honestly think this could be very doable and it could serve a lot of purpose for today’s societal needs.

---

Two-Sprint Plan

Sprint	Weeks	Focus	Tasks	Goal
Sprint 1	Weeks 2–4	Setup and Core Features	Create GitHub repo and file structure Build homepage and map interface (Google Maps or Mapbox API sounds good) Add search function for conventions Display convention markers on the map • Store basic data in JSON or database	Have a working prototype that shows conventions and distance from the user.
Sprint 2	Weeks 5–7	Enhancements and Integration	Add travel cost estimation (car and flight) Include nearby hotel listings • Show attendance from previous year • Improve mobile design Conduct testing and fix bugs	A working version ready for demo with realistic data and smooth performance.

Additional Timeline:

• Week 1: Planning, research, and writing the project charter.
• Week 8: Final testing, bug fixes, and submission.

---

Personal Backlog - User Stories

ID	User Story	Acceptance Criteria
CMT-1	As a user, I want to search for conventions by name so I can find events easily.	Search returns results within 1 second, partial matches work (like typing "Comic" shows "Comic Con"), and it shows "No results" if nothing matches.
CMT-2	As a user, I want to see convention locations on a map so I know where they're held.	Map marker appears at the right spot, map centers on the convention when selected, and hovering over the marker shows the convention name.
CMT-3	As a user, I want to know how far conventions are from my location.	Distance is shown in miles, calculation is accurate within about 5 miles, and it updates if I change my location.
CMT-4	As a user, I want to see gas cost estimates for driving to conventions.	Cost is calculated using distance and average fuel prices, assumes a typical car gets 25–30 MPG, and shows the total in dollars.
CMT-5	As a user, I want to compare flight and driving costs.	Shows estimated roundtrip flight price, compares it to driving cost, and labels which option is cheaper.
CMT-6	As a user, I want to see nearby hotels so I can plan where to stay.	Displays 3–5 hotels near the convention, shows hotel names and nightly rates, and lists how far each one is from the venue.
CMT-7	As a user, I want to see how many people attended last year.	Previous year's attendance number is visible for each convention, shows "N/A" if the data isn't available, and the number is clearly labeled.
CMT-8	As a user, I want to filter conventions by state or distance.	Can filter by radius like 100, 250, or 500 miles, can filter by state using a dropdown, and results update right away.
CMT-9	As a user, I want to click on conventions to see more details.	A detail panel opens with full information including costs, hotels, and attendance, and there's an X button to close it. Cannot forget links to the website either.
CMT-10	As a user, I want the app to load quickly so I'm not waiting around.	Main page loads in under 3 seconds, search results show up within 1 second, and there's no lag when switching between views.
CMT-11	As a user, I want the app to work well on my phone.	Layout adjusts properly for phone screens (320px and up), all buttons are easy to tap, and the map and search work on mobile browsers.
CMT-12	As a user, I want to see updated convention info each year.	Convention data can be updated through the JSON file, new conventions show up after the data refreshes, and past events get archived or marked as inactive.

---

Trend Notes

In the past, software projects followed the Waterfall methodology, where all the planning happened upfront and developers built everything in a strict sequence. The problem with that approach was it didn't handle changes well. If something didn't work or requirements shifted halfway through, you were basically stuck redoing large portions of the project.

Now a days, Agile methods like Scrum are standard. Teams work in short sprints, get working features done early, and adjust based on feedback from users or anyone. For this project, I'm using an Agile approach with two three-week sprints. That way, if something like integrating a mapping API doesn't go as planned in Sprint 1, I can pivot in Sprint 2 instead of being locked into a bad design which would basically mean failure.

A big current trend is using APIs instead of manually entering or hardcoding data. For the Convention Map Tracker, I'll pull in real-time data for things like gas prices, flight estimates, and hotel availability. This keeps the information accurate and updated without constantly having to do manual updates. Another current practice I'm following is a mobile design. Since most people would check convention locations and costs on their phones while traveling, I'm designing the layout with smaller screens in mind first, then scaling up to desktop. I am sure there is some easy software or specific code that would fix this issue easily.

I do not like AI, but from what I can see and what I have been implementing since it is forced upon even in our IDEs now a days, trends include AI-assisted development tools like GitHub Copilot and automated frameworks that catch bugs before code even gets pushed. While I won't have time to implement full CI/CD in this 8-week project, I'm setting up my GitHub workflow with proper branching and pull requests to prepare for those kinds of practices in future work.

By combining Agile principles, API integration, mobile designs, and proper leader shipping, this project does a good job on how it feel to show real development teams operate today and sets me up to adopt emerging tools as they become more accessible.

Furry Convention Map Tracker

A web application that helps anyone locate furry-conventions that they potentially want to travel to, estimate travel costs, and plan trips. (Hoping if this all works, by the very end of this project, I can update the variety of conventions like, anime, technology, Theme Park, ETC.) (I did furry conventions considering it is a multi-million dollar industry that needs attention.)

Week 2 Deliverables

• (SRS)
• UML Class Diagram
• Sequence Search Diagram
• Sequence Details Diagram
• (ERD)
• Data Dictionary
• Traceability Table

Technologies

• Python 3.12+
• FastAPI
• SQLite or MySQL (Still deciding)
• HTML/CSS/JavaScript

---

Week 3: Prototype Week

1st Task: Search for Conventions Near User Location

Related Requirements: REQ-1, REQ-2, REQ-3

Happy Path: ( I learned what happy path and Alternative path means)

1. User opens the homepage and sees a flat USA map with a search bar above labeled "Enter an address or city"
2. User types "Tampa, FL" into the search bar and clicks Search
3. System geocodes the address and gets coordinates for Tampa
4. Map centers on Florida and displays 100 nearest conventions as pawprint icons to indicate exactly where the convention is being held
5. Left panel updates to show the 10 closest conventions with distance in miles as a list
6. Right panel shows the top 100 most popular conventions regardless of location (Possibly We'll keep that list with the highlighted top 10 to also help)
7. Lines appear connecting the user's location to each convention marker
8. User hovers over a pawprint and sees a popup with convention name, up-coming date, distance in miles,

Alternative Path (No Results):

1. User types Australia" and clicks Search
2. System geocodes the location successfully but finds no conventions within 1000 miles (Might happen)
3. A message appears: "No conventions found nearby. Showing all conventions nationwide instead."
4. Map zooms out to show all 100 conventions across the USA without distance lines

---

Task 2: View Convention Details and Nearby Hotels

Related Requirements: REQ-4, REQ-5, REQ-6

Happy Path:

1. User clicks on a pawprint marker labeled "Anthrocon 2025"
2. A popup expands showing full details: name, venue, dates, last year's attendance (8,000 people), and estimated travel cost from user's location
3. Popup includes a "View Nearby Hotels" button
4. User clicks the button
5. System loads 3-5 hotels near the convention venue with names, nightly rates, and distance from venue
6. User can click external links in the popup to visit the convention website

Alternative Path (Missing Data):

1. User clicks on a convention in a small town
2. Popup appears with basic info (name, date, venue) but shows "Hotel data unavailable for this location"
3. Travel cost estimate still displays based on distance calculation
4. "View Nearby Hotels" button is grayed out and disabled
5. User can still see attendance data and external links if available

---

Week 3: UML Updates

The ADR decision to use monolithic architecture (For obvious reasons) and from the prototype, the changes were made to the UML diagrams but very simple:

Changes Made:

• UIController: Added logUserAction() method to support REQ-12 (logging key actions like search, view, and estimate)
• DataRepository: Added caching logic to improve response times for REQ-9 (Was a cool trick I learned in ASP.NET class)
• SearchService: Added handleNoResults() method to support the alternative path where no conventions are found
• PopupInfo: Added disableHotelButton() method to handle the case where hotel data is unavailable

Changes reasons: The monolithic architecture means all components run in the same process, so logging and caching can be handled directly without network use. The prototype revealed edge cases("problem or situation that falls outside normal procedures and on the boundary of operating framework") (no results, missing hotel data) that needed explicit handling in the UML.

Requirements Supported:

• REQ-1, REQ-2, REQ-3 (search and map display)
• REQ-9 (performance)
• REQ-12 (logging)

Week 4: Heuristics

• Inclusivity Heuristic Review
• Project Skeleton (Below)

Prerequisites

• Python 3.12 or higher
• pip (Python package manager)

Installation and Running

1. Clone the repository:

   git clone https://github.com/COP4504/course-project-BerryDragon.git
   cd course-project-BerryDragon

2. Install dependencies:

   pip install -r requirements.txt

3. Run the application:

   uvicorn app.main:app --reload

4. Open your browser and visit:

   http://127.0.0.1:8000

You should see: {"message":"Hello, WORLD!"}

5. Run tests:

   pytest

You should see: 2 passed

Week 5: Algorithm Analysis and Basic Data Structures

Assignment this week

• Benchmark Results
• Performance Analysis

Implementation

Data Structures Package:

• ds/ - Package with all four data structures
  • ds/dynamic_array.py: Custom dynamic array wrapping Python's list with append, pop, and indexing
  • ds/stack.py: Stack using push/pop on top of a list
  • ds/queue.py: Ring buffer queue that doubles in size when it fills up
  • ds/hashset.py: Hash set for quick lookups and membership checks

Testing

Run the unit tests in tests/test_ds.py to make sure everything works:

pytest tests/test_ds.py -v

Benchmarking

I ran microbenchmarks on all four structures for input sizes 1k, 10k, and 100k. This shows how well they actually perform compared to what the textbook says they should do.

python -m bench.bench_ds > doc/bench_results.txt

Check out the Performance Analysis to see what the timing data actually means and how it compares to big-O theory.

Week 6: Search and Sorting Algorithms

The Deliveries

• Algorithm Folder
• Unit Tests
• Benchmarks
• Benchmark Results
• Quality Assessment

Algorithms Implemented

• alg/binary_search.py: This is my O(log n) search I read from PSADS Ch. 5
• alg/mergesort.py: O(n log n) stable sort
• alg/quicksort.py: O(n log n) average, not stable

Running Tests

pytest tests/test_alg.py -v

Benchmarks

python -m bench.bench_alg > doc/bench_alg_results.txt

See Quality Assessment for code review and performance analysis.

Week 7: Search and Distance Calculation API

Overview

Here what I did was implement the backend search API with distance calculation functionality (had to give up the haversine to calculate, replace it with geopy geodesic, harversine was too difficult for this timeframe.(I just had no idea how to use it haha)) This connects the database layer with the search and distance features, integrating the sorting algorithms from Week 5.

Deliverables

• Database Module (app/database.py) - SQLite interface with CRUD operations
• Convention Seed Data (data/seed_conventions.sql) - 25 real furry conventions from WikiFur with 2024/2025 data
• Search API - GET /api/conventions endpoint with query, location, and radius filtering
• Distance Calculation - Using geopy's geodesic for accurate mile calculations
• Action Logging - REQ-12 implementation (logs to logs/actions.log)
• Comprehensive Tests (tests/test_api.py) - 22 tests including edge cases
• PDB Debugging - Documented debugging session (docs/pdb-notes.md)

Requirements Implemented (4 of 12)

• REQ-1: Search by name, city, or state
• REQ-3: Calculate distance from user location (using geopy geodesic)
• REQ-9: API response
• REQ-12: Searching and view detail

Setup and Running

Initialize the database:

python -m app.database

Output: Database setup complete: 25 conventions loaded

Start the API server:

uvicorn app.main:app --reload

Visit:

• http://127.0.0.1:8000 - Basic hello world to show I didn’t break anything
• http://127.0.0.1:8000/docs - For documention
• I did have AI help me to make the documentation look decent as well as some of the math calculations. I hope it was a proper use and not against your policy or an abuse of it.

Run the test suite:

python -m pytest tests/test_api.py -v

Expected: 22 passed

API Endpoints

Search Conventions:

# Search by name
curl "http://127.0.0.1:8000/api/conventions?q=Anthrocon"

# Search with distance calculation
curl "http://127.0.0.1:8000/api/conventions?lat=40.4406&lng=-79.9959&radius=100"

# Get all conventions
curl "http://127.0.0.1:8000/api/conventions"

Get Convention Details:

curl "http://127.0.0.1:8000/api/conventions/1"

Database

• 25 conventions from WikiFur's 2024/2025 attendance data
• Top convention: Anthrocon (Pittsburgh, PA) - 18,357 attendees
• Geographic coverage: USA, Canada, Europe, Asia
• SQLite database: data/conventions.db

Integration with Previous Weeks

• Using mergesort (Although you told me there were better ways) from Week 5 for sorting conventions by distance

Performance

• Average API response time: ~150ms (under the 3-seconds)
• Distance calculation: < 1ms per convention
• Database queries: < 50ms for 25 conventions

Testing Strategy

• 22 tests covering:
  • Basic endpoint functionality
  • Search by name, city, state
  • Distance calculation accuracy
  • Radius filtering
  • Performance
  • Edge cases
  • Logging functionality

PDB Debugging Session

During testing, I discovered the distance test had an incorrect expected value (305 miles instead of 258 miles for Pittsburgh to Philadelphia). Used Python's pdb debugger to:

1. Inspect calculated values and see what the issue was
2. Verify the input coordinates
3. Identify the bug in the test itself
4. Fix and verify the errors

Full session documented in doc/pdb-notes.md.

What's Next (Week 8)

• Frontend with interactive Leaflet map

Final Project Completed

Version: 1.0
Status: ✅ Completed Date: December 11 2025

Requirements Completed

• ✅ REQ-1: Search by name/city/state
• ✅ REQ-2: Interactive map with markers
• ✅ REQ-3: Distance calculation
• ✅ REQ-4: Travel cost estimates
• ⚠️ REQ-5: Hotels (skipped - optional)
• ✅ REQ-6: Last year attendance display
• ✅ REQ-7: CRUD operations
• ⚠️ REQ-8: Favorites (skipped - optional)
• ✅ REQ-9: Performance < 3s (avg 150ms)
• ✅ REQ-10: Responsive UI
• ⚠️ REQ-11: Security (basic - no auth needed)
• ✅ REQ-12: Action logging

Features

• Interactive Map: Leaflet.js map with 100 real conventions from WikiFur
• Distance Calculation: Uses geopy library for accurate distance measurements
• Travel Cost Estimates: Gas ($0.50/mile) + tiered flight estimates
• Navigation Integration: Google Flights, Google Maps, and Waze links
• CRUD API: Full create/read/update/delete functionality
• Performance: API responses average 150ms

Documentation

• ✅ User Guide: doc/user-guide.md
• ✅ Test Summary: doc/test-summary.md
• ✅ Run Instructions: doc/run-instructions.md
• ✅ SRS with REQ mapping: doc/srs.md
• ✅ Traceability Table: doc/traceability-table.md
• ✅ Inclusivity Review: doc/inclusivity-review.md
• ✅ ADR 0001: doc/adr/0001-architecture.md

Testing

• 22 passing API tests (pytest -v)
• Manual frontend testing
• Performance benchmarks
• See doc/test-summary.md for details

Presentation

• https://www.youtube.com/watch?v=Yn8occtM9SE

Technology Stack

Backend:

• Python 3.12.0
• FastAPI 0.124.0
• SQLite database
• geopy for distance calculations

Frontend:

• Vanilla JavaScript (really wanted to use React)
• Leaflet.js 1.9.4
• OpenStreetMap tiles

Algorithms:

• Mergesort (from Week 5) for distance sorting
• Binary search for data retrieval

Running the Application

# Activate virtual environment
venv312\Scripts\activate

# Start server
uvicorn app.main:app --reload

# Visit
http://127.0.0.1:8000

See doc/run-instructions.md for complete setup instructions.

Project Reflection

This project integrated algorithms from Week 5 (mergesort), database design, API development, and interactive frontend development. Biggest challenges were implementing accurate distance calculations, creating an intuitive map interface, and integrating multiple third-party APIs (Google Flights, Nominatim geocoding). The monolithic architecture choice (ADR 0001) proved effective for a local-only application, simplifying development and testing.

The travel cost estimation feature provides real value to users, and the integration with Google Flights, Maps, and Waze makes trip planning easy for users. With 100 real conventions from WikiFur, the application demonstrates scalability and real-world applicability.

Future Enhancements

• Real-time flight/gas pricing via SerpAPI integration or a homemade web-scraper
• Hotel recommendations near convention venues
• User accounts with saved favorites
• Mobile app version
• Convention calendar with notifications
• Review and rating system

---

Repository: https://github.com/COP4504/course-project-BerryDragon

Thank you!