Pattern Instantiation Research Articles

SmartCLIDE design pattern assistant: A decision‐tree based approach

AbstractDesign patterns are well‐known solutions to recurring design problems that are widely adopted in the software industry, either as formal means of communication or as a way to improve structural quality, enabling proper software extension. However, the adoption and correct instantiation of patterns is not a trivial task and requires substantial design experience. Some patterns are conceptually close or present similar design alternatives, leading novice developers to improper pattern selection, thereby reducing maintainability. Additionally, the mis‐instantiation of a GoF (Gang‐of‐Four) design pattern, leads to phenomena such as pattern grime or architecture decay. To alleviate this problem, in this work we propose an approach that can help software engineers to more easily and safely select the proper design pattern, for a given design problem. The approach relies on decision trees, which are constructed using domain knowledge, while options are conveyed to software engineers through an Eclipse Theia plugin. To assess the usefulness and the perceived benefits of the approach, as well as the usability of the tool support, we have conducted an industrial validation study, using various data collection methods, such as questionnaires, focus groups, and task analysis. The results of the study suggest that the proposed approach is promising, since it increases the probability of the proper pattern being selected, and various useful future work suggestions have been obtained by the practitioners.

Really Real Patterns

ABSTRACT Dennett [1991] proposes a novel ontological account of the propositional attitudes—real patterns. Despite its name, the degree to which this account is committed to realism remains unclear. In this paper, I propose an alternative criterion of pattern instantiation, one that assesses the difficultly of faithfully interpreting a physical system as instantiating a particular pattern. Drawing on formal measures of simplicity and similarity, I argue that, for well-instantiated patterns, our interpretation will be computable by using a short program. This approach preserves the flexibility of Dennett’s original, while offering substantially stronger realist commitments.

Verification of the Instantiation and Integration of Security Patterns

As software applications suffer from increasing malicious attacks, security becomes a critically important issue for software development. To avoid security problems and increase efficiency, a large software system design may reuse good security solutions for existing security patterns. While security patterns document expert solutions to common security problems and capture well-examined practices on secure software design, implementing them in a particular context (pattern instantiation) and composing them with other related patterns (pattern integration) are prone to flaws and may break expected security properties. In this paper, we present an approach to verify security patterns instantiation and integration automatically. We offer formal definitions for security pattern instantiation and integration, and establish rules to transform sequence diagrams (representing the behaviors of security patterns) to expressions in Milner’s Calculus of Communicating Systems (CCS). We prove the correctness of the proposed transformation, and propose an algorithm to carry out this transformation automatically. In particular, we formally specify the alternative flows of UML sequence diagrams guarded by constraint conditions, which allows us to model choice making behaviors of security patterns precisely. The properties of the instantiation and integration can be verified by model checking against their CCS expressions. Flaws of instantiation and integration can, therefore, be discovered early in the design stage. We use two case studies to illustrate our approach and show the capability to prove security in integration and detect design errors in instantiation respectively.

An MDE-based approach for self-adaptive RTES model generation

Raising the design abstraction level has been, since many years, a prominent solution to decrease the complexity of self-adaptive real time embedded systems (RTES) and increase productivity. However, the manual specification and integration of the adaptive behavior into the system model is still presenting a big handicap for designers. There is a lack of Computer Aided Software Engineering tools and methodologies that permit to automate the generation of self-adaptive RTES models. Therefore, designers need an expertise in the adaptation domain as well as the modeling language and much time for manual work. At the aim of solving these problems, we propose, in this paper, a Model Driven Engineering based approach that permits to guide the automatic transformation of a classic Y-chart RTES model into a self-adaptive model based on design patterns. A model-based interactive process is developed to enable the generation of self-adaptive models for RTES based on the instantiation, integration and specialization of design patterns. The generated system model is then mapped to the input of a simulation platform in order to perform the non-functional properties verification and simulate the system reconfiguration, if needed. The proposed approach is tested and validated through a case study of an embedded video conferencing system which is CPU and network bandwidth-constrained.

