Introduction

ArchiMate is an open standard for modeling enterprise architecture. ArchiMate is a modeling language and has a close relationship with the architectural framework Togaf. This combination means that ArchiMate has been introduced by many organizations, both commercial, non-profit and government institutions in the Netherlands and other countries. In addition, ArchiMate modeling is powerfully supported in Sparx Enterprise Architect.

In this article we discuss expanding the ArchiMate modeling language. Not for introducing new concepts but by adding properties to elements and relationships in the language. This is part of the metamodel in ArchiMate open standard and offers organizations the opportunity to register c features of the organization-specific enterprise architecture in close connection with the concepts in the language.

ArchiMate metamodel

ArchiMate is a rich modeling language with about sixty elements and twelve relationships. This makes it possible to model all aspects of an organization and its environment. In some situations, ArchiMate is seen as too rich for specific goals and target groups. ArchiMate has also introduced a mechanism for this and described it in detail. Namely views and viewpoints.

Image metamodel

This means that ArchiMate's metamodel closely matches the needs of many organizations, ranging from just the open standard to making extensions in the language for the benefit of their own organizational needs.

ArchiMate in Enterprise Architect

Enterprise Architect supports multiple modeling languages such as UML, BPMN, BABoK. ArchiMate is also well supported in Enterprise Architect. In addition, more and more mechanisms of the ArchiMate language have been implemented. This includes extensions in addition to the ArchiMate diagrams such as the toolbox, working method for the ArchiMate viewpoints and the option to view viewpoints using the model wizard and then generate an initial view based on the viewpoint.

Image ArchiMate in EA

Since version 16 of Enterprise Architect, it has also been easy to restrict the metamodel for elements and relationships. This makes it possible to limit the language in elements, relationships, diagrams and quick linkers for certain user groups. A nice functionality for organizations that want to use a limited set of the ArchiMate language to simplify the language for the various stakeholders.

ArchiMate also describes expanding the language with properties. If you want to make organization-specific extensions, that is possible. There are also functionalities available in Enterprise Architect that support this. The MDG technology builder in particular has the option to expand the language with elements and relationships with their own properties. This allows you to introduce your own modeling language. In itself a powerful functionality, but also with a major disadvantage. You introduce a new modeling language based on ArchiMate, but IN ADDITION to ArchiMate. In many situations this is not desirable.

In this article I will therefore introduce a method that makes it possible to introduce organization-specific properties within the ArchiMate language without creating a new modeling language. For this we use an example based on the description available on the website with the ArchiMate standard (see the useful links below).

Combine functionalities in Enterprise Architect

As mentioned, you can use the MDG Technology builder to expand the metamodel for a language. This functionality uses the Tagged Values concept in the background. This functionality makes it possible to extend the Enterprise Architect data model.

To expand the ArchiMate language, we can suffice with the use of Tagged Values. The description of the ArchiMate language does mention specializations of concepts. However, if we look at the description, we see that no new mutual connections arise. New specializations can therefore be developed using Tagged Values.

You can elaborate these Tagged Values within the UML types, but they can also be used for ArchiMate. What is powerful is that a script can be defined for a Tagged Value. This allows us to set additional behavior and conditions for the different Tagged Values. In the image below you see the screen where you can define the Tagged Values in combination with the result in the tags of an element. I'll use a simple naming convention here. The name of the Tagged Values all start with ArchiMate. I will come back to this later.

Image: Tagged Values

We can now easily expand the model based on the stereotypes and the tagged values without having to introduce new stereotypes. This means that the ArchiMate metamodel remains available unchanged and we can continue to exchange ArchiMate models based on the AMEF exchange format.

However, there is a functionality missing that makes the modeler’s life easy. A bottleneck with the tagged values is that the tagged values have to be added manually via the property screen. This is repetitive and slowing down when working with your own tagged values.

Fortunately, there is something that can be done about that. In Sparx Enterprise Architect you can catch events that occur in Enterprise Architect via a (model-based) add-in. This also applies to a context changed event. This means that if the context changes to another element or another connector, a command is executed. You can then use the Enterprise Architect API to check whether all tagged values are present for a certain stereotype and, if not, create these tagged values for the element or connector.

