Top Community Contributors
Introducing RepoDoc, a document generator for Enterprise Architect
Written by Archimetes
SysML 1.4 reference card
Written by Guillaume
Enterprise Architect User Group: London 2017
Written by DT_Sam
Enterprise Architect identified for Agile Development and DevOps: SD Times In-depth Feature
Written by sparxsystems
Panorama 360 Insurance and Wealth Management Enterprise Business Framework is available on Amazon
Written by Pierre Gagne
RepoDoc, a call for testing
Written by ArchimetesRead more...
We are Profiling EA Users
Written by sparxsystems
Managing a student project with Enterprise Architect - Part 4
Written by doug rosenberg
Sam NiceDunstan Thomas Consulting
In Enterprise Architect SoaML is provided via MDG Technology as a UML Profile and is included as standard in the following editions of Enterprise Architect:
- Business & Software Engineering
- Systems Engineering
- Ultimate Edition
A service is an offer of value to another through a well-defined interface and available to a community (which may be the general public). A service results in work provided to one by another. Service Oriented Architecture (SOA) is a way of organizing and understanding [representations of] organizations, communities and systems to maximize agility, scale and interoperability.
The SOA approach is simple – people, organizations and systems provide services to each other. These services allow us to get something done without doing it ourselves or even without knowing how to do it -enabling us to be more efficient and agile. Services also enable us to offer our capabilities to others in exchange for some value – thus establishing a community, process, or marketplace.
The SOA paradigm works equally well for integrating existing capabilities as for creating and integrating new capabilities.
SOA is an architectural paradigm for defining how people, organizations and systems provide and use services to achieve results. SoaML provides a standard way to architect and model SOA solutions using the Unified Modelling Language (UML). The profile uses the built-in extension mechanisms of UML to define SOA concepts in terms of existing UML concepts.
For detailed information on SoaML, visit: http://www.soaml.org
The Goals of SoaML
- Intuitive and complete support for modelling services in UML.
- Support for bi-directional asynchronous services between multiple parties.
- Support for Services Architectures where parties provide and use multiple services.
- Support for services defined to contain other services.
- Easily mapped to and made part of a business process specification.
- Compatibility with UML and BPMN for business processes.
- Direct mapping to web services.
- Top-down, bottom-up, or meet-in-the-middle modelling.
- Design by contract or dynamic adaption of services.
- To specify and relate the service capability and its contract.
- No changes to UML.
Getting Started with SoaML and Enterprise Architect
Enterprise Architect provides a MDG UML profile for SoaML that can be used as desired to add service modelling to any project. Two diagrams are provided (both of which are variants of standard UML diagrams):
- SoaML Component Diagram
- SoaML Sequence Diagram
These diagrams are added to any Enterprise Architect project in the usual manner, and when one of these diagrams is chosen then the following SoaML toolboxes are added to the standard UML and EA toolboxes:
We now present some examples of the use of SoaML in the context of a Retirement Insurance Benefit domain. The first example is a SoaML Component Diagram aimed at modelling the opt-level collaboration between elements known as Participants and services known as ServiceContract.
The next diagram takes us down a layer of abstraction and “opens up” one of the ServiceContracts defined above. (Of course these diagrams can be linked by using hyerlinks). This diagram is a SoaML Sequence Diagram and shows the interaction between elements defined as Roles inside a ServiceContract.
The next diagram is another SoaML Component Diagram and is used to model the relationship between a ServiceContract, its Roles and the Interfaces derived from the diagram above that provide the necessary implementation.
The Classes referred to here as types of parameters are added to the EA model in the usual manner and provide a link from the Services Model to the Design and Implementation models.
Finally, by re-using elements defined already, we can formulate a SoaML Component Diagram which models the Service Usage.
In this tutorial, we have outlined the SoaML MDG UML profile that is available for Enterprise Architect together with how to get started using the technology.
When working on large diagrams modellers often need to identify certain elements that are of particular interest to them.
Some examples of element selection are:
- Elements which have no value for a particular property (for example the Description)
- Elements who share the same value for a particular property (for example Status or Phase)
- Elements that were written by a particular person
- Elements that have (or have not) been modified since a certain date
Diagram Filters functionality was added to Enterprise Architect version 8.0. Currently the Diagram Filters function only operates on Elements that are visible on a diagram (but the same Diagram Filters can be applied to diagrams of different types). They work by using a slimmed down version of the Search Filters already built-into Enterprise Architect, but instead of returning a list as a result of the search, the appearance of the Elements on the diagram can be changed.
There are four effects that can be applied when Diagram Filters are in use on a diagram, these are:
- Fade – display all elements that do not match the filter criteria in a pale version of the diagram background
- Gray Scale – display all elements that do not match the filter criteria in pale grey
- Hide – conceal all elements that do not match the filter
- Select – select all those elements that do match the filter criteria
Initially the above seems confusing, but when you see the Diagram Filters in action, the effects described above will become more intuitive. It must be noted that any one of the four effects can be applied with any Diagram Filter, that is to say, the effect is not part of the Diagram Filter but rather it controls how the filter is applied to the diagram.
A simple example should clarify matters. It is common modelling practice that all Elements on a diagram be elaborated with a textual description, captured in the Notes property of an Element within Enterprise Architect.
Some modellers add these notes as they create elements whereas others do not, so if we imagine a project team working collaboratively, how can each member of the team identify which elements have notes and which do not? Although there are many possible solutions to this problem, this example will illustrate a simple solution using Diagram Filters.
- Open a diagram and then select View | Diagram Filters from the main menu to open up the Diagram Filters view (as shown below)
- Create a new Diagram Filter, by clicking on the toolbar icon
- Give the Diagram Filter a suitable name, for this example I have used Needs Description
- Create a Diagram Filter by completing the following dialog
- In this example we need a simple filter that tests the value of the Notes property to be Equal to nothing. The condition is selected from a drop down list
- After setting these options our filter now looks like
- Click OK
- The Diagram Filter is now added to the list of available filters (it is perfectly feasible to have many Diagram Filters defined and apply them in many different combinations)
- To apply the filter to the current diagram, use the Drop Down list (Fade, Gray Scale, Hide, Select…) to set the effect and click the check box next to the Diagram Filter name.
The following images illustrate the application of the Diagram Filter for each of the four effects.
Fade out those elements that do have a description leaving those elements that need a description
Colour grey out those elements that do have a description leaving those elements that need a description
Hide those elements that do have a description leaving those elements that need a description
Select these elements that do need a description leaving those elements that have a description unselected.
The modeller is able to identify quickly and easily those elements that require a description to be added.
For some diagrams with many different element types, a filter setting for a particular Object Type could be added to the filter testing for the empty Notes property. Currently, Diagram Filters cannot use a search term, so a separate Diagram Filter would have to be created for each element type.
- If a Diagram Filter has been applied to a diagram (or diagrams) and documentation is produced, then the effect of the filter will be replicated in the documentation output.
- Also the application of a diagram filter does not mark the diagram as unsaved, hence if a Diagram Filter is applied, then diagram closed, when the diagram is re-opened the Diagram Filter is not applied despite the fact that it may still be checked in the Diagram Filters view.
In this tutorial, we have described how use Diagram Filters to “fine tune” the appearance of diagrams. Diagram Filters are a potentially valuable aid to modellers, particularly those who work in a collaborative modelling environment.
You can read more articles like this on our blog.
Users of Enterprise Architect may be aware of the use of “Gang of Four” Design Patterns (Gamma et al) in the use of software designs and the support that Enterprise Architect provides for using these “Gang of Four” patterns.
Enterprise Architect also provides facilities for modellers to create and share their own design patterns. Users of Enterprise Architect may be under the impression that creating and sharing your own patterns is restricted to UML class diagrams however this is not the case.
This tutorial presents an illustration of creating, using and distributing a Business Process Workflow pattern using BPMN 1.1
Business Workflow Patterns
The research work of Professor van der Aalst has resulted in the identification of 21 basic workflow patterns that describe the behaviour of business processes.
These patterns are divided into the following categories:
- Basic Control Flow Patterns
- Advanced Branching and Synchronization Patterns
- Structural Patterns
- Multiple Instance Patterns
- State-based Patterns
- Cancellation Patterns
However you are free to create your own modelling patterns.
For the purpose of this newsletter, I will describe the following pattern, which I will refer to as “Parallel Process Error Propagation”. This pattern is illustrated below:
This workflow patterns ensures that if an exception occurs, then this is handled by a common activity.
Creating the Pattern
To create your own pattern, you must first model the pattern using a diagram from your chosen notation (in this case a BPMN 1.1 Business Process Model Diagram). I would recommend that ALL elements are named so identification within the pattern is made much easier. So the pattern can be maintained I recommend that a separate Enterprise Architect project is used to model your patterns.
The diagram created must now be saved as a UML Pattern using the following steps:
- Select Diagram | Save UML Pattern…from the main menu. The following dialog displays
- Complete the dialog as follows:
- In the Pattern Name: field enter a name to identify your pattern
- In the Filename field, enter a directory path and filename in which to save the pattern
- In the Category field, enter a name under which your pattern will appear in the UML Patterns section in the Resources view
- In the Version field enter any desired version number and in the Notes field enter a description of your pattern
- Complete a selection for the actions that are available when the pattern is used
- Create: creates the pattern directly adding new elements to your model
- Merge: Uses existing elements in your model and assembles them into your pattern (refer to Limitations later in this newsletter)
- Instance and Role are only where Object, Ports or Parts are used within your pattern
- You can also enter a comment for each element in your pattern to give some guidance as to its purpose within the pattern
The illustration below shows a typical completion of the UML Pattern dialog
- After completing the dialog click OK to save your pattern
Importing the Pattern
In order to use your pattern, it must be imported into you modelling project:
- Select the Resources window (if this is not visible, then use the View menu to select the Resources view)
- Right-click on the UML Patterns node, and select Import UML Pattern
- Navigate to the file created when you saved your Pattern
- Click Open to complete the import process
If all has gone well, you should see you pattern in the Resources view as shown below:
Using the Pattern
To use your newly imported pattern, perform the following steps:
- Create a new diagram that matches the type used when the pattern was first created (for this newsletter, this would be a BPMN 1.1 Business Process Model
- Using the Resources view, locate the pattern and Drag and drop the pattern onto your diagram, the following dialog displays:
- Assuming that you wish to Create a new pattern, then for each element in the pattern click the … button and enter a new name (which can be blank) for your element. A typical example is shown below:
- Click OK and your pattern should appear on your diagram using the names you entered in the dialog. This is shown below:
(Note as the labels for the error intermediate event were hidden in the pattern, they are also hidden in the above diagram)
When creating patterns based upon PURE UML diagrams then all features work without fault. However it is important to note that basing a pattern on a UML Profile (which BPMN is) then the Merge option does not work, therefore for BPMN patterns it is not possible (currently) to use existing BPMN elements and assemble them into a pattern.
In this tutorial, we have described how create and use a pattern based upon a modelling notation other than UML.
You can read more articles like this on our blog.
This webinar from Dunstan Thomas demonstrates the capabilites of the AMUSE add-in for Enterprise Architect.
It is presented by Phil Chudley, one of the Senior Consultants and OMG Certified UML Professionals at Dunstan Thomas, but was a combined effort of Phil & Daniel Siegl, Chief Executive Officer, LieberLieber Software GmbH.
During the webinar Phil demonstrates working examples of what AMUSE can do as well as creating an example from scratch. This webinar was orginally broadcast by Dunstan Thomas on the 11th of October 2010.
You can view this & all of our archive videos on our website; http://dthomas-software.co.uk/resources/videos/webinar-archive/
In this newsletter we provided an overview of a new Add-In called AMUSE for Enterprise Architect version 8.862.
An Overview of AMUSE
AMUSE (Advanced Modeling in UML with Simulation and Execution) is an Add-In for EA 8.0 Build 862 or EA 7.5 Build 850 or higher is required (EA Systems Engineering or Ultimate Edition) and extends the functionality of Enterprise Architect to provide the ability to execute workflows that have been modelled using UML State Machine Diagrams. This Add-In has been developed by LieberLieber (www.lieberlieber.com ) and is marketed as:
“Detecting issues early in the project lifecycle can save a lot of time and money. With AMUSE you can validate your Enterprise Architect UML Model to correct errors in your business workflow or application logic before your software engineers write a single line of code. You also can reuse the source code generated by AMUSE for your applications (C# supported in the standard package).
With AMUSE you can create models on any abstraction level and initiate testing in the very early project stages. By integrating mock-objects, existing applications and external hardware, even highly complex behaviors can be validated.“
AMUSE can be downloaded from http://www.dthomas.co.uk/dtalm/products/plugins.htm#AMUSE
A Worked Example
The most appropriate method to describe the functionality of AMUSE is to work through a simple example. Although AMUSE can integrate with .NET dll files, referred to a .NET Mocks, this example takes a somewhat language independent approach.
The example we will be using to illustrate AMUSE is the verification of a workflow designed to model the following situation:
A user is required to provide authentication details consisting of a UserName and a Password. These will be then validated against stored information and the user will be either authenticated or denied access.
Our first stage would be to consider the business rules surrounding this simple example. These are:
1) The user name is alphanumeric of no fixed length
2) The password again is alphanumeric, but must be of at least 8 characters in length
Analysing the above yields three possible error situations:
1) The user name is invalid (does not exist)
2) The password is of the incorrect length
3) The password is incorrect
Using this information we can construct a simple workflow, modelled as a UML State Machine diagram, The key points to bear in mind when modelling workflows as State Machines intending them to be simulated using AMUSE is to use the following:
1) The workflow itself is modelled as a UML Class element which has its language property set to C#
2) A State Machine is added to this class as an immediate child element, this State Machine element will have a child UML State Machine Diagram where the workflow can be modelled.
3) A UML State element is used for every step within the workflow
4) A Transition is used between states (as usual)
5) If a state is simulating a user input, then attach a trigger to the transition to model each possible response from the user. For example, if a User Dialog has two buttons “SUBMIT” and “CANCEL” then two triggers would be created and assigned to two corresponding transitions.
6) Any workflow state data (for example any data the user enters, and simulated stored system data) must be represented as public Attributes for the class created in step 1)
7) The action performed (if any) performed at each step within the workflow (for example a simple validation of user data), is represented as public Operations for the class created in step1)
8) These operations are then linked (as behaviour) to corresponding operations added to the appropriate State elements.
The above infers (somewhat incorrectly), that you would have to be a C# guru in order to use AMUSE effectively, whilst it certainly helps to have some C# programming knowledge; it is by no means essential. The tutorial that ships with AMUSE walks you through a simple example and introduces (as indeed does this newsletter) some very common repeatable code that you can use and modify for your own simulations.
The screen shot below shows the starting position, after a project has been created; the workflow class and associated State Machine have been created:
The Workflow Modelled
Using the business rules above, the following workflow as a UML State Machine Diagram can be created:
Note we have only a single state to display one of the three possible errors that could occur. This method is to be preferred over one state for each possible error.
We now add triggers for the two possible transitions from DisplayLoginForm, these correspond to two buttons on the eventual Login Dialog
Next, we address the issue of what state data we need to add to the class, analysing the workflow requirements we need the following:
- StoredUserName – string
- StoredPassword – string
- EnteredUserName – string
- EnteredPassword – string
When adding these as attributes to the workflow class we will also need to:
1) Store a “hardcoded” value for the StoredUserName and StoredPassword
2) Initialise the EnteredUserName and EnteredPassword to an empty string
The next task is to determine how the state machine will decide which of the two possible transitions from the state ValidateUser. We could use triggers, but a more “automated” approach would to be use a guard constraint on each transition. Each guard constraint is represented by an attribute (of type bool) within the workflow class.
After these additions we have:
Now for the “techie” part! We add the operations. A simple way to display the progress (on our workflow the states begin with “Display”), is to pop-up a simple message box. The C# command for this is:
Where <message> is a string (enclosed in double quotes) representing the message to be displayed, and <title> is the title of the message box.
For example, to simulate the Login Dialog we could use the following:
System.Windows.Forms.MessageBox.Show(“Please enter your user name and password”, “Login”);
This is entered as an operation / behaviour / initial code for the workflow class, as shown below:
This operation can be replicated in the corresponding state by adding an operation to the state and linking its behaviour as shown below:
Finally, our last step is to add an operation that will simulate the validation of the data entered by the user. This is an operation added to the workflow class and then linked to a corresponding operation in the state ValidateUser.
Which results is our final model:
Running the Simulation
To run the simulation, use the View menu and activate the Add-Ins window.
The current State Machine can then be added to the Add-Ins window as shown below:
Clicking the Green Triangle will compile the workflow (hopefully there will be no errors), and the simulation will begin. The simulation will execute the operation showLogin and the message box will display.
After clicking the OK button, simulation will continue and then halt, waiting the trigger to be fired (simulating the user clicking a button on the Login Form)
The simulation now offers the opportunity to “fire a trigger” and / or enter some user data.
The screen shot below, shows the effect of entering an unknown user name:
After clicking OK the workflow loops back to the initial state, at which point other combinations of data can be entered to verify all possible displays.
In this newsletter we have described how you add workflow simulation to your modelling by using a new Add-In for Enterprise Architect, namely AMUSE. If this has whetted your appetite why not give it a trial run?
You can read more articles like this on our blog.
The webinar looks at Team Foundation Server, Microsoft's entry into the domain of Application Lifecycle Management (ALM) tools, and how it can be used alongside Sparx Systems' Enterprise Architect UML Modelling tool.
- Webinar Goals/Introduction
- Integration Options:
- Modelling in Visual Studio
- Developing in Enterprise Architect
- Controlling EA packages using TFS
- TFS/EA integration
- Work item management in EA
- Requirements management in TFS
You can view this video and all of our archived videos on our website; http://dthomas-software.co.uk/resources/videos/webinar-archive/
The webinar is presented by Phil Chudley one of the Senior Consultants and OMG Certified UML Professionals at Dunstan Thomas.
- Provide an overview of the projects within Enterprise Architect & when to use:
- Standalone Projects
- Shared Projects
- Master Replica
- Version Control
- Describe Baselines including Branch and Merge
- Provide advice on how to apply security to projects including locking policies.
This webinar concludes with a Q&A session in which Phil is joined by Stuart Trotter, Principal Consultant & OMG Certified UML Professional.
You can view this video and all of our archived videos on our website; http://dthomas-software.co.uk/resources/videos/webinar-archive/
Dunstan Thomas ALM, LieberLieber and eaDocX have joined forces to bring you the inaugural European User Group Event.
This event aims to bring together users of Enterprise Architect from across the UK & Europe for an afternoon of networking & technical discussion with presentations from all three partners covering different aspects of the implementation of Sparx Systems Enterprise Architect.
Agenda; Tuesday 9th of October 2012
The agenda for the day will be as follows;
• 12:30 - Registration & Networking
• 13:00 – Introduction and Agenda
• 13:30 – The Future of EA
• 14:00 – Creating Excellent Documents from EA – by Ian Mitchell of eaDocX
• 1430 – Requirements Management – Best of Both Worlds - by Phil Chudley of DT ALM
• 1500 – Enterprise Architect in Distributed Environments - by Daniel Siegl of LieberLieber
• 1530 – A Customer's Story
• 1630 – QA and Panel Session
The location for our inaugural event will be the prestigious Institute of Directors, located in heart of London's West End, 116 Pall Mall is a magnificent Grade I listed, Crown Estate building.
The Institute of Directors is located at; 116 Pall Mall, London, SW1Y 5ED (View Map)
There is a dress code of smart / casual for this event.
If you would like to register for this event all you need to do is contact us with the following information; Name, Company, Telephone Number, Email Address. Once we've received your information we'll send you a confirmation and also a reminder nearer the time.
You'll be able to get regular updates through our twitter feed by following @DTUML and also by watching our Facebook page.
We've three new courses in all each varying in length & complexity;
- Introduction to Enterprise Architecture; 1 Day
- TOGAF Demystified; 2 Days
- Putting TOGAF into practice using Enterprise Architect; 4 Days
Please visit our website if you would like to book onto any of the above courses.
Systems Engineering with SysML 1.1; Overview
The Systems Engineering with SysML 1.1 training course is designed to provide System Engineers with a detailed understanding of the practical application of SysML 1.1 to Systems Engineering projects, using a Model Based Systems Engineering (MBSE) approach.
What will I learn on the Systems Engineering with SysML 1.1 training course?
This course covers the practical aspects of SysML and is “tool agnostic”, although example models will be used to underpin the concepts covered. These example models have been created using Sparx Systems Enterprise Architect.
Click here to view the complete outline.