Hofmeister, R. Nord, D. We found that it works well for communicating the static structure of the architecture: the elements of the architecture, their relations, and the variability of a structure. These static properties are much more readily described with it than the dynamic properties.

Author:Tegar Zulucage
Language:English (Spanish)
Published (Last):22 March 2015
PDF File Size:14.70 Mb
ePub File Size:20.3 Mb
Price:Free* [*Free Regsitration Required]

Hofmeister, R. Nord, D. We found that it works well for communicating the static structure of the architecture: the elements of the architecture, their relations, and the variability of a structure. These static properties are much more readily described with it than the dynamic properties. We could easily describe a particular sequence of activities, but not a general sequence. In addition, the ability to show peer-to- peer communication is missing from UML.

Although its original purpose was for detailed design, its ability to describe elements and the relations between them makes it potentially applicable much more broadly.

This paper describes our experience using UML to describe the software architecture of a system. For these architecture descriptions, we wanted a consistent, clear notation that was readily accessible to architects, developers, and managers.

It was not our goal to define a formal architecture description language. The notation could be incomplete, but had to nevertheless capture the most important aspects of the architecture. In this paper we start by giving an overview of the kinds of information we want to capture in a software architecture description. Then we give an example of a software architecture P.

Donohoe ed. Nord, and D. Soni description for part of particular system: the image processing portion of a real-time image acquisition system. The final section discusses the strengths and weaknesses of UML for describing architecture. We separate software architecture into four views: conceptual, module, execution, and code. This separation is based on our study of the software architectures of large systems, and on our experience designing and reviewing architectures Soni, The different views address different engineering concerns, and separation of such concerns helps the architect make sound decisions about design trade-offs.

The notion of this kind of separation is not unique: most of the work in software architecture to date either recognizes different architecture views or focuses on one particular view in order to explore its distinct characteristics and distinguish it from the others Bass, The Garlen and Shaw work focuses on the conceptual view Shaw, Over the years there has been a great deal of work on the module view Prieto-Diaz, There is other work that focuses on the execution view, and in particular explores the dynamic aspects of a system Kramer, ; Purtilo, The code view has been explored in the context of configuration management and system building.

The conceptual view describes the architecture in terms of domain elements. Here the architect designs the functional features of the system. For example, one common goal is to organize the architecture so that functional features can be added, removed, or modified. This is important for evolution, for supporting a product line, and for reuse across generations of a product. The module view describes the decomposition of the software and its organization into layers.

An important consideration here is limiting the impact of a change in external software or hardware. The execution view is the run-time view of the system: it is the mapping of modules to run-time images, defining the communication among them, and assigning them to physical resources. Resource usage and performance are key concerns in the execution view.

Decisions such as whether to use a link library or a shared library, or whether to use threads or processes are made here, although these decisions may feed back to the module view and require changes there. The code view captures how modules and interfaces in the module view are mapped to source files, and run-time images in the execution view are mapped to executable files.

The partitioning of these files and how they are Describing Software Architectures with UML organized into directories affect the buildability of a system, and become increasingly important when supporting multiple versions or product lines. Each of the four views has particular elements that need to be described. The elements must be named, and their interface, attributes, behavior, and relations to each other must be described.

Some of the views also have a configuration, which constrains the elements by defining what roles they can play in a particular system. In the configuration, the architect may want to describe additional attributes or behavior associated with the elements, or to describe the behavior of the configuration as a whole. In the next four sections, we show how we used UML to describe each of these four views, starting with the conceptual view and ending with the code view.

To make the explanation clearer, we use an example from an image acquisition system. The image acquisition system acquires a set of digitized images. The user controls the acquisition by selecting an acquisition procedure from a set of predefined procedures, then starting the procedure and perhaps adjusting it during acquisition.

The raw data for the images is captured by a hardware device, a "camera", and is then sent to an image pipeline where it is converted to images.

The image pipeline does this conversion, first composing the raw data into discrete images, and then running one or more standard imaging transformations to improve the viewability of the images. The image pipeline is the portion of the system that we will use as an example. The components and connectors are bound together to form a configuration.

In order to bind together a port and role in a configuration, the port and role protocols must be compatible. Components can be decomposed into other components and connectors.

These elements, their associated behavior, and the relations of the conceptual view are summarized in Table 1. Table 1. Elements of a conceptual architecture view Elements Behavior Relations component component functionality component decomposition port port protocol port-role binding for connector connector protocol configuration role role protocol C. Soni Figure 1 is a UML diagram that describes much of the conceptual view for the image pipeline. It is represented by the ImagePipeline component, which has ports acqControl for controlling the acquisition, packetln for the incoming raw data, and framedOutput for the resulting images.

