Jul 022018
 2nd July 2018  Posted by at 12:00 pm No Responses »

Today, J-B Sarrodie and I are releasing a preliminary beta version of jArchi, the scripting plug-in for Archi. jArchi has a long (albeit slow) development history and received a recent speed bump with some funding and feedback from the technical architecture team at Adeo, in France. This allowed us to develop a closer integration between the jArchi engine and Archi’s UI, resulting in a seamless menu-driven experience for the end-user.

jArchi is a JavaScript-based scripting plug-in built on the Nashorn engine. This means that the end-user can write code, or simple scripts, using JavaScript, and this is then translated into the underlying Java code that drives Archi. jArchi exposes a user-friendly API to the scripter, allowing them to access their models in ways that were only possible before if they were a Java and Eclipse developer. I first wrote a basic implementation of this about 10 years ago using the Rhino engine. This lay on the shelf until now.

J-B and I revived this work earlier this year and invested a lot of time developing a usable API that allows the user to query and manipulate Archi’s ArchiMate models. The API is modelled on that of jQuery and uses the idea of operating on a collection of objects. The $ (dollar) symbol is used as a JavaScript alias for “jArchi”, in the same way as it used as an alias for “jQuery”, and allows operations on the current model. The current model is either the one selected in Archi’s UI or set by the scripter. The following line of code returns a collection of all elements in the current model:

var allElements = $('element');

This collection can be manipulated to query names, documentation and instances in views.

