This article provides some feedback on the EAUG London 2017 event, covering a full day of presentations, case studies, and user stories which took place on Friday, May 19^th.

It illustrates the quality of information that has been delivered if you couldn't make it this year.

As shown on the agenda below, the day started with a keynote followed by 5 sessions, each time with a choice between 3 topics.

Below is a feedback on some of the presentations I followed on that day.

Keynote: Innovation Needs Models

The keynote this year was run by Peter Lieber, from Sparx Systems Central Europe (Austria).
Peter shared his experience and recommendations when introducing a modelling approach within a project or company:

• To start with, a modelling language (e.g. UML, SysML...) and a tool (EA) must be chosen. A method is paramount to structure the modelling approach and processes. The final item to consider is the existing and progressing experience.
  • It is important to highlight that a tool and language like EA + SysML are not sufficient as the methodology is mandatory to enable a modelling approach. Having no standards for the methodology, it needs to be defined according to the context.
  • The need for a modelling tool such as EA is required to achieve productivity.
• Some useful feedback on failed and successful modelling scenarios were illustrated:
  • A successful modelling experience requires an iterative approach where reachable targets can be completed as the teams make progress.
  • An example of a failed case was given where a complex target was defined and once completed, a lack of acceptance and internal support led to a progressing drop in the related actions.
  • Another example involves the wrong idea that using everything e.g. all diagrams types from UML is the target. Resources and the team's involvement are often completely gone before getting any visible output.

Peter then focused on safety relevant systems e.g. trains, cars, aircrafts, medical MRI, etc. involving both complexity and safety. Safety is often subject to standards such as ISO 26262 for Road Vehicles Functional Safety. Looking at the challenges that need to be solved based on the ISO26262 standard, the modelling approach is considered to be the only sustainable option. This is supported by the fact that modelling makes it possible to maintain elements (e.g. requirements, components) and models (diagrams) that are all connected via traceability, coined as the model intelligence.

Where traceability is achieved with the tool, additional issues need to be addressed with the modelling methodology, e.g. a process to define in what order should one go about working on the model, what diagrams need to be used and for which purpose, where do elements and diagrams need to be stored, etc.

To enable adoption by Systems Engineers, the chosen language (SysML, UML) can be extended e.g. via a UML profile and its stereotypes. For instance the ISO 26262 ASIL levels (Automotive Safety Integrity Level) can be implemented in the system's model blocks through a range of colours.

Where diagrams are not always appropriate, details can be extracted and published through the means of Excel documents, e.g. via a Decision Matrix.

The final idea covered by Peter is to use Enterprise Architect as a platform that provides:

• links with other tools such as DOORS to exchange requirements,
• UML profiles and custom toolbars,
• automated scripts,
• running simulation and validation,
• publish models via the Reusable Assets Service,
• document generation.

Automated tests solution for add-ins and scripts in Enterprise Architect

My presentation was aimed at introducing an automated tests solution for EA automation scripts and add-ins, based on a personal project that I worked over the past months.

Since 2015, I maintain and share a free utilities add-in: eaUtils (www.eautils.com). It is aimed at saving time in specific scenarios involving sorting a wide array of elements within the model, or generating the alias value for elements according to their layout in a diagram.

The enhancements that I identified throughout the time, in addition to the feedback and requests received from users led to an increasing complexity level. Even if eaUtils is published as a free tool, a good level of testing and quality is required for the target users. Time consuming tests prompted the need for an automated tests solution with the following objectives:

• Save time.
• Define and run tests on my add-in in EA, moving away from manual tests.
• Spend time improving tests rather than running them.

I came up with the following business class diagram to define the test structure:

Moving to the design, I created an XML Schema model and generated the XSD file with EA to structure the XML test definition files. Having implemented a first working version of my automated tests in eaUtils, I could use it as illustrated below:

• Run an addin feature with associated settings to generate the test data for a new step. This function prevented me from manually build the XML file which would have been time consuming.
• Enable the automated tests module as the eaUtils developer, and run in on a test EA project.
• Review the results via the generated sequence diagrams.
• Fix any bug in case there's a failed test and repeat this process.

