The first classification criteria that we apply is the source from which the architectural components are derived. Based on this we make a distinction between the following architecture design methods:

Artifact-driven architecture design methods derive architecture components by grouping artifact descriptions of the method. Examples of artifact-driven architectural design approaches are the object-oriented analysis and design methods such as OMT. Hereby, the methods provide a set of artifact types such as class, attribute, inheritance etc. Each artifact type provides a description of the entities that need to be identified in the analysis and design phase. The identification is supported by a set of heuristic rules. For example, OMT provides the artifact type tentative class, for which the following heuristic rule is defined:

IF an entity in the requirement specification is relevant
THEN select it as a TENTATIVE CLASS. 

In these artifact-driven methods architectural components are mainly defined as groupings of a set of artifacts, that is to say, the source of the architecture components are the artifacts. 

Use-case driven architecture design methods, apply use cases as the primary artifacts for deriving the architectural abstractions. A use case is defined as a sequence of actions that the system provides for actors. Actors represent external roles with which the system must interact. The actors and the use cases together form the use case model. The Unified Process, for example, applies a use-case driven architecture design approach. Hereby, the informal requirement specification and the use case model together form the requirement specification. From the use case model the architecturally significant use cases are selected and use-case realizations are created that determine how the system internally performs the tasks in terms of collaborating objects and as such help to identify the artifacts such as classes. These are later grouped as packages that basically define the architectural components. Similar to the artifact-driven methods, the use case driven methods also utilize groupings of artifacts as architectural components. Although use cases are applied to extract artifacts, the difference in the use-case driven methods is that the direct source of the architectural components are the use cases and not the artifacts as in the artifact-driven methods.

Domain-driven architecture design methods do not directly or indirectly derive the architectural components by utilizing artifact descriptions but rather extract the architectural components from the corresponding domain models. Domain models represent the reusable representation of domain knowledge for a given design problem. Domain models are developed through a domain analysis process, which can be defined as the process of identifying, capturing and organizing domain knowledge about the problem domain with the purpose of making it reusable when creating new systems. The domain model may be represented using different representation forms such as classes, entity-relation diagrams, frames, semantics networks, and rules. Although in the domain-driven architecture design methods use cases and artifact type descriptions may also be applied, they basically serve to scope the domain knowledge and extract the domain concepts.

We may classify the methods also according to the scope that the software architecture has to fulfill. Hereby we distinguish between methods that aim to design an architecture for a single system, from methods that try to design an architecture for a family of systems. Correspondingly, we term these methods respectively as single-system scope architecture design methods and multi-system scope architecture design methods. Let us explain this classification in more detail:

Single-System Scope Architecture Design Methods