Shulou(Shulou.com)06/02 Report--

Xiaobian to share with you how to use patterns to integrate UML views, I hope you have something to gain after reading this article, let's discuss it together!

Integrating UML Views Using Patterns

Patterns are important to develop the habit of reusing repeatable designs and architectural configurations during system composition. This thesis studies knowledge about patterns, which can also be used for system analysis to verify the integrity of system models. To support the automated analysis process, this work introduces a view integration framework. Since each view (e.g., block diagram) adds an additional software system perspective to the model, information from one view may be used to verify the integrity of other views. This form of integration requires a deeper understanding of what views indicate and what information they can share (or constrain). Knowledge about the structure and behavior of patterns is therefore also a valuable source for view integration automation.

introduced

To support software product development, we frequently use common software development models (and tools) such as Unified Modeling Language (UML). However, software development in general and software design in particular (which is the main focus of our work) require more than most generic models can provide. Architecture is about:

1)Fully model real-world problems

2)Solve model problems and

3)Interpreting model solutions in the real world

The primary emphasis in doing so is placed on identifying and reconciling mismatches within and between architectural views (e.g., block diagrams). We often find this to be the case, with analysis and interpretation (of architecture) being secondary in most common languages. We build systems not just because we want to build, but because we want to understand. Thus, architecture has a lot of work to do to analyze and verify the conceptual integrity, consistency, and thoroughness of the product model.

The emergence of UML, which has become the de facto standard for OO software development, is no exception to this problem. This work explains the causes of architectural mismatches in UML views and shows how patterns and integration techniques can be applied to identify and resolve them in a more automated manner. To do this, this work discusses the View Integration Framework, its main activities-Mapping, Transformation, and Differentiation.

This paper will examine the role of patterns rather than focusing on the large number of integration technologies that support the activities described above. In this way, we will examine how knowledge of patterns helps ensure model consistency for software systems. In that way, we use patterns in a way that we rarely use before: we use patterns as systems analysis rather than as building materials as system components.

UML Views and Models

In software development, we use models and views to handle the complexity of software systems. In this context, a model refers to a collection of views or a view can be viewed as an aspect (or viewpoint) of the model. IEEE Standard (Draft) 1471[AT & T 1993] reduces the view to "proposing the interests of one or more system stakeholders." Stakeholders are defined as individuals or groups (e.g., developers, users, consumers, etc.) who share system attention or interest. As applied to our context, views are fragments of models that are small enough for us to understand, but also contain relevant information about specific relationships. In UML, views are graphical in nature and are often implemented as block diagrams. Views (such as class or sequence diagrams) serve the following purposes:

Abstract and simplify models

To coordinate the work of different stakeholders

Complementing different interpretations (different audiences/stakeholders)

Extract relevant information about a particular association

Therefore, what types of views will be used and when they will be used depends strongly on who is using them and the associated tasks that need to be completed. Views are not silver bullets for software development, however, because they embody the fundamental problem; they exhibit an equal number of modeling element redundancies within and between them.

To give a simple example, consider a software development case where we have a design (e.g. in the form of a UML class diagram) and a product implementation (e.g. C++ code). Class diagrams and code represent different views, expressing the same or similar information in different ways. Although the code can be generated automatically from the design, this approximation is limited and some information must be added multiple times. Worse, these redundant pieces of information now have to be consistent-mostly manual. Thus, whenever the design changes and the code becomes inconsistent (and vice versa), we apply some view reconciliation activities to find the resulting inconsistencies and to keep the conceptual integrity of the model intact.

UML View Mismatches and Redundancy

Since views are an effective way for us to deal with complexity, we cannot expect to replace them with something less redundant. We need views that break down the total amount of information that software developers have to process at any given time. "It's not the amount of detail per se that brings complexity, but the amount of detail we have to know at the same time. "[Siegfried 1996]

Redundancy, however, is a necessary misfortune. This implies that we need some automated way of identifying and resolving mismatches between views. Thus, all we need is some framework shape for integrating and analyzing views. Interestingly, the possible approaches to the view mismatch problem are based on its particular problem-redundancy. We exploit redundancy between a set of views meaning that one view contains information about other views that can be used to constrain that view. In this way, we use redundant information to verify consistency and integrity between views.