console.log("There are " + $('element').size() + " elements in this model";
console.log("The name of this model is " + model.name);
// All concept type and names
$("concept").each(function(concept) {
    console.log(concept.type + ": " + concept.name);
The scripter is able to read and set attributes of all concepts and views including the name, documentation, properties, colour, font, and so on. This leads to some very powerful possibilities. Some examples of use:
  • Anonymise models for sharing
  • Bulk change element types
  • Create heat maps based on certain criteria
  • Generate Excel spreadsheets
  • Create reports
  • Import and export model data in various formats

We think that jArchi will be a game changer.

But we are also changing the way that we distribute this plug-in. J-B and I have invested a lot of time and work into jArchi, and also into the continuing development and support of Archi itself. We would like this to continue as a two-way process and to thank and reward those Archi users who have joined us in this reciprocal endeavour. So, we are releasing the beta version of jArchi at first to our friends at Patreon and to our friends who have kindly donated to Archi previously via PayPal or in other ways. After a beta testing period we will be asking other users for a relatively small donation in order to download jArchi. If you have already donated (via Patreon or PayPal or in another way) we will be making the download available to you today. Patreon members will be provided with a download link, while our non-Patreon friends (Paypal donators, patch/pull-request submitters and Archi plug-in developers) will need to contact us for the download (we are working on providing a more convenient distribution platform post-beta).

The source code for jArchi is available at GitHub and is licenced under the MIT licence. This will always be the case, and you are, of course, free to use this. But we kindly ask that the binary distribution that we are providing is not shared and that jArchi users please contribute back to us. As a thank-you, the binary distribution will contain premium content in the form of example jArchi scripts and some level of support. For this content we have used the “HUMANS” licence:

The HUMANS (Help Us Make Archi Noteworthy & Sustainable) licence goal is to bring happiness
to both Archi users and developers. This means that we would like users of
jArchi to donate something and get this useful script as a gift in return (and feel great!).

The only restrictions that apply are:
 - You can't redistribute this script.
 - You can't use this script for commercial purposes unless you obtained it from the official
   Archi distribution channels.

If we are able to make Archi and plug-ins such as jArchi successful we will be able to continue to develop more tooling solutions and sustain the overall development and support of Archi. So, please, join us in this adventure! The starting point is the jArchi Wiki.

Jun 112018
 11th June 2018  Posted by at 11:23 am No Responses »

This Archi Spotlight has been written by Ad Gerrits. Ad is an Enterprise Architect at the municipality of Nijmegen and works as an independent entrepreneur at AG4IT. He mainly works within the Dutch government and has contributed, among other things, to the reference architecture for Dutch municipalities. He is a fan of ArchiMate and actively promotes its use in practice.



Nijmegen is one of the 380 Dutch municipalities in the Netherlands. With the increasing importance of IT for business operations, it is becoming increasingly important to work ‘under architecture’. That is why it was decided to adopt ArchiMate as the descriptive language for architecture a few years ago. Recently, Archi was chosen as the standard application to work with ArchiMate.

We love ArchiMate

There were several reasons for choosing ArchiMate: it helps in practice to better describe architecture, it is a worldwide standard and, nowadays, it is widely used within the Dutch government.

The GEMMA Reference Architecture for municipalities makes intensive use of ArchiMate. For, among other things, the modeling of business and application elements and their relations. Every municipality can register its own applications via the National Software Catalog and relate it to the nationwide reference architecture. All data can be exported in AMEFF-format (ArchiMate Model Exchange File Format) and imported into architectural tools used by municipalities.

Tooling that fits

In order to work well with ArchiMate, supporting tooling is necessary. There are several applications that support the use of ArchiMate. Each has its own advantages and disadvantages and are provided by companies with different business models.

We did not have the ambition to find ‘the best application’. Our aim was to select the application that is most suitable for us. For example, we find it important that tooling is easy to use, we don’t need support for BPMN or UML (‘Do one thing and do it well’), it must be affordable, etc.

Although we already used Archi and were charmed by it, there was always a major showstopper: the absence of a shared repository to be able to work well as a team. This is why we came to consider one of the well-known commercial products. However, the pricing of this solution was such that it was impossible for us to get the required funding.

Let there be collaboration

And then Archi’s ‘Model Repository Collaboration Plugin‘ was announced: “an extension to Archi that allows collaborative work on Archi through sharing and versioning of models in a repository”. Archi was back in the race! And more than that…

With the “Grafico” plug-in created by Jean-Baptiste Sarrodie as a base there was now a multi-user distributed repository solution to share and collaborate on Archi models. Because of the genial decision to use git-based repositories, features such as sharing, versioning, branching and reverting came into reach. Finally, the new and exciting features that Software Developers had enjoyed over the last 10 years were available for Enterprise Architects (more about this in ‘ArchOps: a new paradigm for EA Toolsets’).

Because the plug-in was still under development, we did a pilot to check the stability and whether the already available functionality was sufficient for us to get started. The answer to both was a clear ‘yes’.

Open development, open source

More than 10 years ago, the city council of Nijmegen decided to give preference to providers who work according to the ‘open source’ principle when purchasing software. In practice, this has led to a dormant existence, but in recent years the use of open source software has become very current again. Partly because open source products today are just as good or better than commercial products, and partly because with the increasing importance of IT, (too) high dependence on suppliers is undesirable.

With Archi, the benefits of open source development are well realised. There is a quality product, an active development that is driven by the needs of users, and there is no vendor lock-in. All code is public, the AMEFF exchange format was supported immediately after its introduction, and for version management git is used.

One argument against the use of open source is that often no security can be bought from a commercial supplier. Apart from the question of which type of security yields the most in practice, it is true that there is a completely different business model. This is the reason why we as Nijmegen decided to actively contribute to the further development of Archi in the form of a monthly donation. Comparatively, this is a fraction of the amount that commercial packages cost, but a gesture that shows our support for this type of development.

The road ahead

In Nijmegen we are learning step by step to make effective use of the possibilities that ArchiMate and Archi offer. We use Archi on Windows and Linux with Gitlab-hosted repositories. We periodically generate an HTML export that is published on the company intranet so that all employees have easy access to all information. We can continue for years to come.

The Archi roadmap depends for a large part on the available resources. There is still plenty of room for new functionality (go go ‘Scripting and Command Line Tools’!). Hopefully more organizations will choose Archi and are willing to give in the form of development capacity or a donation. In the Netherlands, we as Nijmegen will certainly do our best to encourage use at other municipalities!

Jan 302018
 30th January 2018  Posted by at 12:57 pm No Responses »

Archi version 4.2 has been released!

Archi 4.2

Archi 4.2

In addition to some fixes and small features we’ve added support for 2x icons and images so that those of you with high resolution screens will get a better UI experience.

Also, we’ve greatly improved the Archi Command Line Interface (ACLI). This has become a powerful tool for those who which to automate some Archi processes, such as getting the latest model changes from the Collaboration Plug-in and then perhaps generating reports, or exporting CSV files. You can read about how these improvements to the ACLI came about here. For more information about how to use the ACLI, check out this wiki page.

Here’s a list of commands currently implemented in the ACLI:

usage: Archi -application com.archimatetool.commandline.app -consoleLog -nosplash [options...]

Common options:
 -a,--abortOnException          If present all further command line providers will not run when an exception is thrown
 -h,--help                      Show this help

Registered providers:
 [Create Empty Model] Create an empty model and set to the current model (from optional template)
 [Load & Clone Collaboration Model] Load and/or clone from a local or online collaboration repository and set to the current model
 [Load Model] Load a model from file and set to the current model
 [Import from Open Exchange XML format] Import from an Open Exchange XML format file and set to the current model
 [Import from CSV] Import data from CSV into the current model
 [Export to Open Exchange XML format] Export the current model to the Open Exchange XML file format
 [HTML Reports] Generate a HTML report from the current model
 [Jasper Reports] Generate Jasper Reports from the current model
 [Export to CSV] Export the current model to CSV file format
 [Save Model] Save the current model to file

   --createEmptyModel <*.architemplate file>          Create an empty model and set to the current model. If <*.architemplate file> is set,
                                                      this will be used as the model's template.
   --csv.export <path>                                Export the current model in CSV format to the given path.
   --csv.exportDelimiter <delimiter>                  Delimiter to use for CSV export. One of "," ";" or "\t" (optional, default is ",")
   --csv.exportEncoding <encoding>                    Encoding to use for CSV export. One of "UTF-8", "UTF-8 BOM" or "ANSI" (optional,
                                                      default is "UTF-8",)
   --csv.exportFilenamePrefix <prefix>                Prefix for file names to use for CSV export (optional, default is none).
   --csv.exportLeadingZeros                           Use Excel leading zeros/spaces workaround for CSV export (optional, default is false).
   --csv.exportStripNewLines                          Strip newline characters for CSV export (optional, default is false).
   --csv.import <elements.csv file>                   Import into the current model in CSV format from the supplied elements.csv file.
   --html.createReport <path>                         Create a HTML Report from the current model to the folder set at <path>.
   --jasper.createReport <path>                       Create Jasper Reports from the current model to the folder set at <path>.
   --jasper.filename <name>                           File name to use for Jasper Reports (required).
   --jasper.format <format>                           List of comma separated output formats for Jasper Reports. Any of
                                                      PDF,HTML,RTF,PPT,ODT,DOCX (optional, default is PDF).
   --jasper.locale <locale>                           Locale for Jasper Reports in "en_GB" format (optional, default is the current system
   --jasper.template <main.jrxml>                     Full path to the main.jrxml Jasper Reports template file (optional, default is
                                                      Customisable Report).
   --jasper.title <title>                             Title of Jasper Reports (required).
   --loadModel <*.archimate file>                     Load a *.archimate model from file and set to the current model.
   --modelrepository.cloneModel <url>                 Clone a collaboration model from <url> to the <path> set in option
                                                      --modelrepository.loadModel (optional).
   --modelrepository.loadModel <path>                 Load a collaboration model from the given repository folder at <path> (required if
                                                      option --modelrepository.cloneModel is used).
   --modelrepository.password <password>              Online repository login password (required if option --modelrepository.cloneModel is
   --modelrepository.userName <userName>              Online repository login user name (required if option --modelrepository.cloneModel is
   --saveModel <*.archimate file>                     Save the current model to a *.archimate file.
   --xmlexchange.export <path>                        Export the current model in Open Exchange XML format to <path>.
   --xmlexchange.exportFolders                        If set, the model's folder structure will be exported as an <organization> structure
                                                      (optional, default is false).
   --xmlexchange.exportLang <lang>                    Two letter language code for export. Example - en, fr, de (optional, default is none).
   --xmlexchange.import <*.xml file>                  Import an XML Open Exchange file and set to the current model.

Archi 4.1 download
Collaboration Plug-in

Nov 212017
 21st November 2017  Posted by at 11:18 am 4 Responses »

We’ve just released Archi version 4.1. In addition to many fixes and small features we’ve added support for a Command Line Interface. This means that you can potentially run batch commands without launching Archi in the UI. We’ve added core support and initial support for HTML Report generation for Archi itself, and for the Collaboration plug-in.

Once Archi 4.1 is installed in the target location, you can generate a HTML report into a given folder from an existing *.archimate file like this:

Archi -consoleLog -console -nosplash -application com.archimatetool.commandline.app -HTMLReport_InputFile "/pathtofile/test.archimate" -HTMLReport_OutputFolder "/outputfolder"

For the Collaboration plug-in you can clone an ArchiMate model in an online repository to a given folder, and generate a HTML report to another folder like this:

Archi -consoleLog -console -nosplash -application com.archimatetool.commandline.app -GenerateHTMLReport_CloneFolder "/path/clonefolder" -GenerateHTMLReport_ReportFolder "/path/reportfolder" -GenerateHTMLReport_URL "https://bitbucket.org/thought_leaders_are_us/my-repo.git" -GenerateHTMLReport_UserName "a.thought.leader@nowhere.com" -GenerateHTMLReport_Password "password"

It’s also possible to trigger this from a git hook if you are using GitBlit or a similar repository. So, if a username and password is not set, the model will not be cloned from the on-line repository but will instead take the existing local model repository in the given clone folder and then generate the HTML report. This allows for the case where the model may already have been cloned by another process.

Additional and bespoke Command Line functionality is possible should you require it. See our Support page and contact us if you wish to discuss this further.

Archi 4.1 download
Collaboration Plug-in

Nov 072017
 7th November 2017  Posted by at 1:17 pm No Responses »

By Phil Beauvoir & Jean-Baptiste Sarrodie

The Open Group’s conference in Amsterdam, October 2017

The theme of The Open Group’s conference in Amsterdam last October was “Architecting the Digital Enterprise – Making Standards Work”. We had been invited to talk ostensibly about the ArchiMate Exchange Format, ArchiMate® 3.0, and how these work together. Archi is renowned for being a tool that delivers an “executable standard” as it is ubiquitous, accessible and open source. Here’s the official summary of the presentation that we gave:

ArchiMate® 3.0 was released in June 2016. This latest version of the language represents an important evolution of the open standard that is used for Enterprise Architecture modelling.

Shortly after the release of this new version of the specification, work began on an updated version of the ArchiMate Exchange Format, an XML file format that supports the exchange of ArchiMate models between compliant tools. The new ArchiMate Exchange File Format for ArchiMate 3.0 standard is now a published standard, available from May 2017.

This new version of the Exchange Format not only supports the new concepts in the ArchiMate 3.0 specification but also supports the exchange of more advanced information such as custom viewpoints, concerns, and stakeholders and paves the way for adding new features such as model stereotypes.

In this presentation we outline the new features of the ArchiMate 3.0 Exchange Format and talk about its importance in terms of the exchange of ArchiMate models between tools and how this transparent data format is adding value to organisations by allowing them to visualise and analyse their data in new and interesting ways.

In addition to the original use case (exchange of models between tools) we’ll also speak about several new use-cases that uses the ArchiMate metamodel as a pivot for interesting things (information gathered through big data’s technologies, external scripting, CMDB exchange format together with CMDBf…).

As a summary that sounds pretty dry, so we thought about how to make this more interesting, given that we mention going “beyond modelling tools”. So we started our presentation in the future…

Beyond Modelling Tools – the EA Chatbot

Go forward in time, say five years, and imagine an EA Chatbot – an AI bot that you can talk to, interact with, and that could, for example, assist the Architect to quickly and easily find information about an in-house application, how it connects to other applications, and how it might be visualised. Let’s call the Chatbot “Archie“. We acted out the parts of JB as Architect, and Phil as the Chatbot:


Now come back to the present, October 2017. Does such an EA Bot exist? No, not really. But we can make it happen by moving the focus away from conventional modelling tools and thinking (call them legacy, first-generation tooling) and tracing a development from ArchiMate as a language, through to the ArchiMate Open Exchange Format and then on to Open Data, and, once we have that, to open tooling, paired with machine learning and natural language processing. This was presented as a simple equation:

J-B Sarrodie intends to go into greater depth about the EA Chatbot and the other aspects of the equation in a future blog post, so stay tuned.

ArchiMate® Exchange Format

We spoke a little about the history of the ArchiMate Open Exchange Format, its genesis, how it has been adopted, and how numerous users and developers have been empowered by having access to transparent data (vs. closed, proprietary data formats). We then covered the new changes introduced in ArchiMate 3.0, the need for an updated version of the Exchange Format and how users are taking the data and doing new and unexpected things with it. As Eric S. Raymond said:

And, it turns out, that the “truly great tool” in this case is not a desktop application, but rather the open data that the Exchange Format provides. We gave some examples of how users are manipulating and visualising this data, and how, for some organizations, it’s essential for them to archive their data in an open format (the EIRA project, for example).


The above is a brief summary of the presentation and, as I mentioned, JB intends to write more in detail about the EA Chatbot and other aspects in a future blog post, so stay tuned.

Here’s the static overview image of the presentation (once again, lovingly hand-drawn by JB):

And you can also view the full interactive Sozi presentation here.

ArchiMate Users Group

The first meeting of the ArchiMate Users Group was also held in Amsterdam during the conference. Over 50 people attended this, with a panel consisting of a broad range of representatives (including J-B Sarrodie). Everyone present was given the chance to briefly introduce themselves and their interest or role in using ArchiMate. This took up a fair portion of the meeting, but gave everyone the opportunity to hear about how ArchiMate is being used, and to put some names to faces. Speaking of which, also present at the Users Group was the leading expert and author of “Mastering ArchiMate“, Gerben Wierda. And here are the 3 Amigos, finally together in one room:

The 3 Amigos – Phil, Gerben, and JB

Overall, the conference and user group meeting was productive and informative and there was not enough time to talk to everyone. We had fun with our presentation and, we hope, offered a possible vision for the future and highlighted the potential for interesting developments once different stakeholders come together to work with Open Data and tooling.

The takeaways for the whole event for us, at least, were:

  • There are many Archi users out there who are using it to create ArchiMate models, and have different needs that go beyond the present implementation. It was great to meet some of them in person at the conference
  • The ArchiMate Exchange Format is used quite extensively, and is providing great value to all stakeholders
  • Users and developers are doing new and interesting things with ArchiMate open data and combining other technologies such as OWL, RDF, Graph Databases, CMDBs
  • Quite a few companies are building online repositories and services to store and work with EA models using Archi as a front end and the Exchange Format as means of transport

(Special thanks to Andrew Josey and The Open Group for facilitating this.)

Nov 042017
 4th November 2017  Posted by at 10:37 am No Responses »

More and more EA modellers are downloading Archi and getting up to speed with ArchiMate. We’re seeing around 1500 downloads of the tool every week. Because end user uptake is so high, and because Archi is so ubiquitous, we’re also learning about a greater number of developers and start-ups building services and providing solutions based around ArchiMate tooling and online EA and ArchiMate model repositories. The basic pattern for these solutions generally consists of an ArchiMate enabled desktop client importing and exporting models to a repository, via a web interface, using the tool’s native file format or the ArchiMate File Exchange Format. These repositories form the core of further EA services such as online editing, asset management, reporting, querying, dashboards, and visualisations.

What’s interesting is that many of these solutions are using the ArchiMate Exchange Format as a transport between client and server. Indeed, I heard from many delegates at The Open Group’s conference in Amsterdam last month about how important the Exchange Format has become, and how it has empowered users, developers, customers, and solution providers. (More about this and the presentation that J-B Sarrodie and I gave in Amsterdam in a future blog post)

Some of these solutions providers have contacted me to tell me that they are now provisioning Archi as the editor and connecting it to their repositories via their (commercial and free) interfaces. Whereas before they used to provide a package consisting of a recommended commercial desktop client software, together with their consultancy and custom repository to customers, solutions providers are now recommending Archi as the front-end editing tool on the desktop. One of the reasons for this is cost. Passing on the expense of several commercial licences for third-party tools to the customer is proving to be non-viable.

We can visualise the problem like this:


And this leads to connection issues for stakeholders:

Given that these same providers are now recommending Archi as the client software we can visualise the successful business transformation like this:

As-Is and To-Be

Leading to a positive outcome:

Right now, we’re exploring possibilities for distributing the integration between Archi on the desktop and some providers’ repository solutions within Archi itself, either as custom plug-ins or via a new API. This will naturally lead to even more usage of Archi, ArchiMate and the ArchiMate Exchange Format, once again fulfilling J-B Sarrodie’s vision of “Archi Everywhere” or, to re-purpose (for better) the recent Twitter hashtag, #MAGA, “Make ArchiMate Great Again”.

I had, at one time, thought about building a dedicated online ArchiMate/EA Model store that connects to Archi, and considered in detail how this might work. The first requirement was to store ArchiMate models in the repository either in the Exchange Format, or at least export and import models in that format. Additional features included search, tags, ratings, user submissions, and user permissions. Here’s a mock-up I made:

ArchiMate Model Store – Mockup

I didn’t take this concept any further for various reasons, and I may not need to now. If a model repository provider can offer both paid for and free service plans, like those provided by GitHub, BitBucket and the like, then we might reach the point where their offerings scale to all levels of user requirements – free tooling on the desktop, free integration with online repositories and free provisioning, while additional paid-for services would fulfil advanced and commercial requirements – private repositories, support, dashboards, collaboration, and so on.

Another model repository alternative that you can use today is  the Archi Collaboration Plug-in, a Git-based solution that allows users to collaborate on Archi models in a distributed way. Just like Git, no single central repository is required and users can work off-line. This was the brainchild of J-B Sarrodie, and development was funded by Arismore and the French governmental agency, Pôle Emploi. We are still actively developing and promoting the plug-in, and it was very encouraging for J-B and I to receive very positive feedback from Archi users at The Open Group’s conference in Amsterdam last month. Several people told us about how they are using it in actual deployment. I wrote about the plug-in earlier this year, and you can find out more about it over on the Archi Plug-ins web page and on GitHub.

Archi Collaboration Plug-in

So, that’s a quick round-up of several new developments involving Archi, the ArchiMate Exchange Format, and online repositories. The Archi collaboration plug-in is being used now, and several other third-party repositories and solutions that use Archi as the client are also available, and you can find them online should you wish to pursue this.

But one other very important aspect of the continuing uptake of Archi as the desktop editor of choice is the issue of maintaining support and development of Archi. Archi is free to use, but most of the development work and all support is voluntary, free and done mainly by one or two people. This may be an issue for some solution providers’ clients and customers when assessing possible future risk. However, we welcome dialogue and are open to investment, collaboration and partnerships, so let’s all work together to ensure that this goose keeps laying those golden eggs. 🙂

Sep 062017
 6th September 2017  Posted by at 2:03 pm No Responses »

ArchiMate 3.0.1 Relations

We’ve just released Archi version 4.0.3. The main new features are:

 Add ArchiMate 3.0.1 relationship tables – This updates the ArchiMate relationship rules in accordance with the latest revision. Thanks to Ed Roberts for generating the XML file.

Faster load times on large models – Models now load much faster, in some cases up to 4000% faster.

Implement “Copy As Image to Clipboard” for 64-bit Linux – This has never worked for 64-bit Linux Archi. Until now.

Provide 64-bit Windows builds – These 64-bit builds ensure that users with high application memory demands can scale as necessary.

Bug Fixes – Oh yes, there’s always bug fixes…

Thanks to everyone who contributed in some way – feedback, bug finding, support. And a big thanks to those users who donated. Much appreciated. 🙂

Download Archi 4.0.3

Jun 092017
 9th June 2017  Posted by at 2:53 pm No Responses »

Now that Archi 4 is out in the wild and being downloaded by enterprise architects throughout the world (over a thousand downloads a week!) we’ve not stopped the pace. Thanks to Jean-Baptiste Sarrodie’s initiative and some French sponsors we’ve been working on a multi-user distributed repository solution so that you can finally share and collaborate on your Archi models using the features that users have requested – sharing, versioning, branching, reverting, and so on. This is an exciting time to get on board with Archi as we plan for this and other future enhancements. For more information check out our updated Roadmap.

Archi Model Repository

May 242017
 24th May 2017  Posted by at 2:51 pm No Responses »

We’re very excited to announce that Archi 4 has been released! This release supports the latest ArchiMate 3.0 specification and includes some new features. We’ve re-written a lot of the code from the ground up to support relationships to relationships and all the new concepts that have been added to the specification. It’s been a long time coming, but we got there. We chose to have an extended beta period to make sure that the product was as bug-free as possible, and also to align with the timing of some changes to the ArchiMate 3.0 specification with regard to relationship rules. Also included in Archi 4 is support for the latest ArchiMate File Exchange Format.

We’d like to thank everyone who helped out, contributed code, tested and gave us valuable feedback. We’d particularly like to thank Andrew Josey and The Open Group for their invaluable support without which this would not have been possible.

Archi 4

Nov 032016
 3rd November 2016  Posted by at 7:29 pm 2 Responses »

By Jean-Baptiste Sarrodie

Last week I had the great opportunity to co-present at The Open Group’s October Conference in Paris, France. After Phil Beauvoir presented a summary of Archi’s history and we described the challenges of ArchiMate 3.0, I spoke about a vision for the future of Archi, EA and the ArchiMate ecosystem, taking ideas from DevOps and applying them to Archi and ArchiMate tooling. For those that weren’t with us, here is a 2nd chance…

New tools for a new EA practice

For the past 10 years, a strange thing happened: while (Enterprise) Architects used to have some of the best tools for their work, tool vendors seem to have forgotten to innovate, while at the same time, tools for Software Developers started to take off and offer some really new and exciting features. Why? How?

While I can’t speak for EA tool vendors, I can at least look at what happened in the software development domain. It seems to me that it all started back in 2005 when Linus Torvalds (yes, the same guy who created the Linux kernel) decided to create his own version control system, Git. Did Linus decide to change the world at that moment? No. Did he decide to create a whole new ecosystem for development? Again, no. What Linus did was simply to create a small piece of software for his own needs, but a free/open piece of software with some great features. Basically, what Linus created was a software version control system which allows easy creation of branches, and the ability to merge those (sometimes conflicting) branches. These simple but powerful features then became the building blocks for a powerful new toolset, which in turn laid the foundations for a whole ecosystem now known as DevOps. If I had to summarize what DevOps is, I’d say that it is a software development Capability. In short, a great mix of knowledge, processes and tools. Furthermore, most of these are open – open-knowledge, open-tools.

The GRAFICO plugin

The GRAFICO plugin for Archi

Between 2012 and 2014, there were many discussions on Archi’s Forum about how to make Archi usable in a multi-user environment. While most people tried to solve the problem using the same approach that existing commercial tools took (save the model in a database, and require user to lock part of the model to avoid conflicts) some users suggested to workaround this issue using existing tools like Git. Some early attempts proved that it was feasible, but no plugins were maintained after the initial proof of concept. That’s why in 2015 I decided to work on it with the help of Quentin Varquet. What we created then was a really simple plugin for Archi whose only goal was to save and load an ArchiMate model in a way that makes it manageable by Git, thus the name GRAFICO (Git FRiendly Archi FIle COllection). With the help of this plugin and some GitHub-like solution (e.g. GitBlit or GitBucket) I was able to work with my colleagues on the same model at the same time without any issues.

This work could have stopped at that point, but I decided to make this plugin available under a Creative Commons licence (the choice of a non really open licence was driven by the fact that too few people have donated to Archi, and that this was one opportunity to get some funding for it).

Experiment turned into crazy idea

When the experiment turned into a crazy idea

The great thing about open source is that there are always some people that think out of the box and then take your ideas and use them in an unexpected way. That’s what happened with the GRAFICO plugin. Despite being a proof of concept in beta, some people started to use it, and then shared with me this crazy idea:

Do with Enterprise Architecture what developers did on DevOps

OK, but what does this mean?

ArchOps explained

ArchOps explained

Let’s think out of the box… Ready? Go!

Imagine that there exists a solution to share an ArchiMate model. And that this solution doesn’t require you to lock in advance part of the model before you change it. Imagine that you are free to clone this model, to create branches and then to merge your work with your colleagues. Imagine that you can keep a local copy of the model, work offline and send your changes to the central model when your want (or can). Imagine that there is in fact no “central model” because you can choose to create multiple copies of this model and sync them. Imagine a toolset that allows you to create conflicting changes because it can then raise a warning, allowing your team to discuss the issues, and understand why and how they arose. Wouldn’t it be great? If your answer is yes, then you’ll be happy to know that this is what you can already do with GRAFICO and Git (the only drawback is that it requires you to have Git skills).

Now, imagine that these exact same features could be used with models saved in the Archi native file format but also the ArchiMate Open Exchange File Format designed by The Open Group. Imagine that all these features are packed in a single open-source solution that never requires you to know Git but still provides the powerful interoperability features. What you now have is a solution that can trigger some events when (part of) the model changes. What you can do from here is up to you, but what about:

  • generating a static HTML rendering of the model in order to share it,
  • exporting the model to another repository, such as CMDB,
  • automatically checking that no changes appear in the as-is/baseline branch that could affect a project branch (automatic gap analysis).

If you find it useful, then you have an idea of what ArchOps could be. But the most important is that this is not about tools, it’s about opening new opportunities for our EA work, defining new way of working.

A Boundaryless Information Flow

How to move on?

As Archi is open source, we can’t really provide a definite roadmap for this work, but the key point is that we’d really like to make all this happen in the near future. For this to happen, we are looking for passionate people that could sponsor our work and invest some time with us to discuss ideas in more details and beta-test our solution. I heard that some companies could help us but for the moment no one has really decided to do so. Do you want to be the first?