Design patterns capture expert design experience in generic design structure and behavior. To reuse design experience, a design pattern needs to be instantiated from its generic template to the application design in a particular context. It can be integrated with other patterns to solve multiple design problems. The instantiation and integration of design patterns are two important processes when a designer reuses design experience in an application. It is important to know whether the instantiation and integration commute because it can save considerable time and effort of software designers for trial-and-error. In this paper, we investigate the commutability of the instantiation and integration of design patterns. We provide rigorous proofs on the conditions when the order of these two design processes does not matter. Our results allow the software designers to choose the design processes with assurance of their equivalence. The benefits of our work include helping the designers to make informed design decisions based on the convergence of different design processes and reducing the possible design choices, and thus the complexity of software development.

Cloud computing, a new paradigm of distributed computing, introduces many new ideas, concepts, principals, technologies and architectural styles into enterprise service-oriented computing. The enterprise service-oriented architecture (ESOA) style is an abstraction of concrete enterprise service-orientated architectures, which includes SOA architectural elements, service design patterns as well as principles, and SOA quality attributes. It can be extended to a new style for realizing enterprise cloud computing. Meanwhile, the principles and style of enterprise service-oriented computing facilitate the enterprise-wide adoption of cloud computing. This paper extends the ESOA style to a new hybrid architectural style, Enterprise Cloud Service Architecture (ECSA). The style is described by extending enterprise service-oriented formula for ESOA. We model the style through specifying each element in the formula with both service-oriented and cloud architectural styles.

Distributed governance is the process for individual entities in the system to make autonomous decisions in response to special situations. It is an important principle in governing the actions in cyber physical systems to achieve operation responsiveness. In this paper, we extend the widely adopted service-oriented architecture (SOA) paradigm to build a distributed governance model in the context of cyber-physical systems. To achieve distributed governance, we develop the novel distributed workflow model and the autonomous service composition process. Our distributed workflow infrastructure facilitates easy modification and evolution of the workflows and effectively incorporates the distributed service and workflow management mechanism. Our autonomous service composition scheme allows intelligent entities in the cyber physical system to participate in the service composition process and make local composition decisions which collectively, best satisfy the global Quality of Service (QoS) objectives. The distributed workflow and autonomous composition concepts can greatly enhance the timeliness, effectiveness, scalability, and agility of large-scale Cyber Physical Systems (CPS).

The quality of a software system highly depends on its architectural design. High quality software systems typically apply expert design experience which has been captured as design patterns. As demonstrated solutions to recurring problems, design patterns help to reuse expert experience in software system design. They have been extensively applied in the industry. Mining the instances of design patterns from the source code of software systems can assist in the understanding of the systems and the process of re-engineering them. More importantly, it also helps to trace back to the original design decisions, which are typically missing in legacy systems. This paper presents a review on current techniques and tools for mining design patterns from source code or design of software systems. We classify different approaches and analyze their results in a comparative study. We also examine the disparity of the discovery results of different approaches and analyze possible reasons with some insight.

Abstract Design patterns document flexible designs that may evolve over time. Design pattern evolution typically involves the addition or removal of a group of modeling elements, such as classes, attributes, operations, and relationships. However, the possible evolutions of each design pattern are often not explicitly documented. Missing part of the evolution process may result in inconsistent evolution. Pattern instances may interact with each other making the evolution of design patterns more error‐prone. Undetected design errors and inconsistencies may cause failures of systems. In this paper, we propose a service‐oriented architecture for design pattern evolution and analysis based on two‐level transformations, thus making the possible evolutions of each design pattern explicit. In addition, we automate the evolution processes as XSLT transformations that can transform the unified modeling language (UML) model of a design pattern application into the evolved UML model of the pattern. Both the original and evolved UML models are represented in the XML Metadata Interchange format to facilitate the transformations. Furthermore, we check the consistency of the evolution results using the semantic web checker based on the Java Theorem Prover. A case study on a large real‐world system is presented to illustrate and evaluate our approach. Copyright © 2009 John Wiley & Sons, Ltd.

The semantic Web is the second generation of the Web, which helps sharing and reusing data across application, enterprise, and community boundaries. Ontology defines a set of representational primitives with which a domain of knowledge is modeled. The main purpose of the semantic Web and ontology is to integrate heterogeneous data and enable interoperability among disparate systems. Ontology has been used to model software engineering knowledge by denoting the artifacts that are designed or produced during the engineering process. The semantic Web allows publishing reusable software engineering knowledge resources and providing services for searching and querying. This paper classifies the ontologies developed for software engineering, reviews the current efforts on applying the semantic Web techniques on different software engineering aspects, and presents the benefits of their applications. We also foresee the possible future research directions.

