Graph Data Structure for Software Development Item Relationships
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Software development teams face challenges in coordinating efforts due to the difficulty in determining which developers are familiar with specific code pieces, as the history of code modifications is often scattered across various sources like emails, source code stores, and bug tracking databases, making it hard to find relevant information efficiently.
Innovation Solution
A graph data structure is used to represent software development items and their relationships, allowing for implicit queries and graph browsing, which enables the identification of relevant developers and code history by connecting nodes and edges representing different development items and their interactions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If developers consult multiple sources (emails, source code store, bug tracking database) to find code history, then they can access comprehensive information, but the time required to sift through these sources increases significantly
Solution Approach 1:
The patent combines multiple disconnected data collections (emails, source code store, bug tracking database) into a unified graph data structure that represents software development items and their relationships. This merging allows developers to query all information sources through a single interface, retrieving comprehensive code history information without manually sifting through multiple separate systems, thus resolving the contradiction between information completeness and search time
Solution Approach 2:
The graph data structure acts as an intermediary layer between developers and the underlying data collections. Instead of directly querying multiple sources, developers interact with the graph which automatically retrieves and synthesizes information from emails, source code stores, and bug tracking databases, significantly reducing the time required to find code history while maintaining comprehensive information access
2Loss of information
If a project historian is assigned to track code history, then developers can consult someone knowledgeable, but the historian cannot know entire project history and may leave the team
Solution Approach 1:
The patent creates a machine-readable copy of the code history information by automatically generating a graph data structure that mirrors the relationships and history stored in the underlying data collections. This digital copy encapsulates the knowledge that would otherwise reside in the historian's mind, ensuring the information persists independently of any individual developer's presence on the team
Solution Approach 2:
The system enables self-service by allowing developers to directly query the graph data structure for code history information without needing to consult a human historian. The graph automatically provides the needed information about code relationships, modifications, and developer involvement, making the knowledge accessible and reliable without depending on any single person's availability or memory
3Adaptability or versatility
If developers work on large software projects with many tasks, then project complexity increases, but coordinating efforts and finding familiar developers becomes more difficult
Solution Approach 1:
The patent adds a new dimension to code organization by creating a graph-based representation that visualizes relationships between software development items across multiple dimensions (authorship, modification history, related bugs, etc.). This dimensional transformation allows developers to navigate complex projects by exploring relationships in different directions, making it easier to find relevant developers and understand code contexts in large-scale projects
Data Source
AI summary
Software development items can be represented in a graph data structure. Relationships between the represented items can be detected and reflected in the graph data structure. Queries can be run against the data structure to determine which software development items are related to each other. Implicit query can be implemented in a software development context. A graph browser can present panes showing related items.