This functionality has been realized in the IDEA Add-on. In the settings of the IDEA addon you can prefix which tagged values should be created. In our case this is ArchiMate as a prefix, then the IDEA addon is used based on the handling of an event in EA. In the image below you can see the piece of software that underlies this within the IDEA AddOn. If you want to create a model-based add-in yourself, you can do so based on the code in the example below.

Public Shared Function DefaultTaggedValues(Element As EA.Element, _

 Repository As EA.Repository) As Boolean

           Dim Tag, oTV As EA.TaggedValue

           Dim oDef As New IDEADefinitions()

           Dim Prefix As String

           Dim oPT As EA.PropertyType

           Dim strPTTag As String

           Dim strNames As String = ";"

           Try

               Prefix = oDef.GetSettingValue("TaggedValuePrefix")

               If Prefix.Length > 0 Then

                   For Each oTV In Element.TaggedValues

                       strNames += oTV.Name + ";"

                   Next

                   For Each oPT In Repository.PropertyTypes

                       Dim blnCreateTag As Boolean = False

                       strPTTag = oPT.Tag.ToString()

                       If strNames.Contains(strPTTag) Then

                           blnCreateTag = False

                       Else

                           If strPTTag.Contains(Prefix) Then

If oPT.Detail.ToString().Contains("BaseStereotype") = False And _             Element.Stereotype.Length > 0 Then

                                   blnCreateTag = True

                               End If

                               If (oPT.Detail.ToString().Contains("BaseStereotype") And _

                                    oPT.Detail.ToString().ToUpper().Contains(Element.Stereotype.ToUpper())) Then

                                   blnCreateTag = True

                               End If

                               If oPT.Detail.ToString().Contains("AppliesTo=" + Element.Type) Then

                                   blnCreateTag = True

                               End If

                               If blnCreateTag Then

                                   Tag = Element.TaggedValues.AddNew(oPT.Tag, "")

                                   Tag.Update()

                               End If

                           End If

                       End If

                   Next

                   Element.Update()

                   Return True

               Else

                   Return False

               End If

           Catch ex As Exception

               DLA2EAHelper.Error2Log(ex)

           End Try

           Return False

End Function

Source code

I have created an example for the combination of the tagged values and the IDEA, including a short video on how this can be achieved.

Summary

This whitepaper describes how you can extend the ArchiMate metamodel with properties. In Sparx Enterprise Architect this is possible with the tagged value functionality. In addition, the IDEA AddOn describes how repetitive and slow work for the modeler can be automated. With this we introduce a powerful method to extend the ArchIMate metamodel without having to introduce new stereotypes into the model. Particularly for organizations that see working based on open standards as an important requirement.

Useful Links

• ArchiMate language modifications
• IDEA AddOn productpage
• Introduction video about ArchiMate in Sparx
• Resource file of the tagged values
• Webvideo about tagged values and ArchiMate

Introducting an Architecture Repository is an opportunity to professionalize the architecture modeling process and products. There a publication is prepared  for supporting an approach for introducing Sparx Enterprise Architect as An Architecture Repository. This book focuses on introducing an architecture repository. An architecture repository contributes to a more mature approach to introducing architecture into an organization. This is a combination package of a book, online training and a sample repository.

The book, training and sample repository are prepared based on the following subjects

• Document driven approach as baseline architecture
• Architecture Repository as target architecture
• Solution architecture for the transfer from baseline to architecture
• Step by step guides
• Aids for successfully introducing an architecture repository

The combination package is available from Leanpub. Please follow the link where you see some sample pages of the book and a sample video of the online training. For more information please visit:

https://leanpub.com/architecturerepository

The sample repository included in the combination package is used to write the book, a nice example of the power of Sparx Enterprise Architect and an approach also know as "Eat you own Dogfood". However it gives you an option to make a jumpstart in introducing an architecture repository.

Resume

ArchiMate is a powerful enterprise modelling language for the architect's expressiveness. As a result, ArchiMate is sometimes experienced as complex. However, there are a number of parts in the metamodel that can simplify the views.

In this white paper, we discuss two forms of simplification, namely nesting of elements to simplify the visual representation. In addition, working with derived relationships to reduce the complexity in a diagram.

Both forms of simplification are supported in Sparx Enterprise Architect. However, with two extra routines in the IDEA Addon, the modeller is automatically supported in implementing changes in the model and validating whether these transformations comply with the rules in the ArchiMate metamodel

