A Recommender Plug-in for Enterprise Architecture Models

Sashikanth Raavikanti

, Simon Hacks

2 a

and Sotirios Katsikeas

1 b

KTH Royal Institute of Technology, Stockholm, Sweden

Stockholm University, Stockholm, Sweden

Keywords:

Enterprise Architecture, Archi, ArchiMate, Enterprise Modeling, Recommender Systems.

Abstract:

IT has evolved over the decades, where its role and impact have transitioned from being a tactical tool to a

more strategic one for driving business strategies to transform organizations. The right alignment between IT

strategy and business has become a compelling factor for Chief Information Ofﬁcers and Enterprise Archi-

tecture (EA) in practice is one of the approaches where this alignment can be achieved. Enterprise Modeling

complements EA with models that are composed of enterprise components and relationships, that are stored

in a repository. Over time, the repository grows which opens up research avenues to provide data intelligence.

Recommender Systems is a ﬁeld that can take different forms in the modeling domain and each form of rec-

ommendation can be enhanced with sophisticated models over time. Within this work, we focus on the latter

problem by providing a recommender architecture framework eases the integration of different Recommender

Systems. Thus, researchers can easily compare the performance of different recommender systems for EA

models. The framework is developed as a distributed plugin for Archi, a widely used modeling tool to create

EA models in the ArchiMate notation.

1 INTRODUCTION

IT has evolved over the decades, where its role and

impact have transitioned from being a tactical tool to

a more strategic one for driving business strategies

to transform organizations (Henderson and Venkatra-

man, 1993). With increased digitization of the inter-

connection among products, processes, and services

over the last two decades, the role of IT has been re-

visited to not just view it as an assistance to business

strategy but rather a fusion that creates industry dis-

ruptions. Bharadwaj et al.(Bharadwaj et al., 2013)

termed this phenomenon as ”Digital Business Strat-

egy”. The right alignment between IT strategy and

business has become a compelling factor for Chief In-

formation Ofﬁcers where misalignment could lead to

a degradation of organization performance and slow

them down in market competition (Coltman et al.,

2015). Enterprise Architecture (EA) allows to achieve

such an alignment (Alaeddini et al., 2017). Enterprise

Modeling (EM) complements EA by providing mod-

els that represent the structure, behavior, and orga-

nization of the enterprise with different stakeholder

viewpoints (Sandkuhl et al., 2014). In practice, EM

https://orcid.org/0000-0003-0478-9347

https://orcid.org/0000-0001-8287-3160

is achieved through a language that provides a for-

mal syntax, semantics and notation (Sandkuhl et al.,

2014). A popular language for EA modeling (Bar-

bosa et al., 2019) is ArchiMate that is provided by The

Open Group (The Open Group, 2021a) and Archi

is an open source modeling tool that supports Archi-

Mate.

EA models are composed of enterprise compo-

nents and relationships, and are stored in a reposi-

tory (Sandkuhl et al., 2014). Over time, the repos-

itory grows as architects design new models or up-

date existing models. Recommender Systems (RS)

can help to manage the challenges related to grow-

ing repositories by providing meaningful suggestions

to the user based on context (Ricci et al., 2011); i.e.,

by providing modeling assistance (Shilov et al., 2021)

and component recommendations (Borozanov et al.,

2019). A plethora of different algorithms can be used

as backbone for a RS in EA modeling. Therefore, we

as researchers are interested in a platform that eases

the scientiﬁc comparison of the performance of these

different algorithms. In line, we implement a recom-

mender framework as a plugin for Archi. As the rec-

ommendation algorithms can be implemented in var-

ious technologies, the framework must be able to in-

https://www.archimatetool.com/

474

Raavikanti, S., Hacks, S. and Katsikeas, S.

A Recommender Plug-in for Enterprise Architecture Models.

DOI: 10.5220/0011709000003467

In Proceedings of the 25th International Conference on Enterprise Information Systems (ICEIS 2023) - Volume 2, pages 474-480