The following illustrates the EA test project structure with packages that contain data sets, test step elements, and the automated tests execution process (load the tests description from the XML file, and for each step, load the settings, call the add-in method with the provided parameters, check the post conditions, and generate the results).

Generated sequence diagrams are aimed at reviewing results and keeping a history of run tests. Here is an example:

I ran eaUtils addin automated tests in Enterprise Architect via the first part of my demonstration, having only as a demo effect a spilled glass of water which did not reach my laptop. Thankfully no IT related demo issue.

The second part of my presentation covered the next step forward by making this solution available for other add-ins and even scripts. There are numerous EA automation scripts and add-ins out there. Most of them are specific to a project and therefore not shared with the community, whilst the remaining ones are released as open source, free, or commercial tools. Note that EA add-ins are listed by Sparx Systems on their third party extensions page.

In order to integrate this automated tests solution with other addins and scripts, I selected the following candidates:

• hoTools add-in, an Open Source project maintained by Helmut Ortmann. An Open Source project was paramount so I could access and amend the C# code as part of this study (with the help and support of Helmut).
• EA scripting library shared by Geert Bellekens.
• A selection of scripts defined for a client: Lock Package and a Teiid virtual DB schema DDL import.

The tasks that followed were:

• Extract a generic library from eaUtils automated tests into a new C# project: eaTests.
• Update eaUtils add-in to use eaTests generic library.
• Update hoTools add-in to use eaTests.
• Define a new add-in to tests scripts.

As a result I successfully ran tests on one hoTools feature, a script from Geert, and 2 of my scripts. These were illustrated in the second part of the demonstration.

This study has led to a new solution called eaTests that has a dedicated site (www.eatests.com). The foreseen enhancements for eaTests library are mainly linked to the type of tests to carry on post conditions.

Replacing existing solutions with Enterprise Architect and extending function with custom MDGs

Graham Williamson from Interserve, a major construction company with 85,000 staff worldwide, shared his experience on using Sparx EA to define Enterprise Architecture models, custom ArchiMate 3 stereotyped elements, and EA model validation.

The aim of an Enterprise Architecture was to move away from paper-based processes and achieve a digital construction. The audit of existing services, locations, customers, processes, applications, data, and technologies quickly led to the need of a modelling tool. Sparx Enterprise Architect successfully fulfilled this need, delivering the following:

• Custom meta model
• Flexible modelling
• Archimate 3 support
• UML profile and stereotypes support
• Model search based on SQL queries
• Document generation
• Automation tools
• Low license cost

Graham shared the meta model via the selected Archimate 3.0 relationships and elements, followed by examples of Archimate 3 stereotypes to handle additional properties. All Interserve stereotypes were made available via a custom toolbox.

EA 13 Model Validation feature was used to make sure that relationships between elements were valid according to a set of rules.

• Validation rules i.e. a list of permitted relationships first need to be set up in EA. To save time in defining them in the required XML format, a custom add-in has been created to provide a handy user interface (e.g. Archimate associations allowed between an Application Collaboration and a Meaning element).
• The model validation is then run in EA for a selected package, displaying any error found.

Graham then talked about customizing EA diagrams to provide a suitable view for stakeholders:

It was interesting to see a practical use of Archimate plateau elements as illustrated below (definition from the Open Group: "A plateau represents a relatively stable state of the architecture that exists during a limited period of time").

As relationships couldn't be connected to an Archimate plateau element whereas this level of traceability was expected, the solution involved custom searches based on SQL queries with results grouped by Plateau. Search results enabled Interserve users to review each Plateau or architecture state content.

Other used EA features included:

• The relationship matrix to maintain links between plateau elements and other model elements.
• Roadmap diagram for the transformation planning.
• Heatmap and charts.
• Traceability and insert related elements in a diagram to build the business capability model.

Using Enterprise Architect and SysML for the development of an In-Wheel Motor System

I was looking forward to this presentation as I'm currently involved in an MBSE (Model Based Systems Engineering) project in the automotive industry for ISO 26262 safety compliance.