Introduction

ArchiMate is a powerful language with several dozen concepts, elements and relations. This gives the architect expressiveness to express an architectural elaboration. For architects among themselves, ArchiMate is important as a language with a rich vocabulary. However, this also has a number of drawbacks. The main disadvantages are that the language is experienced as difficult for a number of stakeholders.

Fortunately, a number of concepts have been added in ArchiMate that allow for a simplification of the language with a relatively small limitation in expressiveness. Two of these simplifications are nesting elements to simplify that way. The other set-up is to work with derivative relations. However, both simplifications are included in the meta model and are structured in the language.

In this white paper we discuss these two simplifications with a number of helpers in the IDEA addon for Sparx Enterprise Architect. In these helpers, the simplifications based on the meta model are automatically supported. A nice dimension is that this also offers possibilities to validate the model in accordance with the rules that apply to these simplifications.

The helpers are within the IDEA addon under the ArchimAid functionality. In this article we will discuss this functionality. The addon is available as open source and can be downloaded from https://data-docent.nl/IDEANL.aspx#gsc.tab=0. In addition, a web video has been created to demonstrate the functionality of ArchimAid.

Nested elements

Archimate perspective

In ArchiMate, a large number of elements can be related to each other. In that case, a diagram will soon be regarded as quite full and well-organized for the reader. Consider, for example, hierarchical structures such as representing the organizational structure or the classification of information objects divided into domains. Below is an example of a diagram that shows a simple hierarchy.

This diagram can be greatly simplified by using nesting. Nesting places the child elements within the parent element. In the example, therefore, a nesting is created twice. See below

This makes the classification easier to interpret, even for stakeholders without in-depth ArchiMate knowledge.

The metamodel does, however, impose some restrictions on this method. Nesting is mainly used for structural relationships and for specializations. In addition, it is desirable to include in your own modelling convention that only the same relationship is used in a nested elaboration. So no combination of, for example, composition and aggregation or specialization in one diagram, then it is no longer possible to deduce which relations have been used.

Sparx Enterprise Architect implementation

In Sparx Enterprise architect the design of nesting is adequately implemented. If you connect two elements and then place one inside the other, the connector will be made invisible as expected, provided you choose the relationship types defined in ArchiMate that allow nesting.

The bottleneck in this, however, is that if you do not create a connector between two elements in advance and apply nesting, there will be no notification that a connector based on ArchiMate is relevant. In one diagram it goes well, but in the repository and in other diagrams it is not clear that there should be a relationship. The ArchimAid is helpful here.

ArchimAid Helper

The ArchimAid helper is a screen in the IDEA addon that supports the ArchiMate modeller. This way you can easily search for ArchiMate stereotypes, layers and aspects. However, the Embed tab provides an overview of the connectors that are there, including the stereotypes, or not.

You can then use the Create Embedded button to create the connectors based on the selected stereotype to create the connectors. See also the web video that shows how create embedded works.

Derived relationships

Archimate perspective

Do you work part of an the enterprise in ArchiMate in detail, you see that a model emerges that has many elements and relationships. This provides a level of detail that is most expressive for the community of architects. However, these detailed elaborations are too complex for other stakeholders. Compare it with the construction world where the specifications are relevant for this target group. However, the future residents can suffice with an artist's impression of the house to be built.

Within ArchiMate it is possible to simplify the model by using derived relations. In the image below you can see an example of this. Instead of a diagram consisting of several elements and relationships, a new relationship is established between two elements. The other elements can then be removed.

This diagram shows the simplification by establishing a derivative relationship between two elements. The elements that can be removed as a result are colored grey. If desired, you could remove a few more elements if this simplifies the model.

Sparx Enterprise Architect implementation

Sparx Enterprise Architect offers you the freedom to establish relationships based on the meta model. This also supports the addition of derived relationships. However, this is an activity that must be performed manually by the modeler.

An additional challenge is that the modeller must be aware that adding a derivative relationship to one diagram can also have an effect on other diagrams on which the elements both occur.

ArchimAid Helper

The ArchimAid functionality does support the modeller automatically in determining derived relationships. You can see an example of this on the screen. You choose a start and end entity and determine based on the ArchiMate metamodel rules which relationship arises as a derived relationship. This can be done via multiple paths through the model. You will see it in the diagram.

