It’s that classic line from Monty Python’s film, “The Life of Brian”:
And I was thinking about how to answer this question if it was re-phrased as “What has Archi ever done for us?” or even, “What has Archi ever done for ArchiMate?”
I’m not going to presume anything about the global impact that Archi might have made during its 6 years existence, it might be better if its thousands of users attested to its apparent ubiquity, usefulness and popularity.
But, first, here’s a quote from an Enterprise Architect that someone sent me:
Archi does more to popularize the use of ArchiMate…In my practice as an EA I regularly encounter professionals who refer to Archi as ArchiMate. They are often quite stunned when I point out the difference.
It’s certainly true from my experience that very many people seem to think that Archi and ArchiMate are synonymous. I wouldn’t wish to perpetuate this misunderstanding and I do try to make clear the distinction between Archi® the tool and ArchiMate® the language (both are registered trademarks), but perhaps it’s a bit like the immediate association that we make with internet search and “Google” – “to Google”. The key is in strong branding, clear product and The Power of Pull.
We’re asking users to tell their stories here on this blog about how they use Archi and ArchiMate to model the enterprise, and there are many other stories being posted on-line, but for now I’ll provide some plain statistics. Here are the download figures for Archi as provided by Google Analytics for the Archi website from January 1 2014 up to yesterday (July 12 2016). Note that the Archi website only started to host the downloads from about January 2014 onwards, before that they were available from the old website.
Download figures for Archi from Jan 1 2014 to July 12 2016
And here’s the global picture of site access for the top 30 countries:
Archi website access by country
Adjusting for duplicates and other factors there seems to have been about 3,000 – 4,000 downloads a month of Archi. The Netherlands (the birthplace of ArchiMate) is top of the list in the countries league, followed by the United States and the UK. Russia comes in at 4th place, and I know for a fact that Archi is really popular there, since it has been translated into Russian.
So, what has Archi ever done for the global uptake of ArchiMate? Or, to put it another way, I wonder how popular ArchiMate would be now if, in a parallel universe, Archi had not existed.
I won’t answer that but I will say this – it’s probably a good idea to keep going with Archi.
Are you sharing your ArchiMate models and design patterns with the rest of the ArchiMate modelling community? Or are you hiding them in company silos? What are good and useful examples of ArchiMate models currently in circulation? How does one start with the ArchiMate language as a beginner?
Interesting questions. I often get emails from newcomers to the language asking for examples of ArchiMate models, or snippets of models, to repurpose as design patterns of best practice for learning and training, or to use as a starting point in real-world modelling scenarios. What currently exists in the public domain? Well, there are some excellent and helpful blogs and books with examples of ArchiMate modelling patterns, and there’s always the old favourite, Archisurance (which is probably getting a bit long in the tooth now), and maybe some I’ve missed, but I can’t find a whole lot out there.
Wouldn’t it be great to have a place to share ArchiMate models and parts of models, say, in a public repository? And even better if this repository was searchable by keywords and properties, and maybe even showing a thumbnail preview of the diagrams in the model? And perhaps also supporting user ratings and comments? And, of course, the model files should be in The Open Group’s ArchiMate Exchange Format, so one could open them in any ArchiMate tool.
Well, I did take a stab at this some time ago by creating a public GitHub repository for just this purpose:
ArchiMate Models at GitHub
As you can see, there are only three models there at the moment (and, yes, I included that old chestnut, “Archisurance”), and GitHub doesn’t really support user ratings or comments, but maybe it’s better than nothing, and of course Git and GitHub does support versioning.
Would you like to share and upload ArchiMate models? If you’d like write access to the GitHub repository, contact us. I’m not asking you to share your company secrets by posting confidential model data, but rather to share basic model patterns, anonymised models, or even processes taken from domestic life (feeding the cat was a popular modelling exercise).
GitHub might not be the best place to share ArchiMate models, but it’s a start and, who knows, maybe one day we might have a public “ArchiMateHub” available tuned to this specific task?
Slightly belated Summer Solstice Greetings! It’s time to provide an update on the latest events and progress from Archi world. These are interesting times we live in, and it’s an interesting time of the year. Hence the title of this update – referring of course to Shakespeare’s play dealing with the themes of confusion, trickery, and dreams. And hopefully, as in the play, after a night of foolery and ambiguity, it all works out in the end.
I released a maintenance release of Archi, version 3.3.2, at the beginning of June. This contained a few bug fixes and some new features for the Visualiser and HTML reports. Both contributions were provided by Jean-Baptiste Sarrodie, now working for Arismore in Paris, who has over the years proved to be an absolutely amazing supporter for me personally, and tireless evangelist for Archi. As we move forward, J-B’s vision and involvement in the project will prove to be more vital. It was a pleasure to finally meet J-B in London at The Open Group’s event earlier this year.
There was quite a gap between the previous release, version 3.3.1 in October 2015, and 3.3.2 released this month, and the reason for this was to allow the dust to settle on last year’s release of The Open Group’s ArchiMate Exchange Format, and to wait for the official release of ArchiMate 3.0.
The latest version of ArchiMate was officially released on June 14th. This is a significant development, as we shall see. I won’t go into all the details of what’s new and what’s changed but it’s as if a new broom has come in and swept up all the bad stuff, and re-arranged all the furniture at the same time, hopefully for the better. There are new concepts, such as Capability, Resource, Course of Action, a new Physical layer, relationships to relationships, and a whole lot more. This is a major update to the language. There’s a summary of what’s new here.
Archi, ArchiMate 3.0 and the future
Archi does not currently support ArchiMate 3.0, only version 2.1. I’m now seeing the same question being asked repeatedly on Twitter, in forums, in webinars, in emails, and in person – “When will Archi support ArchiMate 3.0?”.
As I type this, I’ve stopped to consider my response to this burning issue. There are a number of possible responses and I’m not sure which one to choose. Should I mention the significant amount of work involved in this? Should I ask where I might find the time for such a non-trivial task? Should I question whether I am prepared to work for several weeks, if not months, to single-handedly code, document, test, deploy and support a major new update to a piece of software used by hundreds (although it’s probably thousands) of professional enterprise architects. For free?
Let’s be clear about one thing – since it’s initial release in 2010, Archi has become an extremely popular tool in this domain, and many organisations (and some very major ones, too) use it and depend on it. Archi is downloaded on average about 3,000 times a month. Every month. Archi is a game changer and it is a major contributor, if not the major contributor, to the uptake of ArchiMate globally. This is a significant responsibility for one person. For free?
And let’s be clear about another thing – updating Archi to support ArchiMate 3.0 is not a trivial undertaking. It is not simply a matter of adding a few new concepts, compiling the code and then heading down the pub to celebrate. There are many factors to consider – a whole new refactoring of the code, backward compatibility, documentation, testing, asset management, build processes, and of course providing unpaid support. Typically, this process is managed by a team of employed developers, not one (unpaid) person. Some people have suggested that the work can be done in a weekend, or that their nephew has just learnt Java and will do it for a packet of chewing gum.
This has to change, and I have personally come to a crunch point. To be blunt, either I get funding to continue with Archi or I’ll do something else.
Having said that, there is hope. As Robert Fripp says:
In strange and uncertain times such as those we are living in, sometimes a reasonable person might despair. But hope is unreasonable and love is greater even than this. May we trust the inexpressible benevolence of the creative impulse.
Indeed, there is hope. But there are dark clouds, too.
Consider the overall strategy of promoting and supporting the ArchiMate language with an open source implementation and data format. A central plank in this strategy is The Open Group’s ArchiMate Exchange Format. This has proved to be a significant thing, with more and more tools supporting the format, and users discovering further uses for it and realising many benefits of an open data format.
However, the introduction of ArchiMate 3.0 means that a new version of the exchange format needs to be developed, and, indeed, this initiative is ongoing.
But this means that I will need to develop a new implementation of the exchange format in Archi. Archi currently supports the exchange format for ArchiMate 2.1. But, here’s the thing – Archi cannot implement and support a new version of the exchange format if it does not implement ArchiMate 3.0. Obviously, implementation of ArchiMate 3.0 is a pre-requisite for implementation of a new ArchiMate exchange format in Archi.
Furthermore, we need now to recognise that Archi has become an Enterprise in itself. Jean-Baptiste Sarrodie made the compelling case for this with reference to Tom Graves. To use Tom’s definition of an “Enterprise”, Archi has become
a bold endeavour; an emotive or motivational structure, bounded by shared-vision (purpose), shared-values and mutual commitments.
And, to me at least, it’s clear that Archi incorporates a powerful shared vision, and one held by many stakeholders. It is too important to fail.
As I said, there is hope. Hope lies in the fact that funding may have been secured from a benevolent source so that we can proceed with our bold endeavour. On the other hand, the dark clouds that I mentioned are manifesting as opposition to this funding from some not-so-benevolent quarters.
So, please, if you feel that you are part of this “bold endeavour”, speak up and assert your support for Archi. The future is open.
Jean-Baptiste Sarrodie and I have been emailing back and forth for some time with some positive ideas and we now agree on what amounts to an “Archi Philosophy”, a set of principles that guide our future development of Archi and associated services. But these principles have already been written about in detail in the book, Rework, so all I can really do is talk about key points that relate to Archi and quote relevant passages from the book that resonate with us. I want to expand upon these principles and where we see Archi going (a.k.a the “roadmap”) in future blog posts, but, for now, regard Rework as our manual of truth and guiding light.
In this post I want to talk about open source and some of these guiding principles.
Archi’s code has a liberal open source licence, the MIT licence. It means that anyone can take the code and build a commercial product based on it. You can build a commercial product from the code, Microsoft can build a commercial product from the code, and your great aunt Edna can build a commercial product from the code. Heck, even I can build a commercial product from the code. So, what’s to stop somebody else from hijacking Archi and making something commercial from it? Actually, nothing. And, in fact, we want this liberal licence to stay in place because many organisations and developers have already built some interesting things based on Archi’s code, and they use it in a commercial setting. Also, the MIT licence is compatible with other licences.
Here’s a relevant passage from Rework that summarises our view:
Decommoditize your product
If you’re successful, people will try to copy what you do. It’s just a fact of life. But there’s a great way to protect yourself from copycats: Make you part of your product or service. Inject what’s unique about the way you think into what you sell. Decommoditize your product. Make it something no one else can offer.
Look at Zappos.com, a billion-dollar online shoe retailer. A pair of sneakers from Zappos is the same as a pair from Foot Locker or any other retailer. But Zappos sets itself apart by injecting CEO Tony Hsieh’s obsession with customer service into everything it does.
It’s unlikely that somebody would sell a product that has the exact same functionality as Archi using the code but, even if they did, here’s the thing:
Make you part of your product or service.
You see, Archi is a way of doing things and this is what sets it apart. So let’s list some of the guiding principles that make my and Jean-Baptiste’s philosophy part of the product:
There will always be a free and open source version of Archi
Archi is agile, intelligent and lightweight
We believe in elegant and simple design
We do not ask you for your contact details (but please get in touch!)
We believe in “open”, in open standards and in open source, and are therefore open and transparent in what we create
We want to build services based on trust
We believe in sharing
We want to create new ways of doing things
We want to make Archi and its services fun
So, if somebody does take the code and tries to sell another product based on Archi, then good luck to them because they ain’t us!
But let’s be perfectly clear about one thing. When we say that “there will always be a free and open source version of Archi” this does not mean that we will necessarily work for free or that we might not develop some paid-for services that would support Archi in the future. ArchiMate 3.0 will be released on June 14th and it’s important that Archi implements it, both for itself, for its thousands of users, and for the sake of The Open Group’s ArchiMate Exchange Format. This work is not trivial and will take a lot of effort, but unfortunately I cannot do this unpaid as I like to eat and pay bills. So we are now seeking sources of funding that would support this development. We are also thinking about how we can generate some form of income that would help sustain Archi for future support and features. Jean-Baptiste and I have some great ideas for Archi, but first we need to implement ArchiMate 3.0. Let’s work together in bringing you some great tools with the Archi Philosophy.
We’ve just released Archi 3.3.2 which fixes a few bugs and add a Viewpoint and direction filter to the Visualiser, and also tag support for customisable reports. Thanks to Jean-Baptiste Sarrodie for the work on the reports and the Visualiser!
In this Archi Spotlight, Peter Gee talks about how he introduced ArchiMate and Archi to the government of New Brunswick in Canada.
Peter, tell us a little about yourself and how this initiative came about.
Several years ago, the Office of the CIO for New Brunswick embarked on an Enterprise Architecture (EA) program. I was brought in as a consultant to help build a Business Architecture framework, which was considered to be an important foundational piece of the EA landscape. While working with them, I introduced ArchiMate as the recommended modeling notation. Since they had no “official” tool in place I also introduced them to Archi as a means to learn the language and start on the development of some Business Architecture models.
How do you find working with Archi?
Archi is very easy to install and much quicker to learn than most of the commercial tools I have worked with. It also had “just enough” functionality to support our modelling needs at the time. Archi’s CSV import/export functionality allowed us to quickly import model content from external sources as well as utilize an export-update-import approach to manage bulk updates to the model. Its support for the Open Group’s ArchiMate Model Exchange File format further guarantees the portability of model files and mitigates the risk of vendor lock-in. Its sole limitation is that it does not support external image files in a diagram.
What is the nature of the project?
The key deliverables for the project included a Business Capability Map which was developed as a hierarchical, nested diagram based on a set of ArchiMate “business function” elements. Since ArchiMate 2.1 does not include a “capability” element, we followed the prevailing practise of using the “business function” element for this purpose. We also used the Jasper Reports module included with Archi to generate a supporting Business Capability Reference document which contained the capability descriptions, as well as other supporting information.
New Brunswick is officially bilingual (English/French) so we were required to publish these deliverables in both official languages. You can view the resulting deliverables in the following links:
(the Business Capability Map and Reference Model are accessible via the “Quick Links” section on each page)
What techniques were used to produce these artifacts?
This is a summary of some of the techniques:
The Capability Map was created as an ArchiMate view and then the diagram was exported as a PDF file.
Pages that include graphics were created using blank Business Canvas pages.
The Provincial logo was added to the PDF using the open-source Inkscape graphics editor – https://inkscape.org
The Reference document was 100% generated from Archi using a customized set of Jasper control files.
The Jasper report was generated in MS Word format in order to fine tune page breaks and add headers and footers.
User-defined properties for “French:name” and “French:documentation” were added to the French versions.
The model was exported to CSV files, using some Excel tricks to swap the French and English values, and re-imported to Archi before repeating the above steps
Many thanks to Peter Gee for providing us with an insight into how he uses Archi and ArchiMate. It’s interesting to see from the summary of techniques used a specific work-flow emerging when using Archi. This work-flow is valuable in determining possible features in future versions of Archi.
If you’d like to share your story about how you use Archi and ArchiMate and you’d like to be featured in this “Archi Spotlight” series please contact us.
In this blog post I describe how to generate a basic standalone HTML report from an XML file exported in The Open Group’s ArchiMate exchange format using an XSLT stylesheet.
In my last blog post I wrote about The Open Group’s ArchiMate exchange format and how its main purpose is to allow the exchange of ArchiMate models between conforming tools. I also mentioned that it could be possible to do more with an ArchiMate exchange file, and use XSLT (Extensible Stylesheet Language Transformations) to display the contents of the file in a human readable format. XSLT is a language for transforming XML documents into other documents or other formats such as HTML, plain text or PDF, and as an ArchiMate exchange file is in a fairly straightforward XML format this should be possible.
This idea was first brought to my attention (via Andrew Josey of The Open Group) by Thorbjørn Ellefsen, Security Architect for the Agency for Public Management and eGovernment (Difi) in Norway. Thorbjørn had suggested that this would be an avenue worth exploring and provided a simple XSLT file that demonstrated the process. This piqued my interest and so I took Thorbjørn’s XSLT file and played around with it to see if I could produce some interesting HTML that could be used as a proof-of-concept ArchiMate report. In this blog post I want to share the results of my experiments.
Generating the ArchiMate Exchange XML file
The first thing we need is an ArchiMate model saved in the correct format. In Archi I exported the “Archisurance” example model to The Open Group’s exchange format:
I named the output file as “Archisurance.xml”. You can download a copy of the file here.
Here are the first few lines of the file:
Dublin Core1.1ArchisuranceArchisuranceAn example of a fictional Insurance company.
As you can see, it’s not exactly user-friendly, but we can use this file as the data input for something more useful. If you have exported the file yourself and viewed it, you may notice a slight difference between your copy and the one above. Note that the following line has been added near the start of the file:
This line is important. I manually inserted it in my copy of “Archisurance.xml” in order to denote that the contents of the XML file should be processed using the “elements.xsl” XSLT stylesheet. If you are using your own copy of the file, you also need to manually insert this line into the file using a text editor.
Adding the XSLT stylesheet
Next we need the XSLT stylesheet that will transform the data in the XML file into HTML. For this first example, we’ll display a table of all the elements (concepts) in the model. The file is called “elements.xsl” and you can download it here. Here’s what it looks like:
Elements in the model
This stylesheet is basically an XML file with some HTML tags and XPath queries that will generate HTML using data from the “Archisurance.xml” file. There is a <style> section for some simple CSS, a <html> and <body> section for the HTML structure, and a <table> to display all of the ArchiMate elements. If we put the two files together we should see a result. But how do we do that?
Displaying the result
Normally, we would use a special processor or tool to combine the two files in order to generate an HTML file (the command line tool xsltproc on Linux/Mac, for example) but for this demonstration we can very easily display the result in a browser. However, be warned that this may only render correctly in Firefox or Internet Explorer. If the two files, “Archisurance.xml” and “elements.xsl” are in the same directory on your computer you can open the “Archisurance.xml” file in Firefox or Internet Explorer. It should look like this:
We can see the model name and description, the ArchiMate elements, their IDs, name, documentation (if any) and their type. The XSLT code generates a table of elements by looping through each <element> tag in the XML file and displaying the contents of the “identifier” attribute, the <label> tag, the <documentation> tag, and the “type” attribute. The table is sorted alphabetically on the “type” attribute because it is specified in this line:
Note that XPath is used as the query language for selecting the elements in the XML file.
It’s a good start. Perhaps we could also display the relationships in the model? Yes we can, by applying the same principles as we did with the elements. To demonstrate this I’ve created another XSL stylesheet, a file named “elements_relations.xsl” and you can download it here. This file is the same as the first XSL file, but I’ve added some code to display the ArchiMate relationships:
Relationships in the model
The code iterates through each <relationship> tag in the XML file and, using an XPath query, finds the relevant tags and attributes needed to display the data. Notice that there are two XPath queries that reference elements elsewhere in the file in order to display the Source and Target element names of each relationship. The code uses XSLT variables, “Source” and “Target”, to make things a little easier to create the XPath queries.
In order to display the results of this new XSLT stylesheet, we need to replace the line in the “Archisurance.xml” file so it references this new file:
Open up “Archisurance.xml” in Firefox or Internet Explorer again (or refresh).
Here’s a sample of some of the output that is generated:
As before, we can see the ArchiMate relationships, their IDs, name, source and target elements, and their type.
Displaying the structure
One of the features of The Open Group’s ArchiMate exchange format is to be able to (optionally) represent and exchange a given structure of the ArchiMate elements and relationships in the model. By this we mean an organization of elements, relationships, and views much like a table of contents in a book. Most ArchiMate tools allow you to organise ArchiMate elements and relationships in some kind of hierarchical structure. In Archi this is the tree in the “Models View”. This is something that can be usefully exported and imported into another tool.
So far we have displayed the elements and relationships as flat lists, but we can use this structural, or “organization”, information in the XML file to display a tree of links to the elements and relationships.
We need to use a new XSL file containing the new code, named “structure.xsl”, and you can download it here.
Once again, we have to replace the line in the “Archisurance.xml” file so it references the new file:
I won’t show the new code here this time, but you can take a look at it in a text editor. The XSLT code iterates recursively through each <item> tag in the XML file and then generates a hierarchical HTML list of elements, relationships and views with links to the corresponding entry in the tables of elements and relationships.
Open up “Archisurance.xml” in Firefox or Internet Explorer again (or refresh).
Here’s a sample of some of the output:
If you click on one of the links, it will jump to the corresponding element or relationship in the tables.
Further experiments – displaying the diagrams
To demonstrate this, we need another XSLT file, this time it’s named “views_experimental.xsl” and you can download it here.
Once again, we need to replace the line in the “Archisurance.xml” file so it references this new file:
Open up the “Archisurance.xml” file in Firefox (sadly, the SVG does not display in Internet Explorer). If you scroll to the end you should see some basic diagrams. Here’s an example:
As I said, this is very much proof of concept, and it needs much more work. It may turn out to be too onerous to generate the full diagrams using SVG, particularly when it comes to creating connections (they need bend-points, anchor points and so on) and I’m sure there is a better way to do this. This does, at least, demonstrate the possibility of generating diagrams from the raw XML file.
I’ve tried to show that it’s possible to use The Open Group’s ArchiMate XML exchange file and display some of the data as HTML using XSLT stylesheets. I’ve also shown that it’s possible to generate some basic diagrams from the data. All of this needs much more work, and I’m aware that this work is at proof-of-concept level.
But for me the important thing is that this clearly demonstrates that by using existing technologies based on XML, XSLT, HTML, and CSS one doesn’t have to resort to a proprietary tool in order to display and share that data. Both the data and the representations of that data can exist in an open, standalone format.
Personally, I think this is very cool and it would be nice to see some XSLT stylesheets created to display ArchiMate models in more interesting ways. For example, one might display a summary and preview of a model. Or it may be possible to take advantage of a model’s Properties (attributes) and use them as variables that could be parsed conditionally for output formatting. I think that the potential inherent in The Open Group’s ArchiMate exchange format is very exciting and I’d love to see if anyone can take this further.
Many thanks to Thorbjørn Ellefsen for drawing my attention to the potential power of utilising XSLT with The Open Group’s ArchiMate exchange format.
Some of you might have noticed that Archi 3.3 has been released. This latest version of Archi includes a new plug-in which supports The Open Group’s ArchiMate file exchange format. This represents the fruits of some years and months’ labour! I’ve been collaborating with The Open Group, and representatives from associated parties and tool vendors, for some time now to produce a file format that can be used to exchange single ArchiMate models between conforming toolsets. Finally, version 1.0 has been released!
The file format uses XML, which is backed by a validating XSD Schema. Why is this? Wouldn’t XMI be better? Well, yes it would if we had a MOF representation of ArchiMate. Currently, one doesn’t exist. Also, it’s very hard to agree exactly what should be formally represented in a persistence format, as against what can be usefully represented and exchanged using a persistence format. For example, ArchiMate symbols use colour to denote the different layers, and custom colour schemes can be employed to convey meaning. Clearly, this is not something that can be enforced in a specification. Probably the only things that can be enforced are the ArchiMate concepts and relations themselves. Views, viewpoints, and visual arrangements of those concepts and relations are, arguably, optional. A valid ArchiMate model could simply consist of a set of concepts and relations. However, this is probably not very useful in the real world, and so the exchange format seeks to provide a file format for describing and exchanging the most used aspects of ArchiMate models, optional aspects as well as mandatory aspects.
So, simply put, the aim of The Open Group’s ArchiMate file exchange format is to provide a pragmatic and useful mechanism for exchanging ArchiMate models and visual representations between compliant toolsets. It does not seek to create a definitive representation of an ArchiMate model. For that to happen, I believe many things would have to be formally declared in the ArchiMate specification. For this reason, many of the components in the exchange format are optional. For example, the ArchiMate 2.1 specification describes the use of attributes as a means to extend the language and provide additional properties to the concepts and relations. The specification does not rigidly mandate their use. However, many toolsets do support and encourage the use of attributes to create model profiles, for example. To support this, the exchange format provides a properties mechanism, consisting of typed key/value pairs. This allows implementers to (optionally) represent additional information for all of the concepts, relations and views.
Even though I have emphasised that the main use for the exchange format is exchange (the name is a bit of a giveaway here ;-)), another advantage of using XML/XSD for the file format is that it is possible to use XSLT to transform the XML ArchiMate model instances into HTML documents, reports, as input for a database, and so on. I would say that the potential for exploiting ArchiMate data in this way is huge.
The exchange format could also help with learning the ArchiMate language and Enterprise Architecture – imagine a repository of ArchiMate models (tagged with Dublin Core metadata to facilitate search and description) that could be used as a resource pool of model patterns and examples for those new to the language. One thing that I personally would like to see is an extensive pool of example models and model snippets as examples of good modelling practice. And using the exchange format, these models and snippets can be loaded into any supporting toolset.
Here are my five “winning features” for the ArchiMate exchange format:
Well understood format
I’m sure that The Open Group’s ArchiMate exchange format will contribute to, and encourage the use of ArchiMate, and perhaps reassure users that their valuable data is not locked into any one vendor’s proprietary tool format. I personally think that this is a great initiative and that we have achieved a great result. Of course, nothing is perfect and the exchange format is still at version 1.0, so user feedback is welcome. With greater uptake the format can be improved, and we may see it being exploited in ways that we have not yet thought of!
(For more information about the exchange format, see here)
We’re very happy to announce the release of Archi 3.2. This latest release of Archi adds some great new features to help you view and validate your models.
A new and improved HTML reporting feature allows you to interactively view your models in a browser. This feature has been developed by Jean-Baptiste Sarrodie and Quentin Varquet who use Archi in their work at Lafarge in Paris.
Also new is the Model Validator so you can check whether your models align with the ArchiMate 2.1 specification.
Solstice Greetings! I thought I’d write a review of the latter half of 2014 and a brief update of where we are now before we move into 2015. So, what’s happened since the last blog post in July?
In August we moved the forums to a new home at http://forum.archimatetool.com. The Google Groups that we had been using before were cumbersome to manage and not very user-friendly. We hope that the new forums offer a better experience in sharing your discussions related to Archi and ArchiMate. The new forums allow you to upload screen-shots, share models, and open polls. If you’ve not already joined the new forums, we invite you to do so.
Archi version 3 was released at the end of September. This was the biggest and most important event of this year as we had been working on this version of Archi for some time. The main reason why this update is so important is that previous versions of Archi had been built upon the older Eclipse 3.x framework. However, Eclipse 3.x is no longer supported since version 3.8.2 released in 2013. Eclipse 4.x is now the new supported version and, after the elimination of some bugs in Eclipse, we managed to migrate the Archi code-base to this new Eclipse framework with only a relatively few changes. This means that we can move forward with development. At the same time we introduced some great new features including a new look and feel, import and export to CSV files, an improved Magic Connector, Find/Replace, export image to PDF and many other features and fixes. Personally, the migration to Eclipse 4.x has been a great relief because there was a point where I wasn’t sure if it was going to be possible due to a range of issues and bugs in the Eclipse code.
Archi 3.1 was released at the beginning of December and represents a fine-tuning of the work delivered in Archi version 3. This is a maintenance release that fixes a number of bugs and adds some useful, new features. The focus of Archi 3.1 has been to improve the user interface response time when working with larger models, and to implement stronger integrity checking when loading and saving models to disk. This work came about at a time when I was working with a relatively large ArchiMate model. I noticed a sluggishness in response in the Models Tree when many nodes were open and when changing Viewpoints in the diagrams. I spent about three or four weeks experimenting with different threading techniques and algorithms before finding the perfect combination that improved overall response times. At the same time I added some defensive measures that checked the integrity of models and files before saving to disk. Archi 3.1 provides a more robust and smoother user experience.
The Open Group ArchiMate Model Exchange File Format
An important initiative concerning ArchiMate itself has been the ongoing development of The Open Group’s ArchiMate Model Exchange File Format. This initiative is being led by Andrew Josey of The Open Group, and I have been contributing to the development process, as have some other ArchiMate tool vendors. The exchange format is a specification for a standard file format for the exchange of ArchiMate models between different tools. It is not intended to be a definitive persistence representation of an ArchiMate model as you might find for a UML model, for example, since the ArchiMate language has not been formalised enough to create something like a MOF or XMI representation. It is, however, an XML format (validated by a XSD Schema) that so far has proved that it is possible to exchange basic ArchiMate models and diagrams between ArchiMate-aware tools. To date these tools are Archi, BiZZdesign Architect, and Corso’s System Architect ArchiMate plug-in. Clearly this is good news for all stakeholders and I think is important for the ArchiMate language itself, particularly from the point of view of those learning the language. The exchange format will allow users to exchange their models without worrying about target tools and proprietary formats, which is very important for those who may be new to ArchiMate and who do not want to be locked into one tool or framework.
What now for Archi? As it is, Archi is great for the single, file-based, user. But of course the number one request is for repository and multi-user support. This is not a trivial feature to implement, and one that would require many months of hard work. In order to support a transactional-based and multi-user work-flow Archi will need to be re-implemented in a new (Eclipse-based) framework. This has been under investigation over these last few months and we are moving slowly towards this goal. This will be our focus in 2015. Archi 3.x will continue to be supported with bug fixes and small features, but at the same time we will shift our focus onto the longer term aim – Archi 4.
And finally I’d like to offer some thanks. I’d like to thank all Archi users for their support and encouragement in 2014. Also, a special thank-you is due to Jean-Baptiste Sarrodie for his incredible support, encouragement, evangelism, contributions and vision. I’d also like to thank Gerben Wierda, author of the essential book, Mastering ArchiMate, for his support and advice. Thanks are also due to David Rose, and Andrew Josey of The Open Group who have allowed me to participate in The Open Group’s ArchiMate Exchange Format project. And finally, I’d like to say a big thank-you to everyone who has kindly donated to Archi by Paypal. These donations have kept the wolf from the door and encouraged me to continue developing new features in Archi. So, once more…thank-you!