Is there an equivalent to use case inclusion and extension in Archimate model?

I use to use UML use cases and I have to model a system using Archimate.

I need to model the features of the system, and I guess that I can do that using the business layer of Archimate.

In this business layer, a service seems may correspond to a use case. It is possible to model a service in a service: that could be seen as a use case inclusion.

But is there a way to model something like a use case extension in Archimate ?

There is not a one-to-one mapping, as there are subtle semantic differences between the related UML and Archimate concepts.

Use cases in Archimate

UML Use cases are:

a set of behaviors performed by that subject, which yields an observable result that is of value for Actors or other stakeholders of the subject.

The closest concept in Archimate is the service:

An application service represents an explicitly defined exposed application behavior.
(...) An application service should be meaningful from the point of view of the environment; it should provide a unit of behavior that is, in itself, useful to its users. It has a purpose, which states this utility to the environment.

but it could also be business services, depending on the subject considered:

A business service represents explicitly defined behavior that a business role, business actor, or business collaboration exposes to its environment.

These services expose behaviors to their environment, for a purpose, without internal details. More about UML to Archimate mapping here.

Inclusion and extension

In UML, inclusion and extensions are relationships between use-cases :

Include is a DirectedRelationship between two UseCases, indicating that the behavior of the included UseCase (the addition) is inserted into the behavior of the including UseCase (the includingCase).

An Extend is a relationship from an extending UseCase (the extension) to an extended UseCase (the extendedCase) that specifies how and when the behavior defined in the extending UseCase can be inserted into the behavior defined in the extended UseCase.

Take for example:

There is no direct equivalent in Archimate, because its meta model allows direct relationships between services only to model a flow ("triggers / flows to").

For modeling inclusion and extension in Archimate, you'd need to show the reuse of behaviors (the initial purpose of inclusion/extension when use cases were invented) by making a difference between:

• Application services expose behavior to the external environment for a given purpose, equivalent to real use cases

• Application functions correspond to internal behaviour that would be combined to realize a service (the same function being represented for several services):

  An application function describes the internal behavior of an application component. If this behavior is exposed externally, this is done through one or more services. An application function abstracts from the way it is implemented. Only the necessary behavior is specified.

So the translated example would show that same functions can be used to realise several services:

A similar principle could be used for extension.

Isn't this cumbersome?

The more complex Archimate equivalent has some advantages: it forces to make the difference between behaviors exposed directly (real use cases), and reusable application functions (pseudo use cases that mainly serve a functional decomposition without being user-goal oriented - something that is anyway not recommended in use-case modelling). Moreover it leads to a more visual differentiation between different levels of abstraction.