Automated Legacy Code Refactoring via Interface Mediation

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Legacy code, often written in older programming styles, poses challenges due to inconsistent programming practices and languages, making it difficult to test, read, and maintain, especially when integrated with newer object-oriented code, and manual refactoring is impractical and error-prone.

Innovation Solution

Automated code refactoring techniques convert procedural function calls into object-oriented method calls through an interface and class implementation, decoupling the refactored code from original functions, allowing for easier modification and testing without altering the refactored code or its dependencies.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of manufacture

If automated refactoring tools are used to convert procedural code to object-oriented code, then code maintainability and consistency are improved, but the complexity of the refactoring process and potential loss of original functionality increase

Engineering Contradiction:

Improvecode maintainabilityVSAvoidrefactoring process complexity

Core Design Contradiction:

Ease of manufactureVSDevice complexity

Solution Approach 1:

The system performs multiple scanning passes and validates each transformation step, checking that refactored code maintains original functionality. Error handling code is analyzed and preserved throughout the refactoring process, providing feedback loops that ensure code correctness while enabling automated transformation

Inventive Principle:

Principle #23Feedback

Solution Approach 2:

The system scans the source code multiple times before performing transformations to identify all function calls, error handling code, and dependencies. This preliminary analysis creates a comprehensive understanding of the code structure, allowing safe automated refactoring without losing original functionality

Inventive Principle:

Principle #10Preliminary action

2Reliability

If manual refactoring is performed to update legacy code, then code can be customized and optimized, but the process is time-consuming and error-prone

Engineering Contradiction:

Improvecode accuracyVSAvoidrefactoring time

Core Design Contradiction:

ReliabilityVSLoss of time

Solution Approach 1:

The system performs self-service by automatically scanning, analyzing, and transforming legacy code without requiring manual intervention. The automated tool handles function call conversion, error handling preservation, and code generation, eliminating time-consuming manual refactoring while maintaining accuracy through systematic validation

Inventive Principle:

Principle #25Self-service

Solution Approach 2:

The system changes the parameters of function calls by creating interface methods with standardized signatures. Legacy function calls are transformed into method calls on interface implementations, changing the calling convention while preserving the underlying functionality and error handling behavior

Inventive Principle:

Principle #35Parameter changes

3Stability of the object's composition

If legacy code is left unchanged to maintain backwards compatibility, then existing functionality is preserved, but code consistency and modernization are compromised

Engineering Contradiction:

Improvebackwards compatibilityVSAvoidcode readability

Core Design Contradiction:

Stability of the object's compositionVSEase of operation

Solution Approach 1:

The system introduces an intermediary layer by creating interface definitions that wrap legacy function calls. The interface acts as a mediator between modern object-oriented code and legacy procedural functions, allowing new code to use standardized method calls while legacy functions remain unchanged, thus maintaining backwards compatibility while improving code consistency and readability

Inventive Principle:

Principle #24Intermediary (Mediator)

4Adaptability or versatility

If function calls are replaced with interface method calls, then code decoupling and flexibility are improved, but the initial code transformation complexity increases

Engineering Contradiction:

Improvecode flexibilityVSAvoidtransformation complexity

Core Design Contradiction:

Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The system segments the refactoring process into distinct phases: scanning to identify function calls and error handling code, analyzing dependencies, generating interface definitions, creating refactored code, and validating transformations. This segmentation makes the complex transformation process manageable and systematic, enabling code decoupling while controlling complexity

Inventive Principle:

Principle #1Segmentation

Data Source

PatentUS11288062B2Automatic source code refactoring

Publication Date: 2022.03.29 SAP SE

AI summary

Techniques and solutions are described for automatically refactoring code. In particular, disclosed technologies provide for automatically refactoring code that includes function calls, which can be to particular types of functions, such as external functions or functions that are not member functions of a class. For code to be refactored, an interface and a class are created. The class implements the interface. Method declarations corresponding to the function calls being refactored are added to the interface and the class. Code is added instantiating an object of the class. Implementations for the methods in the class can call the functions called by the source code being refactored, or can include code implementing the functionality of the called functions. Refactored code has function calls replaced with calls to corresponding methods of the interface.