Use mode integration UML View

Use mode integration UML view keywords: UML View

Abstract mode is important for developing the habit of reusing reusable design and architecture configuration during system combination (synthesis. This paper studies the model knowledge, which can also be used for system analysis to verify the integrity of the system model. To support automatic analysis, a view integration framework is introduced. Since each view (for example, a block diagram) adds an additional software system view for 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. Therefore, the knowledge about the structure and behavior of patterns is also a valuable source for view integration automation.

Introduction

To support software product development, we frequently use common software development models (and tools), such as the Unified Modeling Language (UML ). However, the general significance of software development and specific software design (which is the main focus of our work) is not only what most common models can provide. The architecture is about:

1) fully model the actual problem

2) solve model problems and

3) Explain the model solution in the real world

In this way, the main focus is on the identification and reconciliation of non-matching in the architecture view (such as the block diagram. We often find this situation, and the analysis and (Architecture) Explanations are secondary in most general languages. We construct a system not only because we want to establish (create), but also because we need to understand. In this way, the system structure has much to do to analyze and verify the conceptual integrity, consistency, and completeness of the product model.

In fact, the emergence of the OO software development standard UML has become a reality, and there is no exception in this issue. This article describes the reasons for the architectural mismatch in the UML view, and describes how modes and integration technologies can be applied to identify and solve them in a more automated manner. To achieve this, we will discuss the view integration framework, its main activities-mapping, transformation and differentiation ).

This paper will study the role of the model, rather than focusing on a large number of integrated technologies (they support the above activities ). In this way, we will study how model knowledge can help to ensure software system model consistency. In this way, we use patterns that are rarely used in the past: We use patterns for system analysis rather than building materials as system components.

Views and Models

In software development, we use models and views to process the complexity of software systems. Here, a model refers to a set or view of a view that can be seen as an aspect (or viewpoint) of the model ). IEEE Standard (draft) 1471 [AT & t1993] attributed the view to "proposing the interests of one or more system stakeholders (stakeholder ". For stakeholder, we define it as sharing system attention or interest individuals or groups (such as developers, users, consumers, and so on ). In our context, a view is a part of a model. It must be small enough to understand, but it also contains information about the association of specific relationships. In UML, a view is essentially graphic and often implemented through a block diagram. A view (such as a class or sequence diagram) serves the following intent:

Abstract and simplified models
Coordinate different stakeholders
Supplement different interpretations (different audiences/stakeholders)
Extract information about a specific Association

Therefore, what types of views will be used and when they will be used are strongly dependent on who is using and the tasks to be completed. However, a view is not a silver bullet in software development because it represents basic issues; they show equal quantities of modeling Element Redundancy internally and between them.

To give a simple example, consider a software development case and product implementation (such as C ++ code) with a design (such as in the form of a UML class diagram ). Class diagrams and codes express different views and use different methods to express the same or similar information. Although the Code can be automatically generated from the design, this approximation is limited and some information must be added multiple times. Even worse, the redundant pieces of information must be consistent-most of the latter are manual activities. In this way, no matter when the design changes, the code will become inconsistent (and vice versa). We need to apply some view reconciliation activities to find the inconsistency generated and ensure the integrity of the model concept.

View mismatch and Redundancy

Since views are the only effective means for us to deal with complexity, we cannot expect some less redundant things to replace them. We need the view to break down the total amount of information that software developers have to process at any given time. "This is not the number of details that bring complexity, but the number of details that we have to know at the same time ." [Siegfried 1996]

However, redundancy is a necessity. This implies that we need some way to identify and solve the mismatch between views for automated activities. In this way, all we need is the framework form that integrates and analyzes the view. Interestingly, the possible approach to view mismatch is based on its unique problem-redundancy. The redundancy between a set of views means that a view contains information about other views and can be used to constrain the view. In this way, we use redundant information to check consistency and integrity between views.