ISBN: 978-989-758-648-4; ISSN: 2184-4992

 2023 by SCITEPRESS – Science and Technology Publications, Lda. Under CC license (CC BY-NC-ND 4.0)

tegrate to external RS outside Archi. The framework

must be resilient to errors during the execution or any

erroneous input. For instance, there can be latency

issues when connecting to systems outside Archi, or

the recommendation systems might not contain ap-

propriate Archi model repository information to gen-

erate recommendations. We deﬁne this resilience as

the robustness of the framework. We also focus on

the ease of integration aspect where the framework

can provide the needed information, and the recom-

mendation system can connect to the framework with

as minimal changes as possible. We, thus, explore the

research question:

”How to design an architecture for Archi that pro-

vides easy integration to different recommendation

systems?”

Using the steps of Design Science Research

Methodology (DSRM) (Peffers et al., 7 12), we iden-

tify our research problem to be design-centric. The

objective of the solution is to design a plugin with an

architecture that satisﬁes our research problem, which

also constitutes the main contribution of this work:

A framework to integrate different recommenda-

tion systems into the open source EA modeling tool

Archi. The design and development stage of DSRM

consumed the most effort. We started with the the-

oretical foundations of EA to understand how Archi

supports Enterprise Architects as a modeling toolkit.

We studied the existing implementations of RS in

the Software Engineering (Elkamel et al., 2016; Agt-

Rickauer et al., 2018) and the EM domain (Borozanov

et al., 2019; Shilov et al., 2021). We found that differ-

ent forms of recommendations are possible and rec-

ommendation algorithms become more sophisticated

over time. We considered a component recommenda-

tion strategy (Borozanov et al., 2019; Elkamel et al.,

2016) as most suitable to base our framework on. We

design our framework to contain a Graphical User In-

terface (GUI) component to show recommendations,

a connector that can integrate the plugin to external

systems, and a model to show the relationship be-

tween an object selection and its corresponding rec-

ommendations.

The rest of this paper is structured as following:

Next, we present our extensions to the Archi tool.

Then, we describe how the framework can be used for

different RS and provide ﬁrst insights from potential

users. Before concluding our work, we shortly shed

light on related work.

Figure 1: Archi Architecture.

2 AN ARCHI FRAMEWORK FOR

RECOMMENDER SYSTEMS

To answer our research question, we rely on the open-

source solution Archi

, which has been designed to

model ArchiMate models. Archi is built on Eclipse

Rich Client Platform (RCP) which provides a modu-

lar architecture. On a high level, Archi is composed of

features that in turn contain sub-features and plugins.

We implemented our RS framework as a sub-feature

to Archi’s editor feature. The high-level architecture

diagram is shown in ﬁgure 1.

With Eclipse RCP’s modular plugin concept and

using the Common Closure principle and Common

https://www.archimatetool.com/

A Recommender Plug-in for Enterprise Architecture Models

475

Reuse principle, we divided our plugin into multi-

ple plugins based on their capabilities such as GUI,

Model, and Connector. We treat each plugin to be

a component. Each component contains classes and

interfaces that are grouped based on The Single Re-

sponsible Principle. These classes change for the

same reason and serve a similar purpose. The plug-

ins are deﬁned with a fully qualiﬁed name following

the naming conventions of Archi.

The plugins Model

(com.archimatetool.recommender.model) and

GUI (com.archimatetool.recommender.ui) are on

the top-level in the hierarchy that contain abstract

classes or interfaces. This adheres to Stable Abstrac-

tions Principle. The CompletableRecommender

class use the CompletableFuture concept in Java

for asynchronous communication when connecting

external systems. The RecommenderPreferenceAg-

gregator class provides an abstract implementation

to capture user preferences. New preferences can

be added by providing an implementation of this

class. The RecommenderView class provides an

abstraction of displaying recommendations in a

Tree-based view. These plugins expose their classes

and interfaces for other plugins to extend and provide

their implementation. This also includes other Archi

plugins that provide recommendation algorithms.

The classes are loosely coupled and changes to a

