Software Dependency Shading for Version Conflict Resolution

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Existing software build processes often encounter dependency conflicts due to version differences in libraries, leading to runtime errors and requiring manual, time-consuming dependency locking, which is error-prone and delays updates.

Innovation Solution

A computer-implemented method using a shading engine that dynamically renames transitive dependencies to disambiguate between different versions, allowing multiple versions of libraries to coexist in an executable software application without manual intervention.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If dependency locking is used to avoid version conflicts, then reliability is improved, but productivity deteriorates due to manual coordination and testing requirements

Engineering Contradiction:

Improvedependency conflict resolutionVSAvoidupdate speed

Core Design Contradiction:

ReliabilityVSProductivity

Solution Approach 1:

The build engine automatically performs dependency analysis, version conflict detection, and resolution without requiring manual developer intervention. The system self-manages the entire dependency locking process, including automatic selection of compatible library versions and updating of dependency descriptors, thereby maintaining reliability while eliminating the productivity bottleneck caused by manual coordination and testing

Inventive Principle:

Principle #25Self-service

Solution Approach 2:

The build engine performs dependency analysis and version conflict resolution during the build process before the application is deployed. By proactively identifying and resolving dependency issues in advance, the system ensures reliability without requiring time-consuming manual testing after updates, thus improving both reliability and productivity

Inventive Principle:

Principle #10Preliminary action

2Stability of the object's composition

If manual dependency locking is implemented, then version consistency is improved, but time consumption increases due to extensive coordination and testing

Engineering Contradiction:

Improvelibrary version consistencyVSAvoiddependency management time

Core Design Contradiction:

Stability of the object's compositionVSLoss of time

Solution Approach 1:

The patent replaces the manual mechanical process of dependency locking with an automated computational system. The build engine uses algorithmic dependency analysis and version conflict detection to automatically maintain library version consistency, eliminating the time-consuming manual coordination and testing while preserving version stability

Inventive Principle:

Principle #28Mechanics substitution (Replace mechanical system)

Solution Approach 2:

The build engine continuously monitors library dependencies and automatically adjusts version selections based on detected conflicts. This feedback mechanism ensures version consistency is maintained dynamically without requiring manual intervention, reducing time loss while preserving stability

Inventive Principle:

Principle #23Feedback

3Device complexity

If only one version of a library is included in the executable, then device complexity is reduced, but reliability deteriorates due to version conflicts

Engineering Contradiction:

Improvelibrary version managementVSAvoidruntime error prevention

Core Design Contradiction:

Device complexityVSReliability

Solution Approach 1:

The build engine segments the dependency resolution process into distinct phases: dependency analysis, version conflict detection, and automatic resolution. By dividing the complex task of managing multiple library versions into manageable segments, the system maintains low device complexity while preventing runtime errors through systematic version management

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The build engine acts as an intermediary between the application code and the libraries, automatically resolving version conflicts before the application runs. This intermediary layer manages the complexity of multiple library versions transparently, allowing the application to run reliably without directly handling version management complexity

Inventive Principle:

Principle #24Intermediary (Mediator)

Data Source

PatentUS10942734B2Software dependency shading

Publication Date: 2021.03.09 NETFLIX INC

AI summary

In one embodiment of the present invention, a shading engine enables multiple versions of dependencies to coexist in an executable software application. During the software build process, the shading engine dynamically renames transitive dependencies of the software application to disambiguated names. The shading engine performs this renaming at both the library and class level. Notably, the shading engine does not rename the first-order dependencies of the software application. Consequently, the code of the software application and interfaces between the software application and the first-order library dependencies of the software application are not modified. Notably, the shading engine efficiently and accurately shades the transitive dependencies without manual intervention. By contrast, primarily manually-based conventional approaches to dependency management are time consuming and susceptible to errors.