Top Community Contributors
For whom develops systems, a good and integrated toolset is fundamental: Herminio Lourenço
Written by sparxsystems
Managing a Student Project with Enterprise Architect – Part 2
Written by doug rosenberg
What's new with ArchiMate 3.0 & EA v.13?
Written by DT_Sam
Reader's Choice Award Recognizes Sparx Systems For Software Architecture
Written by sparxsystems
Managing a Student Project with Enterprise Architect – Part 3
Written by doug rosenberg
Fast access to each diagram in Enterprise Architect
Written by Dr. Konrad Wieland
EA TFS Connector a new add-in for the Bellekens EA Toolpack
Written by Geert Bellekens
New SysML Book for Enterprise Architect Users
Written by Dr. Konrad Wieland
Software and Systems Engineering, as any other interdisciplinary activity, requires the ability and means to build systems which are so large and complex that they have to be built by teams or even by teams of teams of engineers. In combination with a model-based approach, these teams need the possibility for modeling in a concurrent way. With other words, multiple users must be able to work on the same model in parallel or even on multiple versions of the same system. In code-centric software engineering, developers profit for years from the features provided by Version Control Systems (VCS), whereby one of the most important features is the possibility of comparing and merging changes of the same file. The key technique hereby is the so called three-way difference analysis which is also considering the common ancestor version of the artefact under comparison. Traditional approaches uses text- and line-based comparison tools, which are not suitable for graphical-based models.
In general, two different versioning strategies exist to cope with the concurrent evolution of one artifact. These are described in the following:
When pessimistic versioning is applied like it is implemented in EA, an artifact is locked while it is changed by one developer. Since other developers cannot perform any changes while the artifact is locked, conflicts are completely avoided with this strategy. However, the drawbacks are possible idle times for developers waiting for the release of a locked artifact.
To avoid such idle times, optimistic versioning allows the developers to change the same artifact in parallel and independently of each other. This process is depicted in the following figure:
The following videos give you insights into the latest developments in model versioning and act as tutorials in how you can set Enterprise Architect models under optimistic version control:
For more information please visit: lemontree.lieberlieber.com
LieberLieber is proud to present a brand new Enterprise Architect tool named LemonTree (c). The most important function of this ground-breaking product is the diffing and merging of model versions.
Now, you do not have to lock your packages. Just check-in your eap files in your version control system!
Standard approaches use line- and text-based applications that do not suffice for graphic models. Only the finely-grained 3-way diffing algorithm that considers the model’s graph structure enables an exact comparison between two models.
- Diff & Merge: Diffing and merging of Enterprise Architect models
- Model Versioning: Parallel editing of models with optimistic model versioning
- Integration: Seamless integration with Subversion (Tortoise) included
- Automation Interface: Automate LemonTree and integrate it in your versioning tool such as Git, PTC, or SVN
- Model Branches: Branches of models (longer-term, parallel development of versions and variants)
- Merge Preview: Diagram merge and merge preview
- Review: Changes are visualized clearly and understandably for review (including preview)
Stefan Mueller, HIMA Paul Hildebrandt, Safety-Related Automation Solutions: “In general, standards such as IEC 61508 demand the application of configuration management. This applies to all artifacts, including UML models. LemonTree from LieberLieber is our key to revealing the changes that have been made to a revision.”
Test LemonTree now and give us your feedback!
For more information: http://lemontree.lieberlieber.com/
I've been an EA add-in developer folk since version 9 now and every time Sparx announces to release a new version of EA, I look at it with a smile in one eye and a tear in the other. New features on the one hand allow us developers to deliver add-ins with greater user experience, but on the other hand, it also forces us to keep on track with changes in the API and adapting our yet working solutions to them.
However, the EA release notes coming with every new build give only a subset of API changes for developers among mostly EA user-related stuff which is perfectly fine, but not very effective for developers.
In this article, I'm going to show you a small tool I developed for exactly these purposes:
- Highlight for each existing object model class and each broadcast event the changes from a selected source version to a selected target version
- Make the result of the comparison persistent so that it can be possibly copied around or saved in version control
- If possible, show only the actual changed classes/events to have a condensed view on only those
How does the tool work?
The approach, I used, before I had the idea to develop the tool was more or less like you see it in the picture below:
- Fire up to instances of the browser having the old online help version of each class on the left and the new online help version on the right
- Scroll through both side by side and try to not overlook but identify the changes
- Do this for every class/event that exists in the API
Being a computer scientist, it was a natural thing to think about how this process can be speeded up or even automated!
So I searched the net for a tool being able to perform a diff of web pages, because that is obviously not an easy task on HTML source code level.
I found a web page that is exactly doing the change detection/diff for two provided URLs. The advantage is I have only one page where the changes are highlighted plus I don't have to read the rest.
The result looks like this:
Making use of the web page still forced me to perform the diff for each and every class or event separately, i.e. copy URLs of the EA online help pages in the change detection web site and examine the results.
In the end, I automated this task as well by writing a .NET tool that maintains a manually collected list of online help pages and sends a diff request to the change detection website. The response is saved on the local machine class by class in its own html file. Around all these html files I built a simple website that allows easy navigation to the diff of each class.
How does the result look like?
As can be seen in the screen below, on the left frame of the index page, we see a navigation bar to the classes that have changed. Clicking on any of those loads the respective diff in the main frame on the right.
Unfortunately, the change detection website detects ALL changes in the whole HTML file. This means that it cannot be avoided to have false positives, when Sparx changes page layouts or the table headers/footers systematically. As can be seen in the screenshot, the diff between version 12.1 and 13 seems to work quite well :-)
Where can I get the tool and how can I use it?
The tool comes with a minimalistic UI, were source and target version can be selected and after having selected a folder where the results should be saved the process starts to run automatically.
The tool executable is attached to this article and needs an installed .NET framework 4 on the machine. By the time of this writing, EA versions 9.3, 10, 11, 12.0, 12.1 and 13 are supported. An advice of mine is to diff version by version to avoid having too many false positives because of layout changes.
Note that the tool contacts the change detection website and therefore requests an outgoing connection to the internet.