Then, in the list of possible simplifications, you can choose the paths you want to replace with the simplified relation. The other relationships are then made invisible in the chart, not from other charts. See the web video with an interactive example.

More information

For more information about the  IDEA ArchimAid screens please visit the following online content:

• https://youtu.be/7gogT2O2Kf8
• https://data-docent.nl/ideaen.aspx#gsc.tab=0
• https://youtu.be/mkFNc6MCZq8
• https://community.sparxsystems.com/white-papers/1355-using-archimate-viewpoints-in-nterprise-architect
• https://data-docent.nl/frmSearchList.aspx?module=webcontent&mode=direct&searchfor=idea#gsc.tab=0

Introduction

Frequently there are legacy systems/applications with no previous documentation, and the lack of it makes maintenance and further development of those systems/applications stagnant and demanding. This particular article outlines the ability of graphs (created through the Neo4j database) to automate the creation of documentation in the form of ArchiMate model in Sparx Enterprise Architect or Archi.

We will create an ArchiMate model for the legacy application that will describe basic entities, such as screens, fragments, roles, files and relations between them. An HTML version of the automatically generated ArchiMate model is available here. It's an export from Sparx Enterprise Architect to HTML.

In a next article, we use the graph to identify:

• application communities
• communities where fragments are used
• communities with fewer screens than roles
• the missing role setting in a linked screen
• unused parts of the application
• risk business processes

Example

An illustrative example of two screens and its relations to other screens, fragments, roles and files is below: An illustrative example of the relation between two screens and other fragments, roles and files is below:

Even if there is only the source code of the application, there is a way (by source code scrapping) to obtain all required information. The source code scrapping should be implemented accordingly to the specific application. However, it is not covered in this article.

The example of an outcome from the scrapping for one screen (Screen_414) in a json format is below:

Sparx Systems is pleased to announce a new Sparx Systems University Week scheduled June 3^rd-7^th.

During Sparx Systems University week, a range of both free and paid training sessions are hosted at training locations around the world and online.  All sessions are supported by Sparx Service providers and qualified trainers in a number of different languages.

This week-long event is a unique opportunity to gain knowledge and improve skills around Enterprise Architect. June's course line-up covers a broad range of topics, and has been developed with both introductory and advanced users in mind.

The first Sparx University Week for 2018 will be run during March, with most training sessions being held during the week of March 2-9.

University Weeks are hosted by Sparx Systems Japan, Sparx Systems Central Europe, Sparx Services North America, Sparx Systems India and Sparx Services UK (Hippo Software).

The delivery format for each course varies depending on the subject, audience and location, with a mix of both online and face-to-face seminars and courses.

It is anticipated that Sparx University Week will be run on a global basis every few months, in conjunction with Sparx Systems Sister and Services Partner network.

Bookings are essential, please review the course schedule below and visit the course provider's website for more details and to register your place.

Sparx University Week Schedule:

Introduction

One of the challenges of a teambased architecture repository based on the ArchiMate language is to reduce the number of duplicate entities. With duplicates I mean an Archimate concept with the same name and stereotype that has two or more instances in the repository.

Especially in large repositories with a complex project browser configuration and a large number of modellers the changes of duplicates are substantial. Therefore mostly a procedure is introduced based on the steps that a modeller has to do a repository search before he or she can actually add an element from the toolbox and modify it

Search

For searching for elements in the repository there is a search dialog availabe that opens by default in a simple common search that searches for a text in all the items. This works fine but has a number of limitations for an ArchiMate modeller:

• The search is relatively slow
• The modeller is not interested in the full content but only in ArchiMate elements of a specific type.

Luckily we can define our own searches in EA and an example of a ArchiMate specific search is shown bin the image below:

In this image you see that we can search for application components only and the list is by default sorted by objectname. This will help us in a later stage in user friendliness. The SQL statement is given below.

SELECT t_object.ea_guid AS CLASSGUID, t_object.name as ObjectName, t_object.Stereotype, ParentPkg.Name as ParentName, t_object.ModifiedDate, t_object.Author, t_object.[Version], t_object.[Alias], t_object.Object_Type as CLASSTYPE,t_object.Note as Notes FROM t_object, t_package as ParentPkg WHERE (t_object.name LIKE '#WC#[Search Term]#WC#' OR '[Search Term]'='') AND t_object.stereotype IN('ArchiMate_ApplicationComponent') AND t_object.Package_ID = ParentPkg.Package_ID ORDER BY t_object.Name

