Architecture description language

From Wikipedia, the free encyclopedia - View original article

Jump to: navigation, search

Architecture description languages (ADLs) are used in several disciplines: system engineering, software engineering, and enterprise modelling and engineering.

The system engineering community uses an architecture description language as a language and/or a conceptual model to describe and represent system architectures.

The software engineering community uses an architecture description language as a computer language to create a description of a software architecture. In the case of a so-called technical architecture, the architecture must be communicated to software developers; a functional architecture is communicated to various stakeholders and users. Some ADLs that have been developed are: Acme (developed by CMU), AADL (standardized by the SAE), C2 (developed by UCI), Darwin (developed by Imperial College London), and Wright (developed by CMU).

The up-to-date list of currently existing architectural languages might be found at Up-to-date list of ADLs.

The ISO/IEC/IEEE 42010[1] document, Systems and software engineering—Architecture description, defines an architecture description language as "any form of expression for use in architecture descriptions" and specifies minimum requirements on ADLs.

The enterprise modelling and engineering community have also developed architecture description languages catered for at the enterprise level. Examples include ArchiMate (now a standard of The Open Group), DEMO, ABACUS (developed by the University of Technology, Sydney). These languages do not necessarily refer to software components, etc. Most of them, however, refer to an application architecture as the architecture that is communicated to the software engineers.

Most of the writing below refers primarily to the perspective from the software engineering community.


A standard notation (ADL) for representing architectures helps promote mutual communication, the embodiment of early design decisions, and the creation of a transferable abstraction of a system. Architectures in the past were largely represented by box-and-line drawing annotated with such things as the nature of the component, properties, semantics of connections, and overall system behavior. ADLs result from a linguistic approach to the formal representation of architectures, and as such they address its shortcomings. Also important, sophisticated ADLs allow for early analysis and feasibility testing of architectural design decisions.


ADLs have been classified into three broad categories: box-and-line informal drawings, formal architecture description language, and UML-based notations. Box-and-line have been for a long time the most predominant means for describing SAs. While providing useful documentation, the level of informality limited the usefulness of the architecture description. A more rigorous way for describing SAs was required. Quoting Allen and Garlan (1997),[2] "while these [box-and-line] descriptions may provide useful documentation, the current level of informality limits their usefulness. Since it is generally imprecise what is meant by such architectural descriptions, it may be impossible to analyze an architecture for consistency or determine non-trivial properties of it. Moreover, there is no way to check that a system implementation is faithful to its architectural design." A similar conclusion is drawn in Perry and Wolf (1992),[3] which reports that: "Aside from providing clear and precise documentation, the primary purpose of specifications is to provide automated analysis of the documents and to expose various kinds of problems that would otherwise go undetected."

Since then, a thread of research on formal languages for SA description has been carried out. Tens of formal ADLs have been proposed, each characterized by different conceptual architectural elements, different syntax or semantics, focusing on a specific operational domain, or only suitable for different analysis techniques. For example, domain-specific ADLs have been presented to deal with embedded and real-time systems (such as AADL,[4] EAST-ADL,[5] and EADL[6]), control-loop applications (DiaSpec[7]), product line architectures (Koala[8]), and dynamic systems (Π-ADL[8])). Analysis-specific ADLs have been proposed to deal with availability, reliability, security, resource consumption, data quality and real-time performance analysis (AADL, behavioral analysis (Fractal[9])), and trustworthiness analysis (TADL[10]).

However, these efforts have not seen the desired adoption by industrial practice. Some reasons for this lack of industry adoption have been analyzed by Woods and Hilliard,[11] Pandey,[12] Clements,[13] and others: formal ADLs have been rarely integrated in the software life-cycle, they are seldom supported by mature tools, scarcely documented, focusing on very specific needs, and leaving no space for extensions enabling the addition of new features.

As a way to overcome some of those limitations, UML has been indicated as a possible successor of existing ADLs. Many proposals have been presented to use or extend the UML to more properly model software architectures.[14][15]

In fact, as highlighted in a recent study conducted with practitioners,[16] whilst practitioners are generally satisfied with the design capabilities provided by the languages they use, they are dissatisfied with the architectural language analysis features and their abilities to define extra-functional properties; architectural languages used in practice mostly originate from industrial development instead of from academic research; more formality and better usability are required of an architectural language