For example, if we use some architecture patterns to construct a system (for example, layered style), the design must reflect the constraints of the opposite architecture. This means that if the architecture defines a three-tier structure, then the architecture implicitly defines that the first layer in processing does not use the second layer, and direct dialogue with the third layer is not allowed. If the system was subsequently designed using UML (for example, using classes and sequence diagrams), the call dependency requirements within the design element would be consistent with the preceding architecture constraints. We will illustrate an example later.

UML view description vs Integration

Enabling view integration to determine and reconcile views requires two levels of integration-symbol integration and semantic integration. Symbol integration means that the model must fully express the view. Semantic integration is further refined by defining what information can be exchanged and how it can be exchanged. The inconsistency can be determined only after what and how.

The Unified Modeling Language (UML), like other general software system development models, cannot meet the preceding semantic integration requirements. UML provides a model for expressing views of different blocks to process classes, objects, activities, States, packages, and others (see figure 1 ). However, UML is not good at integrating them. The Associations and dependencies between UML views are rarely captured. If the latter is not completed, the model is just a loosely coupled or completely unrelated visual Gallery. Although UML and its meta-models define the symbols and semantic features of a single view in terms of details, it is still not enough to obtain the association within the view (there are only some weak forms of dependency between views, such as class and object ).

Figure 1 also shows another aspect of the problem-that is, extending UML to form new and external concepts (such as style and pattern ). For example, how can we use a more advanced mode in UML, such as a layered architecture mode [[1] or a proxy design mode? In UML, we need to distinguish between expression modes and full integration.

Figure 1 UML notation vs. Integration

View integration framework

The main obstacle to view integration is the lack of well-defined (Engineering) model. Views often use very different information representation methods, which makes it very difficult to determine where they are and how they overlap. In this way, tasks in combination and comparison view are often manual and Latent errors. The purpose of the integration framework is to compensate for the lack of automated auxiliary means to identify and solve system structure mismatch.

As described in the previous section, when we do this, what information should our framework process and how to exchange it. What information can be exchanged and how can it be exchanged. In our view integration framework, we mentioned the ing and transformation activities. We also said that only after these activity definitions can we try to identify inconsistencies. The latter is called differentiation (see figure 2 ).

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

The interaction between the system model and view is View analysis. Once new information is added, it can verify the system model to ensure its conceptual integrity. Figure 2 shows how View analysis can be further subdivided into three main activities:

Figure 2 view integration Activity

Ing: You can use a naming dictionary, trace, and Trace Simulation (such as the use of the same physical classes and methods), and some associated/pattern forms (such as public interfaces) to determine relevant information slices.
Transform: operate model elements in a view so that they (or their fragments) can be shared (or expressed in the system model itself) in other views ). For example, we can use abstract technology to generalize a detailed block diagram. We can use views to convert information between different types of views, alternatively, we can rearrange model elements (or fragments) in different styles to create new perspectives (such as combination and Segmentation ).
Differentiation: Studies in detail the system model identification system model (potential) does not match. (Potential) mismatch is discussed in the form of rules and constraints. In addition, non-matching resolution rules can be associated with the non-matching identification rules that will solve their optional methods. Differentiation is strongly dependent on transformation and ing.

However, it must be noted that those activities are not orthogonal to each other. Obviously, we can make useful transformations only when we know the correct ing of model elements. This dependency is also true. The information exported through view transformation can clarify the ambiguity of many mappings. In this way, a view can be used to clarify the ambiguity of other views.