certain plugin will not force the change to other

plugins.

The Connector

(com.archimatetool.recommender.connector)

plugin contains an abstract Connector interface and

provides HTTPConnector as a default implementa-

tion. This addresses the objective to integrate with

external RS. As multiple RS are also possible, we

implemented an observer pattern where a plugin

can subscribe to a certain RS using the Recom-

mendationSubscriber class. This class maintains

the subscription information and communicates it

back to the plugin once it receives recommendation

information. The HTTPConnector provides both

synchronous and asynchronous communication

between the plugin and the external system, with

synchronous as default.

To see the recommender feature in ac-

tion within Archi, a concrete implementa-

tion of GUI and Model classes is needed.

This is addressed using Contribution

(com.archimatetool.recommender.contribution)

plugin. It provides an implementation to show

component recommendations in a tabular format. In

the case of Archi, the component can be an Element

within a model. The table shows a grid where

the columns provide the recommended component

information along with a similarity score (cf. Figure

2).

The Contribution plugin subscribes to the Con-

nector plugin. With the Contributor plugin, we de-

ﬁned a simple JSON schema. This is to address the

robustness objective of the framework where any ex-

ternal RS adheres to this contract and the behavior of

the plugin will not change when we connect differ-

ent RS. As part of the contract, the outgoing request

will send the id of the element or relationship. The

JSON response must adhere to the contract by vali-

dating against the JSON schema. The schema expects

an array of recommendations, where every recom-

mendation must contain its id, type, name, model-id

and a similarity score. The Contributor plugin uses a

RecommendationJSONParser class to parse the re-

sponse. Figure 3 shows the UML class diagram of the

entire plugin.

3 USAGE OF THE FRAMEWORK

The plugin can connect to any RS that provides an

endpoint over HTTP and provides a JSON response

that complies with the schema. The current imple-

mentation of the plugin supports only one active con-

nection to the external RS. Also, the current im-

plementation supports only synchronous communica-

tion, and we left asynchronous communication as an

avenue for future research.

3.1 Demonstration

As our focus was only on the framework, we have

simulated the external recommendation system by

hosting a REST service using the Java Spring Boot

framework. We have loaded some Archi Model

elements to this external recommendation system

database. Whenever the REST endpoint receives a

GET request, it generates a JSON response with mock

recommendations. The recommendations are dis-

played in a table within Archi as shown in the ﬁgure

2. It contains 3 columns with the name of the element,

the documentation property corresponding to that el-

ement and a similarity score calculated from the rec-

ommendation model.

For each recommendation, we can perform two

different actions: Reveal and Replace using the

ComponentViewActions class in the Contribution

plugin. As the recommended component could be-

long to other models also, Reveal would point to the

corresponding model of a recommended component.

The element belongs to 1 bounded context model

ICEIS 2023 - 25th International Conference on Enterprise Information Systems

476

Figure 2: Recommender Plugin.

A Recommender Plug-in for Enterprise Architecture Models

477

Figure 3: Archi Recommender - Class Diagram.

ICEIS 2023 - 25th International Conference on Enterprise Information Systems

478

and Plugin Connectors is revealed in the Plugin De-

sign model.

Replace would replace the name of the selected

component with the recommended component. It

also appends the properties from the recommended

component to the selected component. This action

is to demonstrate that we can perform modiﬁcations

through the framework.

The plugin is extensible to provide any kind of

new actions by extending this class such as to Revert

the change that was made.

We simulated scenarios with erroneous input and

induced latency to test the robustness of the archi-

tecture. We noticed that the scenarios related to er-

roneous input have no impact, but the thread within

Archi waits for a response which blocks the execu-

tion within Archi. We perceive this to be a limitation

within the Archi framework. This is left as an avenue

for future research.

3.2 First User Feedback

To evaluate the usage of our framework, we consid-

ered technical aspects (ease of integration and ro-

bustness of the architecture) and gathered ﬁrst feed-

back from Archi users. For the technical evalu-