There is a large variety in ADLs developed by either academic or industrial groups. Many languages were not intended to be an ADL, but they turn out to be suitable for representing and analyzing an architecture. In principle ADLs differ from requirements languages, because ADLs are rooted in the solution space, whereas requirements describe problem spaces. They differ from programming languages, because ADLs do not bind architectural abstractions to specific point solutions. Modeling languages represent behaviors, where ADLs focus on representation of components. However, there are domain specific modeling languages (DSMLs) that focus on representation of components.

Minimal requirements

The language must:

ADLs have in common:

ADLs differ in their ability to:

Positive elements of ADL[edit]

Negative elements of ADL[edit]

Common concepts of architecture[edit]

The ADL community generally agrees that Software Architecture is a set of components and the connections among them. But there are different kind of architectures like:

Object Connection Architecture[edit]

Interface Connection Architecture[edit]

Most ADLs implement an interface connection architecture.

Architecture vs. Design[edit]

So what is the difference between architecture and design? Architecture casts non-functional decisions and partitions functional requirements, whereas design specifies or derives functional requirements. The process of defining an architecture may use heuristics or iterative improvements; this may require going a level deeper to validate the choices, so the architect often has to do a high-level design to validate the partitioning.


Below the list gives the candidates for being the best[citation needed] ADL to date.

For an up-to-date list of currently existing architectural languages, please refer Up-to-date list of ADLs.

Approaches to architecture[edit]

Approaches to Architecture


See also[edit]


  1. ^
  2. ^ Allen, R.; Garlan, D. (1997). "A formal basis for architectural connection". ACM Transactions on Software Engineering and Methodology 6 (3): 213. doi:10.1145/258077.258078.  edit
  3. ^ Perry, D. E.; Wolf, A. L. (1992). "Foundations for the study of software architecture". ACM SIGSOFT Software Engineering Notes 17 (4): 40. doi:10.1145/141874.141884.  edit
  4. ^ "AADL". 
  5. ^ "AADL". 
  6. ^ Li, J.; Pilkington, N. T.; Xie, F.; Liu, Q. (2010). "Embedded architecture description language". Journal of Systems and Software 83 (2): 235. doi:10.1016/j.jss.2009.09.043.  edit
  7. ^ "AADL". 
  8. ^ a b Van Ommering, R.; Van Der Linden, F.; Kramer, J.; Magee, J. (2000). "The Koala component model for consumer electronics software". Computer 33 (3): 78. doi:10.1109/2.825699.  edit
  9. ^ Software: Practice and Experience 36 (11–12). 2006. doi:10.1002/spe.v36:11/12.  edit
  10. ^ "TADL". 
  11. ^ Woods, E.; Hilliard, R. (2005). "Architecture Description Languages in Practice Session Report". 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05). p. 243. doi:10.1109/WICSA.2005.15. ISBN 0-7695-2548-2.  edit
  12. ^ Pandey, R. K. (2010). "Architectural description languages (ADLs) vs UML". ACM SIGSOFT Software Engineering Notes 35 (3): 1. doi:10.1145/1764810.1764828.  edit
  13. ^ Clements, P. C. (1996). "A survey of architecture description languages". Proceedings of the 8th International Workshop on Software Specification and Design. pp. 16–00. doi:10.1109/IWSSD.1996.501143. ISBN 0-8186-7361-3.  edit
  14. ^ "Garlan_TR". 
  15. ^ Pérez-Martínez, J. E.; Sierra-Alonso, A. (2004). "UML 1.4 versus UML 2.0 as Languages to Describe Software Architectures". Software Architecture. Lecture Notes in Computer Science 3047. p. 88. doi:10.1007/978-3-540-24769-2_7. ISBN 978-3-540-22000-8.  edit
  16. ^ Malavolta, Ivano; Lago, Patricia; Muccini, Henry; Pelliccione, Patrizio; Tang, Antony (2013). "What Industry Needs from Architectural Languages: A Survey". IEEE Transactions on Software Engineering 39 (6). doi:10.1109/TSE.2012.74.  edit

External links[edit]