AutoCRUD: Automatic generation of CRUD specifications in interaction flow modelling language

Data-intensive Web applications are usually developed by means of specific Web application frameworks, which provide, among other features, the proper tools to automate redundant tasks, e.g. the implementation of CRUD operations. However, although Model-Driven Web Engineering (MDWE) approaches have defined specific languages and tools to significantly reduce development efforts, the provision of such automation tools has been traditionally neglected. This paper presents AutoCRUD, a WebRatio plug-in automating the generation of CRUD operations in OMG Interacting Flow Modelling Language (IFML). It has been developed as a joint effort by academia and industry to assess its validity in a real scenario. • A MDWE tool (WebRatio plugin) to automatically generate CRUD operations specification in IFML by pattern instantiation. • New patterns may be defined to enlarge its default repository. • For teaching purposes, a step-by-step generation of IFML may be performed. • Easy and guided visual instantiation of patterns. • It may significantly increase development team productivity.

Using superimposed multidimensional schemas and OLAP patterns for RDF data analysis

Abstract The foundations for traditional data analysis are Online Analytical Processing (OLAP) systems that operate on multidimensional (MD) data. The Resource Description Framework (RDF) serves as the foundation for the publication of a growing amount of semantic web data still largely untapped by companies for data analysis. Most RDF data sources, however, do not correspond to the MD modeling paradigm and, as a consequence, elude traditional OLAP. The complexity of RDF data in terms of structure, semantics, and query languages renders RDF data analysis challenging for a typical analyst not familiar with the underlying data model or the SPARQL query language. Hence, conducting RDF data analysis is not a straightforward task. We propose an approach for the definition of superimposed MD schemas over arbitrary RDF datasets and show how to represent the superimposed MD schemas using well-known semantic web technologies. On top of that, we introduce OLAP patterns for RDF data analysis, which are recurring, domain-independent elements of data analysis. Analysts may compose queries by instantiating a pattern using only the MD concepts and business terms. Upon pattern instantiation, the corresponding SPARQL query over the source data can be automatically generated, sparing analysts from technical details and fostering self-service capabilities.

Tool support for assurance case development

Argument-based assurance cases, often represented and organized using graphical argument structures, are increasingly being used in practice to provide assurance to stakeholders, e.g., regulatory authorities, that a system is acceptable for its intended use with respect to dependability and safety concerns. In general, comprehensive system-wide assurance arguments aggregate a substantial amount of diverse information, such as the results of safety analysis, requirements analysis, design, verification and other engineering activities. Although a variety of assurance case tools exist, many desirable operations on argument structures such as hierarchical and modular abstraction, argument pattern instantiation, and inclusion/extraction of richly structured information have limited to no automation support. To close this automation gap, over the past four years we have been developing a toolset for assurance case automation, AdvoCATE, at the NASA Ames Research Center. This paper describes how AdvoCATE is being engineered atop formal foundations for assurance case argument structures, to provide unique capabilities for: (a) automated creation and assembly of assurance arguments, (b) integration of formal methods into wider assurance arguments, (c) automated pattern instantiation, (d) hierarchical abstraction, (e) queries and views, and (f) verification of arguments. We (and our colleagues) have used AdvoCATE in real projects for safety assurance, in the context of unmanned aircraft systems.

Elaboration of software requirements documents by means of patterns instantiation