John Gladstone works for Protean Electric Ltd, a UK based company that develops in-wheel electric motor systems for hybrid, plug-in hybrid and battery electric light-duty vehicles. John's presentation provided an interesting feedback on the challenges that have been addressed with SysML and Enterprise Architect models.

Project context

John opened a SysML BDD diagram to illustrate the project context.

• The development of In-Wheel Motor systems falls under the scope of the ISO-26262 (Road vehicles – Functional safety), which requires the identification of Safety Goals. 
• The In-Wheel Motor system must include safety mechanisms which integrity is fulfilled by Design and Safety Architecture models. Such mechanisms are intended to prevent hazardous events such as an unintended acceleration of the vehicle.

System behaviour

The system behaviour was modelled with use cases and sequence diagrams for the scenario details. In order to model the system behaviour when things go wrong, Protean team has invented an actor called the Gremlin.

As a result SysML sequence diagrams had the driver and gremlin lifelines as the actors, and the electric vehicle lifeline in the middle with all interactions.

Modelling needs

Another BDD diagram was used to illustrate a complete view of the modelling needs for a motor system:

• An architecture framework to comply with architectural integrity via consistency, completeness, and correctness as per the ISO-26262 standard needs.
• The system is described by the architecture and modelled by SysML practitioners who use SysML modelling language, a semi-formal notation highly recommended by the ISO-26262. 

Understand SysML

John shared his recommendations on the literature to read about SysML, including:

• SysML Distilled: A Brief Guide to the Systems Modeling Language from L.Delligatti
• SysML for Systems Engineering from Jon Holt and Simon Perry (Simon attended this EAUG)
• A practical guide to SysML from S.Friedenthal and A.Moore

Architecture Framework model

The structure of the framework model was described as follows:

• It defines a number of viewpoints (perspectives).
• It is implemented using an MDG Technology that contains SysML stereotypes, toolboxes, and custom model searches.
• It is defined in the model repository alongside a Design Model.

Process and methodology model

Guidelines and diagrams describing the process to follow according to the methodology have been defined for each viewpoint.

Example model

To help understanding and improving this modelling environment with frameworks, processes and a methodology, an example model has been defined. This worthwhile exercise is based on an example system:

• Sufficiently defined to understand a practical results from the existing frameworks and processes.
• Not in scope of a motor system so nobody can argue about the details.
• Introducing fun: Protean chose the Starship Enterprise from Star Trek series as the system. This led to system elements such as an antimatter reactant injector and storage pod, a warp nacelle, etc.  

Final topics

Remaining covered topics included:

• The need of a glossary of terms to enforce using the right vocabulary the system or ISO standard.
• Generate documents from the models to minimize overheads.
• Structure the models with a library of elements (e.g. blocks, use cases, requirements...) and views/perspectives.

Sparx EA community of users

Throughout this 2 day event, I had the opportunity to meet great people. It was very interesting to share ongoing work and questions around EA, whether the context applied to software projects involving analysis and design, systems engineering with SysML and MBSE, or enterprise architecture with UML or ArchiMate. It was very nice catching up or meeting users that I know via Sparx forum or other online means throughout the year, giving an opportunity for a face to face discussion.

EAUG events are aimed at making the large community of EA users meeting up, gain valuable knowledge, and create new opportunities.

I'm looking forward to next year's EA User Group.

Preparing my presentation at the upcoming EA User Group in London (19/05/2017), I uploaded a video about this subject on Youtube.

It provides a first glimpse on the automated test module for Sparx Enterprise Architect addins that I will discuss in detail at the EA User Group London 2017.

Click on the following url to open the Youtube video: Automated tests with eaUtils addin for Sparx Enterprise Architect video.

There is still time to register at the EA User Group London 2017 from www.eausergroup.com.

Please feel free to contact me on guillaume[at]umlchannel.com if you have any question or comment.

The SysML reference card defined by Tim Weilkiens (oose.de) is now available in a version with diagrams done with Sparx Systems Enterprise Architect modelling tool. This overview illustrates SysML modelling language concepts, organized by topic:

