Visual Expert for PowerBuilder
Find references (Impact Analysis)
Avoid regression bugs: if you need to change any item in your application (object, method, variable, table or column used...) Visual Expert can list all components related to this item. You can then evaluate the consequences of the change and avoid unexpected side effects.
For instance, you can ask for all datawindows or scripts using a given database column.
Document your code
With Visual Expert, generate a complete, customized and always up-to-date technical documentation of your PowerBuilder code. Easily transfer knowledge about your application.
Document the references and calls in your code.
Easily navigate between these using hyperlinks in the documentation.
Customize your documentation
- Select the details you wish to display. For example, for a Window, you can show or hide controls, functions and events code, attributes, items referenced by the window, impact analysis, etc.
- Adapt the documentation style by matching the colours and fonts to your company's visual identity.
Schedule your documentation
- Run automatically once a day/week/month or at a specific time.
- Free up resources by scheduling it when you're not using your computer. Update it and have it available when you need it.
- You can also generate the documentation from a Server to a shared location. Each team member will then get a fresh online documentation whenever needed.
See an example documentation here.
Explore and understand complex code
When maintaining large or complex PB applications, you may need to understand some code you’re not familiar with. In such cases, Visual Expert is the perfect companion for PowerBuilder:
With Visual Expert's treeview, explore the application structure, its components (PBLs, userobjects, windows, datawindows, menus...) and their dependencies.
With Visual Expert's code browser, navigate in your code like you never have before: any reference found in the code comes with a hyperlink to jump to the referenced item; tool tips appear with more information on the selected item.
Easily explore the code structure and components.
- View the structure of a complex object in a treeview. For instance, you can see the embedded controls, methods and variables of complex windows.
- Display the calls between objects or methods; see a cascade of successive calls.
- Check out the dependencies between PBLs, and see which objects of a PBL are calling objects located in other PBLs.
- See the references between objects or methods, and see the specific line in the code where each item is referenced.
- Review the dependencies between the PB code and the database (tables, columns or stored procedure used).
- List the external functions declared in PB and the DLL used by the application.
PB applications often rely on complex frameworks and ancestor libraries.
Understanding inheritance dependencies is key to mastering the inner workings of your application, or maintain your ancestor libraries.
Visual Expert lets you:
- Explore the inheritance hierarchy of Windows, Userobjects and Menus.
- Display inheritance hierarchy at function and event level.
- See which methods are simply inherited or extended.
- Find overridden events and functions of a given PB object.
Advanced string search
With large volumes of code, string searches often return too many results, making such searches tedious and unproductive. Visual Expert addresses this issue as follows:
- Use multiple criteria to reduce the search result
- Restrict search to comments only
- Restrict search to one or several object types
- Search for exact words, or words starting/ending with…
- Search with regular expressions
- Match cases
- Search into several PB targets at the same time
- Include any text files in the search (SQL, other source code, shell scripts, ascii..)
- Analyze the result with advanced exploration features
- Share results between team members (Shared project or export as Excel or HTML document).
Datawindow advanced features
As Datawindows are at the center of PowerBuilder applications,
Visual Expert provides specific features to better find and maintain them:
- List datawindows depending on their datasource (SQL, Stored Procedure, External).
- Find Datawindows referenced by a dynamic change of a “dataobject” property
- View DW used as Dropdown Datawindows
- Find DataWindows sharing the same buffer (Shared DW)
- Find Datawindows with columns calculated dynamically with expressions
- For a given DataWindow, display the mapping DW Columns / DB Columns
Integration with PowerBuilder
- Simply select a PB target and run the code analysis
- While exploring your code, you may find an object in VE that you wish to modify: you can then switch automatically to the PB IDE to edit it.
- You can also select several items, for instance after an impact analysis, and push them in the PB Todolist. You can then edit them in PB by opening them from the Todolist.
Dead code detection: finding and removing dead code improves the performance of your application and simplifies its maintenance. Visual Expert lists the items with no known dependencies (inheritance, reference, embedded objects…). These items are likely to be unused. Dead code detection includes objects, functions, events, properties, parameters or variables.
Duplicated components: If objects of the same type, with the same name, exist in a given target, PowerBuilder will only take into account the first and ignore the others; this may result in the application behaving unexpectedly. Visual Expert can automatically scan your code to find such duplicated components.
Code metrics: Visual Expert can produce some size and volumetry statistics about your code.
Empty methods: while maintaining an application, some methods may be temporarily commented or emptied from any source code. Visual Expert can track down such methods in case you wish to remove them and lighten up your code.
Team Work – Collaborative features
Team members can work together with Visual Expert on the same application:
- Visual Expert can run on a Server. Each team member then opens the same project from their desktop.
- The source code is analyzed on the server side once, for all users.
- All team members can explore the code at the same time.
- To share a result (after an impact analysis for instance), team members can share a Visual Expert view with other members.
- Team members can export and send Visual Expert views as an Excel or HTML file
Analyze multiple applications at the same time
Some systems are composed of several PB applications. These applications may share common resources (tables, stored procedures, dll, PB ancestor libraries…). In such cases, it makes sense to analyze all of them at the same time.
Visual Expert lets you:
- Include several applications at the same time
- Find references to common resources
- Search for strings across several applications
- Generate a documentation on multiple PB targets
Visual Expert supports very large volumes of code, especially when installed on a server with sufficient RAM and using a professional or enterprise versions of SQL Server.
Try Visual Expert
You save the knowledge about an application in a tool.
The knowledge remains available at all times, to every developer
and project leader.
Visual Expert automates Impact Analysis to avoid unexpected side effects may possibly be generated by a modification.
Up to 30 % of your developing efforts are reduced thanks to Visual Expert
A tool may be efficient still; it has to be used! It will take you less than an hour to install Visual Expert and to have a good grip on it.
Visual Expert for PowerBuilder detailed features
- Detailed Impact Analysis
This feature will list all the components related to a given object, method, variable, table, column...
You can use this feature before modifying the application: it will help checking the consequences of the change on the components related to the change.
In order to provide a complete result, the impact analysis includes all type of dependencies:
* PowerBuilder-to-database dependencies: any change in the DB Schema may affect the PowerBuilder components using the table or column modified. For instance, an Impact Analysis on a table gives you all Datawindows, Embedded SQL and Stored Procedures(1) calling this table.
You may filter the references depending on the access type (Select, Insert, Update Delete)
* PowerBuilder Inheritance dependencies: any change in a PowerBuilder object may affect its descendants.
Therefore, an impact analysis on a PB object will includes all its descendants.
* PB code references: An Impact analysis on a PB object, method or variable lists all the PB objects and methods calling it. Special PowerBuilder dependencies are also supported (e.g. the reference between a DataWindow Column and a DropDownDatawindow).
Impact analyses are also available for Global variables and functions as well as system properties and functions. The result contains all references to such variables or functions.
* PB-to-DB Code dependencies:
If your PowerBuilder application calls Stored Procedures, you can list these procedures:
- You can list all stored procedures called by each PBL of the application.
- You can list all stored procedures called by each object coming from a given PBL.
For each Stored procedure referenced by the PB code, you can perform an Impact Analysis.
As a result, you get all PowerBuilder object and functions of the application calling this Stored Procedure.
(1) If your application is also composed of PL/SQL Stored Procedures, Visual Expert analyses all references to tables and columns from these stored procedures.
See Visual Expert for Oracle for more details.
- Calling Hierarchy
List of all successive methods calling a function. The result is displayed in a treeview (e.g. function A is called by function B, itself called by function C, etc...).
- Called Hierarchy
List of all successive methods called by a function. The result is displayed in a treeview (e.g. function A calls function B, which itself calls function C, etc...). You may use this feature when you need to understand a complete process in the application. (For instance, which functions are executed after the user has triggered a specific event?).
- Opening Hierarchy
List of all successive windows or menus opened in the project.
As a result, you get a treeview representing the navigation paths in the application (from Windows to Windows and from Menus to Windows).
- General Architecture
Detailed architecture of an object (treeview of all controls, functions, events and variables composing the object).
- Control Architecture
You may list all variables and parameters referenced in packages, procedures, functions, block, triggers or cursors.
- PowerBuilder Components
After analysing your project, Visual Expert can list in a treeview:
* The PBL included in the application and the components of each PBL
* The PowerBuilder object - by type - included in the application (all the DW of the project for instance).
* The controls, functions, events, attributes, variables, parameters defined in a PowerBuilder object.
While exploring the code in the treeview, you can also display:
* The container of the selected item (for example, the PBL containing an object, the object containing a control, the control containing an event or the event containing a local variable,...)
* The container hierarchy (the list of all successive containers of an item). For instance, the container hierarchy of an event may display the Control/Objet/PBL/Project where this event was defined.
You may display in the treeview some information about menu objects:
* The complete hierarchy of the menu options defined in a menu object.
* Same hierarchy, plus all events defined for each menu item.
- Database Components
While analyzing your code, Visual Expert will find all references to database items.
Therefore, you can list in the treeview:
* The database tables referenced by the PowerBuilder code (both from Datawindows and embedded SQL)
* For each table found, you may list the columns referenced by the PowerBuilder code.
* The stored procedures called by the PowerBuilder code (both from Datawindows and PB scripts)
If your application is also composed of DB code (PL/SQL or Transact-SQL), Visual Expert finds all references to tables, columns and stored procedures from this DB code.
See Visual Expert for Oracle pages for more details.
You can have a global overview of your project (PowerBuilder + DB code) by installing the appropriate versions of Visual expert on the same machine. For instance, if your application is composed of PB code and Oracle stored procedures, you may combine Visual Expert for PowerBuilder and Visual Expert for Oracle on the same PC.
- SQL Queries
After analysing your project, Visual expert may display several lists of Procedure:
* SQL statements defined in the application
* SQL statements containing a given string (text search focused on the SQL statements of the project).
* SQL statements by access type (select, insert, update or delete Statements)
* SQL statements by definition type (defined in PowerBuilder Script, Datawindow or PL/SQL code(1) ).
(1) requires Visual Expert for Oracle
- Inheritance dépendencies
Visual Expert analyses all inheritance dependencies. As a result, you can display:
* The direct descendants (childs) of a PowerBuilder object
* The descendant hierarchy (multi-level treeview of all successive descendants objects). For instance, you can get the complete inheritance hierarchy of your application, including Framework and business objects.
* The direct ancestor of a PowerBuilder object
* The complete ancestor list of an object (all successive ancestors of a given object).
When an object is inherited, the scripts defined in this objects may be modified in the descendant Object.
In such a situation, Visual Expert keeps track of the "inheritance" relationship between the "ancestor" and the "descendant" script.
- String search
You may search for a string in your project. Several options are available:
* Global Search in the whole project (including PowerBuilder Code, PL/SQL, SQL files, ...)
* Search restricted to a given type of component (For instance, you may search in windows only).
* You may search in the name and/or the source code of components.
* You use regular expressions in a search (click here to read about regular expressions)
* You may search into a selection of components (for instance after selecting some procedures in the treeview).
- Dll Calls
While analyzing your PowerBuilder code, Visual Expert will find all referencies to dll functions.
As a result, you can list in the treeview:
* The dll used by the application
* For a given dll, which dll functions are declared in the PowerBuilder code
* For a given dll, which PowerBuilder objects are declaring the dll functions
* For each dll function declared in PowerBuilder, all PowerBuilder references to this dll function
(Impact analysis in the PowerBuilder application on a dll function).
- System and Application Globals
* List of the Global variables declared in the PowerBuilder application (name+number of calls to each variable)
* List of the Global functions defined in the PowerBuilder application (name+number of calls to each function)
* List of the system properties referenced in the PowerBuilder code (e.g. visible, title, with...)
* List of the system functions referenced in the PowerBuilder code (e.g. close, opensheet, setpointer...)
Displays a graphical preview of a PowerBuilder Visual Object (Window, DataWindow, Visual UserObject). This preview helps understanding the application while browsing in the code. You can also locate any control displayed in the preview. As a result, Visual Expert opens the treeview where the control is defined.
- Dead Code (Unused items)
* List of the Windows, OserObjects, DataWindows, Menus, ... not referenced/used in the application.
* List of the functions, events and global functions not referenced/used in the application.
* List of the attributes, global variables, parameters not referenced/used in the application.
* List of the dlls and dll functions declared, but not called in the application.
- Duplicated components
Searches for components with the same object name and same type in your project.
Use this feature to locate an object, method or variable in your project (i.e. where is this item created/declared in your project?). As a result, the treeview opens on the definition
- DropDown Datawindow
Lists all Datawindows used as Dropdown Datawindows in your project
- Dynamic Datawindow
Lists all Datawindows referenced dynamically in the PB code (e.g. Control.DataObject = "<DataWindow name>")
- PBL Statistics
Statistics about the size and content of the PowerBuilder Libraries (PBLs)
- Large PBL
PBL containing a determined amount of bytes