The ImagePipeline is decomposed into a set of components and connectors that are bound together to form a configuration. The components, ports, and connectors are a stereotype of Class 1, but we use the convention of special symbols for ports and connectors and leave off the stereotype for components in order to make the diagrams easier to read. Roles are shown as labels on the port-connector associations. Conceptual configuration The multiplicities on the components, connectors, and bindings show the set of allowable configurations.

Each acquisition procedure has a distinct set of processing steps, represented by the Imager component. So the diagram shows the general structure of an image pipeline, which all acquisition procedures adhere to. The first stage of the pipeline is the Framer, followed by one or more subsequent stages, represented by the Imager.

Each of the stages is connected to "A stereotype is, in effect, a new class of modeling element that is introduced at modeling time.

It represents a subclass of an existing modeling element with the same form attributes and relationships but with a different intent To permit limited graphical extension of the UML notation as well, a graphic icon or a graphic marker such as texture or color can be associated with a stereotype. The Imager component has a multiplicity of " The Imager is bound to " Similarly the " But while the output of the first stage the Framer is always bound to the lmagePipe, the later stages could be bound to framedOutput.

When a later stage is bound to framedOutput, it is necessarily the last stage in the pipeline. We have adopted the ROOM notation here, showing the incoming and outgoing messages, then either a sequence diagram or state diagram to show the legal sequences of these messages Selic, ; Selic, The resource budgets are attributes of the components and connectors.

They can be described in the attribute box of the appropriate class in a UML diagram, in a table, or in text. Soni For the conceptual view, we represent components, ports, and connectors as stereotyped classes.

Decomposition is shown with nesting association , and bindings are shown by association. UML Sequence Diagrams for showing a particular sequence of interactions among a group of components. There is no configuration for the module view because it defines the modules and their inherent relations to each other, but not how they will be combined into a particular product. Table 2. Notice that ports, connectors, and components are sometimes combined into one module. This information could also be shown in a UML class diagram, with the mapping between conceptual and module elements shown as an explicit association.

Table 3. Again we use nesting to Describing Software Architectures with UML show the decomposition, and we use stereotypes for each different type of element.

We do not use the UML "component" notation for a module, because in the module view the modules are abstract, not the physical modules of source code.

These are shown in Figure 4. We use the UML "lollipop" notation to show the interface s of each module, and to make it clear that the modules are dependent on the interface of another module, not the module itself. Figure 4 also shows some of the layers of the system. These are based on the use-dependencies among modules and subsystems, so we often show use-dependencies between and within layers in the same diagram, as we did here.

For the interface definition, we use a simple list of the interface methods. This information could be put inside the class definition in a UML diagram. We generally prefer to list it separately, using the class diagrams to focus on the relations among modules rather than a complete description of the modules.

In the module view, we represent modules with a stereotyped class, and subsystems and layers with stereotyped packages. Decomposition is shown by nesting association , and the use-dependency is a UML dependency. We use: - tables for describing the mapping between the conceptual and module views.

UML Class Diagrams for showing use-dependencies between modules. UML Package Diagrams for showing use-dependencies among layers and the assignment of modules to layers. Use-dependencies of SPipeline 4. Here the run-time images and communication paths are bound together to form a configuration.

Table 4 lists the elements, behavior, and relations of the execution view. Table 4.


Popular Software Architecture Books

Applied Software Architecture is the best book yet that gives guidance as to how to sort out and organize the conflicting pressures and produce a successful design. Quality software architecture design has always been requires juggling differing perspectives and differing goals, and evaluating differing options. Quality software architecture design has always been important, but in todays fast-paced, rapidly changing, and complex development environment, it is essential. A solid, well-thought-out design helps to manage complexity, to resolve trade-offs among conflicting requirements, and, in general, to bring quality software to market in a more timely fashion. Applied Software Architecture provides practical guidelines and techniques for producing quality software designs. It gives an overview of software architecture basics and a detailed guide to architecture design tasks, focusing on four fundamental views of architecture--conceptual, module, execution, and code.


Applied Software Architecture

Grot This book, written at a high doftware of quality, details a wide variety of factors that project managers and architects must consider during the course of planning, designing, and implementing small- medium- and large-scale projects. Be the first to add this to a list. Found at these bookshops Searching — please wait However, you still feel uneasy when it comes to translating use cases to risk management, and especially to take into account those interns who will develop part of the software. Applied Software Architecture Through four real-life case studies, this book reveals the insights and best practices of the most skilled software architects in designing software architecture.

Related Articles