In the context of IBM i RDi (Rational Developer for i), X Analysis typically refers to:

🔍 X-Analysis by Fresche Solutions

X-Analysis is a code analysis and application understanding tool used within the IBM i (AS/400) environment. It integrates with RDi and provides powerful capabilities for:

✅ Key Features of X-Analysis:

1. Impact Analysis

   • Find where a field, file, or program is used across the application.

   • Visualizes how changes will affect other components.

2. Cross-Referencing

   • Locate usage of files, fields, variables, procedures, etc.

   • Trace relationships across RPG, COBOL, CL, DDS, and SQL code.

3. Data Flow and Call Diagrams

   • Generate graphical flow diagrams to understand program logic.

   • See call stacks and dependencies in a visual tree or chart.

4. Modernization Support

   • Helps convert legacy code (RPG/400) into Free Format RPG.

   • Identify dead code, unused variables, and code that can be refactored.

5. Documentation Generation

   • Automatically generate technical documentation.

   • Provides flowcharts and reports for business rules, logic, and more.

6. Security and Code Quality Audits

   • Analyze code against best practices and security standards.

7. Integration with RDi

   • Seamlessly integrates into the RDi IDE.

   • Developers can access X-Analysis insights from within their development environment.

🏢 Who Uses X-Analysis?

• IBM i shops with large legacy systems that need better understanding and control.

• Teams working on modernization projects or system audits.

• Developers needing faster onboarding into large or undocumented systems.

📦 X-Analysis Products

Fresche offers various editions:

• X-Analysis View: Lite version with core features.

• X-Analysis Advisor: For modernization and analysis.

• X-Analysis Developer: Full suite for in-depth code analysis.

📝 Summary

X-Analysis is a critical tool for IBM i developers and architects when:

• Maintaining complex legacy codebases.

• Planning refactoring or modernization.

• Performing impact analysis before changes.

• Gaining visibility into undocumented systems.

Here’s a practical example of how X-Analysis helps in impact analysis and automatic documentation for IBM i (AS/400) systems:

✅ 1. Impact Analysis Example

🔧 Scenario:

You need to modify a field called CUSTNUM in a database file (CUSTOMER)—maybe change its length or type.

Without X-Analysis:

• You would manually search through all RPG, CL, COBOL, SQL, DDS, etc., code for references.

• Risk of missing indirect or dynamic references.

• High chance of introducing bugs or breaking dependencies.

With X-Analysis:

You:

1. Open X-Analysis in RDi.

2. Search for field CUSTNUM.

3. Instantly see:

   • All programs, procedures, and files that reference CUSTNUM.

   • Whether it’s read, written, or modified.

   • Its data flow from input to output.

4. Optionally generate a graphical diagram showing upstream and downstream impacts.

✅ Result: You know exactly what code will break or need testing. Changes are safer, faster, and traceable.

✅ 2. Documentation Example

🔧 Scenario:

You have a 20-year-old RPG program with no documentation and the original developers are gone.

With X-Analysis:

You can:

1. Feed the program into X-Analysis.

2. Automatically generate:

   • A call tree (what this program calls and is called by).

   • A flowchart showing internal logic (IFs, DOs, etc.).

   • A data usage report (files, fields, and variables used).

   • A field-level report for input/output fields.

✅ Result: Instant documentation that can be exported as PDFs, HTML, or Word files—great for audits, handover, or modernization.

📊 Visual Output

• Impact Diagrams: Arrows and boxes showing object relationships.

• Flowcharts: Step-by-step logical view of code execution.

• Data Flow Diagrams: Tracks where data goes throughout the system.

• Field Usage Maps: From database to screen and back.

Here’s a visual preview of how X‑Analysis (version 11.1) provides rich visual analysis within RDi and Eclipse—featuring impact diagrams, flowcharts, data model views, and more. It shows how objects and code structures are graphically displayed and navigable for easier analysis.

X‑Analysis in Action: What the Visuals Reveal

The screenshot above captures several key elements:

• Work with Objects / Object Where Used: Lists objects (e.g., files, programs) and enables drilling down to see where each is referenced (Fresche Solutions).

• Graphical Diagrams: Visualization of program relationships, structure charts, data flows, and call hierarchies that help understand dependencies intuitively (Fresche Solutions).

