A pattern language usually consists of a cascade or hierarchy of parts, linked closely together by patterns, which solve generically recurring problems that are associated with these parts. Each pattern has a specific title, and collectively, these titles form a language for design 1. Pattern languages are in life, simply, a collection of interrelated patterns 2. These interrelated patterns combine in any way and means to create new environments, where practitioners can solve context-specific problems. To be precise, the concept of pattern languages has spilled over into the software engineering field, to describe prior experiences and those processes that stem from them, in a very simple and easy to understand language, where patterns are tactfully woven as a whole, and combined in any manner to solve a particular and complex problem. Yet, this process is ad hoc and is not straightforward enough to ease and speed up the software development process. Thus, three main issues carry forward this theme section. First, how can we classify, develop, design, and utilize analysis and design patterns together, following the path to a problem resolution? Second, what is the ‘behind-the-language’ that guides the sewing of patterns together as a whole? Third, how can we overcome and face challenges, other than pattern composition problems (patterns traceability, etc.) that can hinder the development of a system of patterns? An inherent inability to answer these questions is detrimental in understanding how to put patterns into real practice. The use of software patterns is therefore more complex than it should be in practice. Building high quality systems is not an easy exercise, especially, when several factors undermine their success. These factors include cost, time, and a lack of systematic approaches. The potential promised by using software patterns in software development to deal with these aforementioned obstacles has led software practitioners to believe firmly in the power of pattern languages as a means for constructing complex systems in a constrained environment. Software patterns, along with pattern languages, have attracted software practitioners for more than a decade. These practitioners have observed that software patterns and pattern languages are really promising techniques that can ease and speed up the software development processes 2-5. However, developing robust software patterns and pattern languages has not attained the ease of use and flexibility expected when dealing with determined and specific problems. Instead, practitioners usually construct models that lack some essential qualities, thus diminishing the overall quality of the system rather than improving it 6. The concept of pattern languages 3, 7-9 is spilling over into the software engineering field. They can be used to highlight software development's prior experiences or best practices through the use of a coherent language that can be used for both discussing a particular problem and for creating new environments from the patterns. This language usually works by connecting a collection of patterns, as if they were in a detailed, narrated story. Each of the patterns in the collection represents an insightful and novel way to manage or solve a set of recurring problems in a particular context 2, 3, 5. Taken together, they make clearly visible both the knowledge that is pertinent to a particular domain and the solutions for a set of recurring problems. This theme issue addresses some of the aforementioned challenges of pattern languages and debates several issues that are related to pattern languages creation and development; pattern languages selection process, composition, systems of patterns and general reuse, and the impact on software engineering issues through the following articles. The first paper is titled ‘Towards Design Pattern Definition Language’. It proposes a Design Pattern Definition Language based on XML, which can be used for sharing design pattern implementation details among developers. The second paper is titled ‘Software Patterns Catalog Based on a New Classification Scheme’. It proposes a new classification scheme and uses it as the basis for constructing a software patterns catalog. The paper claims the new scheme to be a uniform approach for creating, maintaining, and expanding the catalog. The third paper is titled ‘A Pattern Language for Developing Privacy Enhancing Technologies’. It describes a pattern language of 12 patterns for developing privacy enhancement technologies that can be applied to design anonymity systems for various types of online communication, online data sharing, location monitoring, and voting, and electronic cash management. The fourth paper is titled ‘Efficiently and Transparently Automating Scalable On-demand Activation and Deactivation of Services with the Activator Pattern’. It provides an effective means to efficiently and transparently automate scalable on-demand activation and deactivation of services accessed by many clients. The fifth paper is titled ‘The Use of Pattern Participants Relationships for Integrating Patterns: A Controlled Experiment’ that addresses the pattern integration issue by discovering and defining a set of pattern participants relationships that serves the purpose of effectively integrating architectural patterns through a controlled experiment. The sixth paper is titled ‘UML Design Pattern Metamodel-Level Constraints for the Maintenance of Software Evolution’. It specifies Design Patterns for UML Profiles (DPUPs) by using an extended UML Profile; it provides a means for instantiating pattern-based designs from DPUPs with naming conventions; and it provides design constraints for maintaining a pattern-based design so as to guide correct changes for a given design in PICUP method. The seventh paper is titled ‘Ontology Patterns for Service-Oriented Software Development’. It outlines general principles for using ontologies in software applications by including the ontology design process as a part of software development processes. Ontologies need to be designed as components of an overall software architecture. Ontologies can then be used to enhance software evolution and to play a role in software validation. The paper proposes some common ontology patterns that can be used to when designing ontologies for service-oriented applications and examines two international projects, SENSEI and FCINT, where ontologies and ontology design patterns are used in service-oriented applications. This theme issue addresses some of the pattern languages' challenges that are listed earlier and later debates several issues that are related to pattern languages creation and development and pattern languages selection process, composition, system of patterns and general reuse, and the impact on software engineering aspects. This theme issue also highlights how current approaches that use pattern languages do best in providing a systematic and cost-effective method to integrate patterns and create complex systems. Throughout this theme issue, several topics are debated. They include pattern formalization, classification, composition, traceability, deployment, and development, and how Knowledge Maps is the ideal way to create a system of patterns.

