Subsystem Usage

Subsystems can be used in a number of complementary ways, to partition the system into units which

• can be independently ordered, configured, or delivered
• can be independently developed, as long as the interfaces remain unchanged
• can be independently deployed across a set of distributed computational nodes
• can be independently changed without breaking other parts of the systems

Thus, subsystems are ideal for modeling components - the replaceable units of assembly in component-based development - that are larger than a single design class.

In addition, subsystems can

• partition the system into units which can provide restricted security over key resources
• represent existing products or external systems in the design.

Identifying Subsystems

A complex analysis class is mapped to a design subsystem if it appears to embody behavior that cannot be the responsibility of a single design class acting alone. A complex design class may also become a subsystem, if it is likely to be implemented as a set of collaborating classes.

Subsystems are also a good means of identifying parts of the system that are to be developed independently by a separate team. If the collaborating design elements can be completely contained within a package along with their collaborations, a subsystem can provide a stronger form of encapsulation than that provided by a simple package. The contents and collaborations within a subsystem are completely isolated behind one or more interfaces, so that the client of the subsystem is only dependent upon the interface. The designer of the subsystem is then completely isolated from external dependencies; the designer (or design team) is required to specify how the interface is realized, but they are completely free to change the internal subsystem design without affecting external dependencies. In large systems with largely independent teams, this degree of de-coupling combined with the architectural enforcement provided by formal interfaces is a strong argument for the choice of subsystems over simple packages.

The design subsystem is used to encapsulate these collaborations in such a way that clients of the subsystem can be completely unaware of the internal design of the subsystem, even as they use the services provided by the subsystem. If the participating classes/subsystems in a collaboration interact only with each other to produce a well-defined set of results, the collaboration and its collaborating design elements should be encapsulated within a subsystem.

This rule can be applied to subsets of collaborations as well. Anywhere part or all of a collaboration can be encapsulated and simplified, doing so will make the design easier to understand.

Hints

Once the design has been organized into subsystems, update the use-case realizations accordingly.

Modeling Subsystems

Design Subsystems are modeled using UML components. This construct provides the following modeling capabilities:

• can group classes to define a larger granularity part of a system
• can separate the visible interfaces from internal implementation
• can have execution at run-time

Some other considerations are:

• Each Design Subsystem must be given a name and a short description.
• The responsibilities of the original analysis class should be transferred to the newly-created subsystem, using the description of the subsystem to document the responsibilities

Note: UML 2.0 also defines a stereotype for component named <<subsystem>>, indicating that this may be used, for example, to represent large scale structures. A RUP Design Subsystem may or may not be a large scale structure; both are Design Subsystems from the RUP perspective. This is an issue for the software architect to decide (whether to choose for example to label components that are composed of components as <<subsystem>>).

Subsystems That Represent Existing Products

Where an existing product is one that exports interfaces, i.e. operations (and perhaps receptions), but otherwise keeps all details of implementation hidden, then it may be modeled as a subsystem in the logical view.  Examples of products the system uses that you may be able to represent by a subsystem include:

• Communication software (middleware).
• Database access support (RDBMS mapping support).
• Application-specific products.

Some existing products such as collections of types and data structures (e.g. stacks, lists, queues) may be better represented as packages, because they reveal more than behavior, and it is the particular contents of the package that are important and useful and not the package itself, which is simply a container. 

Common utilities, such as math libraries, could be represented as subsystems, if they simply export interfaces, but whether this is necessary or makes sense depends on the designer's judgment about the nature of the thing modeled.  Subsystems are object-oriented constructs (as they are modeled components): a subsystem can have instances (if the designer so indicates). UML provides another way to model groups of global variables and procedures in the utility, which is a stereotype of class - the utility has no instances. 

When defining the subsystem to represent the product, also define one or more interfaces to represent the product interfaces.

Subsystem Dependency Restrictions

Design Subsystems (modeled as UML components) differ from packages in their semantics: a subsystem provides behavior through one or more interfaces which it realizes. Packages provide no behavior; they are simply containers of things which provide behavior.

The reason for using a subsystem instead of a package is that subsystems encapsulate their contents, providing behavior only through their interfaces. The benefit of this is that, unlike a package, the contents and internal behaviors of a subsystem can be changed with complete freedom so long as the subsystem's interfaces remain constant. Subsystems also provide a 'replaceable design' element: any two <<realization>> components that realize the same interfaces (or <<specification>> component) are interchangeable.

In order to ensure that subsystems are replaceable elements in the model, a few rules need to be enforced:

• A subsystem should minimize exposing of its contents. Ideally no element contained by a subsystem should have 'public' visibility, and thus no element outside the subsystem depends on the existence of a particular element inside the subsystem. Some exceptions are as follows:
  • In some technologies, the externals of a subsystem cannot be modeled as a UML interface. For example, a Java interface is modeled as a stereotyped class.
  • The subsystem design may require exposing classes rather than UML interfaces. For example, a "delegate" or "access" class can be used to hide a complex collaboration of other classes. While an ordinary package could be used instead, a subsystem could be used in order to emphasize the intent to encapsulate behavior and hide internal details.
• 
  When a subsystem's externals are not UML interfaces, it is often helpful to have a diagram (for example named "External View") that shows the visible elements of the subsystem.
• A subsystem should define its dependencies on subsystem interfaces (and publicly visible elements of subsystem in the exceptional cases described above). In addition, a number of subsystems may share a set of interfaces or class definitions in common, in which case those subsystems 'import' the contents of the packages which contain the common elements. This is more common with packages in lower layers in the architecture, to ensure that common definitions of classes which must pass between subsystems are consistently defined.