Studies show that problems associated with the requirements specifications are widely recognized for affecting software quality and impacting effectiveness of its development process. The reuse of knowledge obtained from previous projects can facilitate the identification and writing of the requirements to reach the elaboration of a complete and consistent requirements document. Software patterns are a solution to capture and reuse knowledge from different contexts for the software development. On the information system domain, it is common to find a set of requirements that have similar characteristics and repeat themselves in different systems of this domain, indicating a possibility of becoming a requirements pattern. By reusing knowledge obtained in previous projects, requirements patterns can be elaborated to facilitate a more complete and consistent specification of system requirements in that domain. The advantage of using requirements patterns is to provide the software engineer a starting point for the elaboration of requirements documents, instead of starting from scratch to solve known problems. The requirements patterns can contribute to the improvement of the software quality, minimize the development time and costs, because previously defined and tested solutions are reused. This paper shows a set of functional requirements patterns and business rules elaborated to help the software engineer in the writing of the requirements document. The non-functional requirements were not considered in this project. A computational support was developed, based on that set of patterns, to facilitate the organized and complete writing of the requirements document. Case studies are presented with the use of the computational support.

A framework for early design and prototyping of service-oriented applications with design patterns

Service-oriented computing is playing an important role in several domains. Today the biggest shift in mainstream design and programming is toward service-oriented applications. However, the service paradigm raises a bundle of problems that did not exist in traditional component-based development where abstraction, encapsulation, and modularity were the only main concerns. Due to their distributed, dynamic, and heterogeneous nature, service-oriented software applications require us to discover, document, and share new design patterns at the service- and architecture-level. Moreover, service-oriented applications are hard to design and validate, and demand for new foundational theories, modeling notations and analysis techniques.In line to such a vision, this article presents a framework, called SCA-PatternBox, to design and prototype service-oriented applications with design patterns. The framework relies on the OASIS standard Service Component Architecture (SCA) and on SCA component implementation types, such as SCA-Java, for supporting an “implementation-oriented” approach to service-oriented architecture modeling and to the definition and instantiation of design patterns. Moreover, in order to provide formally verified design patterns, SCA-PatternBox allows the formal specification and analysis of the functional behavioral aspects of a design pattern using a formal service specification language called SCA-ASM (Service Component Architecture-Abstract State Machine). As major evaluation of the framework, two case studies and lessons learned are presented. A final comparison of existing design pattern languages is also reported.

A new method for constructing and reusing domain specific design patterns: Application to RT domain

Domain specific design patterns capture domain knowledge and provide solutions of non trivial design problems in a specific domain. Their application improves considerably the quality of software design. In order to benefit from these advantages and to reinforce the application of these patterns, we provide, in this paper, new processes and tools for the development and the instantiation of domain specific design patterns, especially those intended for real-time domain.Initially, we propose a pattern development process that guides pattern developers in the construction of patterns. The proposed process defines unification rules that apply a set of comparison criteria on various applications in the pattern domain. This process is illustrated through the design of the controller pattern. Moreover, we propose a process guiding the application designers in pattern instantiation based on model transformation. Finally, the proposed RT patterns and their development process are evaluated by calculating quality metrics and comparing the applications designed with our RT patterns and others developed by experts without the use of our patterns.

Facilitating construction of safety cases from formal models in Event-B

ContextCertification of safety–critical software systems requires submission of safety assurance documents, e.g., in the form of safety cases. A safety case is a justification argument used to show that a system is safe for a particular application in a particular environment. Different argumentation strategies (informal and formal) are applied to determine the evidence for a safety case. For critical software systems, application of formal methods is often highly recommended for their safety assurance. ObjectiveThe objective of this paper is to propose a methodology that combines two activities: formalisation of system safety requirements of critical software systems for their further verification as well as derivation of structured safety cases from the associated formal specifications. MethodWe propose a classification of system safety requirements in order to facilitate the mapping of informally defined requirements into a formal model. Moreover, we propose a set of argument patterns that aim at enabling the construction of (a part of) a safety case from a formal model in Event-B. ResultsThe results reveal that the proposed classification-based mapping of safety requirements into formal models facilitates requirements traceability. Moreover, the provided detailed guidelines on construction of safety cases aim to simplify the task of the argument pattern instantiation for different classes of system safety requirements. The proposed methodology is illustrated by numerous case studies. ConclusionFirstly, the proposed methodology allows us to map the given system safety requirements into elements of the formal model to be constructed, which is then used for verification of these requirements. Secondly, it guides the construction of a safety case, aiming to demonstrate that the safety requirements are indeed met. Consequently, the argumentation used in such a constructed safety case allows us to support it with formal proofs and model checking results used as the safety evidence.