The trick is in two parts of the select statement:

• The first one is that we filter on the stereotype of the element so we only see a limited number of elements based on that stereotype
• The second is that we do a trick with the search term. We combine a search term search with a full search so you can see all the elements when the search term is empty

Model view

This helps us a lot in finding the relevant elements relatively fast however the search screen has a number of limitations in which selecting all the time the right query is relatively user unfriendly. However luckily Enterprise Architect has another screen for implementing this user friendly approach in a convenient way: the model view.

In the modelview you can define your own search view and link these views to a search in the search component of EA. See the picture below

In this screen you see a sample of a number of ArchiMate specific searches based on their stereotype. When you expand one of these searches you get the list of elements based on this stereotype. Since we have a combination of a keyword search and a full search (on the stereotype) the modeller can select the approach that best fits his needs. In the view you can select an element by typing in the first characters another option is to open the conext menu and go to the search function in EA and now we open the richt search immediately.

Download

For download of this solution or for downloading other scripts or add ons please visit the eaxpertise website.

The second Sparx University Week will be run during October, with most training sessions being held during the week of October 23-27.

University Weeks are hosted by Sparx Systems Japan, Sparx Systems Central Europe, Sparx Services North America, Sparx Systems India and Sparx Services UK (Hippo Software).

The delivery format for each course varies depending on the subject, audience and location, with a mix of both online and face-to-face seminars and courses.

It is anticipated that Sparx University Week will be run on a global basis every few months, in conjunction with Sparx Systems Sister and Services Partner network.

Bookings are essential, please review the course schedule below and visit the course provider's website for more details and to register your place.

Sparx University Week Schedule:

Enterprise Architect User Group

London 2017; 18th - 19th May

The London

2017 meeting of the Enterprise Architect User Group sees a shakeup to the agenda in the form of an additional day being added to the roster. In additional to the traditional presentation day of User Stories, How to's etc the extra day added to the event is taking the form of a training day.

The training day adds to the event a selection of six, three hour training sessions on a variety of subjects from BPMN to TOGAF and Model Curation.

Location

Code Node, 10 South Place, London, EC2M 7BT

Get Directions

Agenda; Thursday 18th May

You can find information on these training sessions over at the EA User Group website.

Agenda; Friday 19th May

You can find a synopsis for each of these presentations over on the EA User Group website.

How to buy your tickets...

Tickets for the event are available directly from the EA User Group website and are priced as follows:

• Full two day event ticket; £550.00 +Vat
• Friday only ticket; £75.00 +Vat

ArchiMate 3.0

by Phil Chudley, Principal Consultant at Dunstan Thomas Consulting

  The Open Group released the official specification of ArchiMate 3.0 in June 2016, and this new specification is supported in Enterprise Architect version 13. This article summarises the new features and changes within ArchiMate 3.0 and provides an example of how to migrate an existing ArchiMate 2.0 model to ArchiMate 3.0 model using Enterprise Architect v.13.

Summary of Changes

The following is a summary of the changes made within ArchiMate 3.0:

• Motivation Extension;
  • New element for modelling Outcomes.
  • New set of Strategy Elements, Resource, Capability, Course of Action.
• Business Layer;
  • Representation of the Contract element modified so as to be different from the Business Object Element.
  • Location element removed (although Enterprise Architect has re-located this element to the Technology Layer – Physical Extension).
• Application Layer;
  • Two new elements added, Application Process and Application Event
• Technology layer;
  • Elements called Infrastructure in ArchiMate 2.0 are now called Technology in ArchiMate 3.0.
  • Four new elements added, Technology Process, Technology Interaction, Technology Event and Technology Collaboration.
  • New set of Physical Elements, Equipment, Facility, Distribution Network and Material. These elements are known as the Physical Extension.
• Implementation and Migration Extension;
  • One new element added, Implementation Event.
• Relationships;
  • Representation of Assignment modified to have a directional arrow.
  • Bi-directional Access relationship added.
  • Plus (positive) and Minus (negative) symbols added to Influence Relationship.
  • New relationship, Serving.