Design patterns describe good solutions to common and recurring problems in software design. They have been widely applied in many software systems in industry. However, pattern-related information is typically not available in large system implementations. Recovering these design pattern instances in software systems can help not only to understand the original design decisions and tradeoffs but also to change the systems with quality assurance. This paper presents our approach on recovering design patterns based on matrices and weights. We formally specify our methods to encode both the systems and the design patterns into matrices and weight. Our formal specification rigorously defines the structural, behavioral, and semantic analyses of our approach. A set of experiments on real-world systems is also carried out to evaluate our approach with analysis results.

Due to constant changes of business requirements and applications, dynamical reconfiguration of service composition becomes an important and challenging task. Web service composition may save time and expense in software development. In this paper, we introduce the abstract service hierarchy in the OWL-S Ontology Framework for dynamic web service composition. In our approach, the web services are composed at the abstract service level which is a higher level of abstraction than concrete services. The super instance of an abstract service is also introduced to help describe the abstract service. The super instance of each abstract service is attached with an instance pool including all instances of the abstract service to facilitate fail-over and dynamic compositions. An algorithm to populate the concrete services to the instance pool is also provided. We illustrate our approach using a case study.

Design patterns are generic design solutions that can be applied and composed in different applications where pattern-related information is generally implicit in the Unified Modeling Language (UML) diagrams of the applications. It is unclear in which pattern instances each modeling element, such as class, attribute, and operation, participates. It is hard for a designer to find the design patterns used in an application design. Consequently, the benefits of design patterns are compromised because designers cannot communicate with each other in terms of the design patterns they used and their design decisions and trade-offs. In this paper, we present a UML profile that defines new stereotypes, tagged values, and constraints for tracing design patterns in UML diagrams. These new stereotypes and tagged values are attached to a modeling element to explicitly represent the role the modeling element plays in a design pattern so that the user can identify the pattern in a UML diagram. Based on this profile, we also develop a Web service (tool) for explicitly visualizing design patterns in UML diagrams. With this service, users are able to visualize design patterns in their applications and compositions because pattern-related information can be dynamically displayed. A real-world case study and a comparative experiment with existing approaches are conducted to evaluate our approach.

Software patterns are a new design paradigm used to solve problems that arise when developing software within a particular context. Patterns capture the static and dynamic structure and collaboration among the components in a software design. A key promise of the pattern-based approach is that it may greatly simplify the construction of software systems out of building blocks and thus reuse experience and reduce cost. However, it also introduces significant problems in ensuring the integrity and reliability of these composed systems because of their complex software topologies, interactions and transactions. There is a need to capture these features as a contract through a formal model that allows us to analyze pattern-based designs. In this paper, we provide an overview of a formal framework for ensuring the integrity of the compositions in object-oriented designs by providing mathematically rigorous modeling and analysis techniques for object-oriented systems comprising pattern-based designs as the basic building blocks or design components. A case study related to a hypermedia Web-based application has been presented to illustrate our approach in distributed systems. Copyright © 2005 John Wiley & Sons, Ltd.

Instead of UML diagrams, an alternative approach is using graph grammars according to G. Rozenberg (1997) to specify meta-models. With the capability of formally specifying syntax in a visual fashion, graph grammars have gained much attention in recent years. Based on graph grammar formalism, called the reserved graph grammar (RGG) as stated in D.Q. Zhang et al. (2001), this paper proposes an intuitive yet formal approach to specifying models. More specially, given a graph grammar defining a meta-model, a visual language generator can automatically generate a graphical environment, which allows users to directly manipulate models by drawing box-line diagrams. A graph transformation engine underlying the environment can validate the integrity of user-designed models.

Compared with texts, graphs are more intuitive to express comparative and structural information. Many graphical approaches, however, lack a formal basis for precise specifications in the design. This paper proposes a generative style-driven framework for software architecture specification based on a visual language formalism. In this framework, the designer uses graphical notations to define architectural styles. Given the graphical specifications, a visual language generator, i.e. a meta-tool, can automatically generate a specific design environment, which is suitable for the users without any knowledge of formal methods to directly manipulate software architectures by drawing box-line graphs. The graph transformation engine underlying the design environment can automatically validate structural integrity and reveal the hierarchical structure of a user-defined software architecture.

Software architecture and design are usually modeled and represented by informal diagrams, such as architecture diagrams and UML diagrams. While these graphic notations are easy to understand and are convenient to use, they are not amendable to automated verification and transformation. This paper provides graph grammars for architecture and UML class diagrams. These grammars enable a high level of abstraction for the general organization of a class of software architectures, and form a basis for various analysis and transformations. In this approach, software verification is performed through a syntax analyzer. Architecture transformation is achieved by applying predefined transformation rules.

This paper describes an approach to component-based software engineering based on a formal description of design patterns. The architectural design information, captured by design patterns, is made explicit and represented in a declarative way, being packaged into tangible artifacts as building block design components in the development process. These design component descriptions can be instantiated, adapted, assembled, implemented, and maintained. Furthermore, we can use these representations to reason about properties related to the combination of design components. We illustrate the utility of our approach through a case study involving various design patterns.