Frequently Asked Questions

This section features responses to common questions posted by systems engineers and software developers interested in PathMATE Extensibility. Many replies refer to elements outlined in the PathMATE Extensibility Overview section above.

1) Does the tool provide a means by which it can be extended/scripted to add functionality or to repeatedly perform a task in a specific way (automated)? If not, does it perform the necessary functions someone would need to output documents, presentations and reports and share information between the Architect/Requirements Developer/& product developer?

Yes. In the broad sense, virtually all of PathMATE is not only scriptable, but is also customizable. The Architect/Requirements Developer/ & Product developer use the same model repository (in RSM) for PIMs, so this is a direct sharing. Product Developer only information or “Non-PIM” elements like markings, instance data, and base mechanisms (and other platform specific elements) are kept separate from the PIMs so there is no sharing issue.

2) Is the programming language/extensibility capability easy to use? Is it GUI-based or text-based?

The capabilities are very easy to use, some are available as GUIs, some as text-based. It is difficult to treat the wide range of programming/extensibility capabilities as a single element (there are 11 different PathMATE-provided extensibility areas), the mainstream capabilities are all designed for ease of use and quick adoption. Many have both a GUI and direct-text access, including for instance, the Platform Independent Action Language (PAL) viewer/editor.

3) What scripting or API languages are supported (e.g., C++, C, Java, VB, VBscript, VB macros, etc.)? Does it follow "accepted" or standard language or GUI conventions (ex. C or VB-like)? Is a COM-based API provided?

To control the operation of PathMATE itself (transformations), standard external languages are supported, including Java, Ant scripting in Eclipse, and Windows Command line scripting. PathMATE tightly conforms to the standard Eclipse Extensibility Architecture. On the other hand, to extend the runtime behavior of system being developed, the user has the ability to change, extend, or create new: - PIM constructs - Marking data - Code generation templates - Base execution mechanisms

4) Are there libraries of common routines available or must everything be generated from scratch? Does your tool come with example of scripts?

PathMATE comes with complete Transformation Maps for generating high performance systems in C, C++, and Java. These Maps include a complete set of self optimizing code generation transformation rules/templates, portable and self trimming base mechanisms and project/makefile generation templates. There are several examples scripts provided in the documentation and sample models.

5) Are there helpful user groups/code sharing bulletin boards or knowledge repositories provided by the vendor or commonly available elsewhere such as user groups?

Yes. There are broad sets of online resources, facilities and infrastructures for Eclipse and the IBM Rational Software Platform, including for example: PathMATE/RSM! More significantly is the broad and growing base of users and customization developed by Raytheon itself. The base of general PathMATE modeling expertise at Raytheon is very valuable, as well as some of the specialized results of key research efforts, such as highly customized PathMATE deployments for real-time C++ (for radar scheduling, for example) and the many reusable PathMATE-compatible Rational PIMs.

6) Is the coding regular (i.e., consistent) ? (ex. in a Requirement Management tool's scripting language, for the same command, sometimes it will only work if you have one blank space between a command and an input, but other times it will only work if there are two spaces.... it is not documented, but it a is repeatable "feature")

Yes. The PathMATE environment has been evolved for over a decade, with 5+ years of use directly at Raytheon. The resulting PathMATE interactive and programmatic interfaces are not only "regular", but they are highly reliable.

7) Is the scripting/extension capability well documented?

Yes. Documentation is provided documentation in PDF form and in the PathMATE online help system in Eclipse.

8) Can you add an icon or menu item for your added functions/capabilities or must you always know how to call it from a command line? Can icons be animated with features such as flashing, sound, motion, etc.?

Yes. Icons and menus can be added. PathMATE functions can be invoked from menu items added through the RSM user extensibility facility. Within the PathMATE editor, custom platform models, transformation maps, transformations, and deployments are all represented (and distributed) via icons. However, PathMATE icons do not currently offer flashing or other animation features. Is this an important feature Pathfinder should consider adding?

9) Can a script/extension generated for one database/project be easily used in another database/project by the same user AND can it easily be made available to other users or are there a lot of steps that must be performed to use it elsewhere? (If it had to be "ported" into each program's "project" or each user's PC through a multi-step process, this would become tedious.)

Yes. It is easy to make custom platform models, transformation maps, transformation rules/template files, and execution base mechanisms available among wide populations of users operating on different models and/or platforms. The structural separation of Platform Independent information (PIM) for Platform Dependent information within PathMATE provides for a level of script/extension re-use not previously possible.

11) List some of the functions/capabilities of your most used/useful tools/extensions/scripts.

Please see the PathMATE Extensibility Overview, above, which includes many examples.

12) Is there an accessible command line interface to the tool for the purpose of execution and scheduling model operations (such as builds) or script files? Is it accessible from applications as well as from DOS batch files? What switches or other controls does it provide?

Yes - PathMATE has command line and Ant scripting access for both the Transformation Engine and Spotlight. Please see corresponding user guides for supported command line syntax.

13) Are the API, scripting language, and command line language consistent with each other and do they provide similar functionality?

Yes. They are all avenues to the same capabilities, and are consistent.

14) What types of model manipulation (e.g., creation, deletion, modification, access, traversing, etc.) can be performed with scripts, API's, or command line interfaces? What types of model information (e.g., element names, properties, stereotypes, relationships, sub-components, etc.) can be accessed and/or manipulated?

The PathMATE Transformation Engine language provides all forms of PIM manipulation (including creation, deletion, modification, access, traversal) and provides access to all PIM elements (including element names, properties, stereotypes, relationships, sub-components), supplemental element (such as diagram images, marking data, instance data). Please refer to the PathMATE Transformation Engine User Guide for details.

15) How do the scripts, API's, or command line interfaces handle/report errors? How are they debugged?

PathMATE provides a rich and convenient set of error reporting mechanisms. For all model checking or transformation related extensions errors, the console view lists the error encountered and the context. For action language exceptions, they are isted in the problems view with direct access to the actions themselves (one-click navigation to error source). In addition, Eclipse error markers are used to highlight action language errors direct in the PathMATE action language editing view pane.

16) What are the tool's capabilities for creating UML profiles, stereotypes, constraints, tags, or properties for model extension?

RSM has a rich set of capabilities for creating UML profiles, stereotypes, constraints, tags, and properties for model extension. This information is brought into the PathMATE transformation engine and is directly accessible to the transformation rules/templates - including user defined ones. In addition to this facility, the user can define their own PIM markings, also directly accessible to the transformation rules/templates.

17) Does your tool depend on a meta-modeling language? If yes, can the meta-model be modified by the user?

Yes - PathMATE is based on the UML 2.0 meta-model as defined in the Eclipse UML2 interface, as used in RSM. Some limited aspects of the information structure can be modified by the user (using Property elements and instance data).

18) If your tool supports automatic code generation, how may the code generation be customized (e.g., model attributes, rules, model compiler, etc.)?

The openness of PathMATE is focused on providing a range of ways for the user to control the ultimate implementation of their system. The PathMATE Extensibility Overview above shows the complete stack of elements and how they relate. Below are some key elements:

• The PIM itself: The model controls the platform-independent aspects of their system's behavior, including the PIM actions, as captured in action language.
• PIM Markings: In addition to PathMATE defined markings, the user can define and populate their own PIM markings, and access them from code generation rules/templates to change their generated code.
• Rules/Templates: The actual code generation rules/templates are provided in source form, for the user to customize, or for them to replace completely. Every character of the generated code comes directly from these templates.
• Base Mechanisms: The generated code relies on, calls, and in some cases inherits from the provided base mechanism. Full source is provided, allowing full customization.