• System context diagram
• Use case diagram
• Block Definition diagram
• SysML ports
• Internal Block diagram
• Requirements
• Packages
• Sequence diagram
• Activity diagram
• State Machines
• Comments and constraints
• Allocations
• Parametric diagram

SysML 1.4 reference card is available in the PDF format.

Notes:

• SysML is available in the Systems Engineering and Ultimate editions of Sparx Systems Enterprise Architect.
• This reference card is also available in French and provided during VISEO SysML with Sparx Enterprise Architect training sessions (more details available in French here).

Download links:

• SysML 1.4 reference card with Sparx Systems Enterprise Architect (PDF - english version)
• SysML 1.4 reference card with Sparx Systems Enterprise Architect (PDF - french version)

This article shares an MDG Technology that integrates Sparx Enterprise Architect UML models with JHipster.

VISEO EA UML to JHipster Generator MDG produces JDL (JHipster Domain Language) content from UML models maintained in Enterprise Architect. This output can be used in JHipster to create the application's entities, including properties and relations.

Not being able to find a suitable tool that generates JHipster entities from UML models, I started such integration for a software application that has been implemented with JHipster 2.

Note: the current version of the MDG is compatible with JHipster 2, latest available version when the project started. JHipster 3 new features could be integrated in a future version.

Context

A modelling project has been launched with Enterprise Architect to gather and maintain all the information and knowledge related with the project for the development team and stakeholders.

The initial models included business classes to identify the concepts, shared through a visual representation with UML. This approach has been useful when integrating these concepts in the technical environment JHipster.

JHipster, or “Java Hipster”, is a handy Open Source application generator that aims to create a complete and modern Web app:

• A high-performance and robust Java stack back-end (Spring Boot, Spring Security, Spring Data, Spring MVC, etc.)
• A sleek, modern, mobile-first front-end (Angular.js and Bootstrap)
• A suite of pre-configured development tools like Yeoman, Maven, Gradle, Grunt, Gulp.js and Bower

UML to JHipster JDL generator

Overview

Defining class models on both business and technical layers enabled a proper integration of the business definitions in the software application. Design workshops were carried in an efficient manner through the use of a common language and tool (Sparx Enterprise Architect and UML).

Looking for existing integration solutions between UML tools and JHipster yielded XMI exports/imports. However XMI implementations in UML tools don't provide most of the time a proper and full exchange of UML models i.e. without loss or modification of definitions. JDL Studio looked interesting; this online tool renders an entity diagram matching the JDL content. The downloaded file can be used to generate entities in JHipster (command line example: "yo jhipster:import-jdl export-jdl-uml.jh").
Without a suitable link between Enterprise Architect and JHipster, I wrote a script that generates such content directly from Enterprise Architect models. It requires the following JHipster 2 customizations carried in Enterprise Architect:

• Data types: JHipster types are available for the entities' attributes.
• UML profile: stereotypes on UML classes and attributes to provide JHipster properties via tagged values, listed below.
  • Classes
    • jhipsterDto : use mapstruct for the DTO-entity mapping
    • jhipsterPaginate : pagination choice for lists (infinite-scroll, pager, pagination)
    • jhipsterService : apply serviceClass to the entity
  • Attributes
    • jhipsterisRequired : the attribut is required
    • jhipsterMin: provides the minimum value (declared as minlength for String attributes, or min for Integer, Long, Float, Double, or BigDecimal attributes)
    • jhipsterMax: provides the maximum value (declared as maxlength for String attributes, or max for Integer, Long, Float, Double, or BigDecimal attributes)
    • jhipsterPattern: provide the pattern value for a String attribute
  • Script: generates the JDL content

The following UML class diagram illustrates the meta-model applied for the UML to JHipster 2 JDL integration:

The script and UML profile have been improved through users' feedback and reviews from JHipster experts at VISEO.

Installation

The EA UML to JHipster MDG is published via an XML file. Once installed, it is listed in the MDG Technologies screen:

Note: this MDG is available on request (e-mail: jhipster[at]umlchannel.com).

JHipster diagram and toolbox

EA/JHipster MDG Technology supports a diagram with its toolbox to create stereotyped classes and attributes:

