EuroPLoP 2017 - List of published papers
A Pattern Language for Workflow Engine Conformance and Performance BenchmarkingVincenzo Ferme, Cesare Pautasso, Simon Harrer, Jörg Lenhard, Oliver Kopp
Workflow engines are frequently used in the domains of business process management, service orchestration, and cloud computing, where they serve as middleware platforms for integrated business applications. Engines have a significant impact on the quality of service provided by hosted applications. Therefore, it is desirable to compare them and to select the most appropriate engine for a given task. To enable such a comparison, approaches for benchmarking workflow engines have emerged. Although these approaches deal with different quality attributes, i.e., performance or standard conformance, they face many reoccurring design and implementation problems, which have been solved in similar ways. In this paper, we present a pattern language that captures such common solutions to reoccurring problems (e.g., from test identification, benchmarking procedure validation, automatic engine interaction, and workflow execution observation) in the area of workflow engine conformance and performance benchmarking. Our aim is to help future benchmark authors with the pattern language presented in this paper to benefit from our experience with the design and implementation of workflow engine benchmarks and benchmarking tools.
Keeping TalentsElissaveta Gourova, Nadezhda Stoynova, Mila Dragomirova
Knowledge workers today are characterised by high professional engagement and low commitment to their employers. These highly-qualified employees are looking for opportunities for their professional and personal development and if the organisation is not satisfying their requirements and needs, they change the employer. Subsequently, many worldwide organisations face the problem of high turn-over of their personnel, and lose time and efforts when hiring new employees. Therefore, special emphasis is paid on talent management and attraction, as well as creating an attractive and motivating organisational environment. Many researchers have considered what are the characteristics of a good employer, what attracts the employees, and have focused on the employers branding as a tool for raising employers image and for attracting talented employees. The main goal of this paper is to contribute to the development of an organisational environment that facilitates employee engagement with the organisation and motivation for high performance and creativity at work. The paper presents four patterns (Figure 1): TASKS DISTRIBUTION, LEARNING AND GROWTH, PERFORMANCE RECOGNITION, EFFECTIVE LEADERSHIP. It is closely related with the patterns presented at VikingPLoP 2017: EMPLOYER BRANDING, EMPLOYEES AS AMBASSADORS, EMPLOYER-EMPLOYEE FIT, MEETING EXPECTATIONS. Furthermore, the paper extends the pattern INFO-CULTURE CHANGE discussed at VikingPLoP 2014, as part of a pattern language on Knowledge Management.
Management Stance PatternsThomas Epping
Situations repeat in every organisation. While some of them may constitute a reassuring structure, others may constitute an irritating obstacle in daily routine. Repeating situations may emerge quickly or slowly, they may be stable over time or volatile, and they may have minor or major consequences within an organisation. Either way, they are likely to affect each and every person within an organisation in one way or another. This raises the question if, in turn, one may influence repeating situations by adequate means. In this work, we try to provide such means and propose three management stances that constitute an approach to address repeating situations. We provide examples of use and mention their limits before codifying them into a pattern format as it is used within the pattern community.
Patterns for Idea Management in Innovation CommunitiesMichael Weiss
Innovation communities enable companies and their customers to create new products, discuss product ideas, and promote new products. The patterns in this paper focus on idea management, an essential element of innovation communities concerned with attracting, evaluating, and developing ideas. The paper is part of a series of papers on patterns for designing innovation communities. The audience for the patterns includes organizations and individuals involved in the creation, operation, and growth of innovation communities.
Specification in Continuous Software DevelopmentTheo Theunissen, Uwe van Heesch
"The procession of lean, agile and DevOps development processes introduces new challenges and offers new chances regarding software specification and documentation. Challenges for instance because specifications, just like code and applications, are subject to continuous change
Treating Pattern Sublanguages as Patterns with an Application to Organizational PatternsWaheedullah Sulaiman Khail, Valentino Vranic
Organizing people is very important and one of the great challenges, and in particular in software development. Organizational patterns are the key to piecemeal growth of organizations. To deal with the complexity of choosing right pattern sequences and understanding pattern languages in general, we propose representing them as patterns. Such summary level patterns can be used to treat meaningful parts of pattern languages: pattern sublanguages. We applied this approach to organizational patterns. Specifically, we expressed the pattern story of establishing a new project as the New Project pattern. We also captured the dynamics of this pattern by a state diagram. As it can be observed by comparison, summary level patterns overcome patterns stories in terms of comprehensibility and consistency, with the main contribution being a direct treatment of the conflicting forces.
Analysis of GoF Design Patterns used in Knowledge Processing SystemsStefan Nadschläger, Josef Küng
To increase the quality of knowledge processing systems and provide help to software developers, selected existing knowledge processing systems are analysed for the occurrence of used object-oriented design patterns (especially from the Gang-of-Four catalogue). This analysis intends to draw attention to the lack of good software design in the area of knowledge processing systems and at the same time provides a smaller catalogue of design patterns with proven usage in practice, to support development. The design patterns were identified manually in a structured analysis by reverse engineering the source code, supported by a design pattern detection tool. As a result, Gang-of-Four design patterns, suitable for developing custom knowledge processing systems, are presented and discussed.
Cooperation in Large Code BasesKlaus Marquardt
Combining a branchless configuration management approach (trunk based development) with a single common repository spanning multiple projects or teams, leads to a large, huge, or enormous monolithic code base. Developers find themselves in the middle of a huge project – often not one single project, but many interrelated and physically coupled projects. There is no isolated bit of code that is private or personal. Everybody has to contribute somehow to the large body of code and knowledge and practice around. It is not possible to understand such a code base and the effects of a contribution entirely. Cooperation can happen in different modes. A defensive approach introduces protection against intruders, with separation of changes and possibly many steps for integration, to minimize the risk of destructive updates. A cooperative approach invites to contribute offering changes anywhere and quick integration, aiming to speed up development at the risk of corrective actions. This paper looks at different practices and their context and implications, and evaluates their impact on cooperation and communication. You may select and combine practices that serve your purpose and your desired setting best.
Patterns for a Monolithic Code BaseKlaus Marquardt
Combining a branchless configuration management (trunk based development) with a single common repository leads to a large, huge, or enormous monolithic code base. A monolithic code base is no accident. It reflects what the contained code and the participating projects of an organization actually are: coupled, integrated, and mutually dependent. The monolith now supports important goals, including a defined place and state of integration and ‘truth’, changes and features at any scale, and flexible ownership and team boundaries. By acknowledging the coupling, many traps can be avoided that would stem from applying tools and procedures that are designed for separation and independence. Organizing large software projects and project families, with a large shared ecosystem and many contributions from numerous teams, requires special attention to many aspects of engineering and management that would not be dominant or even visible in smaller settings. Developers find themselves in the middle of a huge cluster of coupled projects. There is no isolated bit of code that is private or personal. Everybody contributes somehow to the large body of code and knowledge and practice around, while it is not possible to entirely understand such code base and the effects of a contribution. This set of patterns explores the balance of separation that is needed for completion of tasks, and the integration that is mandatory for the system aspects. It treat setup and organization, workflows and integration, and release processes. These focus areas are meeting points of engineering and management. Getting them right is a key factor to complexity and risk management, and to the ability to bring the software to its users.
Patterns for C Iterator InterfacesChristopher Preschern
Iterating over a set of elements is a very common operation in any program. Some programming languages provide native constructs to iterate over elements and for object-oriented progamming languages there exists guidance in form of design patterns on how to implement generic iteration functionality. However, there is just very few guidance of this kind for procedural programming languages like C. This paper provides such guidance and presents three patterns on how to design generic iterator interfaces in C.
Physical Quantity: Towards a Pattern Language for Quantities and Units in Physical CalculationsMichael Krisper, Johannes Iber, Tobias Rauter, Christian Kreiner
In this paper an approach is taken towards a pattern language for physical quantities in software applications. The central pattern, Physical Quantity, is described as well as some needed candidate patterns revolving around. The Physical Quantity design pattern is a specialized version of the Quantity analysis pattern, optimized for the SI unit system. It is intended for the physical and mathematical domains where calculations, arithmetic, conversion and simulations are the most used functionalities. Its emphasis is on type safety, dimensional analysis, performance, and convenient syntax. Supporting candidate patterns for handling tolerances, validation, conversion or matrix operations are shortly described. The target audiences are software engineers and practitioners working in the area of physical simulations and calculations.
Service Decoupler: Full Dynamic Decoupling in Service InvocationDionysis Athanasopoulos
According to the service loose-coupling principle, service-oriented software should not be coupled to concrete services. To help developers in implementing dynamic decoupling in service invocation, the patterns of service adapter and abstraction have been adopted by the literature. However, these patterns do not necessarily offer full dynamic-decoupling, since adapters expose specific interfaces and abstractions suffer from the antipattern of abstraction-without-decoupling. To overcome the limitations of the related patterns, we propose a new compound pattern called Service Decoupler. We contribute by specifying the structure and the implementation details of the proposed pattern.
Insertion SpacesMichael Krisper, Johannes Iber, Tobias Rauter, Christian Kreiner
Insertion Spaces is the idea of purposefully leaving out empty space between objects to anticipate changes and insertions. These empty spaces can be used to insert further objects or rearrange existing objects. This idea is applicable in many contexts, but in this paper the context of software development and database development is addressed. Especially the calculation of order-values to change the sequence of objects is discussed. This paper primarily targets software engineers but Insertion Spaces can be useful for everyone having to deal with arrangements of objects and wanting to have flexibility in their solutions.
A Pattern Language for High-Performance Computing ResilienceSaurabh Hukerikar, Christian Engelmann
High-performance computing systems (HPC) provide powerful capabilities for modeling, simulation, and data analytics for a broad class of computational problems. They enable extreme performance of the order of quadrillion floating-point arithmetic calculations per second by aggregating the power of millions of compute, memory, networking and storage components. With the rapidly growing scale and complexity of HPC systems for achieving even greater performance, ensuring their reliable operation in the face of system degradations and failures is a critical challenge. System fault events often lead the scientific applications to produce incorrect results, or may even cause their untimely termination. The sheer number of components in modern extreme-scale HPC systems and the complex interactions and dependencies among the hardware and software components, the applications, and the physical environment makes the design of practical solutions that support fault resilience a complex undertaking. To manage this complexity, we developed a methodology for designing HPC resilience solutions using design patterns. We codified the well-known techniques for handling faults, errors and failures that have been devised, applied and improved upon over the past three decades in the form of design patterns. In this paper, we present a pattern language to enable a structured approach to the development of HPC resilience solutions. The pattern language reveals the relations among the resilience patterns and provides the means to explore alternative techniques for handling a specific fault model that may have different efficiency and complexity characteristics. Using the pattern language enables the design and implementation of comprehensive resilience solutions as a set of interconnected resilience patterns that can be instantiated across layers of the system stack.
Empirical Evaluation Methods for Pattern Languages: Sketches, Classification, and Network AnalysisNiels Seidel
After elaborating design patterns in a certain field or domain building a pattern language will be the next step. This can be a challenging task, because a large amount of text with numerous cross-references and dependencies needs to become inherently consistent. In order to improve the quality of a pattern language it is necessary to analyse and evaluate all individual patterns as well as the pattern language as a whole. This paper provides an overview of existing evaluation methods for pattern languages and contributes further empirical methods that aim to assess and analyse pattern languages from different perspectives. Methods for sketching patterns, pattern classification, and the network analysis of pattern interrelation will be introduced and explained. The three methods are applied and tested in a case study about a pattern language for video learning environments.
Engineering Software for the Cloud: Messaging Systems and LoggingTiago Boldt Sousa, Hugo Sereno Ferreira, Filipe Figueiredo Correia, Ademar Aguiar
"Software business continues to expand globally, highly motivated by the reachability of the Internet and possibilities of Cloud Computing. While widely adopted, development for the cloud has some intrinsic properties to it, making it complex to any newcomer. This research is capturing those intricacies using a pattern catalog, with this paper contributing with three of those patterns: Messaging System, a message bus for abstracting service placement in a cluster and orchestrating messages between multiple services
Internet of Things Patterns for Device Bootstrapping and RegistrationLukas Reinfurt, Uwe Breitenbücher, Michael Falkenthal, Frank Leymann, Andreas Riegg
All kinds of large and small organizations are trying to find their place in the Internet of Things (IoT) space and keep expanding the portfolio of connected devices, platforms, applications, and services. But for these components to be able to communicate with each other they first have to be made aware of other components, their capabilities, and possible communication paths. Depending on the number and distribution of the devices this can become a complicated task. Several solutions are available, but the large number of existing and developing standards and technologies make selecting the right one confusing at times. We collected proven solution descriptions to reoccurring problems in the form of patterns to help Internet of Things architects and developers understand, design, and build systems in this space. We present ten new patterns which deal with initializing communication. Five of these patterns are described in detail in this paper. The patterns Factory Bootstrap, Medium -Based Bootstrap, and Remote Bootstrap are used to bring information for setting up communication onto the device. Devices can be registered using the Automatic Client -Driven Registration, Automatic Server -Driven Registration, or Manual User -Driven Registration patterns. During this process, a Server -Driven Model, Pre -Defined Device -Driven Model, or Device -Driven Model is stored in a Device Registry to digitally represent the device.
Patterns for Managing Tenants in a Multi-tenant ApplicationSumit Kalra, T V Prabhakar
Multi-tenant architectural principle for cloud applications is a relatively new principle as compared to others such as multiuser and multi-instance. It allows to share a single instance of an application among multiple tenants with a high degree of customization. In this paper, we present a collection of patterns to design a multi-tenant application such that it can manage its tenants efficiently. The patterns described here are - multi-tenant, tenant manager, tenant observability, tenant separability and tenant elasticity. Each pattern covers the different aspects of systematic tenant management.
Patterns for the Industrial Internet / Industrie 4.0Diethelm Bienhaus
Internet technologies have conquered industry domains. Devices on the shop floor are getting connectivity to the Internet. Industrial application of such devices provide the basis for Cyber Physical Production Systems (CPPS) or the so called Industrial Internet of Things (IioT). Sensor data or control commands can be interchanged with remote servers or cloud systems which host applications for further data processing like business analytics, reporting, visualization or process control. This paper introduces four patterns dealing with challenges occurring when collecting data from shop floor machines and devices to enable Internet based data processing.
Patterns grasping the trade-off between distributing data or informationJohannes Iber, Tobias Rauter, Michael Krisper, Christian Kreiner
Today, we are at the dawn of the age of cyber-physical systems and internet of things. One of the commonalities these areas share is that such systems typically consist of networks of entities with means to gather data about the state of the surrounding environment. A fundamental design decision in such settings is whether to transfer data to more capable entities or to analyze data at the sensing entity and to share the resulting information. With this work, we discuss this trade-off by grasping it with three patterns, namely the LOCAL DATA PROCESSING, CENTRAL DATA PROCESSING, and MIXED DATA PROCESSING patterns.
A Taxonomy and Catalog of Business Process Model PatternsRalf Laue, Michael Fellmann, Agnes Koschmider, Andreas Schoknecht, Arthur Vetter
While a large number of business process model patterns have been suggested in the literature, it is currently difficult to find patterns that might be useful in a given context. The reason is that the relevant publications are spread in various journals and other types of publications, and there is no guidance for locating a pattern that can be useful for solving a given problem. In our article, we present the results of a literature survey that has been conducted with the aim to get an exhaustive overview on existing publications on business process modeling patterns. The results of the survey allowed us to propose a taxonomy of existing patterns as a first step towards a pattern language of business process model patterns. Furthermore, we created an online catalog that allows finding publications on business process model patterns based on various search criteria. It is intended to be useful both for business process modeling practitioners as for researchers in need of sound literature references. Currently, this catalog includes links to 89 publications (usually containing more than one pattern). It is our aim to populate the catalog with patterns published in the future.
Anti-Patterns in End-User DocumentationRalf Laue
The purpose of technical documentation for end-users (in printed or on-screen form) is to enable people to achieve their goals by working with a product effectively, efficiently and in a safe manner. Technical documentation that has to be read by end users provides a special demand because the way of thinking and the vocabulary of a typical end user is different from that of a technical expert. Six documentation anti-patterns are discussed in this paper. They address the structure of the documentation, the organization of the access to its contents and the language used in the documentation. In addition to the discussion of anti-patterns, the article contains suggestions for better solutions.
Patterns for Interactive Line Charts on Mobile DevicesPadmalata V Nistala, Trevor Dsouza, Swapna Bijayinee, Sonali Joshi, Prachi Sakhardande, Kesav V Nori
"Mobile devices are gaining prominence for a variety of activities. From casual browsing to complex tasks like online shopping and banking, people have started using mobiles for almost everything previously done on a desktop. As more and more tasks are shifting towards mobiles, it has become crucial to redesign desktop elements to fit and function consistently on mobile devices as well. One such element is data visualization. The process of designing visualizations for desktops is fairly matured
Linguistic Patterns and Linguistic Styles for Requirements Specification (I): An Application Case with the Rigorous RSL/Business-Level LanguageAlberto Rodrigues da Silva
"System requirements specification describes technical concerns of a system and is used throughout the project life-cycle. Requirements specification helps sharing the system vision among its stakeholders, as well facilitating the communication, project management and system development processes. For an effective communication, everyone communicates by means of a common language, and natural language provides the foundations for such language. Although natural language is the most common and preferred form of requirements representation, it also exhibits intrinsic characteristics that often present themselves as the root cause of many requirements quality problems, such as incorrectness, inconsistency, incompleteness and ambiguousness. This paper presents the RSL (short name for ""Requirements Specification Language"") which is a language to improve the production of requirements specifications in a more systematic, rigorous and consistent way. RSL includes constructs logically arranged into views according to the specific requirement engineering concerns they address. These constructs are defined as linguistic patterns and are represented textually by multiple linguistic styles. Due to space constraints, this paper focuses only on its business level constructs and views, namely on glossary terms, stakeholders, business goals, processes, events and flows. RSL can be used and applied by different types of users such as requirement engineers, business analysts, or domain experts. They can produce system requirements specifications with RSL at different level of detail, considering different writing styles and different types of requirements (e.g., business goals, system goals, functional requirements, quality requirements, constraints, user stories, and use cases). In addition, they can use other types of constructs (e.g., terms, stakeholders, actors, data entities) that, in spite of not being requirements, are important to complement and enrich the specification of such requirements. Based on a simple running example, we also show how RSL users (i.e., requirements engineers and business analysts) can produce requirements specifications in a more systematic and rigorous way."
TinG-PL: A Pattern Language for Text in the GUIBrigit van Loggem
User-Centered Design Journey for Pattern DevelopmentPadmalata V Nistala, Sonali Joshi, Hetal Jani, Prachi Sakhardande, Trevor Dsouza
Digital information is widely accessed through tangible mediums such as desktop, tablets, smart phones, and so on. It is important to make the digitized information easily as well as effectively perceivable and interactive, through user interfaces on these devices. There are several challenges and complexities involved in designing interfaces to ensure good user experience. This paper describes the journey of a user experience designer in effectively selecting a user interface design based on User-Centered Design approach. In this journey, we address multiple aspects: understanding user as well as business perspectives, challenges faced by end-user and designer, evaluation of various design solutions in problem context, selecting the most apt solution and formulation of a design pattern appropriate to the problem. The paper illustrates this journey through a case study and also describes the final pattern manifestation - 'Progressive disclosure' pattern. The progressive disclosure pattern enables user to focus on a task at hand by reducing clutter and confusion, and at the same time providing means to deep dive into details. The case study helps to understand how the non-linear nature of the journey is accommodative and flexible of the newly identified problems or ideas for solution, which eventually helped in creating robust and long-lasting patterns.
Architecture Management in Software Development OrganizationsViktor Sauermann, Frank Frey
As long as a software development organization drives several development projects in parallel the enterprise architecture gets more and more complex. Every initiative and every project has its own goals and timelines. This context implies a great challenge steering and managing the architecture to achieve more homogeneity, evolve according to new technology stacks and still pay credit to a necessary independence between projects. Short-term goals of the projects need to be balanced out with mid- and long-term objectives of the company. Therefore, architecture management measures should be considered, planned, and realized. This paper describes eight high-level architecture management patterns as starting point for central architecture teams, chiefs of architects, lead and principal software architects or CTOs.
Aspect Frames: Describing Cross-Cutting Concerns in Aspect-Oriented Requirements EngineeringRene Meis, Maritta Heisel
Cross-cutting concerns often arise when non-functional requirements are operationalized, because non-functional requirements are themselves cross-cutting. In the field of aspect-oriented requirements engineering (AORE), functional requirements that cross-cut multiple other functional requirements are called aspects. An aspect describes in most cases a solution for a non-functional requirement and how this solution can be integrated into the realization of the functional requirements it cross-cuts. Examples for cross-cutting concerns are logging, encryption, and access control. We observed that aspects often share a basic structure, behavior, and the way of how they have to be integrated into the realization of the functional requirements they cross-cut. We propose in this paper aspect frames. An aspect frame is a kind of pattern for aspects that share a common concern, behavior, and way how they are integrated into the realization of the functional requirements they cross-cut. These aspect frames support requirements engineers to describe concrete aspects that fit to an aspect frame.
Identifying Agile Requirements Engineering Patterns in IndustryE.-M. Schön, J. Thomaschewski, M.J. Escalona
Agile Software Development (ASD) is gaining in popularity in today's business world. Industry is adopting agile methodologies both to accelerate value delivery and to enhance the ability to deal with changing requirements. However, ASD has a great impact on how Requirements Engineering (RE) is carried out in agile environments. The integration of Human-Centered Design (HCD) plays an important role due to the focus on user and stakeholder involvement. To this end, we aim to introduce agile RE patterns as main objective of this paper. On the one hand, we will describe our pattern mining process based on empirical research in literature and industry. On the other hand, we will discuss our results and provide two examples of agile RE patterns. In sum, the pattern mining process identifies 41 agile RE patterns. The accumulated knowledge will be shared by means of a web application.
Interface Representation Patterns: Crafting and Consuming Message-Based Remote APIsOlaf Zimmermann, Mirko Stocker, Daniel Lübke, Uwe Zdun
Remote Application Programming Interfaces (APIs) are technology enablers for major distributed system trends such as mobile and cloud computing and the Internet of Things. In such settings, message-based APIs dominate over procedural and object-oriented ones. It is hard to design such APIs so that they are easy and efficient to use for client developers. Maintaining their runtime qualities while preserving backward compatibility is equally challenging for API providers. For instance, finding a well suited granularity for services and their operations is a particularly important design concern in APIs that realize service-oriented software architectures. Due to the fallacies of distributed computing, the forces for message-based APIs and service interfaces differ from those for local APIs -- for instance, network latency and security concerns deserve special attention. Existing pattern languages have dealt with local APIs in object-oriented programming, with remote objects, with queue-based messaging and with service-oriented computing platforms. However, patterns or equivalent guidance for the structural design of request and response messages in message-based remote APIs is still missing. In this paper, we outline such a pattern language and introduce five basic interface representation patterns to promote platform-independent design advice for common remote API technologies such as RESTful HTTP and Web services (WSDL/SOAP). Known uses and examples of the patterns are drawn from public Web APIs, as well as application development and software integration projects the authors have been involved in.
The Container Manager PatternEduardo B. Fernandez, Madiha H. Syed
A container manager orchestrates and manages distributed environments composed of groups or clusters of software containers. Virtual machines have long been the option when it comes to virtualization solutions in clouds but containers provide a more portable, reusable and lightweight alternative. Containers provide operating system level virtualization where applications are executed in isolated environments sharing a host operating system, binaries, and libraries with other containers. Software containers although not new, have become very important to support convenient, and low overhead applications. Containers facilitate application deployment and distribution across computing environments. Containers are not the only components in the environment but work closely with other components that manage and support them. We present a pattern for a Container Manager which describes these components along with the required functions of this manager.
Towards Containment Checking of Behaviour in Architectural PatternsUwe Zdun, Faiz ul Muram, Huy Tran
The behaviour of architectural patterns must be consistent in terms of the artefacts produced in the various activities of the software development process, such as requirements, software architecture, detailed design and implementation. In this context, high-level models are mainly used to convey the core concepts or principles of the reality they represent in an abstract and/or concise way (e.g., requirements or architecture design). If a specific architectural pattern like model-view-controller is used in such high-level models, the corresponding detailed designs and implementations are also based on the particular pattern. Low-level or detailed design models are used to provide a (more) precise specification of the source code. However, because of the involvement of different stakeholders and independent evolution of software systems, inconsistencies might occur in architectural patterns' behaviour at those different abstraction levels. Previous studies have not considered the checking of architectural patterns' behaviour. In this paper, we present a solution to the containment checking problem that verifies whether the behaviour described by a low-level model still is consistent with the pattern specifications provided in its high-level counterparts. Here, the interactions between architectural pattern elements are captured using UML2 sequence diagrams. This paper also aims at providing more informative and comprehensive feedbacks to the stakeholders for identification of violation causes and their resolutions. The applicability of the proposed solution is demonstrated by applying it on three architectural patterns, namely model-view-controller, layers, and pipe and filter. The proposed solutions can also be applied to other types of behaviour models, such as state machines, activity diagrams and BPMN models, as well as other architectural patterns.
Two safety patterns: Safety Assertion and Safety Assertion EnforcerEduardo B. Fernandez, Brahim Hamid
Safety is the avoidance of unacceptable hazards, including threats to human lives, the environment, or to costly facilities. Safety constraints are expressed using assertions that define system states that should not occur because they may lead to mishaps. We present here two safety patterns. The Safety Assertion pattern describes the contents of an assertion that indicates a state of the system that must not happen. The Safety Assertion Enforcer pattern evaluates safety assertions when there is an incoming event that can change the state of the system and prevents the change if it violates an assertion. These patterns can be useful for designing or certifying safe systems.
Feedback Design Patterns for Math Online Learning SystemsPaul Salvador Inventado, Peter Scupelli, Cristina Heffernan, Neil Heffernan III
Increasingly, computer-based learning systems are used by educators to facilitate learning. Evaluations of several math learning systems show that they result in significant student learning improvements. Feedback provision is one of the key features in math learning systems that contribute to its success. We have recently been uncovering feedback design patterns as part of a larger pattern language for math problems and learning support in online learning systems. In this paper, we present three feedback design patterns developed from the application of the data-driven design pattern methodology on a large educational dataset collected from actual student data in a math online learning system. These design patterns can help teachers, learning designers, and other stakeholders construct effective feedback for interactive learning activities that facilitate student learning.
Organizing Design Patterns for Privacy: A Taxonomy of Types of RelationshipsJ.C. Caiza, Y.S. Martin, J.M. del Alamo, D.S. Guaman
There has recently been an upsurge of legislative, technical and organizational frameworks in the field of privacy which recommend, and even mandate the need to consider privacy issues in the design of information systems. Privacy design patterns have been acknowledged as a useful tool to support engineers in this complex task, as they leverage best-practices which are already available in the engineering community. There are currently different privacy pattern catalogs coexisting, however, an ongoing effort is being made to unify these scattered contributions into one comprehensive system of patterns. To this end, the relationships between the privacy patterns must be expressed consistently. However, the catalogs available describe pattern relationships at different, incompatible levels of detail, or do not describe them at all. To solve this problem, this paper presents a taxonomy of types of relationships that can be used to describe the relationships between privacy patterns. This taxonomy has been validated against each individual catalog to ensure its applicability in the unified privacy pattern system.
Patterns for cross device communication in a blended space for innovationChristian Kohls, Dennis Dubbert, Meryem Dural, Matthias Groß, Beate Münster, Guido Münster
Blended spaces are spaces that mix different spaces (e.g. physical and digital, social and conceptual) into one coherent whole. The blend is more than the sum of its part because new properties emerge. In a blended space, physical and digital activities overlap. A blended space consists of several physical devices that connect to the digital world (e.g. digital whiteboards, interactive tablets, smartphones, game arcades etc.). It is important to connect the digital devices between each other in order to create one holistic experience of the space.
Sharing is CaringChristian Kohls
Hybrid education aims at dissolving the dichotomies within education such as physical-digital, academic-nonacademic, online-offline, formal-informal, learning-teaching and individual-collective. It takes a more holistic view and take the diversity of students and teachers into account. In this paper we will focus on mixing the digital and non-digital world, digital and non-digital artefacts, in order to make sharing resources simpler and more open. This addresses educational values such as self-expression (as contribution becomes both simpler and more diverse), openness, flow of activities (avoiding any seams between media), and inclusion (allowing everyone to participate). This paper introduces five patterns of hybrid pedagogy which enable sharing between learners and educators.
Software Specification and Documentation in Continuous Software Development: A Focus Group ReportUwe van Heesch, Theo Theunissen, Uwe Zdun, Olaf Zimmermann
We have been observing an ongoing trend in the software engineering domain towards development practices that rely heavily on verbal communication and small, closely-interacting teams. Among others, approaches like Scrum, Lean Software Development, and DevOps fall under this category. We refer to such development practices as Continuous Software Development (ConSD). Some core principles of ConSD are working in short iterations with frequent delivery, striving for an optimal balance between effectiveness and efficiency, and amplify learning in the development team. In such a context, many traditional patterns of software specification, documentation and knowledge preservation are not applicable anymore. To explore relevant topics, opinions, challenges and chances around specification, documentation and knowledge preservation in ConSD, we conducted a workshop at the 22nd European Conference on Pattern Languages of Programs (EuroPLoP), held in Germany in July 2017. The workshop participants came from the industry and academia. In this report, we present the results of the workshop. Among others, we elaborate on the difference between specification and documentation, the special role of architecture in ConSD in general, and architecture decision documentation in particular, and the importance of tooling that combines aspects of development, project management, and quality assurance. Furthermore, we describe typical issues with documentation and identify means to efficiently and effectively organize specification and documentation tasks in ConSD.
Towards a Community Centric Pattern RepositoryPaul Salvador Inventado, Peter Scupelli
In 2014, we began prototyping of an online, publicly available repository for pedagogical design patterns. We developed it mainly to facilitate locating pedagogical design patterns, but it has since evolved to address other challenges. This report presents ideas discussed during the focus group such as the goals of the repository, the technical and practical issues we faced in the development of the repository, and the current solutions we have applied to address these issues. Participants learned about the repository, discussed pattern repository issues, and brainstormed solutions to such issues. Some notable repository issues discussed include the organization and navigation of patterns in the repository, management of pattern format variations, and community support for the repository's continued development.
Focus Group: Patterns for Fog ComputingAndreas Seitz, Felix Thiele, Bernd Bruegge
Fog computing addresses non-functional requirements such as real-time, latency, location-awareness and platform heterogeneity to overcome the limitations of cloud-based architectures. In this focus group, we explore the use of patterns for fog, edge and cloudlet solutions. The goal is to identify a set of patterns that can be used by software engineers for the design of fog computing applications.