ation, we collaborated with a developer who pos-

sesses knowledge on Natural Language Processing

for working with text data. We implemented a new

RS that recommends components that have similar

names. The exemplary implementation of a RS with

our framework by the developer showed that some

minor changes were needed: On the RS side, addi-

tional functions were implemented to provide more

information within the request. For example, the de-

veloper expected more parameters such as the type,

name, component id, and model id. To evaluate the

robustness, we provided the plugin with incorrect data

and simulated different types of responses with vari-

ous HTTP codes to verify if the plugin breaks or af-

fects the performance of Archi. There were no latency

issues when accessing RS on localhost or the internet

through ngrok

. The developer suggested the imple-

mentation of a queue in between the plugin and the

external RS to make it more robust when dealing with

multiple requests. Generally, the developer was pos-

itive on the plugin’s error handling, besides that the

synchronous connection caused waiting times. The

integration was perceived as efﬁcient.

We have also collected feedback from Archi users

regarding the usability of the plugin and possible im-

provements. We demonstrated the plugin and re-

ceived positive feedback regarding its usability. One

https://ngrok.com/

suggested improvement to the plugin was to provide a

possibility to include repository information for mod-

els when requesting recommendations. For instance,

the current implementation only shows recommenda-

tions for models open within the Archi workspace. In-

stead, several repositories should be considered. Most

of the discussion was based on the recommendation

capabilities within the plugin such as the user inter-

face. As our focus is only on the architecture, we

have not captured those discussions as part for this

ﬁrst step. Providing different GUI capabilities for the

framework is left as an avenue for future research.

4 RELATED WORK

In Software Engineering (SE) and EA, RS is a recent

trend (Elkamel et al., 2016; Shilov et al., 2021). We

used related research to modeling in SE and EA as

rationale for our framework.

In SE, we took a closer look at the UML. E.g.,

Elkamel et al. (Elkamel et al., 2016) developed a

prototype for recommending UML classes that are

semantically similar in terms of their characteris-

tics. Once the recommendations are displayed, the

user can accept one or more of the recommended

classes. For each class, the user can accept all the

attributes and methods or only some of them. An-

other contribution is RS for domain modeling (Do-

MoRe) (Agt-Rickauer et al., 2018). DoMoRe pro-

vides context-sensitive information during domain

modeling and suggests names for model elements that

are ordered by relevance and are semantically similar.

The DoMoRe system integrates with various knowl-

edge bases using mediator-based information. A typ-

ical example to demonstrate the usage of DoMoRe is

to take a modeling use-case for the HealthCare do-

main. Consider there are 2 UML classes Patient and

Doctor, when an association relationship is set from

Doctor class to Patient class, DoMoRe takes the con-

textual information based on the class names, refers

to its knowledge base, and comes up with some rec-

ommendations for the name of the association such as

treats, examines, visits, etc., These contributions used

the applications of RS to address different research

problems. The former addresses redundant classes

and the latter helps in having a shared understanding

of the problem domain across different stakeholders.

Within EA research, Borozonaov et al. used ma-

chine learning (ML) techniques to reduce repository

pollution which arises when models have redundant

components that are semantically similar (Borozanov

et al., 2019). This is demonstrated with a client-

server architecture, and as a plugin for Archi, where

A Recommender Plug-in for Enterprise Architecture Models

479

Archi sends model information in an XML format

(The Open Group, 2021b) to a recommendation sys-

tem outside Archi. Once the response is received, the

recommendations are displayed to the Enterprise Ar-

chitects. Another research uses ML for EA model

prediction which reduces the manual effort during the

modeling process (Shilov et al., 2021). With the help

of Graph Neural Networks, models have been built

for node classiﬁcation and edge prediction. This helps

modeling by extracting patterns and best practices.

5 CONCLUSION

As main contribution of this work, we designed an

architecture for a recommender plugin for Archi that

could easily integrate with an external RS. The cur-

rent implementation of the plugin is lightweight in

terms of the amount of data exchange. Hence, there