Detail of Changes

The following tables provided an example of the changes for each of the sections listed in the Summary of Changes above.

Motivation Extension

Element	Definition	Notation
Outcome	An end result that has been achieved.
Resource	An asset owned or controlled by an individual or organisation.
Capability	An ability that an active structure element, such as an organisation, person, or system possesses.
Course of Action	An approach or plan for configuring some capabilities and resources of the enterprise, undertaken to achieve a goal.

Business Layer

Element	Definition	Notation
Contract	A formal or informal specification of an agreement between a provided and consumer that specifies the rights and obligations associated with a product.

Application Layer

Element	Definition	Notation
Application Process	A sequence of application behaviours that achieves a specific outcome.
Application Event	An application behaviour element that denotes a state change.

Technology Layer

Element	Definition	Notation
Technology Collaboration	An aggregate of two or more nodes that work together to perform collective technology behaviour.
Technology Process	A sequence of technology behaviours that achieves a specific outcome.
Technology Event	A technology behaviour element that denotes a state of change.
Technology Interaction	A unit of collective technology behaviour performed by (a collaboration of) two or more nodes.
Equipment	One or more physical machines, tools, or instruments that can create, use, store, move, or transform materials.
Facility	A physical structure or environment.
Distribution Network	A physical network used to transport materials or energy.
Material	Tangible physical matter or physical elements.

Implementation & Migration Extension

Element	Definition	Notation
Implementation Event	A behaviour element that denotes a change of state related to an implementation or migration.

Relationships

Element	Definition	Notation
Assignment	Expresses the allocation of responsibility, performance of behaviour, or execution.
Serving	Models that an element provides its functionality to another element.
Access	Models the ability of behaviour and active structure elements to observe or act upon passive structure elements.
Influence	Models that an element affects the implementation or achievement of some motivation element.

Implications to existing ArchiMate models

If an organisation has modelled their Enterprise Architecture using Enterprise Architect and ArchiMate 2, and are now using Version 13 of Enterprise Architect, they have two courses of action:

1. Continue to model using ArchiMate 2.0. In this case no action is required either for Enterprise Architect or the model repository. An organisation would continue to model using ArchiMate 2.0 if they do not wish to make use of any of the new features in ArchiMate 3.0.
2. Migrate their existing ArchiMate 2.0 model to ArchiMate 3.0, and then continue to model using ArchiMate 3.0. An organisation would continue to model using ArchiMate 2.0 if they wish to make use of any of the new features in ArchiMate 3.0.

My own personal opinion is that an organisation should consider moving to Enterprise Architect version 13 (mainly due its new feature of “Time Aware Modelling”) and ArchiMate 3.0. One of the main reasons, is due to inherent ambiguity (due to the lack of direction indication) in the assigns relationship in ArchiMate 2.0, which has been eliminated in ArchiMate 3.0 by making the assigns relationship directional.

Migrating an ArchiMate 2.0 model to ArchiMate 3.0

Enterprise Architect version 13 provides a migration script for this purpose. The following steps are used to perform the migration:

1. Take a backup copy of the existing model repository.
2. Using the Configure | Manage Technology ribbon, ensure that both ArchiMate 2.0 and ArchiMate 3.0 MDG technologies are enabled.
3. Using the Code | Scripting ribbon, make the scripting window visible:
   
4. Select the topmost package (or view) that contains the model to migrate:
   
5. Select the script Migrate ArchiMate 2 to ArchiMate 3 in the scripting window.
6. Right-click and select Run Script from the menu.
7. The progress of the migration, together with any errors / warnings will be displayed in the system output window.
8. Review the diagrams (you may have to tidy some of the relationships).
9. Turn off the MDG ArchiMate 2.0 using the Configure | Manage Technology ribbon.

NOTE: It appears that composition relationships are NOT HIDDEN, when using nested structures in ArchiMate 3.0. I suspect this is an Enterprise Architect version 13 issue. This is likely to be fixed and should not deter migration, as these relationships can always be hidden using the Visible Relations function in Enterprise Architect. (Layout | Manage ribbon and select Show and Hide Relationships… from the menu).

Phil Chudley
Principal Consultant
Dunstan Thomas Consulting
@SparxEAGuru

You'll find lots of useful Enterprise Architect videos on our YouTube Channel.