For example, if we construct a system using some form of architectural pattern (e.g., hierarchical style), then the design must reflect architecturally opposed constraints. This means that if the architecture defines a three-tier structure, then the architecture implicitly defines that it is not allowed for the first tier to talk directly to the third tier without using the second tier. if that lat system is designed use UML (e. g., using class and sequence diagrams), the invocation dependencies within the design element are required to be consistent with the architectural constraint described above. An example will be described later.

UML View Description vs Integration

Enabling view integration to determine and reconcile views requires two levels of integration-symbolic integration and semantic integration. For symbolic integration, this means that the model needs the ability to fully represent the view. Semantic integration refines further by defining what information can be exchanged and how. Inconsistency can only be determined after what and how has been established.

The Unified Modeling Language (UML), like other generic software systems development models, just doesn't quite satisfy the semantic integrations described above. UML provides a model for expressing views of different block diagrams dealing with classes, objects, activities, states, packages, and others (see Figure 1). However, UML is not good at integrating them. Associations and dependencies between UML views are rarely captured. If the latter is not done, the model is simply a loosely coupled or completely disconnected set of views. Although UML and its metamodels define the symbolic and semantic characteristics of individual views in detail, the capture of associations within views is still insufficient (there are only weak forms of dependencies between views, such as classes and objects).

Figure 1 also illustrates another aspect of the problem--extending UML to express new and external concepts (for example, styles and patterns). For example, how can I use higher-level patterns in UML such as the Layered Architecture Pattern [[1]] or the Proxy Design Pattern? In UML, we need to distinguish again between merely expressing patterns and fully integrating them.

Figure 1 Representation vs. Integration in UML

UML View Integration Framework

The main obstacle to view integration is the lack of a well-defined (engineered) model base. Views often use very different ways of representing information, which makes it difficult to determine where and how they overlap. Thus, the task of combining and comparing views is often manual and potentially wrong. The goal of the integration framework is to compensate for the lack of automated aids for identifying and resolving architectural mismatches.

In doing so, our framework needs to process what information and how it is exchanged, as described briefly above. We write there about the need to judge what information can be exchanged and how it can be exchanged. In our view integration framework, we mention mapping and transformation as two activities. We also say that only after these activities have been defined can we attempt to identify inconsistencies. The latter we call differentiation (see Figure 2).

Figure 2 depicts our view integration framework in a high-level style. There, system models are used to express the knowledge base of software systems. Software developers use views to add new data to the system model and review existing data (view synthesis). For UML, a system model might be thought of as a UML model and view synthesis done through UML design tools such as Rational Rose.

The interaction between system model and view synthesis is view analysis. Once new information is added, it can be validated against the system model to ensure its conceptual integrity. Figure 2 shows how view analysis can be further broken down into its three main activities described above:

Figure 2 View integration activity

Mapping: Related pieces of information are identified by using naming dictionaries, tracing and tracing simulations (e.g., use of the same physical classes and methods), and some form of association/pattern (e.g., common interfaces).

Transformations: Manipulate model elements in views so that they (or fragments of them) can be shared in other views (or represented in the system model itself). For example, we can generalize a detailed block diagram using abstraction techniques, we can use view transformations to exchange information between different types of views, or we can rearrange model elements (or fragments) in different styles to produce new perspectives (such as stitching and splitting).

Differentiation: Detailed study of system models to identify (potential) mismatches in system models. Mismatches are discussed in terms of rules and constraints. in addition, mismatch resolution rule may be associated with mismatch identification rule for alternative methods of how they are to be resolved. Differentiation is strongly dependent on transformation and mapping.

However, it must be noted that those activities are not mutually orthogonal. Obviously, we can only make useful transformations if we know the correct mapping of model elements. This dependency is also true in reverse. The information derived from the view transformation can clarify ambiguities in many mappings. In this way, one view can be used to clarify ambiguities in other views.

Furthermore, as Figure 2 shows, UML view integration is not limited to patterns; however, patterns form a very important foundation for view integration. We will discuss this pattern-oriented view integration direction in subsequent chapters. Other non-schema dependent view integration directions are discussed in [Eggy 1999a] and [Eggy 1999b]. These frameworks are often applicable outside of UML.

After reading this article, I believe you have a certain understanding of "how to use pattern integration UML view", if you want to know more related knowledge, welcome to pay attention to the industry information channel, thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.