In addition, as shown in figure 2, view integration is not limited to mode. However, mode forms a very important foundation for view integration. We will discuss this mode-oriented view integration direction in subsequent chapters. Other non-mode-related view integration directions are described in [egyed1999a] and [egyed1999b. The above frameworks are also applicable outside UML.

Product Ordering System case

We will use a simple product ordering system throughout the full text for guidance. This system is divided into two major subsystems: the order acquisition subsystem and the order processing subsystem. The first subsystem obtains order and payment information from the consumer through the sales representative. The next sub-system obtains how the Warehouse administrator processes the product order queue. Product Ordering system combines two cots (Commercial cial off the shelf) Products: Inventory System Processes product inventory, the Order warehouse is used as a database (the latter is used for both the Product Ordering System and the inventory system ).

Table 1 shows that our system architecture is designed in Layered mode (or layered style. The architecture model will be supplemented by the design model and other design features.

Table 1 shows the hierarchical architecture of the Product Ordering System.

Product Ordering System
-User Interface (Order Acquisition Interface, order processing user interface, inventory User Interface)
-Order framework (consumer, payment, order, order line, recorder)
-Inventory System
-Network (LAN)
-Order warehouse

How does the mode help view integration?

In the article, we will reveal more details about the product ordering system. However, due to space limitations, we can neither express the entire system nor describe all integration technologies here. On the contrary, as mentioned above, we will focus on the roles assumed by the mode during view integration. Corresponding to the three integration activities described in Figure 2, the mode supports the following activities (the example is described in the following section ):

Ing

Mode supports ing (cross-reference) between views at different abstract levels ). For example, a high-level block diagram indicates a pattern that is known to be implemented later in a low-level block diagram. In this way, this type of pattern exists in the knowledge of low-level block graphs and a rough understanding of this pattern (for example, in [gamma et al. 1994] and [defined in buschman et al 1996]) knowledge helps to automatically identify in the low-layer block diagram.

Modes also support ing between different types of views. For example, the schema description often specifies its structure and their dynamic behavior. Then, we can use this knowledge in our model to cross-reference structured and dynamic information.

Transform

The methods used for Pattern Transformation are similar to those used in ing. For transformations, we can use them for abstraction and conversion. For abstraction, we mean to simplify the processing of views. For example, if we want to know whether the high-level view is consistent with the lower-level view, we need to refine the high-level view or abstract the lower-level view to make direct comparison possible. The former cannot be performed automatically, while the latter can. To abstract views, You need to determine the relevant fragments and then replace them with simpler things. In this regard, patterns are perfect raw materials because they provide the knowledge of which fragments belong together. We can use pattern knowledge to abstract the lower-layer pattern to the upper-layer pattern (or equivalent to a single part ).

The schema can also be used for conversion between static and dynamic structures as discussed in the ing. Since patterns are often described in two patterns, we can deduce behavior through structure (and vice versa ). In this way, we can also convert the view using the mode.

Differentiation

2. differentiation is strongly dependent on ing and transformation. This means that to identify inconsistencies in the view, we need to determine the relationship between the Modeling Elements and find a way to change information from one view to another. Without the previous step, we do not know what information to compare. Without the next step, we do not know how to compare it. Once the preceding steps are completed, we can use two main technical comparison views:

(Graphics) Comparison: Compare the transformed view with the original view. This technique implies that a view can be fully and completely transformed into another view.
Constraints and rule check: we often find that a view cannot be broadly transformed into another view, but its few parts and fragments are acceptable. In this case, we can use rules and constraints to discuss and analyze these fragments.

The design pattern is not directly useful for differentiation. However, we can map and transform the information about the view. We have briefly discussed how schema helps map and transform views. In these examples, the comparison view is direct because direct (graphical) comparison is enabled for ing and transformation. In any case, the pattern is also useful in constraints and rule checks. For example, the layered mode described in table 1 defines natural constraints: the user interface only allows dialog with the order framework, and the order framework can only talk with the inventory system in turn. The architecture pattern affects the design structure and its behavior.

Use mode in Product Ordering System

This section describes how the model can be applied to integration activities in the context of our product ordering system.

Differentiation

Figure 3 use the UML package to describe the high-level design view of our system. The figure shows the interaction between the main order system components (or subsystems. Knowledge about the layered architecture can now help us automatically determine the mismatch between the architecture in table 1 and the design in figure 3. Table 2 summarizes the opposing constraints of the two views.

The architecture view constraints are exported from table 1. They define call dependencies between our system layers (for example, the user interface depends on the order framework ). Figure 3 is the basis for designing view constraints. This diagram illustrates a UML package diagram containing a set of packages and call dependencies between them (the meaning of packages and dependencies is defined in [booch-jacson-rambaugh 1997 ).

Table 2 constraints on the opposite architecture and design view

View constraints of the Architecture

Architecture [the user interface depends on the order framework];

Architecture [order framework depends on the inventory system];

Architecture [inventory system depends on network];

Architecture [the network depends on the order warehouse];

Design view Constraints

Design [order acquisition UI depends on the order framework];

Design [order processing UI depends on the order framework];

Design [inventory UI depends on the inventory system];

Design [order framework depends on the inventory system];

Design [order framework depends on the network];

Design [inventory system depends on network];

Design [the network depends on the order warehouse];

Ing

Design [order acquisition UI] ing to architecture [user interface]

Design the [order processing UI] ing to the architecture [user interface]

Design [inventory UI] ing to architecture [user interface]

Design [order framework] ing to architecture [order framework]

Design [Inventory System] ing to system structure [inventory system]

Design [network] ing to architecture [network]

Design [order warehouse] ing to architecture [order warehouse]

Integrity rules

There are design view constraints for view constraints of all architectures;

For example:

Architecture [user interface depends on order framework] =>

Exist: Design [order acquisition UI depends on order framework] or

Design the [order processing UI depends on the order framework] or

Design [inventory UI depends on order framework]

Consistency rules

Architecture constraints exist for the design view constraints;

Example:

Design [order processing UI depends on the order framework] =>

Exist: Architecture [the user interface depends on the order framework];

Table 3 describes the hierarchical architecture of the Product Ordering System

Product Ordering System

User Interface (Order acquisition UI, order processing UI, inventory UI)

Order framework
Inventory System

Network (LAN)

Order warehouse

Creating these constraints is the responsibility of transformation and can be automatically completed in this case. For example, we can use the layered mode knowledge in table 1 to automatically export the call dependencies between layers. The advantage is that the schema semantics only needs to be defined once and can be reused later. View semantics and symbols can also be seen as patterns. In this way, the package diagram in Figure 3 contains a set of predefined constraints. Once defined, you can export design constraints for different instances of the package chart.

The ing section in table 2 defines the relationship between the architecture view (table 1) and the design view (Figure 3) component. In this example, the usage of the ing mode is not so obvious. We will discuss their use of ing later.

The last two parts in Table 2 are partial differentiation activities. There, two types of rules are defined, one for consistency and the other for integrity. Potential incompleteness may be displayed if some components or connectors defined by the architecture are not reflected in the design. On the other hand, if the design conflicts with the architecture, this may indicate potential inconsistency. In addition, for each set of views we compare, rules only need to be defined once; those rules can then be reused. Determining the mismatch between the architecture and design implementation is now a matter of evaluating rules and constraints. This reveals the non-integrity mismatch. However, some non-Consistency do not match:

1) the dependency of inventory UI components on the inventory system conflicts with the hierarchical system. The user interface does not allow direct communication with the inventory system without going through the order framework.

2) Similarly, the order system requires the use of the inventory system to access the network.

 
Figure 3 high-level design in UML (package diagram and dependency)

No feedback is given to the cause of these non-matching. For example, is the architecture or design error? Table 3 illustrates how to upgrade the inventory system to the same level of the Order framework to solve all the above-mentioned non-matching without introducing new possible methods of non-matching. We do not believe that the actual mismatch solution will be completely automated. This method is the same as the previous self-correction source code compiler attempts. This effort finally fails due to the complexity of the included society and technology. However, we believe that not only (potentially) Non-matching is provided to designers, but they are also addressed in the context of how to handle non-matching and understand them in a highly beneficial manner. In addition, it may be very beneficial for technologies that have a better choice for handling situations. We will discuss this situation in more detail in [egyed 1996.

Ing

Figure 4 shows another view of our system, which is refined in figure 3. In addition, this view can verify both the revised architecture and the high-level design. However, no mismatch is found. This view uses another design mode, such as the template [[2] (Template) mode (specified by the <> constructor) and the proxy [3] (proxy) mode (specified by the proxy constructor ). We will use them to further explore the value of patterns in view integration.

Figure 4 high-level design view refining using UML classes and packages

Figure 5 lower-layer design view use UML class diagram

Figure 5 describes the corresponding low-level implementation. It not only solves the pattern used in figure 4, but also refines some other modeling elements. The three categories at the top correspond to the user interface layer. The inventory system can be accessed through the inventory proxy, and the warehouse can be accessed similarly through the warehouse proxy. To check whether the view is consistent with the previous one, we can use several integrated technologies.

First, we need to find out which model elements correspond to each other (ing ). These technologies can be applied, such as name similarity. However, the extensive use of patterns in this example enables us to develop knowledge about their use for ing. Through the high-level design shown in figure 4, we understand several facts:

Template mode for orderline)
The proxy mode is used to bridge the order line (orderline) and inventory system
The proxy mode is used to bridge the order framework subsystem using the Oracle database.
Interface features (for example, consumer class and order, payment, and consumer UI interfaces)

Figure 6 structured mode knowledge (adapted from [buschman et al. 1996])

Although technically speaking, the last one is not a clearly defined pattern, it constitutes the knowledge of class configuration-in this way, interface features can be seen as patterns, even if most of them are just domain patterns. The pattern knowledge about the domain is just like the predefined pattern (see Figure 6), so that we can now deduce the relationship of modeling information. Tasks mapped to Figure 4 and figure 5 are streamlined to use the predefined structured pattern knowledge discussed in Figure 6 to determine the locations of the preceding pattern and (Interface) features.

Using figure 6 as a guide, we can easily determine the template mode (products, queues, and product queues correspond to orderline. Although it can also easily find the proxy mode, it is not clear how to distinguish them. Note that the goal is to allow computers to automatically authenticate them. To do this later, we can use the interface features (patterns) discussed above ). The idea is that at least some mappings exist or can be established through name similarity. With this additional information, it may automatically distinguish inventory mode from Oracle mode.

Unfortunately, schema-based ing is still more difficult than the preceding example. We have simplified the assumption that the schema structure and behavior are static. Although, the general patterns are not exactly defined, and we need a more general description of them. Figure 5 shows that the repository proxy mode does not look as defined. However, since the network is a part of the proxy class, it can be merged into the proxy class, and the proxy class inherits all its dependencies (the Rose/effecect in the next section will express a model to do so ).

Another problem with this ing technology is that during recognition, it is sometimes possible to point out their locations roughly. For example, the corresponding queue, product, and product queue, and orderline queue can be found in the low-layer block diagram. Although this is true, it also loses the order line (orderline) that is expressed in the lower-layer block diagram ).

Transform

Mode and abstraction

The mappings between the higher-level views in Figure 4 and the lower-level views in Figure 5 are not sufficient to determine the mismatch. For example, you can see in Figure 4 that payment is a part of the consumer, but in Figure 5 this relationship is more complex. To verify that the two graphs discuss the relationship in the same way, we can use the Rose/effecect concept.

Rose/effecect [egyed-kruchten 1999] considers the mode group as three types, and replaces them with a simpler mode by using the pass relationship. In the class diagram, the thing-to-thing relationship describes the relationships between classes that are not directly linked. However, a link can exist through other classes (such as the helper class), which forms a bridge between them (for example, if the payment in the above example is not directly linked to the consumer, however, it still gives a relationship through the Helper (helper) Class transaction and account class ). In this way, if some formulas are found, they can be exported based on the effective precision, then the tool can provide automatic support for simplification and abstract class diagrams. This will allow the designer to abstract important classes from the existing, more detailed model by deleting the helper class, so that they can further describe and analyze the intermediate relationship between classes, even if these classes are scattered across different locations of the entire model (for example, different block charts, or in different packages and namespaces ).

RA provides this mechanism, and [egyed-kruchten 1999] discusses this technology in detail. Currently, the RA model consists of about 80 abstract rules. For example, rule 4 describes the situation in which a class is generalized by the Second Class (inherited antonym) and the parent class is the aggregation (partial) of the third class (see figure 7. In this three-class mode, you can now Delete the intermediate class to simplify and create a pass-object relationship from the first class to the third class (an aggregation in this example ). The following Ra model discusses these rules and how they must be applied to produce valid results.

Figure 7 shows the RA refining steps for payment to consumer relationship cases in our low-level design view (figure 5. After applying the two Rules (rule 4 and Rule 17 respectively), we get a simplified mode with two classes and their dependencies. If this can also be done for other classes and the mode [[4] discussed in the ing section, we can automatically generate a higher level class diagram (figure 8 ). The generated abstract view can now be directly compared with the original higher-level class diagram described in Figure 4. In this way, we can use the mode to convert the view so that it can express information in a very similar way to other views. The comparison view can now be simply completed using some graphical comparison algorithms (see the preceding differentiation. Figure 8 also shows possible inconsistencies. For example, if the aggregate from payment to order is lost, the inventory system does not use network components for Oracle Database calls, and some links are different (for example, using the link instead of the dependency link ). After Transformation (abstraction), these non-matching can be easily identified.

Note that the abstraction is not completely automated. Although patterns help determine mappings and transformations between certain modeling information, they cannot completely automate the process. Therefore, you need some help to export figure 8. In addition, the RA tool currently can only deal with the three simple patterns discussed in 7, rather than the more advanced design patterns discussed in figure 6. In this way, the abstract design mode (such as proxy) is manually completed due to this job. However, this abstraction can be automated once a more complex design pattern concept is embodied in RA. In this regard, the design patterns need to be discussed based on their input (source), purpose, and their access points.

Figure 7 abstraction through the Rose/terraect Mode

At present, another disadvantage of RA is that it can only be used for abstract class graph information. Although this technology can be extended to abstract other types of views, it does not help us to compare modeling elements of different types of views. The next section will discuss this situation.

Mode and conversion

In view of the simplified view of abstract processing, the transformation process shares modeling information between different types of views. For example, classes and class diagrams are widely used in the above discussion, which express information in a structured form. Since the structure view is insufficient to indicate system behavior, the behavior view, for example, a sequence diagram, must be used to fill this gap.

For example, consider the hierarchy constraints in table 1 (together with the constraints of the high-level design view ). Where the constraints of the architecture do not cover all the behaviors of the layered architecture. A layered architecture not only limits which layers allow interaction, but also limits the interaction direction. Although the structure diagram, such as a class diagram, can describe certain directionality dependencies, it may ignore other aspects.

Figure 8 class diagrams abstracted using rose/terraect and Design Patterns

Figure 9 sequence diagram of new order creation (corresponding to low-level block diagram)

Figure 9 shows a more complex behavior case. A uml sequence diagram is used here to describe possible scenarios for creating a new consumer order. After some user input is verified, it checks whether the consumer exists. If it does not exist, a new consumer is created, and then a new order is created. This scenario describes some behavior aspects of the low-level design view (figure 5. As shown in figure 5, call dependencies between classes (or objects) can be automatically verified. In this case, mismatch is not revealed. This sequence diagram also conforms to our architecture because all the hierarchy constraints are observed (both can be checked automatically ). Since the behavior structure view of components has a high degree of ambiguity, we can use our patterns to refine the behavior information again.

Figure 9 use the order warehouse proxy, network, and Oracle database, as well as the classes corresponding to the proxy design pattern we found in the ing. As found in [buschman et al 1996], Figure 10 shows the definition of the proxy mode structure and behavior. In terms of effect, behavior definition is a conversion of structure. In this way, we can use this knowledge to verify the correctness of Figure 9.

Because the proxy definition in Figure 10 and the proxy instantiation in Figure 9 have different abstraction levels, we need to first abstract figure 9. Basically, we can use the Rose/effecect concept to abstract the network by merging the network to the order warehouse proxy (this is valid because the network is part of the proxy ). After that, direct comparison between definitions and instantiation is possible. No mismatch was found in this case.

Figure 10 structure and behavior of proxy Mode

Due to space limitations, we cannot further discuss more details of this process. For more information, see [egyed 1999a] and [egyed 1999b.

Related work

The lack of view integration is not a new discovery. On the contrary, many model descriptions talk about the need to maintain consistent views. Sometimes, the processing model provides additional guidelines on what tasks can improve the conceptual integrity of the architecture. For example, a case study on the use of winwin spiral model (spiral model) [Boehm et al 1998] suggests that) the architecture Review Boards [at&t 1993] is used to test and verify the integrity of the analysis and design after the life-cycle architecture (lifecycle architecture) phase. Similar points of view can be seen in other numerous research work:

[Sage-Lynch 1998] discusses different aspects of integration (enterprise scope. They repeatedly stressed that "architecture plays an important role in system integration ." They want to express their needs in three major views: Enterprise view, system process and management view, and technical implementation view-and they emphasize consistency between these views.
[Rechtin 1991] It is strongly required that the effectiveness and consistency of requirements be emphasized equally with the interface definition. He further facilitates the needs of problem detection and diagnosis.
[IEEE 1998] architecture evaluation speech. "The purpose of the evaluation is to determine the descriptive quality of an architecture and evaluate the quality of the associated architecture through it ". They further stated the need to determine which architecture can validate the evaluation criteria.
[Nuseibeh 1995] wrote "inconsistency is an inevitable part of the complex and incremental software development process", and "incremental software system development includes inconsistency detection and processing ".
[Perry0wolf 1992] has long been aware of the importance of software architecture, and they have presented it as one of the four main advantages of architecture, which are "the basis for dependency and consistency analysis ".
[Shaw-Garlan 1996] It is very excited to discuss the architecture. As a saying that the essence of system design is rarely consistent and accurate ". He further states that "the software architecture finds its foundation in the block diagram and popular prose. Unfortunately, block charts and descriptions are highly unambiguous ."

These and more references talk about the need for integration (or missing ). However, they generally do not discuss included activities in detail (and some exceptions ). Sometimes this work is not out of a special liking for integration. On the other hand, sometimes the proposed technology is often just intended to allow people to communicate with each other. For example, the architecture Review Board [at&t 1993] or the inspection process [NASA 1993] is mainly used to bring the majority of competent people together so that they can share information. These technologies may follow the defined process (for example, checklists) and may produce valid results. However, in fact, the activities to identify and solve defects must be completed manually without much automatic assistance.

Conclusion

This article discusses the cause of architectural mismatch in the UML view and explains how the integrated technology can be applied to identify and solve them in a more automated manner. We use the context of the Unified Modeling Language (UML) and its view (block diagram) to express this work, and use an example to guide the main phase of view integration. The view integration framework expressed in this paper is not limited to UML. It can also be applied to other models and views (such as the architecture Description Language ).

This article further introduces the usage of models in analyzing the conceptual integrity of software system models. Since the schema is well-described and documented, We can frequently use this knowledge for View analysis in terms of structure and behavior. As shown in the following figure, the schema knowledge can be used to map views (cross-reference of modeling information) or transform information from one view to another. Later, we explained the abstract and transformation technologies.

Although the purpose of creating a view integration framework is to support automatic View analysis, manual intervention is often necessary. Since this article only focuses on models, other integration technologies are not discussed (see [egyed]). The content we will post is:

Discovery (or development) integration technology that covers a wider range of views
Quantifiable Processing
More accuracy is added to UML to clarify the ambiguity.
Describe the situation of automatically supported non-matching solutions (not just the Automatic Determination of non-matching)

Regardless of these issues, we have made extensive progress in this field and we feel the benefits of using integrated technology. For example, what we have discussed in this article is unlimited. We have already indicated that the automation of unmatched identification tasks is possible (at least partially acceptable). Since computers are more efficient in comparison view, this means that manual work is saved in essence. Another advantage of similarity is that they can be determined when they are created. Every time new data is added to the model, the tool can verify them.