UML profile and JHipster stereotypes

EA/JHipster MDG Technology includes a UML profile with stereotypes on classes and attributes to provide relevant Tagged Values.

When starting a JHipster design class diagram, JHipster entities contain tagged values available from the JHipster tab: DTO, paginate, service. The "none" value is set by default so all tagged values are optional.

The JHipster entity "Language" field is set to JHipster so its attributes are associated with the JHipster data types list.

The diagram toolbox can be used to add a stereotyped attribute to a JHipster Entity class. Such attributes also contains properties from the Tagged Values tab:

UML to JHipster generation script

The following UML class diagram has been defined with Sparx Enterprise Architect based on the JDL Studio example. This model provides a mean to check that the generated JDL content from either solution matches.

Compared with the JDL studio diagram, UML class diagrams have the advantage of being based on the OMG standard. Furthermore using a tool like Sparx Enterprise Architect provides a way to maintain the entity design model within a complete modelling repository e.g. including requirements, business, analysis and architecture models.

The following JDL content has been generated using this script:

=== EA UML to JHipster Entity Export ===
== More information is available from www.umlchannel.com/jhipster ==
INSTRUCTIONS: copy and paste the following content in a text file, and rename it e.g. as dpl.jh =
entity Department {
departmentId Long,
departmentName String required
}
entity JobHistory {
startDate ZonedDateTime,
endDate ZonedDateTime,
language Language
}
entity Job {
jobId Long,
jobTitle String,
minSalary Long,
maxSalary Long
}
/**
* The Employee entity.
*/
entity Employee {
employeeId Long,
/**
* The firstname attribute.
*/
firstName String,
lastName String,
email String,
phoneNumber String,
hireDate ZonedDateTime,
salary Long,
commissionPct Long
}
entity Location {
locationId Long,
streetAddress String,
postalCode String,
city String,
stateProvince String
}
entity Task {
taskId Long,
title String,
description String
}
entity Country {
countryId Long,
countryName String
}
entity Region {
regionId Long,
regionName String
}
enum Language {
FRENCH, ENGLISH, SPANISH
}
relationship OneToOne {
Department{location} to Location
}
relationship OneToMany {

/**
* A relationship
*/
Department{employee} to
/**
* Another side of the same relationship
*/
Employee
}
relationship OneToOne {
JobHistory{department} to Department
}
relationship OneToOne {
JobHistory{employee} to Employee
}
relationship OneToOne {
JobHistory{job} to Job
}
relationship ManyToMany {
Job{task(title)} to Task{job}
}
relationship ManyToOne {
Employee{manager} to Employee
}
relationship OneToMany {
Employee{job} to Job
}
relationship OneToOne {
Location{country} to Country
}
relationship OneToOne {
Country{region} to Region
}
paginate JobHistory, Employee with infinite-scroll
paginate Job with pagination
dto Job, Employee with mapstruct
service Employee with serviceClass

The final step involves copying this content to a JH file, and use it in JHipster to generate entities.

Scope

This approach was used as a mean to easily generate new versions of the design entity model within JHipster. Updates were carried in Enterprise Architect to remain consistent with the business model, whilst being generated, tested and approved directly in the application.

Once entities are updated in JHipster with custom code, it prevents any synchronization with the UML model. Where a full synchronization between the JHipster and UML projects is not the final purpose of this MDG, it allows having a design model that matches exactly the entities definition in the development environment during the first iterations of the project. This level of information in the design layer is very useful, even if mismatches with the code are bound to occur. The design team may chose to manually update the UML design model when needed.

Future versions

This MDG has been implemented and used with JHipster 2. A future version could be released to support JHipster 3 that has introduced new properties such as:

• new serviceImpl service
• new syntax e.g. "dto (ou service ) * with … except …"
• skipClient and skipServer declaration on entities
• angularSuffix
• Microservices (e.g. microservice with <jhipster app name>)
• elasticsearch search on entities (e.g. search * with elasticsearch except …)
• New types (AnyBlob, ImageBlob)
• Generate minbytes and maxbypes for blob attributes( Blob, AnyBlob, ImageBlob)