• Documentation Wizard: A guided interface for generating system documentation in PDF, Word, or Visio format complete with diagrams and annotations (Fresche Solutions).

Deeper Analysis & Documentation Features

1. Automated Impact Analysis & Cross‑Referencing

• Search any object—file, program, variable—and instantly view where and how it's used across the application (Fresche Solutions).

• Supports multi-level drill-down, so you can trace down into field references or individual code lines.

2. Graphical Diagrams for System Understanding

• Structure Charts (SCD): Illustrate program-to-program relationships visually in hierarchy form (Fresche Solutions).

• Data Flow Diagrams (DFD): Show how data moves through the application logic, including file and variable usage (Fresche Solutions).

• Data Model Diagrams (DMD): Automatically generated diagrams that visualize relationships among database files, including foreign keys and data structure hierarchies (Fresche Solutions).

3. Documentation Manager & Export Capabilities

• Flag desired objects for inclusion, configure output settings, and generate structured documentation—complete with diagrams—via a wizard interface (Fresche Solutions).

• Outputs can be exported to PDF, Word (DOCX), Excel, or Visio for external sharing or review (Fresche Solutions).

The Value of X‑Analysis

Accelerated Modernization & Maintenance

• Quickly understand complex legacy systems through autogenerated maps and diagrams, reducing manual code exploration (IT Jungle).

• Identify critical change dependencies and hidden risks before beginning any update (IT Jungle).

Enhanced Documentation and Clarity

• Create audit-ready documentation and actionable system intelligence without manual effort (Fresche Solutions, Proximity).

• Graphical views make technical designs accessible to non-RPG/COBOL experts—like business analysts or QA teams (Fresche Solutions, Proximity).

Better Than Traditional Tools

• Unlike older green-screen cross-reference or documentation tools, X‑Analysis offers interactive, repository-based analysis with rich diagrams (Fresche Solutions).

• It supports industry-standard modeling (e.g., UML, DFD, ERD) and deep analysis down to variable-level relationships, offering comprehensive coverage unmatched by legacy tools (Fresche Solutions).

Summary Table

Great — here’s a step-by-step walkthrough of how you'd use X-Analysis within RDi for a real-world task, such as tracing a field and generating documentation.

✅ Scenario: Perform Impact Analysis on a Field

Let’s say you want to analyze the field CUSTNUM from file CUSTOMER.

🔄 Step-by-Step:

🔹 Step 1: Launch RDi

• Open Rational Developer for i (RDi).

• Ensure the X-Analysis plugin is installed and connected to your IBM i system.

🔹 Step 2: Open X-Analysis Perspective

• In RDi, go to Window → Perspective → Open Perspective → Other...

• Select X-Analysis to switch views.

🔹 Step 3: Use “Where Used” Feature

• Open Object Where Used tool from the X-Analysis toolbar.

• Enter object name: CUSTNUM

• Select type: Field

• Choose library: MYLIB or relevant library.

• Run the search.

🔹 Step 4: View Results

• You'll get a full cross-reference list showing:

  • Programs, display files, CLs using the field

  • Type of usage: read, update, display, etc.

• You can double-click on any item to jump directly to the code.

🔹 Step 5: Generate Impact Diagram

• Right-click on the field in the result pane.

• Select Show Impact Diagram or Data Flow Diagram.

• A visual tree appears showing how data flows from or to this field across multiple programs and layers.

📄 Scenario: Generate Technical Documentation

Let’s say you want to document the program ORDRPGM and its dependencies.

📘 Step-by-Step:

🔹 Step 1: Open Documentation Wizard

• In RDi’s X-Analysis view, go to Tools → Documentation Manager.

🔹 Step 2: Select Object(s)

• Use the search to find your program (ORDRPGM).

• Optionally include related files and called programs.

🔹 Step 3: Choose Output Format

• Choose formats like PDF, Word, Excel, or Visio.

• Select whether to include:

  • Call hierarchy

  • File and field usage

  • Source listing

  • Flowchart/structure chart

🔹 Step 4: Generate & Export

• Click Generate.

• Documentation is compiled and saved in your chosen location.

✅ Results You’ll Get

• A visual impact map that helps you decide what else to test or change.

• Fully documented program flow that helps with onboarding, audits, or modernization.

• Time saved by avoiding manual code tracing or analysis.