EVALUATION OF AN AUTOMATED MULTI-PHASE APPROACH FOR PATTERNS DISCOVERY

Design patterns capitalize the knowledge of expert designers and offer reuse that provides for higher design quality and overall faster development. To attain these advantages, a designer must, however, overcome the difficulties in understanding design patterns and determining those appropriate for his/her particular application. On the other hand, one way to benefit from design patterns is to assist inexperienced designers in pattern detection during the design elaboration. Such detection should tolerate variations between the design and the pattern since the exact instantiation of a pattern is infrequent in a design. However, not all variations of a pattern are tolerated. In particular, some structural variations may result in non-optimal instantiations where the requirements are respected but the structure is different; such variations are called spoiled patterns and should also be detected and transformed into acceptable pattern instantiations. This paper first presents an improvement of our design/spoiled pattern detection approach, named MAPeD (Multi-phase Approach for Pattern Discovery). The latter uses an XML information retrieval technique to identify design/spoiled pattern occurrences in a design using, first, static and semantic information and, secondly, dynamic information. This multi-phase detection approach tolerates structural differences between the examined design and the identified design pattern. Furthermore, thanks to the matching information it collects, our identification technique can offer assistance for the improvement of a design. In its second contribution, this paper evaluates MAPeD by comparing its recall and precision rates for five open source systems: JHotDraw, JUnit, JRefactory, MapperXML, QuickUML. The latter were used by other approaches in experimental evaluations. Our evaluation shows that our design pattern identification approach has an average improvement of 9.98% in terms of precision over the best known approach.

A metamodeling approach for pattern specification and management

The formal specification of design patterns is central to pattern research and is the foundation of solving various pattern-related problems. In this paper, we propose a metamodeling approach for pattern specification, in which a pattern is modeled as a meta-level class and its participants are meta-level references. Instead of defining a new metamodel, we reuse the Unified Modeling Language (UML) metamodel and incorporate the concepts of Variable and Set into our approach, which are unavailable in the UML but essential for pattern specification. Our approach provides straightforward solutions for pattern-related problems, such as pattern instantiation, evolution, and implementation. By integrating the solutions into a single framework, we can construct a pattern management system, in which patterns can be instantiated, evolved, and implemented in a correct and manageable way.

GORDON BELOT. Geometric Possibility. Oxford and New York: Oxford University Press, 2011. ISBN 978-0-19-959532-7. Pp. x + 219

How are we to understand the truth conditions for claims about space-time geometry, e.g., that a cyclist's front tire is trailing the rear tire of another cyclist by 10 cm, or that both cyclists are accelerating as they go downhill? A substantivalist regards the truth or falsity of such claims as underwritten by geometrical relations among the regions of space-time occupied by the tires at different times. Yet do we need to treat these claims as parasitic on structural properties of space-time? A relationalist argues that we only need the geometrical relations among bodies, but then owes us an account of the truth conditions for geometrical claims to replace the substantivalist's. Belot's aim, partially inspired by Leibniz, is to ‘retool the substantivalist truth conditions so that they demand not that certain patterns of geometric relations be (un)instantiated by actual material points, but rather that the instantiation of such patterns be geometrically (im)possible’ (p. 4). The bulk of the book is devoted to a clever and engaging exploration of different ways to flesh out this idea of ‘geometric possibility’, taken as a distinctive kind of modality.

An Efficient CBIR Approach for Diagnosing the Stages of Breast Cancer Using KNN Classifier

