Presumption 3: Structures are constrained by space
All actions in the system are performed by actors or components that occupy space and must be addressable.
Interfaces, roles, and functions don’t define behavior, they only define behavior. identify They’re behavioral choices. name Behavioral models for which addressable components, human subjects and organizational units are responsible.
Principle 3.1: A type of behavioral element describes similar initial characteristics.
Sophistry — skill, skill, cunning fiction, trick) — formally seeming correct, but essentially false inference, based on intentionally incorrect selection of initial positions.
ArchiMate’s processes are initial or cyclical, but its functions are not. Because the functions are more like roles, classifying them as behavioral is confusing. ArchiMate tries to make a distinction by saying that roles are responsibility behavior, while functions describe It’s behavior, but the subsequent discussion suggests it’s sophistry.
Principle 3.2: Roles and functions determineThey do not follow patterns of behavior.
What makes a thing (subject or object) structuralThat it’s addressable. If you can’t locate an object in space, you can’t ask it to do a job. If you can’t locate an object in space, you can’t work with it. Next, what does the structural element do? livelyThat it performs one or more actions (each of which has a purely logical structure over time) or identifies or names actions to be performed.
Components, organizational units and actors demonstrate behavior. Interfaces, roles and functions do not; they only identify/name behavior.
- The separation of interfaces (which determine behavior) and components (responsible for performing behavior) separates what needs to be done from how it is assigned to components in the system structure.
- The separation of functions (which determine behavior) and organizational units (responsible for performing behavior) separates what needs to be done from how it is distributed among organizational units.
- The division of roles (which determine behavior) between actors (responsible for performing behavior) separates what needs to be done from how it is assigned to people.
Note that ArchiMate uses the term actor for both an individual unit of an organization and an individual.
What the system can do perform, defined in definitions of its active structural elements. Business functions define what the divisions of the organization do, and roles determine what the actors do. Functions and roles are structural elements, not behavioral. lightly Modify to distinguish processes (behavior from beginning to end) from functions and roles (logic components), and this table shows how elements can be renamed and moved.
| Levels of architecture | Behavior over time | Addressable structures |
| Business-level | Business service | Business interface |
| Business process | Function / Role / Acting person | |
| Application level | Application service | Application interface |
| Application process | Annex, function / Component | |
| Infrastructure level | Infrastructure services | Infrastructure interface |
| Infrastructure process | The infrastructure, function / The knot |
Principle 3.3: Clustering individual services creates a structural function, not a larger service
In addition to the kinds of abstraction mentioned above, simply removing detail from a description is the simplest kind of abstraction. One way to erase detail is to combine several related objects into a group and then name a group of objects or a type of object. So individuals become a set, things become a type, the unique becomes a collection.
Combining different types of behavior into a group is a way of designing logical structural elements that we call interfaces, functions, and roles.
| Logical structure | Types of Cluster Behavior That | more about physical structures | are responsible for |
| External interface | Types of Cluster Behavior That | Components | are responsible for |
| Business function | Types of Cluster Behavior That | operatives of organizational units | are responsible for |
| Role | Types of Cluster Behavior That | protagonists | are responsible for |
A behavioral element (a service or process) can be fine-grained or coarse-grained, depending on the degree of detail and the nature of the system that provides or executes it. A single business service can be a project that goes from requesting a project to delivering it over many years. plurality But combining different units of behavior into an aggregate using some kind of behavior. other Criteria is how we design. logicThe aggregate differs from the internal behavior and is very similar to a role or function, or what TOGAF calls. logical a component (the root object of the “opportunities” to perform this function using physical resources).
In short, if you combine individual services into a named group, you should represent it using a feature symbol or interface..
Principle 3.4: Unambiguous relationships and blocks of synonyms
In practice, some architecture diagrams are cluttered with redundant 1-to-1 ratios and blocks of synonyms. If a block called gardening is linked 1-to-1 to a block called gardener, then having two blocks is superfluous. A verb-named field simply attaches an alternate label to a block with a noun name. By defining a service as anything a component does, we see diagrams cluttered with 1-to-1 ratios such as: transaction processing <is a service implemented> by the transaction processor; messaging mediation <is a service implemented> by the message intermediary; and customer relationship management is <is a service implemented> by the customer relationship management system.
Similarly, if one component has one interface located at the same address, there is no need to separate the interface from the component. If two components cooperate to support the same interface, then this interface is a collaboration, so there is no need to also draw a collaboration window. If one process provides the same service, separation of service and process may not help. And so on.
Prerequisite 4: Data conveys meaning
Background: A data object contains a data structure or element that has meaning or value to its creators and users. Business system developers need to know what data is being transferred between participants or components, what data is being shared, and what data is being shared.Enterprise architects model “information-intensive” business systems in which data streams and data warehouses are important elements.
ArchiMate is poorly versed in data architecture: Is its “data object” a message or a data stream, a memory area or a data store, or a separate piece of information transmitted within a message or stored in memory? The premise here is that each data object is a data item or a larger data structure that has meaning or value to its creators and users.
ArchiMate doesn’t talk about the data structures contained in the data objects, but they are there. The data object can be small or large. It can be a separate data element or a client object with multiple attributes. It can be a cumulative entity, such as a client, with orders and order nomenclatures. Or a large and complex data structure, containing customers, orders, order nomenclatures and product types. No matter how small or large the content of the data object, it can be defined in the data model.
Principle 4.1: A message or data stream transmits a data object from a source to a target.
A discrete message or data stream (or an interface in TOGAF) transmits the data object from source to target. The messages take up space and take physical form (e.g., digital or paper). You can draw a stream arrow to show the movement of data/information/value between source and target elements. You can design each relationship of data flows using two arrows and a data object, so [source element -> data object -> target element].
Please note that any individual service may use and/or return a data stream, even if this is not shown in the chart.
Principle 4.2: A data object is stored in memory or storage for use by entities or components performing certain actions.
Discrete memory or data storage (or a data component in TOGAF) stores the data object for use by actors or components performing certain actions. The memory takes up space and takes physical form (e.g., digital or paper) The purpose of displaying data warehouses in a system model is to identify independently supported memory regions, especially those that contain large and complex data structures consisting of many data structures and smaller elements.
How do you imagine a data warehouse? ArchiMate doesn’t have a data warehouse symbol, but there are various characters that can be used.
- A data object can represent a data structure of any scale, from an atomic data element to a large and complex data structure.
- An artifact may represent a deployable definition of a data structure (e.g., a message schema or a database schema).
- System software – may represent a data management system (e.g., DBMS).
- An application component may represent a data server layer that encapsulates a data store or other data source.
It’s not obvious which character is better. You can say that the data store is a passive structure that doesn’t do anything. So the data store can be modeled as a data object — maybe large and complex. During execution, the data store creates instances of concepts defined in any related logical data model; it contains actual data (like rows in database tables). In order for this to be useful, it has to be somehow encapsulated by input/receive services. This means that it can be modeled as an application component. So should we draw a data object or an application component? ArchiMate doesn’t let you draw data streams to or from data objects, so if you want to do that, you’ll have to imagine the data store as an application component.
Principle 4.3: The number of associations Important!
In ArchiMate, there is no way to show the number of elements of an associative relationship. As a result, people use a composition to denote an association of 1-N, and aggregation to denote an association of N-N. Just as we need AND and OR symbols to connect relationships, we need a power symbol to show where a system element at one end of a relationship can be displayed in multiple instances in an operating system.
Presumption 5: Models are abstractions
All system descriptions are abstracted from existing or planned operating systems, and omitting details is perhaps the most basic and universal method of abstraction. For example:
- After abstraction by means of delegation The client description does not contain behavior delegated to the servers.
- After abstraction by means of composition The description of the whole hides the details of its parts.
- After abstraction by means of generalization The description of the generalization omits the details of any specializations.
- After abstraction by means of idealization The description of a logical thing omits the details of more physical improvements or concretizations.
*Abstraction The process of abstraction (abstraction) from certain characteristics of the object for their selective analysis; while the observed object is replaced by its idealized theoretical image — an abstract object.
This table presents each of these four types of abstraction as a four-level hierarchy.
| Delegation of authority | Composition | Generalization | Idealization |
| Applications System Software Hardware | Medium-grain composite Detalized composite Elementary part | Quite general Quite specific Unique configuration | Logical model Physical materials |
| Servers | Decomposition | Specialization | Implementation |
Note: Correspondences along the series are not intended.
Principle 5.1: Decomposition of representations of active structure and behavior determines the same elementary actions
*Decomposition is the operation of thinking, which consists in dividing the whole into parts, and also decomposition is the general technique used in solving problems, which consists in dividing a problem into many particular problems, as well as problems that do not exceed the total complexity of the original problem, by combining the solutions of which, you can form a solution to the original problem as a whole.
In UML, the fundamental or elementary unit of behavior—the most detailed behavior in a system model—is called “action.” Combining actions into a sequential flow is how we define a longer behavior (process, document flow, finite automaton, or interaction). other The criterion of cohesion is how we design structural elements (functions, components, interfaces, etc.). ArchiMate should consider the principle that representations of active structure and behavior can be broken down into the same elementary actions, and how to represent this combination using symbols in diagrams.
Principle 5.2: Architects generalize and idealize the types of system elements
Corporate architects typically seek to generalize components, services, and interfaces for reuse in the enterprise. This chart shows how the TOGAF scheme for architectural description artifacts (enterprise continuum) compares generalization levels (columns) with idealization levels (line).
| Idealization | (Universal) | (Pretty general) | (Pretty specific) | (Unique setting) |
| Requirements and context | ||||
| Architectural continuum (logical models) | Foundation architecture | General system architecture | Industry architecture | Architecture of organization |
| Continuum of Decisions (Physical Models) | Fundamental solutions | General system solutions | Industry-specific solutions | Organizational decisions |
| Deployed solutions |
Principle 5.3: Delegation is best distinguished from implementation
Typically, a complex system is described or designed by dividing it into hierarchical client-server layers. This simplifies the design of higher systems that delegate authority to lower systems that depend on lower systems, etc. Delegation allows you to describe a higher-level system without any reference to how the lower-level system works.
ArchiMate speaks of an implementation where delegation seems to be a more appropriate term: the client uses the server or delegates it to the server; idealize The application delegates authority to devices; does not idealize The billing application delegates authority to the database software node or function; idealize Conversely, the server serves the client. consciously The device serves the system software; it doesn’t. consciouslyThe database system software node serves the billing application; implement him.
UML can display delegation of authority from clients to servers using the dependency arrow. To this end, ArchiMate uses the «used» relation in reverse (meaning «serves»).
Principle 5.4: Corporate architects model only a fraction of reality
Corporate architects don’t describe the hustle and bustle, the muddle of reality; the amazing variety of actors and activities in business operations; they don’t describe human biochemistry, human cognition, or human social communication; they don’t describe buildings, elevators, doors, vehicles, cables, and computer processor chips; they don’t describe perhaps 99 percent of the biological, physical, or material world on which business relies.
TOGAF uses four different kinds of abstraction in its design method and enterprise continuum to classify and separate architectural descriptions. In this table, each type of abstraction is represented as a four-tiered hierarchy; no correspondence along the series is implied.
| Method of designing architecture | Business continuum | ||
| Delegation of authority | Composition | Generalization | Idealization |
| Clients. | Compiled | Background | Ideal. |
| rolely | Enterprise/Strategy | Basis | Requirements |
| Annexes | Segments | Common system | Building blocks of architecture |
| System software | empowerment | Industry | Building blocks of solutions |
| Hardware support | Organization | Deployed solutions | |
| Sections | Set in shelves. | Specificity | Real. |
Even the bottom line of TOGAF’s enterprise continuum represents a huge abstraction from the reality of operating systems.
Principle 5.5: Omission of details
Omitting details is perhaps the most basic and versatile method of abstraction. TOGAF involves omitting intermediate objects, which are often displayed on archimat diagrams.
Presumption 6: Everything is typed
The premise: Architects typically model types, not instances. An operating system contains individual elements (structure elements and behavioral characteristics) that are complete, precise, and specific.Actual models. The models are type Types are abstract, incomplete, and may be fuzzy.
The difference between type and instance is usually interpreted as the difference between description and reality. A specimen is anything that embodies or demonstrates a type property. Creating a behavioral type instance is different. Symphonic execution is an example of a symphony. Manufacturing a car is an example of the manufacturing process of a car. Calculating the area of a rectangle is an example of calculating the area of a rectangle.
Systems are typically composed of actors (addressable entities) who perform actions (time-limited behaviors) and both actors and actions are presented as descriptive types and operational instances.
| Systems | Time-limited behaviour | Addressable structures |
| Types. | Types of action describe units of behavior that are transient. e.g., a service contract, a process flow diagram, or an interaction/sequence diagram. | Types of actors They describe the types of attributes that an actor needs to have, and the kinds of actions that an actor can do, like a role, a function, an interface definition. |
| Examples | Action These are temporal characteristics that are executed over time from start to finish, such as any process that implements logic in a service contract, flowchart, or interaction/sequence diagram. | Actors They are addressable in space, they perform actions, they have a flow of control and a current state. For example, actors who play roles, organizational units that implement functions, instances of components that implement interfaces. |
For example, in UML, a class defines the types of behaviors that can be performed by objects that create an instance of a class.
| UML | Time-limited behaviour | Addressable structures |
| Types. | Types of operations | Classes. |
| Examples | Examples of operations | Active objects |
Natural language often blurs the distinction between types and instances of system elements, using UML and ArchiMate terminology to distinguish them.
- The type of active structural element describes (each element in the set) similar Actors, components or nodes.
- The type of behavioral element describes (each element in the set) similar characteristics
- The type of event describes (each element in the set) similar events.
- The data type describes (each element in the set) similar data-structure.
In this table, the types and instances above correlate with the system aspects of ArchiMate.
| ArchiMate Aspect | Enter the model. | The Man in the Operating System |
| Active structure | Role | Subject: Has a state and relationships with other entities |
| Behavior | Process | Productivity: Executed from start to finish in accordance with business rules |
| Behavior | Event | Emergence: triggers the productivity of the process |
| Passive structure | Data object | Data structure/element: encodes specific meaningful information (may be created, moved, changed or destroyed). |
Architects almost never refer to individual events or characteristics of processes, but sometimes they name individual actors or components and perhaps even the values of individual data structures/elements (invariants).
Principle 6.1: The type of actor or component describes similar actors or components.
The actors are assigned by role, and strictly speaking, what creates the instance of the role is appointment However, the creation of this instance is usually seen in terms of the role (rather than in terms of the person). performer What actors are and what they do outside of roles in the system is not reflected in our business system models.
The table below shows the divisions of the organization that create instances of functions in a manner similar to performers that create instances of roles.
| Business | People. | Organization |
| Types. | rolely | Functions |
| Examples | Actors | Organizational units |
ArchiMate clearly doesn’t distinguish types from instances, but it usually models types. You’re not going to model the production of one individual car, but you can model the overall manufacturing process of cars. However, you can model one individual subject assigned a specific role. This table extends the two-dimensional grid to show the differences between the types and instances that you can draw in ArchiMate.
| species | Behavior patterns | Structures | ||
| Logical types | Examples in time | Examples in space | Logical types | |
| External | Business services | Cases of provision of services | Business interfaces? | Service-level agreements |
| Inner | Business processes | Process efficiency | People— protagonists | rolely |
Now, interestingly, ArchiMate is positioning functions as behaviors, and in this chart, the business function is finally where it seems to be, but now the position of the business interface is questionable.
Principle 6.2: Implementation has multiple possible meanings
System models hide infinitely detailed physical characteristics of actual operating systems. ArchiMate says that “implementation connects a logical entity to a more specific entity that implements it.” Defining a term using the term itself is bad practice because it does not help the reader. This leaves the implementation open to at least four possible meanings illustrated here in terms of object-oriented software concepts.
| These more logical things | You could say | These are more specific things |
| Classes. | This is done by creating a copy of the | Facilities |
| Methods (services) | implemented through the introduction of | Method bodies (processes) |
| Abstract classes (interfaces) | implemented through the introduction of | Specific classes (components) |
| UML classes | designed | Java classes |
But in the ArchiMate examples, the implementation arrow is used to select these values.
You will probably hear what “realization” means. creation a sample of the type in real conditions, as shown in this table.
| Logical types | You could say | Physical copies |
| Data types | This is done by creating a copy of the | Data structures/elements |
| Activities | This is done by creating a copy of the | Examples |
| Processes | This is done by creating a copy of the | Results |
| rolely | This is done by creating a copy of the | Actors |
But ArchiMate doesn’t seem to be using an implementation in this sense of creating an instance.
It can be said that an external service or interface is implemented by implementation One or more internal processes or components.
| External elements | You could say | Internal elements |
| Services | implemented through the introduction of | Processes |
| Interfaces | implemented through the introduction of | Components |
Curiously, ArchiMate speaks of the former, but not the latter (instead, it says that the interface is the first one). part component.
You may have noticed that TOGAF places great emphasis on defining the building blocks of logical architecture (ABB) above and precedes the building blocks of physical solutions (SBB).ABB logical descriptions are pre-engineered into SBBs, which are still only descriptions and are «strongly abstracted» from material components or execution components.
| Logical ABBs | You could say | Physical ABBs |
| Business functions | designed | Descriptions of organizational units |
| Components of logical applications | designed | Physical components of the application |
| Components of logical technologies | designed | Components of physical technologies |
ArchiMate uses this advanced approach, but only in the field of data architecture.
| Logical ABBs | You could say | Physical ABBs |
| Business facilities | designed | Data objects in a data model |
| Data objects | designed | Database Tables in a Database Scheme or Artifact |
ArchiMate does not offer a hierarchy of idealization-implementation of active structural elements. However, the table below (using a combination of TOGAF and ArchiMate terms) shows where the implementation arrow can be used to link logical elements to more physical/real elements.
| domains | This logical type. | pertaining | implementation |
| Annexes | TOGAF: Logical component of the application | implemented | Physical components of the application |
| ArchiMate: Application function/interface/service | implemented | Components of the annex | |
| TECHNOLOgy | TOGAF: Logical technology component | implemented | Components of physical technologies |
| ArchiMate: Infrastructure function/interface/service | implemented | Infrastructure nodes |
Development of three principles
Principle 5.1: Decomposition of representations of active structure and behavior determines the same elementary actions
Physicists believe that our world is embedded in a four-dimensional space-time continuum. This is called a «continuum» because it assumes that space and time can be separated without any constraints on size or duration. Descriptions of business systems can be hierarchically separated by space/structure and time/behavior.
Structural composition/decomposition
Structural view defines what a system consists of. It defines actors and components that perform behavior (along with interfaces and data structures). Structural decomposition sequentially divides space into smaller regions. Biologists describe an organism in terms of organs, then tissues, then cells, etc. Architects break up a large system into larger components that are subdivided into smaller components, and so on. A higher-level system can only be described in terms of the largest components that hide the inner details of smaller components.
Behavioral composition/decomposition
The behavioral view of a system determines what a system does, how it works. It defines the usual services and processes that are performed from start to finish, repeatedly. Behavioral decomposition sequentially divides time into shorter intervals. We can divide the long process into shorter stages, divide these steps into shorter stages, and so on. The higher-level process can only be described in terms of the next largest stages of the process, hiding the inner details of the smaller steps.
Functions can be thought of as logical components. Business functions can be thought of as logical organizational units. Functional decomposition hierarchy groups actions into structural representation. On the contrary, process decomposition hierarchy groups actions into behavioral representation. So if both hierarchies are arranged into the same level, they should be reduced to the same elementary actions. This principle is evident in structured analysis methods used in EA frameworks such as Avancier Methods, EA3 and TOGAF. Elementary activity may be referred to as an elementary business function and/or an elementary business process.
Decomposition of Behavioral Representations and Active Structure on the Same Level
In UML, the fundamental or elementary unit of behavior—the most detailed behavior in a system model—is called “action.” Combining actions into a sequential flow is how we define a longer behavior (process, document flow, finite automaton, or interaction). other The criterion of cohesion is how we design structural elements (functions, components, interfaces, etc. ArchiMate should consider the principle that representations of active structure and behavior can be decomposed into the same elementary actions, and how to represent this combination using symbols in diagrams.
Principle 5.5: Omission of details
Omitting details is perhaps the most basic and versatile method of abstraction. TOGAF involves omitting intermediate objects, which are often displayed on archimat diagrams.
For example, this is an ArchiMate style model.
| Element | Attitude | Element | Attitude | Element |
| Services | Assigned from | Interface. | Part part | Component |
| Implemented | Process | For |
Usually in TOGAF it comes down to this model.
| Element | Attitude | Element |
| Services | Implemented | Component |
On the other hand, it’s not always possible or useful to deduce a direct relationship from a straight line, sometimes because there are several possible ways to interconnect, sometimes because blocks represent large and complex types, consisting of many smaller and simpler elements, and the strings connecting instances of the original and target types often connect elements. inside The original and the target instances, and sometimes because the interrelationships can be optional.
For example, ArchiMate argues that if A-linked-to-B-linked-to-C, then A-linked-to-C. Is that necessarily true? What if A triggers behavior within B that is not relevant to C? Or triggers behavior that selects whether to run C or not? If a strategy triggers Marketing and sales, triggers complaints and compensation, is it appropriate to say that the strategy triggers complaints and compensation?
For example, ArchiMate states that if A-linked-to-B-linked-to-C, then A-linked-to-C. partly B, which is not related to C? If the client-screening association is a film actor, is it appropriate to say that Clients are related to actors?
In a sense, every part of the system is connected to every other part, directly or indirectly, otherwise there would be separate systems, but from an architectural point of view, it doesn’t make sense or do any good to link each part to any other part.
Principle 1.4: Business interfaces are not platform communication channels
A social, business, or software system is encapsulated logically rather than physically. Subject-to-subject or business-to-business interfaces can be defined in a service level agreement document that lists the business services being called. Because actors and components are distributed, they must exchange individual communication events to induce behavior and respond to calls, and there must be a physical communication channel through which communication events can be transmitted. In ArchiMate’s examples, there is confusion between the concept of a logical business interface (indicating what services can be called) and the physical infrastructure channels through which services can be called.
This table presents a business function where it seems to be, but highlights the question of where the business interface is.
| species | Behavior patterns | Structures | ||
| Logical types | Examples in time | Examples in space | Logical types | |
| External | Business services | Cases of provision of services | Business interfaces? | Service-level agreements |
| Inner | Business processes | Process efficiency | People. protagonists | rolely |
Because ArchiMate assumes that the interface is a point of access to services, it’s an example above. But business architecture diagrams showing business interfaces called «phone» or «web» are highly questionable. These are shared infrastructure devices or communication paths. They’re not tied (as ArchiMate insists, the interface should be) to a single business role or actor.
B2B and B2C communications depend, for example, on a common communication infrastructure.
- Face-to-face speech – from mouth to ear through the physical medium of sound waves.
- Speak in the ear through the deep communication stack of the telecommunications network.
- Email Snail – from writing to reading using paper over the communication stack of the postal service.
- Email – from writing to reading from keyboard and screen via SMTP/IMAP via TCP via IP via Ethernet via physical IT media.
We think of business domains, applications, and infrastructure as client-server layers. And in an «open» (rather than closed) client-server architecture, you can skip layers. So, in a business role, a person-executor can call the infrastructure service directly. But shared infrastructure devices and communication channels are not business-specific system interfaces.
So, what is a business-specific interface? A service-level agreement of sorts determines (logically) what services are required or provided to a business. This logical interface can then be implemented in an application interface through which customers can call individual services. Or in a telephone answering machine that provides customers with domain-dependent services (click 1 for that, 2 for that). Often this is implemented in formal job requests and less formal communication between people.
Here are some concepts related to the idea of the interface that should be unraveled.
- Service Level Agreement: A contract or other form of interface definition that declares what services customers can call but is not an access mechanism at runtime.
- Control elements: Mechanisms (including user interfaces) that provide customers with tools to directly call domain-specific services.
- A “direct broker” or implementation agent who announces services and provides their addresses to customers.
- Facade: An “indirect intermediary” component that receives events and service requests and transmits them to server components.
- Communication stack: platform technologies used in communication channels between participants or components.
Conclusions and recommendations
It is very difficult (unnatural) to use words in a disciplined way, but the professional has to understand which words are ambiguous for a particular subject area, where misunderstandings can occur, and clearly indicate the solutions. Standard modeling languages are only part of the answer.
There is widespread ignorance of the premises of systems theory, which makes it difficult for people to learn architectural concepts and leads to inconsistent use of modeling languages. Using the same symbols as anyone else does not mean that you use the same language. And quite often, the diagram reader is not sure what the diagram author meant.
Words like function and service are used in natural language in different and vague ways. If you ask the committee to define their meanings in modeling language, it can try to please everyone by weakening the definitions to a degree of ambiguity. So it becomes impossible to convey valuable and necessary concepts with any certainty. Compromising character definitions to satisfy everyone and all practices leads to inconsistency and inconsistency and makes it difficult for architects to learn.
Of course, many people use systems modeling tools in the same way they would use PowerPoint. There’s a combination of laziness, questionable examples, and poor learning. But the problems raised in this article can be solved fairly easily, and certainly should be addressed, not silenced. We should grit our teeth and use «controlled vocabulary» — rather, what seems to be the most natural or common language today. Here’s an attempt to define the basic terms in TOGAF.
ArchiMate may remain intentionally lax, defined in ambiguous places and places independent of the broader system theory.This article suggests using ArchiMate symbols in a way that is more compatible with the assumptions of system theory underlying UML and TOGAF. Options include:
- Explain that the difference between the structure and behavior of ArchiMate is different from the differences in other standards, and change the definitions of “service” and “interface” in the standard to resemble what the diagram examples often show (although this will further confuse the structure with the behavior and the abstract with the specific).
- Bring ArchiMate’s premises into line with the principles of systems theory, review all the principles in this article, and revise the diagram examples to fit them.
- Add this document to the standard as an ArchiMate setup app to match UML and TOFAF (the current guide on this issue is naive and inadequate).