I ran a number of times a 3 day training course for a client in the automotive industry on SysML with Sparx Systems Enterprise Architect tool to model complex systems. This training course in french involved two instructors: Pascal Roques, a SysML and Systems Engineering expert in France, and myself on modelling and Sparx Enterprise Architect.

This training course combines the theory with the SysML modelling language brought by Pascal expertise alongside Enteprise Architect as a SysML modelling tool, brought by Viseo. Enterprise Architect tool is covered throughout the 3 days course to understand its environment, its SysML integration and features, and putting it all in practice via exercises.

Following several successful "intra company" training sessions, Pascal and myself have decided to run "inter-company" training sessions throughout France, starting 2017. The first SysML + Enterprise Architect training session will take place in Grenoble in April (4 to 6th April).

Full details in French are available from this link. Contact me on This email address is being protected from spambots. You need JavaScript enabled to view it. for any further information.

This article provides a preview about the upcoming Enterprise Architect 13, available in its beta version since beginning of June.

SparxSystems Enterprise Architect 13 leaflet covers the main enhancements including:

• Ribbon interface, replacing the traditional menus
• Links between connectors for a new level of traceability
• Time Aware Modeling with a package and element Cloning approach
• SysML simulation with OpenModelica and parametric diagrams
• Tagged Values support within diagram filters
• A new "Progress bar" tagged value type
• Various other enhancements:
  • Direct publishing to Joomla CMS
  • Improved Linux and Mac compatibility
  • Back end repository updates when accessing a shared Enterprise Architect project, hosted on a centralized database with the Security feature enabled
  • Cloud Service improved (IPv6 support, better performance)

Enterprise Architect 13 Ribbon interface

The screenshot below illustrates Enterprise Architect 13 user interface:

Traditional menus have been replaced with a Ribbon interface. As a result, some time will be needed to find Enterprise Architect features. This modern look and feel should make it easier to use features compared with the previous interface.
Activation of the main views such as notes, project browser, pan and zoom is available via the Window button, available from all ribbons.

The Start ribbon provides access to a Search button:

• Search in Model opens the project search screen (also available via the Ctrl+F shortcut).
• Search in Project Browser opens the Project Browser search dialog window.
• Search for Diagram or Package opens an associated predefined search.
• Browse for Diagram or Package is a new feature to browse a project tree version without the elements, making it easier to find a diagram or package. Choosing a package or diagram selects it in the Project Browser.

The Configure ribbon provides access to the project options and settings including Security, Version Control (e.g. SVN), code and MDA templates, installed MDG technologies, etc. 

Enterprise Architect tool configuration is available from the Start ribbon > Preferences.

The Extend ribbon shows all installed extensions/add-ins such as eaDocX, eaUtils, eaNavigator... Each extension menu can be accessed via its own button, improving the access to their features.

Important: add-ins menus in this ribbon don't match with Enterprise Architect v12.1 and earlier (see EXTENSIONS menu). Instead options from these menus match the ones listed upon a right click from the project browser. This seems to be something to fix or clarify. It would be nice to have a way also to replace the buttons images with the extensions logos.

Current versions of Enterprise Architect (12.1, 12, 11...) make it possible to personalize and reduce Enterprise Architect menus on a local PC. This customization can be very useful in order to simplify the user interface e.g. by removing the Execution Analyzer and other features that are not used by a group of users. Enterprise Architect 13 ribbon interface can be customized via the Start ribbon > Perspectives > Show Perspectives Window > Ribbon Menu.

Menu search with the Office 2016 visual style

Visual Styles can be modified from the Start ribbon to customize the user interface. Office 2016 visual style provides a search module on the menus. To activate this style, open the Start ribbon > Visual Style and select Microsoft Office 2016.

The search feature is illustrated below.

Enterprise Architect 13 helpers

Helpers features can be enabled via the Layout ribbon.

Sweeper and HV lock provide custom behaviours when moving diagram elements:

• Enable the Sweeper helper so a collection of elements within a diagram section can be moved altogether. Where this looks useful, one has to understand and control the definition of a section.
• Enable the HV lock helper so selected elements can either be moved horizontally or vertically.