This paper aims at modeling a system that has to perform maintenance, by employing a Corrective Action and come up with a stable pattern, which can form a part of such a system, focusing at applying corrective action in a holistic way, rather than tying it on only one application specific context, which might cause potential impedance mismatch between process and workflows at a later stage. This ensures high reusability, ensuring that a design once created can be used to model any application, in any domain, thus making the task of designing more efficient, and the modeled system, largely domain independent. The goal of this paper is to design a Stable Pattern for Corrective Action and to model the system on the basis on an Enduring Business Theme (EBT). Here, the ultimate goal or the EBT is Maintenance and AnyCorrective action is what acts as a workhorse to achieve the goal of maintenance. In this paper, we have first designed a model, which defines the relationship of the Enduring Business Theme to Business Objects. We have then gone ahead with modeling an application scenario, which portrays the reusability of the developed stable pattern. A comparison of the Traditional Models and the Stable Model has also been included to describe how the latter overcomes to drawbacks of the former. Different models, such as, use cases, CRC cards, class diagrams and sequence diagrams have been used to give a better insight into the pattern and possible applications of it.

This paper specifically deals with patterns topology or pattern language for performance evaluation, a cognitive process involved in producing and understanding different concepts of patterns in this discipline. It also explains how this language can be used to obtain the relationship between certain stable patterns, exhibiting a rich set of behaviors capable of handling features that are reusable, adaptable, and maintainable with minimal modification. The main goal of this paper is to overcome the issues with "forgettable" systems. The proposed solution is not intended to replace existing systems; rather, the effort is to define and provide a new methodology for designing such systems, with a rich set of patterns for performance evaluation that can be used efficiently.

Domain models (DMs) play an important role in different software development activities. DMs are conceptual models that capture the core concepts of the domain and their relationships. But developing DMs requires both domain knowledge and modeling skills, which can be challenging for both novice as well as experienced practitioners. Analysis patterns are conceptual models that model domain knowledge, and hence, they can facilitate the development of DMs. However, most existing analysis patterns intermingle core and business-specific concepts in a single domain model; limiting the reusability of the model to analyze related problems. We argue that, the reusability of conceptual models can be enhanced if the core common concepts of the domain can be separated from business-specific concepts. Accordingly, in this paper, we propose the concept of Stable Analysis Pattern as an approach to improve analysis patterns by identifying and modeling the core concepts of the domain.