This paper proposes a mammogram image retrieval technique using pattern similarity scheme. Comparing previous and current mammogram images associated with pathologic conditions are used to diagnose the real stage of breast cancer by doctors. Lack of awareness and screening programs causes the breast cancer deaths. Early detection is the best way to reduce the deaths per incident ratio. Mammogram is the best one in the currently used technique for diagnosing breast cancer. In this paper, the retrieval process is divided into four distinct parts that are feature extraction, kNN classification, pattern instantiation and computation of pattern similarity. In feature extraction step, low level texture features like entropy, homogeneity, contrast, energy, correlation and run length matrix features are extracted. These extracted features are classified using K- Nearest Neighbor classifier to differentiate the normal tissue from abnormal one. Each group is considered as patterns. Finally, pattern similarity is estimated for retrieving images based on their similarity with the query image. This scheme is effectively applied to the Content Based Image Retrieval systems to retrieve the images from large databases and identify the real stage of breast cancer. If we find cancer in early stages we can cure it.

Retrieval from the Brain's Perspective

Retrieval from the Brain's Perspective

Design pattern instantiation directed by concretization and specialization

Design patterns provide an especially effective way to improve the quality of a software system design as they provide abstracted, generalized and verified solutions of non-trivial design problems that occur repeatedly. The paper presents a method of design pattern instantiation support based on the key principles of both MDD and MDA. The method allows specification of the pattern instance occurrence via the semantic extension of UML directly on the context. The rest of the pattern instantiation is automated by model transformations of the specified pattern instances to lower levels of abstraction. Such approach enables the use of higher levels of abstraction in the modeling of patterns. Moreover, the model transformations are driven by models of patterns besides the instance specification, and thus the approach provides very useful ways how to determine and control the results of transformations. The method is not limited to design pattern support only, it also provides a framework for the addition of support for custom model structures which are often created in models mechanically.

Pattern and spoiled pattern detection through an information retrieval approach

Design patterns provide for a higher software quality and a reduced development cost. However, to reach these benefits, designers are expected to have a good understanding and experience with design patterns, which is not evident to acquire. Another way to benefit from design patterns is by assisting designers in their detection/identification within a given design in order to improve it. Since the exact structural instantiation of a pattern is less frequent to find within a design, the identification process should account for variations of the design with respect to the pattern. It assists the designer by showing the pattern elements in terms of the design which can be validated with respect to the classes, attributes, methods and relations of the pattern: the designer can add/remove some elements from the design in order to ensure a good instantiation of the identified pattern. However, not all structural variations of a pattern are tolerated; in fact, some variations may result in non-optimal instantiations of the pattern, a.k.a. spoiled patterns. In this case, the identification process can assist the designer by proposing corrections for an acceptable pattern instantiation. Within this design context, we propose a method that identifies design patterns and spoiled patterns through an XML document retrieval approach. This latter provides for the possibility of tolerating structural variations between the design and the searched pattern. In addition, our pattern identification method can be parameterized in order to delimit the degree of acceptable variations.

On Instantiation and Integration Commutability of Design Pattern

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.

Monitoring of Temporal Requirements with Stocharts Observation Patterns, Application to a Level Crossing Control System

Works in the field of verification systems have shown the critical importance of time. The non-satisfaction of time may have important consequences for both security and performance points of view. For automated systems with level of security, the verification of time requirements is an essential part of the process validation system. In this paper, we are laying the foundations for a new and systematic approach for the verification of discrete event systems with time constraints. The contribution of this approach is threefold: first, unlike existing approaches, it allows for the verification of several requirements at once. Therefore, the approach is generic because we focus on developing mechanisms that take into account different types of requirements rather than the system to be verified. Finally, the implementation of the approach is almost as systematic because the verification tools we are developing are based on the instantiation of patterns. These patterns are designed on the basis of a classification of temporal requirements that we have established. The concepts of parallelism and hierarchy which characterize the Stocharts formalism compared to other state-transitions models help us build the foundations of our approach. An example of application to the control-command in the railway field is presented to illustrate the key concepts of our approach and its implementation.