I need a reading report for the paper I attach below, it should contain, at least, the following information: a. The objectives of your reading on this article. b. Some background information about the article and the author. c. The major points, concept, opinion, or arguments of the article. d. What do you learn from the article, or what are your opinions or arguments on the topic
of the article? e. References/bibliography and citations of the references/bibliography in the text (follow
the format as specified by the end of the “8910 Guidelines to project proposal”
document). f. Anything else – your gains from the article, critiques to the article, etc. I attach my paper below. and I also attach one report of pushpasameeramondu for your reference and just use it as reference for the format.
a21_khwaja.pdf
pushpasameeramondu_readingreport1.docx
Unformatted Attachment Preview
21
Survey On Software Design-Pattern Specification Languages
SALMAN KHWAJA and MOHAMMAD ALSHAYEB, King Fahd University
of Petroleum & Minerals
A design pattern is a well-defined solution to a recurrent problem. Over the years, the number of patterns
and domains of design patterns have expanded, as the patterns are the experiences of the experts of the
domain captured in a higher-level abstraction. This led others to work on languages for design patterns to
systematically document abstraction detailed in the design pattern rather than capture algorithms and data.
These design-pattern specification languages come in different flavors, targeting different aspects of design
patterns. Some design-pattern specification languages tried to capture the description of the design pattern
in graphical or textual format, others tried to discover design patterns in code or design diagrams, and still
other design-pattern specification languages have other objectives. However, so far, no effort has been made
to compare these design-pattern specification languages and identify their strengths and weaknesses. This
article provides a survey and a comparison between existing design-pattern specification languages using a
design-pattern specification language evaluation framework. Analysis is done by grouping the design-pattern
specification languages into different categories. In addition, a brief description is provided regarding the
tools available for the design-pattern specification languages. Finally, we identify some open research issues
that still need to be resolved.
CCS Concepts:
r
Software and its engineering → Specification languages; Design patterns
Additional Key Words and Phrases: Design pattern specification languages, domain specific languages
ACM Reference Format:
Salman Khwaja and Mohammad Alshayeb. 2016. Survey on software design-pattern specification languages.
ACM Comput. Surv. 49, 1, Article 21 (June 2016), 35 pages.
DOI: http://dx.doi.org/10.1145/2926966
1. INTRODUCTION
A design pattern is a reflection of the developer’s experience and empirical knowledge, but is more generalized because it describes a problem and gives a solution to it
[Alexander 1977; Lea 1994]. It provides a sound solution to a described problem. Riehle
and Zullighoven [1996] defined design pattern as a recurring specific software design
construct to handle a recurring issue.
Design patterns are named uniquely, but they are written in a consistent format to
allow designers, developers, and others to communicate using a common vocabulary.
Design patterns can expedite the design and development process of a system because
they provide proven solutions to the problem, which recur commonly across multiple
This work is supported by King Fahd University of Petroleum & Minerals.
Authors’ addresses: S. Khwaja, Information and Computer Science Department, King Fahd University of
Petroleum & Minerals, PO Box 1172, Dhahran 31261, Saudi Arabia; M. Alshayeb (corresponding author),
Information and Computer Science Department, King Fahd University of Petroleum & Minerals, PO Box
1172, Dhahran 31261, Saudi Arabia; email: alshayeb@kfupm.edu.sa.
Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted
without fee provided that copies are not made or distributed for profit or commercial advantage and that
copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for
components of this work owned by others than ACM must be honored. Abstracting with credit is permitted.
To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this
work in other works requires prior specific permission and/or a fee. Permissions may be requested from
Publications Dept., ACM, Inc., 2 Penn Plaza, Suite 701, New York, NY 10121-0701 USA, fax +1 (212)
869-0481, or permissions@acm.org.
c 2016 ACM 0360-0300/2016/06-ART21 $15.00
DOI: http://dx.doi.org/10.1145/2926966
ACM Computing Surveys, Vol. 49, No. 1, Article 21, Publication date: June 2016.
21:2
S. Khwaja and M. Alshayeb
domains and architectures. Moreover, they provide ideas in a consistent high-level
language.
Gabriel [1996] considered a design pattern as a constituent of expression, repetition,
and configuration, in which expression is about a certain context that is repeatable but
can also be resolved through a specific system configuration.
Formalizing design patterns is beneficial to enhancing the understandability of pattern semantics [Sriharsha and Reddy 2015], representing and sharing knowledge, identifying interactions [Pan and Stolterman 2013], modeling software, generating code,
and detecting patterns [Shi 2007]. Nonetheless, design-pattern formalism received a
lot of criticism. Pan and Stolterman [2013] reported that formalizing design patterns
requires too much work to be developed; they are too formal and hard to organize; it
is hard to get people to adopt them; and they are not abstract nor concrete. Seffah
and Taleb [2012] also reported a few challenges with design-pattern specification languages. They indicated that pattern interrelationships are sometimes incomplete and
lack context-oriented perspective.
Furthermore, Buschmann et al. [2007] indicated that there are difficulties for developers to learn the pattern languages and deal with detailed specification; thus, tool
support is needed when dealing with design-pattern specification languages. They also
argued that there is no definitive formal description of patterns because it must always
be confined to a certain subset of options. Therefore, the required detail levels by formal
approaches may restrict how generic a pattern specification language is [Buschmann
et al. 2007].
The objective of this article is to present a survey and a comparison for software
design-pattern specification languages. The results of this survey are beneficial to people who would like to know the pros and cons of design-pattern specification languages.
The results can also be used by design-pattern practitioners, designers, and developers.
In addition, in this article, we highlight different aspects of these languages to help
researchers, programmers, and others in this area to find adequate information and
knowledge on design-pattern specification languages.
1.1. Brief History of Design Patterns
Beck and Cunningham [1987] used some of the ideas of Alexander [1979] to develop
a language for novice Smalltalk programmers based on five patterns. Coplien [2002]
compiled a catalog of C++ idioms and published them as a book in 1991 [Coplien
1992]. In April 1994, the Hillside Group held the first conference on pattern languages
under the title of “Pattern Languages of Programs (PLoP) Conference [1994].” Shortly
thereafter, Erich Gamma et al. [1994] published their patterns book (known as the
Gang of Four book).
1.2. Classification of Design Patterns
Design patterns can be classified in four different ways, which are discussed in this
section.
Classification Based on Purpose/Scope: Purpose and scope are the basic criteria
for this classification. The purpose criterion deals with the kind of problem that the
pattern solves. The scope of the pattern is determined by the component used in the
pattern. If the pattern uses classes for implementing the desired behavior, then it is a
class pattern; if it uses objects to accomplish its task, then it is an object pattern [Erich
Gamma 1994].
Classification Based on Intent: Patterns can be classified based on their intent.
Metsker [2002] adopted the notion that the intent of a design pattern is usually
expressed as the need to go beyond the ordinary facilities that are built into a programming language.
ACM Computing Surveys, Vol. 49, No. 1, Article 21, Publication date: June 2016.
Survey On Software Design-Pattern Specification Languages
21:3
Classification Based on Relationship among Design Patterns: Another classification is
based on the relationships between the design patterns [Appleton 2000]. Each pattern
has a “related patterns” section in its description. Hence, patterns can be classified
based on the relationship between them.
Classification Based on Organization: This classification resulted in a unique shape,
which is similar to the periodic table used in chemistry. At the top level, the pattern is
presented in the purest form, which is called a role model. It captures the spirit of the
model without any details. The domain-specific configurations for the design pattern
are added in the “type model” level. At the lowest level, the concrete deployment model
is presented and is named class model [Lauder and Kent 1998].
1.3. Categorization of Design-Pattern Specification Languages
Design-pattern specification languages can be categorized in three different ways
[Khwaja and Alshayeb 2013a] based on:
The Intent: Design-pattern specification languages can be divided into different
categories according to their intention: (i) defining and describing design patterns,
(ii) detection of design patterns, (iii) verification and validation of design patterns, and
(iv) graphical modeling of design patterns.
The specification languages: Design-pattern specification languages can be divided
into different categories according to their underlying syntax: (i) those based on mathematical formalism, (ii) those based on other modeling languages, and (iii) those based
on other languages.
The notation of the language: Design-pattern specification languages can be divided
into different categories according to the type of notation that they use: (i) textual notation, (ii) graphical notation, and (iii) amphibious design pattern specification languages
that use both textual and graphical notation.
2. RELATED SURVEYS
Most of the research work in the pattern field focuses on microarchitectural details, that
is, describing the generic aspects of software systems in an abstract fashion. It became
apparent in the academic circles that, to increase the understanding of design patterns,
the systematic investigation of both the system and the design pattern is necessary.
Currently, work has been undertaken on the comparative analyses of design patterns;
proposing precise specifications of design patterns; developing tools and rules for the
recognition of design patterns, their validation, and other aspects; and identifying the
relationships among patterns. Another area is the investigations of the impact of design
patterns on fault-proneness of the system [Jaafar et al. 2015].
Most of the time, design-pattern application is manual. This is because the effort
required to describe the specifications of design patterns is either too formal or too
generic. The manual application of design patterns is difficult and highly error prone
[Prechelt et al. 2001]. Precise and workable specifications can help promote the use
of design patterns. Another domain in which research effort has been utilized is the
identification and recovery of design patterns from the code, using the structural or
behavioral aspects of the design patterns [Bernardi et al. 2014; Chihada et al. 2015; Di
Noia et al. 2014; Yu et al. 2015]. Different surveys have also been conducted to identify
which techniques and tools are most successful in identifying the design patterns
correctly [Fulop et al. 2008; Pettersson et al. 2010; Rasool and Streitferdt 2011].
Some good research has been conducted on building a repository of design-pattern
instances for practical and research usage [Chihada et al. 2015].
ACM Computing Surveys, Vol. 49, No. 1, Article 21, Publication date: June 2016.
21:4
S. Khwaja and M. Alshayeb
Understanding design patterns’ microarchitectures is not given due importance
[Eden 1999]. In this article, we intend to capture the “essence” of design-pattern
specification languages, showing the importance of formalizing design patterns through
different languages, and present a framework for categorizing these languages.
There are different types of design patterns such as architectural, requirements,
and security patterns. However, in this article, we focus on specification languages of
object-oriented design patterns.
2.1. Document Organization
The article is organized as follows: Section 3 discusses the existing design-pattern
specification languages. Section 4 provides an overview of the framework for evaluating the design-pattern specification languages. In Section 5, we conduct an evaluation
of the design-pattern specification languages, based on the evaluation framework. Section 6 presents an analysis of the evaluation for the design patterns. We present our
conclusions in Section 7.
3. DESIGN-PATTERN SPECIFICATION LANGUAGES
In this section, we discuss the existing design-pattern specification languages. The
languages are listed according to the underlying syntax of the design-pattern specification language. Languages based on mathematical formalism are discussed first,
followed by languages based on other modelling languages, and languages based on
other languages.
3.1. LePUS
LePUS is a formal approach to solving the design-pattern problem. It is very comprehensive and has been validated in the context of different design patterns; it is limited
to the description of the structure of the design pattern [Gasparis 2007].
LePUS gives an abstract representation of design patterns. The specification of LePUS can be written as a formula or represented in a semantically equivalent graphical
form. Both methods are sufficiently accurate and descriptive. LePUS specifications
of design patterns consist of two major parts. The first part details the participants
involved; the second part describes the collaboration of the participants, such as the
constraints of the participants and the relationships that must or must not take place
among the participants [Baroni et al. 2003].
Most LePUS relations are depicted as edges. The exceptions are the relations ReturnType and Argk, which have a more traditional, textual representation. Symbols in
LePUS represent relations and (typed) variables. The formula of LePUS contains typed
variables in conjunction with relation predicates. Figure 1 depicts most LePUS symbols.
The biggest restriction of LePUS is that the strong mathematical basis makes it
easy for theoretical conformance but hard for use in real-world applications by software developers. There are more restrictions, as follows. Some of the design-pattern
restrictions cannot be accurately expressed in mathematical expression. Some of the
relationships in the design pattern, such as variants, cannot be sufficiently expressed
[Kodituwakku and Bertok 2009]. The integrated tool support for it is weak. One of the
tools based on LePUS is built on Prolog, and LePUS visual notation support is not
offered. The visual notation of LePUS defines many abstractions to make diagrams
concise. However, these elements make the diagram difficult to decipher. LePUS can
only define design-pattern structures; therefore, using it in designing a system or a
code [Mapelsden et al. 2002] is not well defined.
3.2. eLePUS
Attempts were made to rectify the shortcomings of LePUS by Eden et al. [1996]
in eLePUS. They enhanced LePUS as a language for specifications concerning
ACM Computing Surveys, Vol. 49, No. 1, Article 21, Publication date: June 2016.
Survey On Software Design-Pattern Specification Languages
21:5
Fig. 1. LePUS symbols [Gasparis 2007].
object-oriented design and architecture. They tried to overcome the ambiguities of natural languages and the incompleteness of visual representations. Their approach was
also suggested for tackling various management issues related to creating and maintaining a repository of design patterns based on its underlying mathematical model.
eLePUS provides the formalization of three additional aspects—intent, applicability,
and collaboration of the design pattern—thereby augmenting the structural specifications of LePUS [Raje and Chinnasamy 2001]. The enhancements provided by eLePUS
are (a) amendments to basic abstractions, (b) addition of new constructs, and (c) modifications to the representation of patterns. Moreover, eLePUS allows temporal relations,
which indicate a time instance when the relation is realized.
The relationship among ground variables such as classes and functions, hierarchy
variables such as inheritance, and higher-dimension variables such as a set of entities
are specified in first-order logic. Three types of relationships are defined for the entities:
(i) ground relations, (ii) generalized relations, and (iii) commuting relations. These
relations are presented as predicates in pattern specification.
The specification problem of LePUS has not been solved completely in eLePUS.
Specification of the design pattern is defined at the higher level of abstraction, but the
creation of a design pattern requires much lower-level detail, such as the number of
objects to create. Also, the separation of different parts of the specification makes it
harder to obtain the full picture of the design pattern [Hannousse and Liu 2007].
3.3. DisCo
Mikkonen proposed the design-pattern specification language DisCo [Mikkonen 1998].
DisCo uses the concept of the layer for the formalization of the behavior of the design
pattern. The refinements of these layers are used for the final description of the design
pattern composition.
DisCo can also be defined as the combination of an object-oriented view with an
action-oriented view. The behavioral aspect of the design pattern in DisCo is described
ACM Computing Surveys, Vol. 49, No. 1, Article 21, Publication date: June 2016.
21:6
S. Khwaja and M. Alshayeb
using the Temporal Logic of Actions (TLA) [Lamport 1994]. The necessary constituents
of the formalism are (i) classes, (ii) guarded actions, and (iii) relations. The class part
of DisCo is different, as it only describes data elements, and is an object and does not
include any function information. Guarded actions receive objects as input, and perform
data manipulation. The relations part is optional and provides transient associations
among groups of objects.
The approach is successful in capturing the temporal properties of design patterns.
However, this approach lacks the necessary details for implementation. In addition,
the properties that the design pattern brings to the applications are omitted. Separating objects from functions violates a principal tenet of object-oriented design. Thus,
the resulting specifications lack clear guidance on the structural aspect of the design
pattern. Therefore, it fails to provide a good object-oriented solution.
In addition, the behavioral guidance provided by the formalism is not easy to specify
using DisCo. As one action cannot invoke other actions directly, this makes action selection nondeterministic. Furthermore, there is no mechanism for imposing applicationlevel restrictions that might be required for the correctness of the design pattern. Since
the DisCo specification is not parameterized, it limits the flexibility of design patterns,
but it describes both aspects of the design pattern, that is, structure and dynamics of
the pattern [Martino and Esposito 2015].
3.4. Graphical Extension of BNF
Graphical Extended Backus Normal Form (GEBNF), developed by Bayley and Zhu
[2007], uses the class diagram for the description of the design pattern by implementing
the predicate logic.
The graphical structure in GEBNF is an extension of the BNF notation using the
reference feature. To enable GEBNF, each design pattern is constrained by the firstorder predicate so that the model satisfies an instance of the pattern. This makes
GEBNF a meta-model language comprising an abstract syntax along with the firstorder predicate. The constraints, which are based on UML, are readable and very
expressive [Hedin 1998].
The constraints of the language are define …
Purchase answer to see full
attachment
Recent Comments