Guillaume Finance

This article is a preview of Enterprise Architect 16 beta (build 1600) which is available to download with your registered account (if you own an active license) from www.sparxsystems.com.

Covered features and enhancements:

• Enterprise Architect 64 bits
• New QEA/QEAx file-based repositories
• Native connection to DBMS repositories
• XEA new exchange format
• JavaScript support
• User interface improvements

Enterprise Architect 64 bits

Sparx Systems has released its first 64-bit version of Enterprise Architect to provide increased performances and support larger data sets: increased efficiency in processing larger XMI import/export or report generation tasks, saving or exporting larger diagram, run bigger simulations, etc.
It is possible to install both 32- and 64-bits versions on the same computer, respectively in C:\Program Files (x86)\Sparx Systems\EA and C:\Program Files\Sparx Systems\EA.

Add-ins/extensions support

In the Specialize menu, I noticed that none of the add-ins were available with Enterprise Architect 64 bits. The manage add-ins window was empty:

With some investigations, I identified a way to fix this for my add-in eaUtils (built with .Net C#).

• Step 1: build the add-in with the x86 platform (32 bits), and then repeat the build with the x64 platform (64 bits). As a result, each DLL is available from a separate folder and registered in the respective COM.
• Step 2: add the 64 bits version of the add-in in the Windows Registry as explained here:

When opening the 32 bits version of Enterprise Architect, it reads the Windows registry to load the installed add-ins under \HKEY_CURRENT_USER\SOFTWARE\Sparx Systems\EAAddins.

I noticed a new entry to store all options and settings for the 64-bits version of Enterprise Architect: HKEY_CURRENT_USER\SOFTWARE\Sparx Systems\EA64. So, I gave it a try, created HKEY_CURRENT_USER\SOFTWARE\Sparx Systems\EAAddins64, and copied my add-in details.

 Opening Enterprise Architect 16 64 bits, it worked!

Model Repositories

New file-based repositories with QEA and QEAx files

Until then, local Enterprise Architect projects have involved files using the EAP or EAPx extension. These are Jet Engine databases that can be opened using Ms Access.

Enterprise Architect 16 introduces the new QEA and QEAx extensions, backed by SQLite. 

It remains possible to open existing EAPx files with EA 16 (Jet Engine v4) contrary to older EAP files that use a previous Jet Engine version. When an EAP file is opened in EA 16, there’s an Access error message followed by the prompt below:

A window is opened to copy your local project to a new QEA/QEAx local file or an existing centralized database.

This feature is available from the Settings > Transfer menu, where additional Project Transfer options are available:

Simplified access to DBMS repositories

When users share access to a common Enterprise Architect repository hosted on a DBMS such as MySQL (or any other supported server), they can either open the project using a URL for the Pro Cloud Server http/https gateway, or an ODBC data source. In the latter case, the following configuration is required:

• Install the ODBC driver for the chosen DBMS e.g., MySQL.
• Create an ODBC data source (DSN) with the custom configuration to access the EA repository as per Enterprise Architect user guide.
• Open a project using “Server Connection” and select the DSN.

Enterprise Architect 16 introduces a new native connection as a simplified alternative to the ODBC connection. This is a very useful enhancement as custom ODBC drivers and DSN are longer required to be setup on each user’s PC since DBMS drivers are now distributed with Enterprise Architect.

Note: Current ODBC settings can still be used with Enterprise Architect 16.

The native connection simplifies the access to a centralized database repository. As illustrated below, I simply had to select the DBMS (PostgreSQL), and provide the database server details and credentials. Once the Test is successful, the connection can be opened.

New exchange format: native XEA

XMI (XML Metadata Interchange) files is a convenient way to exchange models via Enterprise Architect export/import XMI features. With Enterprise Architect 15, the Native XML format was introduced as an alternative to the Project Transfer by exporting the entire DB content to XML files matching EA tables content (one of the advantage is that it's compatible with the Pro Cloud Server). Enterprise Architect 16 adds a new XEA format that “helps to streamline model archiving and the export and import of Enterprise Architect repositories”.

In the Publish menu, the Export Package includes XEA as an alternative to XMI: 

Looking at the content of the generated XEA file, it’s an SQLite database with the data matching the exported package.

The XMI export involves a conversion process (DB to XML) which can be time consuming for large models. Hence moving the export to a file-based SQLite makes sense as it involves a direct DB data extraction.

Scripting: JavaScript support

JavaScript is the new default scripting language that Sparx Systems recommends using with Enterprise Architect 16. Built-in libraries until then available for VBScript and JScript are now available for JavaScript.

Enterprise Architect is using Mozilla Spider Monkey JavaScript engine. Like JScript, JavaScript has the advantage to be object-oriented. Here is an example based on Sparx Systems Logging script after replacing the functions by a Logger “class”:

const LOGLEVEL_ERROR = 0;
const LOGLEVEL_INFO = 1;
const LOGLEVEL_WARNING = 2;
const LOGLEVEL_DEBUG = 3;
const LOGLEVEL_TRACE = 4;
class Logger {
        constructor(logLevel) {
                this.logLevel = logLevel;
        }
        get Level() {
                return this.logLevel;
        }
        Clear() {
                Repository.ClearOutput("Script");
        }
        LOGError(message) {
                if (this.logLevel >= LOGLEVEL_ERROR)
                        Session.Output( this.DisplayDate() + " [ERROR]: " + message );
        }
        LOGDebug(message) {
                if (this.logLevel >= LOGLEVEL_DEBUG)
                        Session.Output( this.DisplayDate() + " [DEBUG]: " + message );
        }
        LOGInfo(message) {
                if (this.logLevel >= LOGLEVEL_INFO )
                        Session.Output( this.DisplayDate() + " [INFO]: " + message );
        }
        DisplayDate() {
                var now = new Date();
                var hours = now.getHours();
                if ( hours < 10 )
                        hours = "0" + hours;
                var minutes = now.getMinutes();
                if ( minutes < 10 )
                        minutes = "0" + minutes;
                var seconds = now.getSeconds();
                if ( seconds < 10 )
                        seconds = "0" + seconds;
                var displayDate = now.getFullYear() + "-" + (now.getMonth() + 1) + "-" + now.getDate();
                displayDate += " " + hours + ":" + minutes + ":" + seconds;
                return displayDate;
        }
}

Here is an example of how it is called from a JavaScript script:

var log = new Logger(LOGLEVEL_INFO);
log.Clear();

A JavaScript console is available to help with building and testing a script.

User Interface

Here are the main UI enhancements I identified so far with Enterprise Architect 16 beta.

Quick Access toolbar

A new Quick Access toolbar is available. As experienced with common Microsoft applications such as Word or Excel, this is a very handy feature.

• Right click on a menu from the ribbon to add the menu (e.g. Package Matrix).

• Result: the package matrix is available from the Quick Access toolbar.

• - It is possible to move this toolbar below the ribbon menu.

Refreshing Diagrams

For a more streamlined use in a collaborative environment, Enterprise Architect 16 provides two new options:

1- Auto-Refresh diagram

This feature is intended to collaborate and co-edit the same diagram e.g. during a workshop involving remote peers.

• A first user enables the collaboration on the diagram via the Collaborate menu.

• Once saved, the diagram is locked so no one can edit it.
• A second user would like to carry updates: to get an exclusive edit lock, the Pause & Edit collaborative option must be selected.
• Whenever this user saves the diagram (Ctrl + S), these changes are automatically updated and visible for all users within a few seconds.
• The edit lock can be released by choosing the Resume collaborative option.

2- Auto-Reload diagrams

Working on a shared model repository, when one updates and saves a diagram, other users with this active diagram are notified to reload this diagram.

Message when the diagram hasn’t been modified:

Message when the diagram has been modified locally:

A new option is available for all diagrams under the menu Layout > Diagram > Options > Auto Reload Changed Diagrams. Purpose: “Set Enterprise Architect to reload any diagrams you have open when there are changes made by others working in the same model at the same time”.

This option reloads more transparently the opened diagrams (without any prompt window).

Other UI enhancements

This new feature is one of my favourites; Notes, hyperlinks, text elements, boundaries are now visible in the project browser under a specific blue sub-package named “{ }”. This is very handy as such elements have been hidden until then and workarounds with scripts or others means were required to manage them.

Here are some of the advantages from this feature:

• Running a Find in Browser on a selected notes, boundary or text element from a diagram now selects it in the project browser to see in which package it is located. It can easily be moved to a different package.
• This visibility makes it possible to set up a diagram navigation and appropriately reuse text elements i.e. a single title text element can be updated once and propagated in all diagrams.
• When exporting a package, one can check that all elements are included.

The start page has tabs to easily access the Create from Pattern, Add Diagram and Guidance:

The order of fields on the Model Search has been changed: it starts with the search criteria.

About Enterprise Architect Native XML Project Transfer

Native XML Project Transfer is a feature introduced in Enterprise Architect 15.1. Until then a full project could be transferred via Enterprise Architect Project Transfer between databases (from and to a local EAP file and/or a DBMS).

Enterprise Architect Native XML involves a two-step process:

1. Export the source project: generated in the selected target folder, XML files match each Enterprise Architect DB table (e.g. t_attribute, t_object) and contain data in the XML format.
2. Import the XML files and overwrite the target project.

Important: Native XML is different from the XMI import/export since it supports the entire project data, whereas the XMI only exports the model information (e.g. packages, elements, and diagrams) to be exchanged between EA projects or with other modelling tools.

Native XML advantages:

• Compared with the Project Transfer function, a connection to the source and/or target database is no longer needed.
  • This is convenient to load a project on a Cloud-hosted project (e.g. in AWS or Ms Azure) by transferring files and run an import.
• Available on an http/https “Cloud Connection” via the Pro Cloud Server.
• Provides a convenient full backup function.
• Unnecessary data can be easily removed by deleting the XML file(s) matching a table (e.g. t_document.xml).

Description

EAPostgresImportfromNativeXML is a specific third-party solution for Sparx Systems Enterprise Architect modelling tool.

Goals:

• Import a Native XML into a PostgreSQL database from a command-line prompt or via a CMD batch file, instead of opening Enterprise Architect.
• Deliver better performances with a reduced execution time, especially relevant for very large model repositories.

This solution can be useful for a publication process involving transferring the work model repository to a publication database, dedicated for end users via Prolaborate; a batch file can be configured in this case with Windows Task Scheduler to run the transfer on a nightly basis.

You can contact me via email (guillaume [at] umlchannel.com) to obtain a copy of EAPostgresImportfromNativeXML.

Notes:

• Requires .NET Core 3.1 or greater.
  • If it is not installed yet, you need to download Microsoft NET Core 3.1 Runtime Windows x64 Installer (or greater) from the following link: dotnet.microsoft.com/download
• This project uses Npgsql C# library (www.npgsql.org).
• The target PostgreSQL database must have an existing Enterprise Architect Project i.e. the SQL scripts available from Sparx Systems must have been run and an initial project loaded.

Initial Setup Instructions

• Extract the zip file e.g. in C:\EAProjectTransfer.

• Open the source EA project and run the Native XML Export (Configure > Transfer menu) to a target folder.
• Example with C:\EAProjectTransfer\nativeXML:

• Result for Sparx Systems "EAExample" project:

• Create a text file with details of the target Postgres database.
  
  • An Enterprise Architect repository must be running on this Postgres database.
  • WARNING: ALL THE DATA WILL BE DELETED ON THE TARGET DATABASE BEFORE RUNNING THE TRANSFER.
  • The text file must contain the following details, separated by semi-colons:
    • Database server IP address or name;
    • Postgres Port number;
    • Database name;
    • Username;
    • Password;
  • Example
    • Create dbdetails.txt text file in C:\EAProjectTransfer folder with the following content: localhost;5432;test_db;postgres;admin

Running the Native XML to Postgres EA database full project transfer

• Open the command line prompt (cmd).
• Go to the active folder e.g. cd C:\EAProjectTransfer.
• Run dotnet –version to check if .NET Core is installed.

• Running dotnet EAPostgresImportfromNativeXML.dll will display the following instructions.

• EAPostgresImportfromNativeXML tool takes 2 or 3 parameters:
  • Parameter 1: full path to the text file that contains the database details (see previous instructions).
    • e.g. C:\EAProjectTransfer\dbdetails.txt.
  • Paramètre 2: path to the folder with the Native XML files generated by Enterprise Architect.
    • e.g. "C:\EAProjectTransfer\nativeXML"
  • Optional parameter 3: when the value skipwarning is provided, it skips the warning prompt before clearing data from the target Postgres database.
• Example to run the import to a target database as per the dbdetails.txt file and using XML files from C:\EAProjectTransfer\nativeXML:
  • dotnet EAPostgresImportfromNativeXML.dll C:\EAProjectTransfer\dbdetails.txt C:\EAProjectTransfer\nativeXML
  • An executable file is also available:
    • EAPostgresImportfromNativeXML.exe C:\EAProjectTransfer\dbdetails.txt "C:\EAProjectTransfer\nativeXML"
  • Here is an illustration of the main steps executed by EAPostgresImportfromNativeXML.
    • Parameters and the db details file content are checked.
    • A connection with the Postgres database is established.
    • If the database is missing one or several Enterprise Architect tables such as t_object, an error message displays all the missing tables.

• When all the native XML files are processed, the number of resulting INSERT queries is shown (no query has yet been executed on the target DB).

• Press "Enter" to confirm DELETING ALL DATA from the target DB Enterprise Architect tables and load the data from the XML files.
  • Note this step is skipped when skipwarning parameter is provided.

• Data is deleted from each Enterprise Architect table (e.g. DELETE from t_object, etc.).
• The INSERT queries are executed to populate the database.
• Finally, the elapsed time in milliseconds is displayed and the project can be opened using the target database.
  • Transferring the "EAExample" project to a local Postgres DB took 40 seconds (note: it includes the time to confirm the prompt message).

 Contact: guillaume [at] umlchannel.com.

eaUtils 1.19.6 introduces a new feature to compare diagrams.

Native feature in Enterprise Architect

Enterprise Architect provides a baseline comparison tool to compare the current state of the model in the database with a "baseline" i.e. an XMI export of a model branch. This is relevant and convenient to compare the model with an older state when snapsnots (baselines) are available.

For more information, search for model baseline in Enterprise Architect User Guide.

Alternative approach with eaUtils

eaUtils Compare Diagrams feature provides a different approach by running a comparison on the content from 2 diagrams, to identify differences in terms of elements and connectors visible in each diagram.  

An Enterprise Architecture model built with ArchiMate (Open Group) illustrates the purpose in this article.

The following diagrams establish the current and future states of the organization's main applications flows i.e. before and after a planned migration to replace "Application 2" with "NewAPP A" and "NewAPP B" applications.

Current state with "Application 2":

Future state with "NewAPP A" and "NewAPP B":

Procedure to use eaUtils Compare Diagrams:

• Create a new diagram where eaUtils will be executed.
• Add a hyperlink for each diagram to compare (drag and drop each diagram and select Hyperlink).

• Set the hyperlinks alias values as follows:
  • Diagram 1 alias = eautils_compare_v1
  • Diagram 2 alias = eautils_compare_v2

• The setup is complete. Right click on this diagram and select Specialize > eaUtils > [Diagrams] Compare Diagrams
• The following window is opened with the status update:

• Note: an error is displayed if the diagram is not properly set up.

• Result: 
  • A diagram is generated with the elements and connectors from both diagrams.
  • Elements and connectors with the border line in RED were only found in Diagram 1 i.e. they can be considered as removed from Diagram 2.
  • Elements and connectors with the border line in GREEN were only found in Diagram 2 i.e. they can be considered as added in Diagram 2.
  • Other elements and connectors with the default border line were found in both diagrams (matching).
  • A legend is available.

"eaUtils Compare Results 20210412-190632" diagram:

• This diagram can be finalized and saved:

It is also possible to set a different colour from the default red and green. To do so, update each hyperlink font (text) colour e.g. diagram 1 = blue and diagram 2 = orange.

Running eaUtils Compare Diagrams feature generates the following result:

Click here to open a video demonstration (YouTube).

The latest version of eaUtils addin is available from the following link : www.eautils.com/download.

Prolaborate 3.4 has been released mid-February with new features and enhancements.

• Custom query-based properties applicable for the elements attributes view
  • Using Prolaborate Modelling Language form designer, Enterprise Architect fields such as the name, alias, notes... can be selected to define the available details for web users (e.g. on UML classes). This new feature supports custom properties based on queries to display details on a selected element that are not available via other tabs. Sub elements such as the list interfaces and ports for a component is an example of what can be rendered with this new feature.
• Diagram Editor
  • Prolaborate and Enterprise Architect are part of Sparx Systems complete modelling solution. With the latter needed to update diagrams, an optional link can be enabled on Prolaborate diagrams to be opened in Enterprise Architect for editing purposes. 
• Customize Prolaborate Log Paths
• New Dashboard Collaboration widget
  • This new widget is convenient to create discussions within a dashboard for a dedicated for a group of users.
• Improved JIRA integration

Custom query-based properties (Modelling Language Form Designer)

Available from Prolaborate Modelling Languages menu, the Form Designer is a useful feature to define a suitable view for relevant element types.

You may want to only show the name and notes of a UML class with custom labels "Entity" and "Description", as per the configuration below:

 The resulting view for a class is illustrated below (note: the entity is read-only as configured).

Introduced in Prolaborate 3.4, EA Custom Attributes can be created and used in the Form Designer to retrieve and display specific information for a given element.

SysML Block example: show sub elements (ports)

Let's start with a SysML block with the aim to show the list of ports, managed in EA as sub elements. An EA Custom Attribute is created with its query which has been defined and tested in Enterprise Architect (using the model search > SQL Scratch Pad).

Important notes:

• The query is specific to the model and the SQL syntax is defined according to the chosen DBMS (Postgres, MySQL, SQL Server...)
• As documented on Prolaborate site, the query is expected to return specific fields for Prolaborate to process:
  • Results are rendered within a single column showing the value of the "name".
  • The GUID and Basetype respectively make it possible to navigate to a listed element and show the icon.

The Form Designer is opened to customize SysML Blocks:

The Ports custom attribute has been added to the list of available fields for SysML blocks.

Result: details of the Coffee Machine SysML block below include the list of ports (name + port type if set). Note: this process could be repeated to show the block's parts.

ArchiMate Business Process example (show N+2 or greater linked elements)

Consider the following ArchiMate example with a business process served by a service, itself served by an application component.

Prolaborate Traceability view show the N+1 related elements e.g. the Goods Selling business service.

The aim with the Custom Attribute is to show the applications under the services serving a given business process. The result is illustrated below (see Clients CRM).

UML Class and Data Model example (use advanced mapping connectors information)

Enterprise Architect "Link to Element Feature" has been used in the following example to map attributes between a logical and a physical data model.

Clicking on the customers class, the Attribute Mapping list shows for each class attribute the matching DB table column, e.g. comments = customers.comments (line 1).

Further details are available from Prolaborate site.

Diagram Editor: open diagrams in Enterprise Architect from Prolaborate

Prolaborate is a convenient tool to collaborate with stakeholders and members of a project team. Everyone, including Enterprise Architect users, has a real-time access to the shared models.

Collected feedback on a diagram may impact its content. At this stage, someone needs to edit this diagram in Enterprise Architect. Instead of having to open the model and browse to the relevant diagram, Prolaborate provides a new link from the diagram:

Once clicked, a page shows 2 options.

• First the Diagram Editor application needs to be downloaded and installed.
• Once installed, clicking on Open Enterprise Architect prompts the user to open the Diagram Editor application (see below).
• This application launches Enterprise Architect with a Cloud Connexion to the active repository via the Pro Cloud Server, and opens the diagram.
  
  • Note: in order to use this feature, Enterprise Architect desktop application must be installed, and the Pro Cloud Server + repository must be available.

I personally find that it leads also to a simple and efficient invitation for Prolaborate users to move to Enterprise Architect modelling tool when needed. 

It would be useful to have a customizable field on this page to add a specific message, for instance to advise where to request Enterprise Architect installation if managed to the company IT support.

Customize Prolaborate Log Paths

Prolaborate log files are generated in different folders on the server. Until then, the path of some of these folders couldn't be modified. This can be an issue for a number of organizations with strict IT security rules e.g. to store log files on a dedicated location.

This was actually the case for one of my clients. Thank you Prolaborate team for implementing this feature request :) 

Through Prolaborate Service Management tool available on the server, the Location value illustrated below can be modified accordingly.

Note: Sparx Systems Pro Cloud Server log path can be configured via the LOGGING_DIRECTORY settings in the config file.

Dashboard Collaboration widget

Discussions can be created within the model and associated with an element or diagram.

Whilst diagram and element discussions are relevant for specific parts of the model, discussions can now be created within a dashboard. This can be useful for any member of a project team to collaborate, or discuss about reports, graphs published on the same dashboard.

JIRA Integration enhancements

Prolaborate can make the link between EA models and web project management and ticketing software such as JIRA or Ms Azure DevOps.

The integration with JIRA involves associating a JIRA project request type with an element type e.g. a class, use case, requirement, component... JIRA tickets can be associated in Prolaborate, resulting in new tagged values created against the element in EA (value = JIRA url).

The features and user interface have been improved with the release 3.4.

Associate a JIRA ticket with a UML class:

Select and associate an existing JIRA ticket with the class:

Create new JIRA tickets from Prolaborate, and associate them with the class:

If you own an active Prolaborate license, you can log in Sparx Systems registered users section to download the latest version.

Data Models generated by reverse engineering an existing Database in Enterprise Architect can be shared dynamically with Prolaborate web solution. This can be useful to provide access to an existing Physical Data Model or "work in progress" database redesign views, and gather feedback via Prolaborate collaborative features (discussions, reviews, etc.).

Sparx Enterprise Architect (EA) data models support tables and columns, views, stored procedures, functions from all major DBMS (SQL server, MySQL, Postgres, etc.). This is achieved with built-in stereotyped UML classes, attributes and operations.

When such information is shared outside Enterprise Architect tool, it is important to customize or hide unnecessary details for the target users.

Prolaborate Modeling Language feature is ideal to achieve this via custom profiles and a form designer. Built-in Prolaborate languages are available for UML, BPMN, or Archimate elements (SysML is available on request). If you use your own stereotypes, the MDG XML file used for Enterprise Architect can also be imported in Prolaborate. When it comes to Data Modelling, I found that Prolaborate doesn't currently support this definition. Since data models are built in EA, there isn't any MDG XML file available to manually import. Hence my only option was to recreate a Data Modelling MDG in EA solely for the purpose of configuring Prolaborate web solution.

Below is an illustration of how it works with Sparx EA Example project.

Note: this MDG definition has been submitted to Prolaborate team and will be available to download, before it is included in Prolaborate future releases. In the meantime you can contact me on guillaume[at]umlchannel.com to get a copy. 

Initial context

To illustrate the advantage of using Modelling Languages, the following screenshot shows how the details of a table is rendered in Prolaborate:

The default table element details are displayed with all tagged values. Not only some of these fields may not be relevant, but also note the field Type mentions that it's a Class; where this element is rightly a "table" stereotyped UML class, this information to an end user can be rather confusing!

The aim of installing and configuring the Data Model Modelling Language is to have the ability to manage the visible and hidden information amongst the element fields (e.g. name, notes, author, modified date, etc.) or custom tagged values, and rename their label when needed.

• Important: Prolaborate doesn't currently support customization of attributes and operations from a Modeling Language profile. Hence table columns and constraints cannot currently be customized.

Install the Data Model Modelling Language

• Once logged in, open Prolaborate Repository configuration, and select Modelling Languages

• Fill in the form, select the provided MDG Prolaborate EAUML.xml file, and click on Add Modeling Language

• The Data Model custom language is installed and ready to be configured.

Customize the users' views with profiles

Below is an illustration to customize the fields for a DB table.

• Click on Manage Profiles
• Create a new profile or edit the default one 

• The data model stereotypes are listed e.g. table, column, view, trigger, etc.
  • Note: the eye icon can be used to hide all elements under the selected stereotype to be hidden e.g. views and stored procedures.

• Open the form designer to customize the visible fields for a given stereotype e.g. table.

• The initial configuration is illustrated below.
  • The table name, notes, author and type (e.g. Class) are listed under the Basic Attributes.
  • All three tagged values are listed under EAUML::table Attributes

• These fields can removed, hidden, made read-only, or renamed. Other fields can be added (see the lists on the right hand side).
  • Notes:
    • The element's EA fields (e.g. name, notes, alias, etc.) can be freely mixed with tagged values, within any group.
    • The order can be updated as needed.
•  The example below matches the following configuration:
  • The fields' group titles have been renamed to Main Properties (from Basic Attributes) and Additional Properties (from EAUML::table Attributes).
  • The table name field is read-only and available against the label "Table name".
  • The table notes is visible against the "Description" label, and can be updated if the user has the write permission.
  • The Type field has been removed.
  • The Author field is not visible.
  • Only Tablespace and DBVersion tagged values are visible in read-only mode.

• Important - in theory, a table index constraint can be customised as illustrated here. However Modelling Language profiles are not yet supported by Prolaborate for attributes and operations (all columns and constraints remain visible). This is a possible enhancement for Prolaborate team to consider in a future release.

• The Profile can be saved.

Note: further details are available from Prolaborate online help.

User experience

Accessing the same physical data model, the displayed information matches the new table profile definition:

Sparx Systems has released Prolaborate 3.2 this summer with the following enhancements.

• Charts
  
  • ** Architecture Landscape: new chart dedicated for your Enterprise Architecture data.
  • Chart Designer: build your graphs with this step by step design tool (SQL queries can be used as an alternative to address complex issues).
• ** Relationships Matrices created in Enterprise Architect can be used with your web browser. 
• ** Excel-like spreadsheet interface: Bulk import and edit EA elements online + CSV download and upload.
• Integration
  • Ms Azure DevOps is now supported to create end to end links between items in EA and Azure DevOps (similar to the existing JIRA integration).
  • Public APIs introduced for custom Integration with Prolaborate.
• Multiple Active Directory domains supported for SSO

** Features detailed in this article.

Architecture Landscape charts

Architecture Landscape is a new chart available in Prolaborate. It provides a way to render any kind of architectural views on a single page.

In the example below, ArchiMate Business Actors are displayed under each assigned Business Role (roles are listed by type i.e. internal or external).

With this chart view, a single element can be rendered several times e.g. the "Distribution Department" actor is visible under "Delivery Driver" and "Logistic operator" roles, compared with the matching view in Enterprise Architect.

This chart has been created using the Chart Designer:

• The Business Roles package (model) must be selected.

• With the following setup, ArchiMate Business Roles are grouped by Alias value (Internal/External), and the elements names are shown (alternatives: tagged values, etc.).

• In the next group, the graph is looking for the actors assigned to each business role.

The resulting graph is dynamic i.e. a role can be selected to get the assigned actors within a report e.g. Retailer role -> Customer. Selecting an actor from this report provides access to its properties as per the Attributes zone illustrated below.

I tried a different scenario using my Prolaborate ArchiMate demo EA project with the aim to list all data flows between applications. In the following example, ArchiMate flows have been defined between application components, and ArchiMate Data Objects (e.g. Data1, Data2) have been associated as "conveyed items".

The required details from EA require to define the chart using custom SQL queries instead of the Chart Designer.

Relationships matrix

Relationships matrix is a very useful Enterprise Architect feature to visualize, understand and update relations between elements. The following matrix illustrates business actor assignments with roles.

EA matrix profiles are now available in Prolaborate to be opened with your browser (note: matrices can also be created in Prolaborate).

Result:

Bulk import and edit of EA elements via Prolaborate Excel-like interface 

Creating or updating model information in bulk can be relevant using CSV or Excel spreadsheets. Available in Enterprise Architect, this is now available with Prolaborate: you can create or update packages and elements in your Enterprise Architect models using an intuitive spreadsheet interface.

Once permissions are granted, a user can create an import profile as illustrated here with ArchiMate application components.

Notes: 

• The element and parent element unique EA identifiers (GUID) makes it possible to respectively update an existing element, and/or set the target element.
• Data Flow definition will be imported within a tagged value, itself used in EA using a custom script to generate data flows between applications.

Details can be entered directly within the displayed worksheet. Otherwise a CSV file can be generated (Download as CSV), populated, and imported into Enterprise Architect (Import CSV File).

I found that Prolaborate lets you copy and paste data a matching Excel file, very useful!

Once the details are provided, the import can be carried globally or row by row. 

Sparx Systems released this month the beta version of Enterprise Architect 15.

Below is a selection of the main features and enhancements that will be detailed in this article:

• Data Miner
• JavaScript Model Based Add-ins
• Custom tables (new spreadsheet artefacts)
• Browser new organization
• Diagrams enhancements
  • Custom drawing style diagram property
  • Google GCP, Amazon AWS web images
  • Bookmark values
  • Group elements
  • New keyboard shortcuts
  • Simplified access to the "Link to element feature"
  • Image Assets drag and drop to a diagram
• New keyboard shortcuts

Data Miner

Data Miner is a new feature to create model elements and relationships in Enterprise Architect from a data source such as a database, JSON file, or an XML file.

Data Miner is available via its associated diagram type, giving access to the following toolbox:

• DMConnection class [1]: properties to open a database via ODBC, a local file, or a URL.
• DMSet class [1..*]: query on the data source.
• DMScripts class [1]: scripts to update the EA models using the data available via the DMSets.
• Data Source and Harvester relationships: links DMSet to DMConnection, or DMScripts to DMSet classes.
• Note: it is recommended to use patterns to create all required Data Miner elements.

Below is an example to import data from an Excel file:

Process:

• Open the Edit Data Miner Connection on the DMConnection class to define the file location (local or URL).

The Excel file used in this example contains a spreadsheet for each type of information: applications, interfaces, data objects, data flows between applications.

• Use the Open Data Miner Visualizer menu on the DMSet classes to define the query and check the results. In the following example, the query gathers all the information from the APPS tab.

• Updating or creating model elements, attributes, operations, relationships, diagrams, etc. in Enterprise Architect is defined via the JavaScript code in the DMScript class (use Edit Data Miner Processor).
•  Notes:
  • The pattern from the Data Miner toolbox generates a DMScript class with an initial JavaScript code.
  • New classes are available in EA API: EA.DataMiner, EA.DataMinerManager, EA.DataSet, EA.DMAction, EA.DMArray, EA.DMConnection, and EA.DMScript.
• Once the script is defined, it can be used via a right click > Run Data Miner Processor.

Result:

• ArchiMate Application Component, Interface and Data Object elements have been generated according to the script definition:

• Stereotypes tagged values have been initialized with mapped values from the Excel spreadsheet:

• Data flows (information flows) have been generated between applications with the Data Object set as the conveyed item.
  • Note: check the enhanced Find in All Diagrams feature from eaUtils add-in to search flows from a data object.

DataMiner works one-way i.e. it doesn’t export or update information in the data source. It can prove to be very useful when custom data sources need to be imported without having to use a CSV file or other supported formats. Importing such data model can relevant to share a visual view of its concepts, link it with analysis and design models, map it to another project or data model, etc.

Note: I started testing the ODATA metadata import as an alternative to the XSLT process available here. The Data Miner not only generates classes and attributes, but also relationships – more to follow on this subject!

JavaScript Model Based Add-ins

Enterprise Architect traditional add-ins stand for applications that need to be installed on each user's PC (eaUtils is an example). Enterprise Architect 15 supports a new type of add-in known as Model-Based, to set up on a modelling project (no installation required), similarly to scripts (see my EA User Group London 2018 presentation).

Model-based add-ins are implemented in JavaScript within Enterprise Architect, whereas traditional add-ins mostly use C# or Java. Contrary to the scripts, add-ins support broadcast events and add-in menus (in the Specialize ribbon or via a right click).

The following Model Based Add-in is available from the EA Example project:

When the project is opened, this add-in is automatically recognized as an optional one:

Once enabled, this add-in provides a menu to generate the attributes details in the system output view from a selected class:

Custom Tables

Enterprise Architect supports a number of artefacts such as Model Views to generate results from a custom query in a table. The following list matches automated test cases defined for eaUtils add-in with eaTests library:

Custom table is a new type of artefact to manage spreadsheets and make them viewable on a diagram. The following custom table has been defined to show data flows between applications:

Notes: the edition mode is quite easy to use, however having a dedicated menu would help (similarly to the RTF document generator). Also, there is no support to copy and paste an existing content from Excel.

The table structure is available in the XML format via the following tagged value: 

The cell layout is available via the dataFormat tab:

Finally, the script tab is available to dynamically update values from the model data.

Running the Execute behavior script gathers all data flows and update the table accordingly:

Browser enhancements

The Browser (previously known as the Project Browser) is now complete with 4 tabs:

• 1- Project: tree structure view of the model elements and diagrams

• 2- Context: filtered view of the current package content (introduced in EA 14)

• 3- Diagram: new view with the list of elements (alphabetical order) used in the current diagram, as well as the in/out relationships. It can be useful to work with the diagram content.
  • A single click on an element or connector in the list selects it in the diagram.
  • A double click opens the properties window.

•  4- Element: the element browser view has been improved and merged in the Browser view.

A "find in browser" action is available from the Browser menu:

This feature is useful when called from a diagram as it selects an element or the diagram in the repository browser. This new menu is an alternative to the right click access, or existing keyboard shortcuts (Alt+G or Shift+Alt+G).

Diagramming improvements

Custom Diagram Drawing Style

Custom style is a new diagram property option. It is used to remove notation-specific details (UML, SysML, BPMN, ArchiMate…), making diagrams more easily understood by stakeholders.

Custom applications view:

Standard BPMN view:

Custom BPMN view:

The custom diagram drawing style can replace the need to use Visio or Powerpoint with decoupled information from the repository.

The available layout options are illustrated in the diagram below:

Using Enterprise Architect 15 beta version, I encountered a few issues in manipulating elements on the diagrams. I will test it again with the final release.

Bookmark value

Bookmark values are available to set and display a value on top of an element in a diagram. This setting is specific to a diagram i.e. different bookmark values can be set for each diagram that needs it. This feature can be useful for instance to tag the logical order on each step as illustrated here:

To enable and set a value, right click on the element, select Set Bookmark Value, enable the option and provide the value.

The diagram contextual menu provides an option to Show or Hide All Bookmark Values.

Group Elements

Group Elements is a new option to enable or disable on a selection of elements e.g. to move, change colours, or align them.

Link to Element Feature

This feature is known to link or map most of the time a class attribute or operation with another one (e.g. mapping between a data model with standard data model, or a logical data model with a physical one). Until now, once an association was created between classes, the process to link attributes or operations could take time for multiple links. This is now easier to achieve as illustrated here:

Resources: Amazon AWS and Google GCP Image and Icon sets

Comprehensive series of images and icons required to model AWS (Amazon Web Services) and GCP (Google Cloud Platform) architectures are now available from Enterprise Architect 15.

Here are some examples of Amazon and Google icons:

Images assets

Image assets have been introduced with Enterprise Architect 13 as an alternative to the image library with the ability to manage images as modelling elements.

Image asset elements are not supposed to be used directly in diagrams. Instead they should be set as the alternative image of elements. Enterprise Architect 15 provides a specific option when drag/dropping an image asset from the browser onto a diagram.

• Set as Alternate Image: define the image asset as the alternate image of an existing element e.g. class Class1
• Add as element with image: create a new element (class, component…) with the image asset identified as the alternate image
• Add as link: add the image asset element itself on the diagram

Note: it would be great if the option Add as element with image could support Boundary elements as they are commonly used to display images (cf. eaUtils Find in All Diagrams help for more information).

New keyboard shortcuts

Notes: Ctrl+Space

Access to the elements notes is very useful to read or update its description, hence the need to enable most of the time the Notes view.

A handy quick access to Notes has been released with the Ctrl+Space shortcut which opens the notes in a temporary popup window.

Properties: Ctrl+Return

The Ctrl+Return shortcut on the selected element or diagram opens and selects the properties view.

Note: the Tagged Values view has now been merged into the Properties view via a new tab.

Sparx Systems has released Prolaborate 3, the latest version of its web solution for Enterprise Architect modelling tool.

Main improvements:

• Increased performances.
• New widget to include Impact Analysis views in the dashboards.
• New CxO multi-level charts to represent complex data in an impressive and easily understandable way.

The EAExample sample project pre-installed with Enterprise Architect has been used in this article to illustrate some of Prolaborate 3 features.

Model visibility and access

Prolaborate makes it possible to pick and select the models that are relevant for a user profile, e.g. a business stakeholder could request visibility and access only on the BPMN diagrams matching the enterprise business processes.

In the screenshot below, a user has a read/write access to the SysML model from the EAExample project. The full project content is illustrated on the left (Enterprise Architect Project Browser).

The above customization has been entered via Prolaborate administration screen:

Model navigation and access

Prolaborate supports multiple Enterprise Architect projects (restrictions may apply based on the owned license) as set up in Sparx Systems Pro Cloud Server. The user below can either access both Sparx EAExample and an Archimate project.

The above main screen is a Dashboard with convenient links to the main SysML diagrams for the Portable Audio Player system. Clicking on the Design BDD opens the diagram below. Once displayed, the user can select an element (e.g. the main block) to open its properties (real-time details from the EA database). Text based information such as the element's notes can be updated directly with Prolaborate (note: Enterprise Architect tool is required for advanced modelling uses including updating diagrams).

Once the notes description has been saved, the update is straight away visible within Enterprise Architect:

Amongst the other properties tabs, EA matching traceability functions are available: find the element's usage within diagrams and the linked elements.

Collaboration modelling platform: discussions, model review

Prolaborate provides most features that users can expect from a collaboration tool. As regards it supports discussions on selected elements and diagrams, model review processes, etc.

As illustrated hereafter, a user submits a query to the system engineer in charge of the system design:

The target user is notified and submits a reply online, having dealt with the request within the given context.

A link to any model element or diagram can easily be created and copied into an e-mail or document.

Charts and reports

A model based approach involves gathering all the project related information and knowledge within a single location, the model repository. An Enterprise Architect modelling project is a true database with a structured content that can be analyzed and used in EA:

• Advanced model search.
• Custom add-in to run model validation as defined by the team (contact me for any query).
• Charts.

Prolaborate expands the access to this content beyond the EA users group via custom charts and reports.

Charts and sub reports

Prolaborate supports most chart types: pie, donut, bar, stacked bar, bubble, heat map, and nested pie.

A report can be enabled as an option for the chart selected values.

A Nested Pie chart has been defined for the SysML model:

• To review the number of SysML blocks, parts and ports, organized by stereotype.
• To display a list of results for the selected value e.g. all Flow Property stereotyped parts.

Click here or on the image below to open a video demonstration.

For Enterprise Architect projects, the Heat Map is useful to review the identified applications.

Reports

As an alternative to charts, a table can be produced according to the definition of a custom query. Sub reports are also available as an option to access details for a selected line within the main table.

Publishing model information via tables can be useful for common data models or glossaries maintained via UML models.

In the following example, the Portable Audio Player SysML parts are listed (name + type). Selecting a part opens its properties (name, notes, diagram usage, traceability...).

The "View" link in the last column can be clicked to open the part's details i.e. its ports and parts.

Delivered by Enterprise Architect experts from VISEO, up to date training courses are available in France with the latest version 14.1. 

• Training courses combine theory and exercises. One of its goals is to understand and practice Enterprise Architect modelling tool whilst covering a modelling repository and the chosen standard visual modelling language (UML or SysML).
• SysML with Enterprise Architect training for Model-Based Systems Engineering (MBSE).
  • Covers all 9 SysML diagrams.
  • Exercises follow a given process, starting with requirements and use cases, system design with the BDD and IBD diagrams, and system behaviour with SysML dynamic diagrams.
  • Duration: 3 days.
  • Click here for more information (french content).
• UML with Enterprise Architect for software analysis and design.
  • Covers the most important UML diagrams.
  • Duration: 2 or 3 days.
  • Click here for more information (french content).
• Available optional modules for both UML and SysML training courses:
  • Generate documents from the model with the built-in RTF generator.
  • Collaborative environnement to share models within a team.
  • Prolaborate, the new web collaborative platform from Sparx Systems.
  • Extending UML or SysML with MDG Technologies and stereotypes.
  • State machine simulation.
  • Scripting. 

Contact me on This email address is being protected from spambots. You need JavaScript enabled to view it. for any further information.

This year’s London EA User Group took place at the Skills Matters Code Node venue. It has been enjoyable and useful to discuss and share experiences with users via this unique dedicated SparxSystems Enterprise Architect event.

This article shares some feedback on the following presentations:

• Keynote on Enterprise Architect 14 by Peter Lieber.
• Model Driven Enterprise Knowledge with Gemalto GMOD platform by David Faus.
• My presentation on scripting with Enterprise Architect.

Keynote: Sparx Enterprise Architect 14

The keynote was an opportunity to discover some of the new features available in Enterprise Architect 14. Having started evaluating version 14 since its beta release, this presentation saved me time as I received an overview of the relevant enhancements.

A new checklist artifact is available from the common toolbox.

Once created, items can be added alongside their Boolean status (checked: true or false).

Result:

Other rendering options are available:

EA 14 has introduced the EAPX file extension, as an alternative to local EAP files, matching a Jet4 engine database. Jet4 EA projects can be created in previous EA versions within an EAP file. EAPX are useful since it is explicitly tied with Jet4 engine (this format provides enhancements on the database capacities). Note that EAPX files can be opened with earlier EA versions.

A new Cloud tab is available in the CONFIGURE > Options menu (note: the following options are available in EA 13.5).

The above Data Cache option can be enabled to create images of each diagram in the EA project database when saved in EA. These images can be used and rendered in external solutions via SparxSystems Pro Cloud Server. A create batch feature is available to generate all diagrams images.

Perspectives in EA 14 can be used to enable only the notations or languages that are relevant to the current use and context. The built-in Systems Engineering\SysML perspective can be enabled for instance so users only work with SysML 1.5 elements and diagrams, and will never come across other SysML versions, or UML, BPMN, ArchiMate and so son. Custom perspectives can be defined to select a range of technologies e.g. UML and BPMN. Note: I find perspectives very useful to scale down EA features to the ones that are needed by users through a built-in feature (instead of custom XML or registry updates by the company IT services). The Model Wizard has been redesigned in EA14; in EA 13.5 and earlier versions, it was mainly used to generate Model Patterns.

EA 14 Model Wizard runs in a view (not a popup) with redesigned model patterns. First of all, the available patterns are displayed for the selected perspective, e.g. UML, Business with BPMN, Systems Engineering with SysML, Enterprise Architecture with ArchiMate, etc.

Where the previous patterns generated a full structure with samples in each model e.g. class, use case, and so on, the logic here is to individually select and add model patterns to the local project. Patterns may include several packages, elements and diagrams.
For each pattern, a nicely illustrated explanation on the purpose is available, enhancing the usability and value delivered by Model Patterns.

EA 14 Model Patterns also include a new Process Guidance tab as an addition to EA Help. It creates a step by step process via an activity diagram e.g. to create a central database EA repository in MySQL as illustrated below.

The element properties have been integrated within views to replace the pop-up properties window. For elements, additional views provide access to the attributes, operations, etc.

Also available as a view, the diagram properties now display the Diagram GUID which can be useful:

The Compartments tab provides access to the elements visibility properties. Note: I would expect in the future to have all diagram properties in this view e.g. Features, Connectors properties.

The Diagram properties include new MetaModel options, linked with MetaModel Views, both introduced in EA 14. This Views system is aimed at restricting the available elements and connections from the diagram toolbox. MetaModel Views are either built-in or user defined (note: user defined views can be useful to combine stereotyped elements and built-in elements such as a UML class, use case and actor).

When creating a diagram, a list of built-in views is available under the diagram type, for instance a UML Class diagram illustrated below:

The resulting toolbox is different from the default UML class diagram.

This selection sets the “Applied to Metamodel” diagram option.

In addition to the toolbox content, the Filter to Metamodel diagram property is now available: when set, this option will grey out all elements that are not in the current Metamodel as illustrated below.

Another new option is the Display Lock Element Status: when enabled, locked elements will be visible accordingly on the diagram.

A smart placement feature is now available to dynamically visualize the selected element’s alignment.

Model Driven Enterprise Knowledge

Note: the following summary has been written by its author and speaker, David Faus (Gemalto).

Our goal was to build enterprise knowledge repositories based on models in several business units in Gemalto. The following diagram shows our strategy coming from the well-known Nonanaka and Takeuchi knowledge management theory:

We successfully used SPARX to build our model based KM platform called GMOD (Gemalto MODeling).

To deploy our “GMOD” adaptation of the Nonaka and Takeuchi approach, we used:

• The EA MDG to implement the “UC” method which I have been building during the last 25 years. This method is quite innovative because it is based on several domains (graphical user interface specification methods, functional analysis and also Object Oriented Programming), and is customer oriented: that means everyone is able, in few minutes of explanation, to understand a UC model.
• The EA client server architecture to allow all team members to produce UC models in parallel, what is finally relevant when building a huge model oriented knowledge base. The first big success we had was the delivery of the GBPR (Gemalto Business Process Repository): All Gemalto corporate business processes are now published and maintained thru GMOD.
• The EA java API to implement the Gemalto “SPARX Companion Tool”. This tool is complementing SPARX EA functionalities by adding reporting features, UC model integrity check, one click deployment web service…
• The Gemalto FAST & Easy knowledge management platform. This platform is based on the concept of patrimonial archiving. It is used to index any important UC diagrams produced thru GMOD. This is possible because the “SPARX Companion Tool” generates static URLs for diagrams.

As a conclusion, we are now able to retrieve model oriented knowledge by simply using a Google like search engine. Our next goal is to focus on the support functions and provide some knowledge base composed by hundreds of comprehensible use cases helpful at any level and anywhere in the company. 

Extending EA with custom scripts to cater for specific needs and user requests

It was my pleasure to be selected for the third time this year as a speaker. I offered to share my experience on defining scripts in EA over the past years to extend the tool’s features e.g. via custom Excel import/exports, save users' time in avoiding repetitive or time consuming tasks, etc.

The full presentation content is available from SlideShare.

Below is a summary with selected slides to illustrate the topics:

• Enterprise Architect can be greatly customized to cater for a client or project, and it includes creating features using the API from scripts, add-ins, Excel macros, etc.
• Where EA already provides numerous features, there is still a need to create additional ones as illustrated below.

• The choice of using Scripting was supported by the need to frequently update and deploy new versions to a large group of users.

•  Having introduced the different types of scripts (project browser, diagram, normal), I discussed the need to apply naming conventions so users can clearly find the appropriate script to run.

• The usual way to use EA API is to call methods from the Object Model, e.g. get an element’s parent package element with the following VBScript method call: set parentPkg = Repository.GetPackageByID(curElement.PackageID).

• Alternatively SQL queries can be used …
  • To run complex queries.
  • To select specific elements, preventing time consuming loops.
  • To address performance issues related. Replacing a method call with SQL update reduced the execution time for ~1000 attributes from 120 minutes down to 4 minutes.
•  SQL queries can be used on the Repository object methods:
  • Repository.GetElementSet(query,2) : returns a collection of EA elements according to the SQL query
  • Repository.SQLQuery(query) : returns an XML formatted string value (SELECT queries only)
  • Repository.Execute(query) : runs a query (UPDATE/DELETE/INSERT)
• Care should be taken when running UPDATE/DELETE/INSERT queries as it can delete or break the model.
• Moving on Scripts helpers, I shared ways to address issues both from the developer and user perspective.
• Below is the publication process that has been defined (illustrated via the first demo on EA).

• With some scripts requiring to select a source or target folder to process or generate files, a common script feature made it possible to suggest the previously selected folder. Other users’ script helpers are illustrated below and were demonstrated in EA.

• Geert Bellekens’ free EA-Matic add-in has been used to automatically trigger scripts based on configured events e.g. before creating a connector.

• Having shared a few hints, I completed the presentation with a demonstration of custom scripts defined for a number of clients.

Note: this article is available in French here.