Abstract. Branding is a concept that spans multiple areas of application. It is used to create identifiable associations between any type of entity and its brands, with the sole purpose of differentiating it from its peers. This paper introduces the Branding analysis pattern. This pattern focuses on providing a conceptual model that represents any type of branding need in any domain. To achieve this, we used Software Stability Models “SSMs” [1, 2, 3, 4] as the main recipe. This paper also provides full pattern documentation. Additionally, in order to demonstrate the application of this pattern, we provide two examples: one related to HCI, and the other one related to Marketing. Keywords: Branding, Branding Analysis Patterns, Software Stability Models. I. Introduction Branding is a mental construct that establishes a connection between your desires and a particular entity. This connection is achieved through the use of a combination of logos, names, trademarks, tag lines, color palettes, sounds and tones, and physical and behavioral features in a manner that reflects the emotional make-up of any entity. Branding’s origin references to the earliest shepherds that branded their cattle to identify them and differentiate them from other shepherds’ cattle. Nowadays, this activity has found great acceptance in areas as diverse as Marketing and Forensics. In Marketing, branding has emerged as the means for both enhancing customers’ perception with respect to an identifiable product, establishing a pervasive means to communicate information and mark differences among this product and its peers, i.e. Nike,

Abstract Concurrent systems tend to have certain properties that are not localized in single modular units, but their implementations cut across functional components, increasing coupling and making modular units difficult to reuse and adapt. Example properties include concurrency, synchronization, and authentication. This problem is particularly apparent in systems with evolving requirements, as adapting code that is not localized in single modular units proves to be a tedious process. In this paper we discuss issues related to requirements of concurrent software systems to provide explicit support for these cross‐cutting concerns, and we present the Aspect Moderator, a framework extension to the object model that can ease the development of concurrent object‐oriented systems. Copyright © 2002 John Wiley & Sons, Ltd.

Abstract Enterprise frameworks are a special class of application frameworks. They are distinguished from other application frameworks in terms of scale and focus. In terms of focus, application frameworks typically cover one particular aspect of an application, either a domain‐dependent aspect (e.g., billing in a web‐based customer‐to‐business ordering system), or a computational infrastructure aspect such as distribution, man‐machine interface, or persistence, etc. Generally, an application framework alone delivers no useful end‐user function. With infrastructure frameworks, we still have to plug in domain functionalities, while with domain frameworks, we need to set‐up the infrastructure. In contrast, enterprise frameworks embody a reference architecture for an entire application, covering both the infrastructure aspects of the application, and much of the domain‐specific functionality. Instantiating an enterprise framework is nothing short of application engineering, where the architecture and many of the components are reusable. While creativity and continual improvement may be the major ingredients for building a good application framework, anything related to enterprise frameworks, be it building, documenting, or instantiating them, is complex and requires careful design and planning. In this paper, we identify the issues involved in building, using, and maintaining enterprise frameworks, both from research and practical perspective. Copyright © 2002 John Wiley & Sons, Ltd.

The pervasive introduction of the Internet into robotics and automation systems pushes forward an evolution that began when the computer was introduced in the enterprise in the middle of the last century, and that continued. with the interconnection of shop-floor workstations in local networks in the 1980s. Today, the Internet represents a challenge both for research and development in the area of distributed robotics and automation. In order to gain a better understanding and evaluation of results in distributed computing the paper classifies the most promising technological approaches, provides examples of how they are applied in robotics and automation, and discusses available standards and commercial solutions.

Enforcing framework adaptability is one of the key points in the process of building an object-oriented application framework. When it comes to simulation, some adaptation mechanisms to configure components on-the-fly are usually required in order to produce quality software artifacts and alleviate development effort. The paper reports on an experience using a simulation multi-agent framework, initially conceived to be used in fluid flow problems. The framework architecture demonstrated during its evolution a great potential regarding to flexibility and modularity, tackling a wide range of other problems ranging from a network protocol simulation to a soccer simulation.

The authors: develop mapping rules from the relational algebra to linear predicates defining relations in the (output) domain; describe how these predicates can be interpreted in the (input) domain using f/sub Q/, a specified query relation; describe a translation from these predicates to sets of systems of linear inequalities; and discuss the use of a set of systems of linear inequalities to generate complete test cases, inputs, and expected outputs from the queries using the domain testing theory. The proposed techniques support software development based on specification testing, specification-directed testing, and rapid prototyping.>