The Collaborator 🤝

📌 Overview

The Collaborator is a full-stack web application that calculates the shortest connection path between developers across different technology domains.

Using a Breadth-First Search (BFS) graph traversal algorithm, the system identifies how two developers are connected through shared projects or contributions — similar to a degree-of-separation model used in professional networks.

---

🎯 Problem It Solves

In large tech ecosystems, developers are often indirectly connected through shared projects or contributions.

This application:

• Models developers and projects as a graph
• Traverses the graph efficiently
• Finds the shortest path between two individuals
• Displays the connection in a clean, user-friendly format

---

🚀 Features

• 🔍 Shortest Path Finder
  Calculates the minimum number of connections between two developers using BFS.

• 🌐 Interactive Search Interface
  Fast searchable dropdown powered by Choices.js.

• 🧠 Graph-Based Data Modeling
  Developers and projects stored as relational CSV datasets.

• 🎨 Responsive Dark-Themed UI
  Built with Flask templates and custom CSS.

• ⚡ Efficient Traversal Logic
  Optimized BFS implementation for shortest-path discovery.

---

🛠️ Tech Stack

Backend

• Python
• Flask

Frontend

• HTML5
• CSS3
• JavaScript
• Bootstrap
• Choices.js

Data & Logic

• Breadth-First Search (BFS)
• Graph traversal
• CSV-based relational datasets

---

🏗️ Project Structure

collaborator/
│── app.py
│── templates/
│── static/
│── data/
│── logic/   (BFS implementation - excluded for academic integrity)
│── requirements.txt

---

🔒 Note on Core Logic

The core BFS implementation files (degree.py and util.py) are excluded from this public repository to comply with academic integrity rules from CS50’s Introduction to Artificial Intelligence with Python.

The project focuses on frontend integration, application architecture, and data modeling. The BFS algorithm logic can be explained as follows:

---

🧠 Algorithm Approach (BFS Pseudocode)

The shortest connection path is computed using a Breadth-First Search (BFS) traversal on a graph where:

• Nodes represent developers
• Edges represent shared project contributions
• A queue is used to explore nodes level by level

Pseudocode Overview

function shortest_path(source, target):

    create a start node with state = source
    initialize a frontier **queue** and add start node
    initialize an empty set for explored nodes

    while frontier queue is not empty:
        remove node from the front of the queue

        if node state == target:
            initialize empty path
            while node has a parent:
                add (action, state) to path
                move to parent node
            reverse path
            return path

        add node state to explored set

        for each neighbor (project_id, dev_id) of node state:
            if neighbor not in frontier queue and not in explored:
                create child node with state = dev_id, parent = node, action = project_id
                add child to the end of the frontier queue

    return None  # no path found

Key Points Highlighted for Recruiters:

• BFS uses a queue to ensure nodes are explored level by level
• Explored set prevents revisiting nodes
• Each node keeps a reference to its parent to reconstruct the shortest path
• Handles cases where no connection exists

---

📸 Preview

---

⚙️ Installation & Setup

1️⃣ Clone the Repository

git clone https://github.com/aabelalexmathew/collaborator.git
cd collaborator

2️⃣ Create Virtual Environment

python -m venv venv
source venv/bin/activate   # Windows: venv\Scripts\activate

3️⃣ Install Dependencies

pip install -r requirements.txt

4️⃣ Run the Application

python app.py

Visit:
http://127.0.0.1:5000

---

📈 What I Learned

• Implementing graph traversal algorithms in real-world applications
• Designing relational datasets for network-based problems
• Structuring Flask applications cleanly
• Building responsive UI with interactive search components
• Separating algorithm logic from presentation layer

---

🔮 Future Improvements

• Database integration (MongoDB / MySQL instead of CSV)
• User authentication system
• API version of the shortest-path service
• Performance optimization for large datasets
• Deployment with Docker