The Presentation mode highlights any selected element and prevents from creating associations between elements (quicklinker is disabled).

Reorder messages mode is only active in UML or SysML sequence diagrams. When enabled, it lets you move messages without ordering the surrounding ones (same effect as when using the Alt key shortcut).

Enable the Show direction helper so that connectors are displayed in red or green when an element is selected according to the following rules:

• Green: the selected element is the connector's source.
• Red: the selected element is the connector's target.

This feature can be useful to control that relations are set in the right direction according to traceability rules.

Links between connectors

Enterprise Architect 13 makes it possible to create links between connectors. This feature can be useful for advanced traceability needs, e.g. in a Systems Engineering context, a control flow between action pins can be associated with a matching connector between SysML blocks' ports. This provides a way to ensure consistency between the static and dynamic view of a system.

Important: to prevent "not UML compliant" error messages, the Strict Connector Syntax option must be disabled in the preferences.

The following screenshots illustrate this feature.

• Select one of the connectors to enable the quicklinker (see arrow).

• Use the quicklinker to create a dependency with another connector.

• As a result, the following dependency link has been created:

Improvements would be required to access this type of traceability. For instance it would be useful to have a Links tab in the connectors' properties window. It would also be useful to see this link within the traceability view once a connector has been selected in the diagram.

Diagrams

The diagram toolbox displayed at the top of diagrams in current versions of Enterprise Architect has disappeared in version 13. It is however useful to easily change the colour of elements or links, the font, to align elements, apply the same dimensions, etc. Hopefully it will be available again in the final version.
All these features are currently solely available from the Layout ribbon.

Managing versions with a package and element Cloning approach

Sparx Systems provides a new "time aware model" feature to manage versions via a cloning approach. Right click on a package from the project browser and select "Clone Structure as a new version". Provide the new version and select a target package.

This version has been allocated to a new package (it needs to be renamed). A diagram has also been created and it contains the elements from the existing version.

Any element needs to be cloned within the new version before carrying modifications.

In the following example, Class2 has been cloned in the new version 1.1, and an attribute has been added to this class.

It is subsequently possible to display all elements onto the same diagram and apply versioning filtrers.

This feature can be useful to manage versions within an Enterprise Architect modelling project, e.g. to define and compare an "as-is" with a "to-be" vision of a model. However this approach seems to be limited when applied on a complex branch of models.

SysML simulation with OpenModelica

Enterprise Architect 13 offers an alternative and much more powerful SysML parametric simulation compared with the existing built-in tool. As regards, Sparx Systems has integrated a link with the OpenModelica, an Open Source Modelica-based modeling and simulation environment.

