AgileML™ for Agile Architecture & Design

The AgileML™ (Agile Modeling Language™) is a Lean (as in Lean manufacturing and methods) extended subset of the SysML system architecture modeling language standard that is used for precisely specifying scalable and simulatable Agile Architectures and Designs.

The AgileML core language is defined as a UML/SysML profile (dialect or customization); AgileML extensions are defined as both UML/SysML profiles and model libraries. Since AgileML is designed and implemented as a UML/SysML profile (UML/SysML dialect) and model library it is compatible with the OMG UML and OMG SysML architecture modeling language standards, and it can be implemented in popular architecture modeling tools that comply with those standards (e.g., Cameo, MagicDraw, Sparx EA, etc.).

The AgileML model library specifies recursive analysis, design, and architecture patterns that can be applied during the full System Development Life Cycle (SDLC) on "both sides" of the System V-Model (a.k.a. System Vee Model). These powerful recursive analysis, design, and architecture patterns facilitate scalable traceability on the "left side" of the System-V Model, and scalable Verification & Validation (V&V) on the "right side" of the System-V Model.

The AgileML can be customized to support a broad range of problem domains ranging from aerospace and automotive to healthcare and finance.

AgileML is designed to be used by Agile and Lean systems engineers and software developers who are tasked with developing scalable and simulatable system architectures and designs, but who want to avoid the problems associated with traditional BUFD ("Big Up Front Design" ) languages, such as full standard UML 2 and its SysML dialect:

AgileML offers the following advantages over BUFD languages:

• Lean & Compact → easier to learn and apply: AgileML is significantly smaller (50+% fewer diagram and 50+% fewer model elements) than UML 2, so it is relatively easy to learn and apply.
• Supports recursive analysis, design and architecture patterns → scalable: The AgileML model library specifies recursive analysis, design, and architecture patterns that can be applied during the full System Development Life Cycle (SDLC) on "both sides" of the System V-Model (a.k.a. System Vee Model). These powerful recursive analysis, design, and architecture patterns facilitate scalable traceability on the "left side" of the System-V Model, and scalable Verification & Validation (V&V) on the "right side" of the System-V Model.
• Emphasizes pervasive integration of dynamic behavior and mathematical (parametric) MODSIM patterns → simulatable & executable: The AgileML model library emphasizes broad integration of Turing-complete dynamic behavior patterns for Activity (ACT), Sequence (SD), and State Machine (STM) diagrams, and comprehensive integration of mathematical (parametric) structure patterns for Block Definition Diagrams (BDD), Internal Block Diagrams (IBD), and Parametric (PAR) diagrams. Consequently, since AgileML behavioral and parametric diagrams can be simulated and executed in system architecture modeling tools that support those features AgileML model are easier to test and debug.
• Compatibility & Portability → straightforward to implement in UML2/SysML compliant tools: Since AgileML is designed and implemented as a UML profile (UML dialect) and model library it is compatible with the UML and OMG SysML architecture modeling language standards, and can be implemented in popular visual modeling tools that comply with those standards.
• Expressibility & Precision → precise simulatable blueprints for systems of arbitrary complexity: Since AgileML emphasizes precise basic constructs and powerful recursive patterns, a relatively small number of AgileML constructs can specify systems of arbitrary complexity (arbitrary system DECOMPOSITION: systems → subsystems → sub-subsystems → sub-sub-subsystems → …; and arbitrary system COMPOSITION: systems ← system-of-systems ← system-of-systems-of-systems ← system-of-systems-of-systems-of-systems ← …).

AgileML supports the following diagram types:

AgileML Core Diagrams (derived and adapted from SysML)

1. Requirement (REQ) [reduced and extended]
2. Block Definition Diagram (BDD) [reduced and extended with SOA and Data Modeling model libraries]
3. Internal Block Diagram (IBD) (reduced and extended with SOA model library)
4. Parametric (PAR)
5. Activity (ACT) [Turing-complete MODSIM patterns emphasized; syntax significantly reduced]
6. Sequence (SD) [Turing-complete MODSIM patterns emphasized; syntax significantly reduced]
7. State Machine (STM) [Turing-complete MODSIM patterns emphasized; syntax significantly reduced]
8. Package (PKG) [reduced and extended]

AgileML Extension Diagrams (derived and adapted from UML2, SysML parent language)

9. Object (OBJ) [reduced from UML counterpart]
10. 10 Profile (PRO) [reduced from UML counterpart]
11. 11 Network (NET) [added; cf. UML Deployment]

SysML & UML 2 Diagrams Intentionally Not Used
The following UML 2 diagrams are considered gratuitous and/or "worst practice":

• UML/SysML Use Case (use high-level simulatable ACT instead)
• UML Communication (use AgileML Network instead)
• UML Deployment (use AgileML Network instead)
• UML Component (use AgileML BDD instead)
• UML Interaction Overview

Agile Architecture is a disciplined Agile + Lean approach to system and software architecture that emphasizes the specification of a Lean (as in Lean Engineering) System-of-Systems Architecture Model (SAM) using a mainstream software or system architectural modeling language (UML 2 or SysML) as an architecture framework for organizing the work artifacts of the Agile System Development Life Cycle (SDLC).

The scalable and simulatable Lean System-of-Systems Architecture Model (SAM) represents "architecture truth" for all stakeholders on "both sides" of the traditional System V-Model, including business stakeholders and various kinds of engineers (software, electrical, mechanical, aerospace, automotive, etc.). Consequently, SAM "architecture truth" subsumes and trumps Agile development software-centric "code is truth" maxim.

Agile Design is a disciplined Agile + Lean approach to system and software design that emphasizes the specification of higher-level abstractions vis-a-vis the software code. Typically, these higher-level abstractions include Object Oriented Analysis and Object Oriented Design techniques using a mainstream architecture modeling language, such as UML or OMG SysML. Agile Design best practices include Service-Oriented Design (cf. Interface Based Design), Test-First Design (TFD), and Design patterns for reuse.

Just as AgileML customizes UML2 and OMG SysML via profiles and model libraries, AgileML is is designed to be further tailored for problem domains and projects. Contact us for details.

AgileML™ was designed by Cris Kobryn, an internationally recognized system architecture modeling language expert known for successfully leading the UML 1, UML 2, and SysML language design teams for these de facto international standards. Cris has over 25 years professional experience in the design and implementation of system architecture modeling languages that are scalable and simulatable. In addition to his contributions to the UML 1, UML 2, and SysML de facto standards, Cris has also designed several specialized languages and model libraries that extend SysML:

• AgileML™ (Agile Modeling Language™) for Agile Architecture & Design MODSIM applications
• CyberML™ (Cyber Modeling Language™) for Cybersecurity Architecture & Design MODSIM applications
• CryptoML™ (Crypto Modeling Language™) for Cryptoeconomic Architecture & Design MODSIM applications
• SafetyML™ (Safety Modeling Language™) for Safety-critical Architecture & Design MODSIM applications

We plan to publish more information about AgileML on this web in the near future. While AgileML continues to evolve it is being actively used in PivotPoint's Agile Architecture & Design hands-on training.

If you would like to submit new questions for the AgileML FAQ or would like to subscribe to a AgileML mailing list, please contact us.