were no latency issues. For evaluation, we imple-

mented a connection to an external RS and collected

feedback from the user and research community re-

garding the usability of the plugin. Further evalua-

tion can be done, with other RS that have a different

implementation and have other requirements for data

exchange. The plugin framework is also extensible to

add new features. However, we only implemented a

simple RS using the current framework to showcase

its use. The current implementation is tailored for a

component-based RS. With a more sophisticated rec-

ommender framework in terms of GUI, the plugin can

be more generic to accommodate different forms of

recommendation. For instance, context-based recom-

mendations (Agt-Rickauer et al., 2018) and enterprise

model prediction (Shilov et al., 2021). This is left as

an avenue for future research.

6 ADDITIONAL MATERIAL

The source code of the plugin can be accessed via our

github repository

. Additionally, we prepared a short

video to present the tool

REFERENCES

Agt-Rickauer, H., Kutsche, R.-D., and Sack, H. (2018).

DoMoRe-a recommender system for domain model-

ing. In MODELSWARD, pages 71–82.

https://github.com/sashikanthr/archi-recommender

https://youtu.be/iA51FG39omE

Alaeddini, M., Asgari, H., Gharibi, A., and Rashidi Rad, M.

(2017). Leveraging business-IT alignment through en-

terprise architecture—an empirical study to estimate

the extents. Information Technology and Manage-

ment, 18(1):55–82.

Barbosa, A., Santana, A., Hacks, S., and Stein, N. v. (2019).

A taxonomy for enterprise architecture analysis re-

search. In 21st International Conference on Enter-

prise Information Systems, volume 2, pages 493–504.

SciTePress.

Bharadwaj, A., El Sawy, O. A., Pavlou, P. A., and Venka-

traman, N. (2013). Digital business strategy: To-

ward a next generation of insights. MIS Quarterly,

37(2):471–482.

Borozanov, V., Hacks, S., and Silva, N. (2019). Using ma-

chine learning techniques for evaluating the similar-

ity of enterprise architecture models. In Giorgini, P.

and Weber, B., editors, Advanced Information Sys-

tems Engineering, pages 563–578. Springer Interna-

tional Publishing.

Coltman, T., Tallon, P., Sharma, R., and Queiroz, M. (2015).

Strategic IT alignment: Twenty-ﬁve years on. Journal

of Information Technology, 30(2):91–100.

Elkamel, A., Gzara, M., and Ben-Abdallah, H. (2016). An

UML class recommender system for software design.

In 2016 IEEE/ACS 13th International Conference of

Computer Systems and Applications (AICCSA), pages

1–8.

Henderson, J. C. and Venkatraman, H. (1993). Strate-

gic alignment: Leveraging information technology for

transforming organizations. IBM Systems Journal,

32(1):472–484.

Peffers, K., Tuunanen, T., Rothenberger, M. A., and Chat-

terjee, S. (2007-12). A design science research

methodology for information systems research. Jour-

nal of Management Information Systems, 24(3):45–

77.

Ricci, F., Rokach, L., and Shapira, B. (2011). Introduc-

tion to recommender systems handbook. In Ricci,

F., Rokach, L., Shapira, B., and Kantor, P. B., edi-

tors, Recommender Systems Handbook, pages 1–35.

Springer US.

Sandkuhl, K., Stirna, J., Persson, A., and Wißotzki, M.

(2014). Enterprise modeling. Springer.

Shilov, N., Othman, W., Fellmann, M., and Sandkuhl, K.

(2021). Machine learning-based enterprise modeling

assistance: Approach and potentials. In Serral, E.,

Stirna, J., Ralyt

e, J., and Grabis, J., editors, The Prac-

tice of Enterprise Modeling, pages 19–33. Springer

International Publishing.

The Open Group (2021a). ArchiMate® 3.1 speciﬁcation.

The Open Group (2021b). ArchiMate® model exchange ﬁle

format for the ArchiMate modeling language, version

3.0.

ICEIS 2023 - 25th International Conference on Enterprise Information Systems

480