This feature requires installing OpenModelica tool (https://www.openmodelica.org/). Algorithms must be entered in SysML constraint blocks' invariant constraints, and SysMLSim configurations must be created via the Enterprise Architect 13 Simulate ribbon. This feature requires identifying and understanding all the properties to set prior to get a running simulation configuration.

The following screenshots illustrate the OpenModelica SysML simulation in Enterprise Architect 13.

Diagram filters: tagged values support

Diagram filters make it possible to hide or grey out elements from an active diagram according to a set of criteria. Tagged values support has been added in Enterprise Architect 13:

Conclusion

Enterprise Architect 13 upcoming version should be released end of 2016 or early 2017. This new version not only provides a nice and useful user interface in line with the latest applications, but also carries an interesting number of enhancements and features that will be handy once finalized.

I started last year a personal addin project for Sparx Enterprise Architect; eaUtils was intended to gather features that have addressed situations I came across over the past years. Initial eaUtils features come from scripts that were shared with the community (see Enterprise Architect project browser scripts: sort elements by alias or by tagged value).

Following an initial version launched in December 2015, enhancements were released in February 2016 with eaUtils 1.11. Current features include:

• Sort elements from a package tree, a package, or composite element by Alias, Tagged Value, Stereotype or Name
• Sort a package elements according to their layout order in a diagram (top to bottom or left to right)
• Generate elements alias values according to their order in a diagram
• Generate the breadcrumb trail in a diagram

Elements sorting

eaUtils sorting features update the elements tree position from a package or element. Enterprise Architect applies a default sorting order based on the name of the elements. In order to achieve a better management and more efficient use of the elements from within the project browser, it can be useful to have alternative and enhanced sorting options e.g. based on the alias, stereotype, tagged value, or according to the layout in a diagram.

eaUtils latest version provides a way to sort elements within a package tree, which is illustrated below. Further information on eaUtils sorting features is available from eaUtils Help.

Sort elements by alias in a package tree

Having enabled the package tree option, this feature can be used via a right click on the main package > Extensions > eaUtils > Project Browser : Sort elements by alias. eaUtils addin opens the following dialog window, prompting to select the packages to process within the current tree:

Below is a summary of the available actions or information:

• Status: set to Ready unless the elements sorting is running (Busy).
• eaUtils settings: a summary of the sorting settings values is displayed. A button is available to open eaUtils Settings.
• Select all/none: enable or disable all packages within the displayed tree.
• Tree: packages within the tree are displayed and can be individually enabled or disabled. Any locked package is greyed out and followed by (Locked).
  • Note: Root nodes are always disabled and marked as locked as they cannot have any element to sort.
• Sort elements in the selected packages by...: run the elements sorting within each selected package.
• Cancel: close this window.

Whilst eaUtils sorting by feature is running, progress is updated as packages are processed.

Once completed, all selected packages are marked as DONE, and a confirmation dialog is displayed.

Generate aliases

eaUtils provides a feature that generates elements aliases according to their order in a diagram, from top to bottom or left to right. I often use this feature to generate use case aliases according to their order in a diagram e.g. UC_001, UC_002.... It also can be applied to other diagrams such as UML activity, BPMN process, Archimate, etc.

Consider the following use case diagram:

Note: use cases on the above diagram are stored in the same package whereas actors are located in a dedicated one. eaUtils provides an option to deal with this situation so that external elements (actors) are ignored when generating the alias.

eaUtils provides a range of settings to define the prefix, suffix and numbering format to generate in each alias. Below is an example for the current example:

• the prefix is set with the element's name followed by an underscore e.g. UseCase_
• the numbering will be generated with 2 leading zeros e.g. 001, 002...
• the suffix is set to "_BookStore"
• only Use Case elements are processed

Running eaUtils "Generate Alias" leads to the result below:

Breadcrumb trail for diagram navigation

Navigating between a large number of opened diagrams within a Sparx Enterprise Architect modelling project can be cumbersome. Having opened successive composite elements such as an activity, use case, or BPMN2 subprocess, going back to the previous diagram is often not easily achievable. This issue is not only valid when one uses Sparx tool, but also when a published HTML version is opened in a web browser (e.g. Firefox, Chrome, IE).

A workaround involves creating a diagram hyperlink back to each calling/linking diagram; eaUtils addin provides a Breadcrumb Trail feature that generates such hyperlinks within an active diagram. In the example below, a BPMN2 process is detailed via an associated composite BPMN diagram:

Running eaUtils breadcrumb feature on BusinessProcess1 diagram leads to the following result i.e. a hyperlink back to the Business diagram has been created:

eaUtils addin for Sparx Systems Enterprise Architect

eaUtils is listed as a Sparx Systems 3rd Party Add-In in the Model Management Category.

eaUtils addin can be downloaded for free from www.eautils.com website, where an online help content is also available.

VISEO released its 2016 training catalogue, including a full range of updated training courses for Sparx Systems Enterprise Architect. All training materials are available in French.

• Slides and exercises content updated with Enterprise Architect 12.1 version.
• 2 or 3 day thorough training courses, involving UML, BPMN2, or SysML.
• Optional sessions available: 
  • configure a project to be shared with other users;
  • create an MDG Technology;
  • implement an add-in with C#;
  • generate a document (built-in RTF generator or eaDocX);
  • define business processes with BPMN 2.0;
  • ArchiMate 2.0.

Please visit Viseo website for more details:

• Link to VISEO 2016 training catalogue (in french)
• Modelling and Design training courses (in french)