How Open‑Source Tools Are Revolutionizing Legacy System Modernization

Motivation for Open‑Source Legacy Modernization Tools

Legacy systems are common; developers need automated tools to surface hidden technical debt, clarify ownership, and provide actionable refactoring guidance.

Desired Tool Characteristics

Visualization‑driven : generate metrics, dependency graphs, and property charts that can be exported for reporting.

Interactive : allow developers to locate refactoring entry points directly from the analysis.

Customizable : detect language‑specific smells not covered by generic static analysers, perform automated refactoring, balance syntax precision against development cost, and run on macOS and Windows.

Architecture of a Modernization Toolkit

The toolkit is composed of four layers:

Syntax analysis : parse source code into language‑specific ASTs using Antlr, Ctags, TreeSitter, Doxygen, or CodeQuery.

Result visualization : render numeric metrics, dependency graphs (PlantUML, Graphviz, D3.js, Echarts) and code‑property charts (modification frequency, file size, etc.).

Automated refactoring (optional) : apply transformations such as removing unused classes across repositories, clustering modules, or refactoring CSS colors.

Architecture guard : enforce architectural constraints with ArchUnit, ArchGuard, or a custom DSL (Guarding).

Syntax Analysis

Typical parsers:

Antlr – full‑featured grammar support.

Ctags – fast symbol extraction.

TreeSitter – incremental parsing for editors.

Doxygen – documentation‑driven extraction.

CodeQuery – SQLite‑backed code search.

Result Visualization

Common visualizations:

Numeric metrics (e.g., smell counts, test coverage).

Dependency graphs using PlantUML, Graphviz, D3.js, or Echarts.

Code‑property charts such as file modification frequency and size.

Automated Refactoring

Typical use cases:

Delete unused classes across multiple codebases.

Cluster related modules.

Refactor CSS color definitions.

Architecture Guard

Define guard rules to prevent violations of layered architecture, cyclic dependencies, or forbidden imports. Implementations include ArchUnit (Java), ArchGuard, and the Rust‑based Guarding DSL built on TreeSitter.

Implemented Tools (Modernizing Organization)

Single‑language tools:

Coca (Java, ★691) – Antlr‑based full‑feature refactoring tool with call‑graph analysis, visualization, and automated refactoring.

Lemonj (TypeScript, ★128) – Parses CSS/LESS with Antlr to extract color definitions and perform automated color refactoring.

SQLing (Go) – Uses PingCAP’s SQL parser to analyze MySQL code, generate UML diagrams, and support PL/SQL.

Merry (Go + Antlr) – Semi‑automatic migration from Ant build files to Maven.

Clij (TypeScript) – Front‑end standardization tool that adds eslint, husky, lint‑staged, etc.

Multi‑language tools:

Chapi (Kotlin) – Antlr‑based language‑model analysis that produces the same data structures as Coca for cross‑language visualizations.

Tequila (Go) – Doxygen‑driven analysis and visualization for multiple languages.

Modeling (Rust) – Ctags‑based source analysis that generates model‑driven dependency visualizations.

Guarding (Rust) – TreeSitter‑based architecture guard with a custom DSL.

Future Direction

Current tools emit heterogeneous data formats, making unified visualization difficult. The goal is to define a common output schema and build a pipeline architecture (pipes + filters) so that downstream visualizers—e.g., the CodeCity metaverse visualizer—can consume data from any tool.

Source code and releases are hosted at https://github.com/modernizing