An example of Subsystem and Package dependencies is shown below:

Subsystem and Package Dependencies in the Design Model

Subsystem Specification and Realization

Definition

The UML ([UML04]) states:

A number of UML standard stereotypes exist that apply to component, e.g. <<specification>> and <<realization>> to model components with distinct specification and realization definitions, where one specification may have multiple realizations.

A Component stereotyped by <<specification>> specifies a domain of objects without defining the physical implementation of those objects. It will only have provided and required interfaces, and is not intended to have any realizing classes and sub components as part of its definition.

A Component stereotyped by <<realization>> specifies a domain of objects and that also defines the physical implementation of those objects. For example, a Component stereotyped by <<realization>> will only have realizing classes and sub components that implement behavior specified by a separate <<specification>> Component.

The separation of specification and realization essentially allows for two separate descriptions of the subsystem. The specification serves as a contract that defines everything that a client needs to know to use the subsystem. The realization is the detailed internal design intended to guide the implementer. If you wish to support multiple realizations, create separate "realization" subsystems, and draw a realization from each realization subsystem to the specification subsystem.

When and how to use

If the internal state and behavior of the subsystem is relatively simple, it may be sufficient to specify the subsystem by its exposed interfaces, state diagrams to describe the behavior, and descriptive text.

For more complex internal state and behavior, analysis classes can be used to specify the subsystem at a high level of abstraction. For large systems of systems, the specification of a subsystem may also include use cases. See Developing Large-Scale Systems with the Rational Unified Process.

Providing a detailed specification separate from the realization tends to be most useful in the following situations:

• the subsystem realization's internal state or behavior is complex - and the specification needs to be expressed as simply as possible in order for clients to use it effectively;
• the subsystem is a reusable "assembly component" intended for assembly into a number of systems (see Concept: Component);
• the subsystem's internals are expected to be developed by a separate organization;
• multiple implementations of the subsystem need to be created;
• the subsystem is expected to be replaced with another version that has significant internal changes without changes to the externally visible behavior.

Maintaining a separate specification takes effort, however - as one must ensure that the realization of the subsystem is compliant with the specification. The criteria for when and if to create separate specification and realization classes and collaborations should be defined in  Work Product: Project Specific Guidelines.

Dependencies

A specification should define its dependencies. These are the interfaces and visible elements from other subsystems and packages that must be available in all compliant realizations of the subsystem.

A realization may have additional dependencies, introduced by the designer or implementer. For example, there may be an opportunity to use a utility component to simplify the implementation - but the use of this utility component is a detail that need not be exposed to clients. These additional dependencies should be captured on a separate diagram as part of the realization.

Relationship to Implementation

A fully detailed specification defines everything a client needs to use the subsystem. This means refining the exposed interfaces and any publicly visible elements so that they are one-to-one with code. Analysis classes introduced to specify the subsystem behavior should remain as high level abstractions, since they are intended to be independent of any subsystems realizations.

The realization elements of a subsystem should align closely to the code.

See Concept: Mapping from Design to Code for some further discussion on this topic.

UML 1.x Representation

Modeling

Design subsystems may be modeled as either UML 2.0 components or UML 1.5 subsystems. These constructs provide almost equivalent modeling capabilities like modularity, encapsulation, and instances able to execute at run-time.

Some additional considerations about these modeling options are:

• UML 1.5 subsystems explicitly included the notion of "specification" and "realization" (defined above in the section titled Subsystem Specification and Realization). The UML 2.0 components support the notion of specification (in the form of one or more provided and required interfaces) and realization (internal implementation consisting of one or more classes and sub components that realize its behavior).
• UML 1.5 subsystems were also packages. UML 2.0 components have packaging capabilities, which means they may own and import a potentially large set of model elements.

However, by and large, these notations can be used interchangeably. Whether to represent Design Subsystems as UML 1.5 subsystems or UML 2.0 components is a decision that should be documented in the  Project-Specific Guidelines tailored for your project.

If your visual modeling tool supports UML 1.5 packages but not UML 1.5 subsystems, a package stereotyped as <<subsystem>> can be used to denote a subsystem.

Subsystem Dependency Restrictions

The same dependency restrictions and discussions mentioned in the section titled Subsystem Dependency Restrictions also apply for design subsystems being modeled as UML 1.5 subsystems.

An example of Subsystem and Package dependencies in UML 1.5 is shown below:

Subsystem and Package Dependencies in the Design Model

Subsystem Specification and Realization

The contents of a subsystem are divided into two subsets: 1) specification elements and 2) realization elements. The specification elements, together with the operations and receptions of the subsystem, are used for giving an abstract specification of the behavior offered by the realization elements. The collection of realization elements model the interior of the behavioral unit of the physical system.

The separation of specification and realization essentially allows for two separate descriptions of the subsystem. The specification serves as a contract that defines everything that a client needs to know to use the subsystem. The realization is the detailed internal design intended to guide the implementer.

One option for modeling specifications and realizations, if not directly supported by the modeling environment, is to place two packages, specification and realization, inside each subsystem.

One motivation for specifications is to support multiple realizations. This was not directly supported in the UML 1.x. If you wish to support multiple realizations using UML 1.5 subsystems, create separate "realization" subsystems, and draw a realization from each realization subsystem to the specification subsystem.

Basically, the same considerations for Specification and Realization that apply for UML 2.0, also apply here (see When and How to Use, Dependencies, and Relationship to Implementation for explanation).

Additional Information

Refer to Differences Between UML 1.x and UML 2.0 for more information.