Renaissance Methodology

Renaissance is a methodology for large-scale understanding, transformation, and modernization of complex, long-lived, multi-disciplinary software systems. Renaissance introduces a novel approach to software maintenance that leverages compiler technology, graph-based code analysis, and rule-based code transformation. It provides a systematic methodology that can be used without deep compiler expertise to extract comprehensive insights into their codebases and facilitate large-scale transformations. Key features include its adaptability to specific tasks and codebases.

Software analysis and understanding

Software engineers frequently analyze code dependencies across source files, make files, and configuration files from multiple codebases. Renaissance supports this process with a high-level graph database that can be queried, and the results can be visualized as customizable architectural diagrams. We leverage code graphs extracted via Renaissance to ground the responses of LLM-based code assistants, such as GitHub Copilot, in facts extracted from code.

Software transformation and modernization

Additionally, Renaissance allows the use of specific code patterns to identify and fix issues, including code smells, antipatterns, and outdated frameworks. This capability enables advanced code analysis and transformation, leading to significant code improvements that would otherwise be too costly or impractical to achieve.

How does it work?

The methodology, called Renaissance, leverages parser technology to analyze codebases, with a focus on static analysis and program transformation. It is designed to support automated and semi-automated software maintenance and evolution, especially for large, complex, multilingual, and long-lived codebases.

Parsing and Representation

Code is parsed into an Abstract Syntax Tree (AST), which provides a structured representation of the code’s syntax. The methodology currently supports C++, ADA, and IDL, with ongoing work to expand to more languages.

Pattern Matching and Information Extraction

AST matching is used to guide information extraction and code transformation. Patterns are defined using concrete syntax (the same language as the code), with placeholders for generic matching. This enables the extraction of custom information, such as middleware usage or architectural patterns, beyond standard code elements.

Code Graph Construction

Extracted information is stored in a code graph, which can be queried for analysis. The code graph supports architectural views, metrics, and visualization, helping users understand dependencies, structure, and progress in refactoring or migration projects.

Rule-Based Program Transformation

Transformation rules specify patterns to match and replace patterns. Rules can depend on each other and are applied recursively, enabling custom, scalable code modifications. This supports migrations, refactoring, and adaptation to new frameworks or languages.

Validation and Testing

Changes are validated for behavior preservation, often using regression tests rather than formal methods, due to the scale of industrial projects.

Human-Centered and Customizable

The methodology is designed to be human-centered, allowing customization of analysis, transformation, and visualization. It aims to reduce complexity for users by integrating LLMs for natural language query translation and providing plugins (e.g., for Visual Studio).

Integration with AI and Knowledge Graphs

Ongoing research explores expanding the code graph into a knowledge graph by linking code, execution traces, documentation, and models. Integration with generative AI is also being pursued to improve code restructuring and scenario-based testing.

Successful Stories

Repository splitting at Philips

Renaissance methodology was used to support Philips in splitting a large repository containing both real-time and non-real-time components for image processing. A code graph was extracted to visualize dependencies and identify violations of architectural rules, such as unwanted dependencies between imaging and workflow libraries. Metrics and heatmaps were used to track shared libraries and guide the decoupling process, helping to monitor project progress and prioritize refactoring areas.

Grounding GitHub Copilot’s answers with Code Graph

The methodology was integrated with GitHub Copilot to answer complex architectural questions that require system-level information across multiple repositories. A tool was developed to convert natural-language queries into Cypher queries for Neo4j, leveraging LLMs (GPT-4) and exposing the service to Copilot. This enabled Copilot to provide accurate answers about code structure and dependencies and to improve the usability of code graph data for developers.

Migration from Proprietary test framework to Google Test (Philips)

The methodology was used to support Philips in migrating from a proprietary test framework to Google Test within C++. Transformation recipes were defined using pattern matching and rule-based program transformation, automating the conversion of test cases and reducing human error. The migration improved maintainability and usability, with about 100 tests converted in under an hour, and eliminated the need for manual test declarations in header files.

Migration from C Motif UI framework to Python Tkinter (ASML)

ASML needed to migrate from a legacy C-based Motif UI framework to Python Tkinter due to end-of-life support. The methodology ensured idiomatic conversion to maintainable Python code by prioritizing transformation rules and recursively applying them. Validation was performed by converting and reusing test cases to confirm that behavior was preserved, resulting in an estimated 70% effort savings for ASML.