Search

A design pattern is a successful solution to recurring problems. It is a powerful tool to improve design quality and to reduce the time and cost of design. One of the major challenges confronting developers while using of design pattern is finding a suitable selection for them, thus it is considered as a challenging task for developers with less experience in the area of the design pattern. Therefore, the developers need a pattern recommendation to assist them by suggesting suitable design patterns. This paper presents the architecture Design Pattern Selection based on a Multi-Agent System (DPSA). The DPSA aims to obtain the appropriate recommendation to reduce development efforts, facilitate and assist the developers in selecting suitable patterns for their problems. DPSA's agents operate to support four different types of recommendations: single pattern, implement the pattern, pattern sequences, and recommending practical.

This paper presents OntologyFixer, a web-based tool that supports a methodology to build, assess, and improve the quality of ontology web language (OWL) ontologies. Using our software, knowledge engineers are able to fix low-quality OWL ontologies (such as those created from natural language documents using ontology learning processes). The fixing process is guided by a set of metrics and fixing mechanisms provided by the tool, and executed primarily through automated changes (inspired by quick fix actions used in the software engineering domain). To evaluate the quality, the tool supports numerical and graphical quality assessments, focusing on ontology content and structure attributes. This tool follows principles, and provides features, typical of scientific software, including user parameter requests, logging, multithreading execution, and experiment repeatability, among others. OntologyFixer architecture takes advantage of model view controller (MVC), strategy, template, and factory design patterns, and decouples graphical user interfaces (GUI) from ontology quality metrics, ontology fixing, and REST (REpresentational State Transfer) API (Application Programming Interface) components (used for pitfall identification, and ontology evaluation). We also separate part of the OntologyFixer functionality into a new package called OntoMetrics, which focuses on the identification of symptoms and the evaluation of the quality of ontologies. Finally, OntologyFixer provides mechanisms to easily develop and integrate new quick fix methods.

Stateful priorities are used for imposing precise restrictions on system actions, in order to meet safety constraints. Those priorities restrict erroneous system behavior, whereas safe system behavior remains unrestricted. In this work, we present the design of the tool CrEStO, which obtains those priorities, and we extend its query support. We also present several examples, experiments and point out future research work.

When proposing new design patterns or design guidelines for IEC 61499 Applications, their performance and quality has to be compared to alternative solutions. Software measures are a way of achieving that. Although first attempts towards software measures for IEC 61499 were made, the standard still lacks a solid set of measures to evaluate applications. Taking a first step in that direction, we propose a set of measures for an IEC 61499 Basic Function Block.

Machine-learning (ML) software engineering design patterns encapsulate reusable solutions to commonly occurring problems within the given contexts of ML systems and software design. These ML patterns should help develop and maintain ML systems and software from the design perspective. However, to the best of our knowledge, there is no study on the practitioners’ insights on the use of ML patterns for design of their ML systems and software. Herein we report the preliminary results of a literature review and a questionnaire-based survey on ML system developers’ state-of-practices with concrete ML patterns.

Today's web designers are encountering multiple issues regarding website development within specific application domains. These issues can be successfully addressed using Domain-Specific Design Patterns, enhancing the final deliverable quality for the domain under consideration. Having in mind the benefits of using web design patterns, domain ontologies can also complement their identification within the context of a specific application domain. They define the underlying semantic context of a domain, by encapsulating the domain knowledge. To this end, an approach is proposed to support the automated recommendation of candidate web design patterns relying on the respective domain ontology. The website designs, occurring in a particular application domain, are automatically analyzed so that all recurrent patterns among them can be detected. These patterns are validated and matched against domain's ontology, and subsequently evaluated and categorized. Finally, the best-rated design solutions are recommended as candidate design patterns for addressing typical domain design problems. Ultimately, it becomes easier for domain designers to recognize best practices among them and thus identify domain-specific design patterns.

5G promises to bring back value to the network operator and not only serve as a data pipe solution anymore. Operators have started to adopt cloud-native paradigms for the deployment of the 5G core architecture. With it goes the introduction of the service-based architecture as a key design pattern for realizing future control, and ultimately user planes of mobile networks. New design patterns offer a more flexible network and address new use cases utilising the features of a 5G system, such as slicing. We present aspects of a dynamic slicing approach as well as low-layered slicing and forwarding methodology within a service delivery platform entirely built upon service-based architecture principles.

In order to exchange traceability information within supply chains, the use of Distributed Ledger Technology (DLT) has recently been discussed in research and industry. As part of the Design Science Research Methodology (DSRM) chosen for this work, a structured literature review is conducted to provide a knowledge base regarding this topic. By reviewing the proposed approaches, a summary of collected requirements is given and the identified system concepts and design patterns are presented and discussed. The lack of mechanisms to protect trade secrets is identified as the most important challenge for the real-world application of such systems. There is a particular need for solutions when the exchange of information with third parties or the public is required but business-relevant data or metadata could be disclosed. Therefore, the research question arises, how sensitive data could be provided from inside a DLTbased system to external third parties by considering the risk of metadata analysis. As result, we propose an approach using existing mechanisms and design patterns to reduce the risk of competitor analysis. The applicability in real-world scenarios is focused, which is why a proof of concept is implemented as software artifact using Hyperledger Fabric. An evaluation of this artifact regarding the key requirements concludes this paper.

In object-oriented software development, several design patterns are used to design software to solve different problems. The Model-View-ViewModel or MVVM pattern is a design pattern that can be used to design structure of software which comprises three components. The Model component holds application data. The View component displays visual elements and controls on the screen. The ViewModel component is the intermediary between the Model and View and transforms model information for display on a view. The advantages of this pattern are that there is a clear separation between domain logic in the Model and the display on the View, and tests and maintenance of different components are facilitated. However, there are several developers in a software development team, and not all developers use the MVVM pattern. This makes the code not compliant with the pattern and affects code maintenance. To help developers to revise the code to comply with the MVVM pattern, this paper has studied the MVVM design pattern, summarized principles of the pattern, and proposed the criteria to detect pattern violation in Objective-C code. An automated tool has been developed to detect MVVM violation and report violation locations in the code so that developers can revise the code to follow the pattern. An experiment shows that the tool performs satisfactorily in pattern violation detection, compared with manual detection, with the precision of 0.81, recall of 0.77, and F1 of 0.79.

Economic aspects of modern engineering lead to more frequent inclusion of mixed-effort networks in system architecture. Which pose the challenge of allowing for a degree of guaranteed delivery while keeping the network schedule dynamic. Introducing an Arbiter as role or component can prevent bus contention, through prioritizing specific categories of telegrams. This publication examines different approaches to arbitration of shared resources. Most commonly bus systems and networks. We propose a pattern called Registration Arbiter for controlling access to the shared medium by passively monitoring the medium, as well as further candidate patterns. The target audience are Embedded System Architects. We examine this pattern in the context of Industrial Control Systems.

This paper presents a concise pattern language that has been developed for designing online learning and teaching. The aim of these patterns is to facilitate novice teachers in designing both their online environments and learning experiences in a manner that is scaffolded yet maintains and supports their agency in the design process. The value of these patterns, as sources of reusable design insights that capture expert knowledge, provides a mechanism for novice teachers to realise their creative pedagogical intent in a tested and framed manner. The openness of these patterns to individual and group interpretation also allows for connections to related pattern languages that sit within the learning and teaching domain.

This paper presents a set of patterns for user interface designers to help users better protect themselves from cyberattacks. The basic idea is to create and support mental models of cybersecurity that resembles the way people manage security in the physical world. The patterns therefore focus on conceptual strategies, and allow a range of UI designs appropriate to different platforms, including desktop, web, and mobile presentations. This idea stems from focus group studies of how people manage everyday security, and our identification of the common steps that people follow. A key concept that emerged was the distinction between being 'home', where they were present and engaged, and 'away', when they were distant. The common steps involved preparation for being away, and what to do on return. Our cybersecurity patterns suggest and support similar behaviour online. The patterns already have known uses, but many others are possible, and greater use and consistency would be beneficial.

While pattern mining is characterized by empirical examinations the applied solutions propagated in the patterns are only rarely the subject or the result of empirical tests. However, confidence that a pattern will serve its purpose can only be obtained through testing and using them in practice.This article uses the pattern VIDEO SEGMENTATION as a use case to present an iterative approach on how to integrate iterative empirical tests into the elaboration of design patterns. This approach aims to explore the design space and specifies the context of a pattern. With the approach presented here, we want to encourage researchers from different disciplines to communicate their empirical research results in the form of design patterns.Using learning analytics methods, two studies were conducted for this purpose. In the first study 10 popular educational YouTube channels were analysed regarding the length and sequence of 4.136 videos. By using a cluster analysis three groups of videos of different length could be identified: videos under 8 minutes playing time, videos between 8 and 20 minutes duration and longer videos.For the second study 22 participants were split up into two groups using a video player supporting segmented videos in two different ways, and a control group watching a non-segmented video. Segmented videos with sequences of up to 10 minutes resulted in higher learning effects than the non-segmented version of the same video.

Implementing large and modular C programs is tricky, because there hardly is any support by the C programming language and hardly any guidance for implementing large C programs in a way that they become modular and thus maintainable. In order to implement modular C programs, as with any other programming language, the question arises how to split the code into different files and where to put these files. While there are conventions in other programming languages on how to do that (e.g. Java advices how to structure files for packages), there are no such specific conventions for C programs. To address this issue, this paper presents design patterns containing guidance on how to structure files for modular C programs.

Developers often combine multiple programming languages to build large-scale applications. They choose programming languages properly for their tasks at hand instead of solving all of their problems with a single language. Foreign Functions Interface allow code written in one programming language to access features available in another programming language. Multi-language systems benefits from several advantages. However, they also introduce challenges related to the development, comprehension, and maintenance of such systems. Software quality is achieved partly by following good practices---architectural styles, design patterns, idioms---and avoiding bad practices---design anti-patterns and code smells. Yet, a review of the literature shows that there are a few works that study developers' practices among multi-language systems. The heterogeneity of components introduces code smells at the source code level. While design patterns are defined as good solutions to a recurrent problem, code smells are defined as poor design and coding choices that can negatively impact the quality of a software program despite satisfying functional requirements. In this paper, we report four patterns and five code smells related to multi-language systems. Those patterns and code smells were extracted from open-source systems, developers' documentation, and bug reports. We encoded these practices in the form of patterns and code smells in the context of Java Native Interface systems.

The present paper details the process we have carried out in order to articulate, assemble, and validate design values, principles and patterns for task-based technology-enhanced language learning. During the first phase, we identified an initial set of pedagogical principles based on language acquisition theories, computerassisted language learning literature, and pedagogical approaches to teaching second and foreign languages enhanced by the use of technology. Following a Delphi study, we refined the initial set of principles after running two rounds of consultations to a group of experts in order to achieve general consensus about the principles. After reaching consensus and assembling a list of sixteen principles, we focused on deriving values and epistemic principles from them. The next step in the process of unveiling a signature pedagogy (Shulman, 2005) for technology-enhanced language teaching involved eliciting concrete examples of practices from language teachers embodying the principles, and extract design patterns from these. One of the authors, who has a broad expertise as language educator in computer-assisted language learning and computer-mediated communication, offered several examples of practices and problems which derived into the six patterns we will present in this article. Finally, the six design patterns were linked back with the pedagogical principles.

Self-sovereign identity is a new identity management paradigm that allows entities to really have the ownership of their identity data and control their use without involving any intermediary. Blockchain is an enabling technology for building self-sovereign identity systems by providing a neutral and trustable storage and computing infrastructure and can be viewed as a component of the systems. Both blockchain and self-sovereign identity are emerging technologies which could present a steep learning curve for architects. We collect and propose 12 design patterns for blockchain-based self-sovereign identity systems to help the architects understand and easily apply the concepts in system design. Based on the lifecycles of three main objects involved in self-sovereign identity, we categorise the patterns into three groups: key management patterns, decentralised identifier management patterns, and credential design patterns. The proposed patterns provide a systematic and holistic guide for architects to design the architecture of blockchain-based self-sovereign identity systems., Comment: Accepted by European Conference on Pattern Languages of Programs 2020

Oftentimes information disclosures describing personal data-gathering research activities are so poorly designed that participants fail to be informed and blindly agree to the terms, without grasping the rights they can exercise and the risks derived from their coopera- tion. To respond to the challenge, this article presents a series of operational strategies for transparent communication in line with legal-ethical requirements. These “transparency- enhancing design patterns” can be implemented by data controllers/researchers to maximize the clarity, navigability, and noticeability of the information provided and ultimately empower data subjects/research subjects to appreciate and determine the permissible use of their data.

In the domain of autonomous unmanned vehicles, some design patterns emerge from various distinct software designs. These patterns are the result of the search for modularity and, in consequence, customisation. They point to the possibility of a more general architecture and design process that are able to comply to at least most of design requirements made for unmanned vehicles, including regulatory ones. This paper explores the possibility of proposing this modular and customisable architecture as a simpler approach to responding to design requirements.

In this article we discuss the distinction between human delegation modes of single and multiple unmanned vehicles (UV). To describe the co-agency of humans and highly automated unmanned systems (i.e. human autonomy teaming, HAT) a design and description language for HAT design patterns will be used to describe and distinguish between control modes of tasking, teaming and swarming. Concerning tasking, we advocate for a scalable delegation concept. A distinction of multi-UV teaming and swarming will be made from a human user’s perspective. Finally, we will briefly report on some preliminary results from human-in-the-loop experimentation in our fast-jet research simulator, involving the cockpit-based control of UVs and swarms.

Energy consumption of software is receiving more attention as concerns regarding climate change increase. One factor that significantly impacts how much energy is expended by a software application is the design of the software itself. Existing studies find few consistent results regarding the impact of common refactorings on energy consumption, nor do they define a concrete set of metrics that measure the energy efficiency of software. In this paper, we present the results of preliminary experiments that explore the Replace Inheritance with Delegation refactoring, and its inverse, to assess the impact these design-level refactorings have on energy consumption in the Java programming language. In the tested programs, inheritance proved to be more energy efficient than delegation, with a reduction in run time of 77% and a reduction in average power consumption of 4%. We subsequently propose a research plan to further explore this problem and observe a number of specific challenges in this area. The primary goals of this research are threefold: (i) to investigate how redundancy in an object-oriented design can contribute to unnecessary energy consumption, (ii) to determine how refactoring of the software can remove this redundancy, and (iii) to develop a general-purpose automated tool to perform this refactoring.

In object-oriented languages, constructors often have a combination of required and optional formal parameters. It is tedious and inconvenient for programmers to write a constructor by hand for each combination. The multitude of constructors is error-prone for clients, and client code is difficult to read due to the large number of constructor arguments. Therefore, programmers often use design patterns that enable more flexible object construction---the builder pattern, dependency injection, or factory methods. However, these design patterns can be too flexible: not all combinations of logical parameters lead to the construction of well-formed objects. When a client uses the builder pattern to construct an object, the compiler does not check that a valid set of values was provided. Incorrect use of builders can lead to security vulnerabilities, run-time crashes, and other problems. This work shows how to statically verify uses of object construction, such as the builder pattern. Using a simple specification language, programmers specify which combinations of logical arguments are permitted. Our compile-time analysis detects client code that may construct objects unsafely. Our analysis is based on a novel special case of typestate checking, accumulation analysis, that modularly reasons about accumulations of method calls. Because accumulation analysis does not require precise aliasing information for soundness, our analysis scales to industrial programs. We evaluated it on over 9 million lines of code, discovering defects which included previously-unknown security vulnerabilities and potential null-pointer violations in heavily-used open-source codebases. Our analysis has a low false positive rate and low annotation burden. Our implementation and experimental data are publicly available.

The goal of this paper is to present a vision of research and associated practice that is intended to help transcend many of the barriers that are preventing society from adopting the sustainable goals that will help them survive, and even thrive in the coming decades. We believe the research enterprise could be expanded to meet contemporary needs, and to see it as more of a collaborative undertaking involving thinking, implementing, monitoring and evaluations of interventions with larger groups of people (not only specialists) and would be more focused on social benefit. The approach integrates social practices with technological support. It is intended to help us work effectively given the constraints that exist today. It is intended to be flexible enough to change with the times and to help create the opportunities to create these changes. It is to be built on the idea of patterns and pattern languages, an evolving paradigm that can help provide a shared vocabulary that can promote shared goals and methodologies, and, above all, shared visions. Patterns are highly influential in the technology sector, and we believe they can be broadly used by communities to address the pressing issues of our time. These range from building an effective healthcare system, to reforming economic activity towards the public interest so as to address the climate emergency.

In this paper an extension of the design method graph-based design languages is proposed. This is realized by adding object-oriented class methods and interface mechanisms to the design method. Additionally, graphical mechanisms for modeling and calling the methods are proposed. This allows object-oriented design patterns to be transferred to the product design, where they improve the handling of complexity in the product engineering. As result, the proposed extension enables modularization and reuse of engineering knowledge, the integration of engineering domains is enhanced and multi-stakeholder collaboration with security access control (information security) becomes feasible.

In recent years, there has been an immense demand for unique designs across creative industries. This demand for designs is significantly fueled by social media trends, innovations in technology, industry and consumer psychology. Most of the designs patterns from the industry are curetted by designers. Therefore, there is an increased need for designers to create unique patterns based on user preferences in the shortest time possible. The proposed system described in this paper is intended to build a artificial neural network with three fully connected hidden layer to generate unique hybrid design patterns with the help of an input image from the user. The designs that are created through this network of neurons are called as hybrid designs because these patterns are generated by specialized algorithms having image transformation techniques like pencil sketch, watercolor and pattern merge. Thus the generated images ends up being ranked by the user making the model learn with updated weights every time the preferences are changed. The primary goal of utilizing this network is to improve deal through insightful automation in designing patterns.

As neuroscience datasets continue to grow in size, the complexity of data analyses can require a detailed understanding and implementation of systems computer science for storage, access, processing, and sharing. Currently, several general data standards (e.g., Zarr, HDF5, precompute, tensorstore) and purpose-built ecosystems (e.g., BossDB, CloudVolume, DVID, and Knossos) exist. Each of these systems has advantages and limitations and is most appropriate for different use cases. Using datasets that don’t fit into RAM in this heterogeneous environment is challenging, and significant barriers exist to leverage underlying research investments. In this manuscript, we outline our perspective for how to approach this challenge through the use of community provided, standardized interfaces that unify various computational backends and abstract computer science challenges from the scientist. We introduce desirable design patterns and our reference implementation called intern.

The frequency with which people interact with technology means that users may develop interface habits, i.e. fast, automatic responses to stable interface cues. Design guidelines often assume that interface habits are beneficial. However, we lack quantitative evidence of how the development of habits actually affect user performance and an understanding of how changes in the interface design may affect habit development. Our work quantifies the effect of habit formation and disruption on user performance in interaction. Through a forced choice lab study task (n=19) and in the wild deployment (n=18) of a notificationdialog experiment on smartphones, we show that people become more accurate and faster at option selection as they develop an interface habit. Crucially this performance gain is entirely eliminated once the habit is disrupted. We discuss reasons for this performance shift and analyse some disadvantages of interface habits, outlining general design patterns on how to both support and disrupt them.Keywords: Interface habits, user behaviour, breaking habit, interaction science, quantitative research., 32 pages, 8 figures, to be published in the International Journal of Human Computer Interaction

The notion to digitally articulate, execute, and enforce agreements with smart contracts has become a feasible reality today. Smart contracts have the potential to vastly improve the efficiency and security of traditional contracts through their self-executing autonomy. To realize smart contracts several blockchain-based ecosystems exist. Today a prominent representative is Ethereum. Its programming language Solidity is used to capture and express contractual clauses in the form of code. However, due to the conceptual discrepancy between contractual clauses and corresponding code, it is hard for domain stakeholders to easily understand contracts, and for developers to write code efficiently without errors. Our research addresses these issues by the design and study of a domain-specific smart contract language based on higher level of abstraction that can be automatically transformed to an implementation. In particular, we propose a clause grammar close to natural language, helpful coding abstractions, and the automatic integration of commonly occurring design patterns during code generation. Through these measures, our approach can reduce the design complexity leading to an increased comprehensibility and reduced error susceptibility. Several implementations of exemplary smart contract scenarios, mostly taken from the Solidity documentation, are used to demonstrate the applicability of our approach.

Containers are a method of virtualization. Advantages of containers include increasing utilization of bare-metal resources, and adding security isolation properties to various types of systems. These advantages make containers well-suited for applicable Internet-of-Things devices. This paper defines and describes our ‘kill switch’ Internet-of-Things container architecture pattern, aimed at enforcing multiple modes of application functionality. To our knowledge, this is a new and novel pattern that could lead to further research in the area. An example implementation that modifies the Docker engine, and an implementation using a Go script demonstrate that implementing the kill switch is feasible and achieves desired functionality.

The use of collaborative tools has notably increased recently. It is common to see distinct users that need to work simultaneously on shared documents. In most cases, large companies provide tools whose implementations have been a very complicated and expensive task. Likewise, their platform deployment requirements should be robust hardware infrastructures. It becomes even more critical when their main target is to reach scalability and highavailability. Therefore, this study aims to design and implement a microservices-based collaborative architecture using assembled containers in the cloud, enabling them to deploy Etherpad instances to guarantee high availability. To ensure such a task, we developed and optimized a central management system that creates Etherpad instances and continuously interacts with other Etherpad tools running on Docker containers. This design goes from the monolithic Etherpad instantiation and handling towards a service architecture, where every Etherpad is offered as a microservice. Furthermore, the management system follows (implements) the Observer, Factory Method, Proxy, and Service Layerpopular design patterns. This allows users to gain more privacy through access to validations and shared resources. Our results indicate both the correct operation in the automation of containers’ creation for new users who register in the system and quantifiable improvement in performance., The funding of this research is provided by the Mobility Regulation of the Universidad de las Fuerzas Armadas ESPE, from Sangolquí, Ecuador

Building blockchain-based applications and deciding which elements of an architecture should employ blockchain technologies poses several challenges. Architectural design decisions have a strong impact on quality attributes such as privacy, operational cost, transparency, risk and user experience (UX). To deal with these challenges, we propose a structured approach using existing architectural concepts such as strategies, tactics and design patterns and illustrate their application using the Meta-Transaction design pattern. Meta-Transactions are cryptographically signed function calls (i.e. transactions) a user sends to a backend. The backend submits the transaction to the blockchain and pays the fees on behalf of the user. Due to the cryptographic signature, the backend is not able to manipulate the function name or its parameters, thus acting as a trustless proxy. Several other design patterns exist in the area of blockchain-oriented applications but it remains unclear how to decide which are suitable for a given use case and how quality attributes of the resulting system are affected. By using the Meta-Transaction design pattern as an example, this paper motivates why Blockchain Tactics and corresponding design patterns are necessary and help to structure best practices and common solutions for challenges of using blockchain technology.

Empirical experience regarding how real-life performance issues are caused and resolved can provide valuable insights for practitioners to effectively and efciently prevent, detect, and fx performance issues. Prior work shows that most performance issues have their roots in poor architectural decisions. This paper contributes a large scale empirical study of 192 real-life performance issues, with an emphasis on software design. First, this paper contributes a holistic view of eight common root causes and typical resolutions that recur in different projects, and surveyed existing literature, in particular, tools, that can detect and fx each type of performance issue. Second, this study is frst-of-its-kind to investigate performance issues from a design perspective. In the 192 issues, 33% required design-level optimization, i.e. simultaneously revising a group of related source fles for resolving the issues. We reveal four design-level optimization patterns, which have shown different prevalence in resolving different root causes. Finally, this study investigated the Return on Investment for addressing performance issues, to help practitioners choose between localized or design-level optimization resolutions, and to prioritize issues due to different root causes. &nbsp

Online status indicators (OSIs) improve online communication by helping users convey and assess availability, but they also let users infer potentially sensitive information about one another. We surveyed 200 smartphone users to understand the extent to which users are aware of information shared via OSIs and the extent to which this shapes their behavior. Despite familiarity with OSIs, participants misunderstand many aspects of OSIs, and they describe carefully curating and seeking to control their self-presentation via OSIs. Some users further report leveraging OSI-conveyed information for problematic and malicious purposes. Drawing on existing constructs of app dependence (i.e., when users contort their behavior to meet an app's demands) and app enablement (i.e., when apps enable users to engage in behaviors they feel good about), we demonstrate that current OSI design patterns promote app dependence, and we call for a shift toward OSI designs that are more enabling for users.

In this paper we describe the design and evaluation of The Next Fairy Tale (TNFT) VR, a theatrical interactive storytelling system created in virtual reality and informed by performing arts theories. TNFT was designed to produce opportunities for interactors to experience role-taking and character identification using design principles drawn from actor training and theatrical performance. We report the results of a pilot qualitative study of interactors using TNFT to explore the elements of the design that supported or hindered roleplaying behavior. We identify four design patterns that supported roleplaying in the system: (1) using explicit roles to set player expectations, (2) embracing the "mask and the mirror" effect, (3) attending to visual and interactional details, and (4) easing the player gently into the roleplaying experience. These patterns speak to a broader need to support roleplay through explicit scaffolding of desired player behaviors in digital narrative experiences.

Community engagement has been widely discussed in both academic and practitioner literature, in particular around the types of tools, techniques, and methods used to undertake engagement. The practice of community engagement is at risk of becoming fragmented if there is a disconnection between the engagement objectives, the mechanisms used for people to interact, and the outcomes that ultimately contribute towards decision-making. Building on their previous work, including an established set of dynamic design patterns for situated, digitally augmented community engagement, authors propose a smart engagement ecosystem as a conceptual model that has the ability to connect people through physical, digital, online, and hybrid engagement approaches. The model postulates that participation between these various approaches are non-linear and reactive; where each approach can be used individually or collectively within the ecosystem. The chapter discusses how this capability can be leveraged within our smart engagement ecosystem model to connect, engage, and interact with local communities.

In order to teach software design in a part-time bachelor program we have to consider different conditions. Part-time students start with various practical experiences and heterogeneous knowledge. They differ in age and come from various corporate cultures. At the same time, advances in digitization drive new approaches in education. Over the last five years, we have implemented a step-by-step transformation process that led us from a blended learning environment to a flipped classroom model. One outcome of this transformation process was the positive impact of using inductive learning methods. In our paper, we present a novel didactic model which combines the well-known flipped classroom concept with aspects of inductive learning. Based on our approach we run two consecutive software design courses over a period of two semesters. The evaluated results show a high acceptance among our students. Because of this success, we decided to make our examples available on GitHub as an Open Educational Resource (OER).

Privacy patterns have become a cornerstone of the Privacy by Design paradigm realization by being used in different methodologies, strategies, tools, and many other privacy engineering proposals reported in the state-of-the-art. While these proposals treat the privacy patterns as ready-to-use components, their application is far from trivial. Overlooking the effort required to put privacy patterns into action could hinder their adoption and thus the success of all the proposals based on them. In spite of that, the application of privacy patterns has not been studied before. In this work, we firstly study the aspects influencing the application of patterns based on previous experiences reported in the close and more mature domain of security patterns. Then, we propose a framework for enhancing the application of patterns. This framework is used as a reference to analyze the current state of the privacy-pattern domain, including the solutions that are already available and the drawbacks still hindering their application. Finally, future steps in this area are discussed.

It has been argued that people are more inclined to accept a robot in their daily lives and even their home, if they have the feeling that the robot's behavior and interaction style matches their characteristics, needs and abilities. The concept of personalization has been introduced in order to create such personal, tailored human-robot interactions (HRI). Personalizing HRI means that robot takes into account individual user characteristics and can adjust its behavior to the situation and the human interaction partner. Previous HRI research indicates that personalization can have positive effects on the user experience during HRI as well as the user's attitudes towards and perceptions of the robot. This workshop is aimed at discussing the value of and exchanging ideas about the concept of personalization for HRI design. More concretely, we want to explore tools, methods and processes for appropriate robot behavior design and interaction modelling for personalized HRI. The workshop uses interactive, creative activities inspired by design thinking and participatory design to promote collaboration and co-creation between the participants and to inspire new, innovative perspectives on personalized HRI.

In game development, mechanics are one of the basis of the entertainment experience. However, the cost of implementing, improving, and refactoring economy mechanics is high because solutions cannot be easily reused across products. We argue that a reference architecture reduces this cost by providing knowledge reuse in addition to software reuse. To achieve that, we designed Unlimited Rulebook, a reference architecture for economy subsystems in games. It builds on established techniques such as Predicate Dispatching, the Entity-Component-System pattern, and the Adaptive Object-Model architectural style to facilitate the addition and modification of entity types and mechanics to the game while reducing the cost of changing existing code. We evaluated this cost reduction empirically via quasi-experiments with university students in two game programming courses.

Architectural and design patterns are the building blocks of modern software systems. Understanding patterns applied in these systems is critical to comprehend their architecture. Current research is not adequately addressing either the architecture recovery and comprehension problem nor the pattern detection problem. What makes it more complicated is the gaining popularity of new language and multiple languages, which makes existing pattern recognition techniques infeasible. Our vision is to allow developers to interactively understand the complexity of a software system by grasping the key abstractions of the system and extracting the associated design spaces and patterns. The long-term objective is to create an interactive and language-independent pattern-oriented architecture recovery framework. We propose to standardize the design structure framed by major patterns, against which the user can detect the variation of design patterns and potential violations.

Design patterns commonly pre-owned in Object-Software oriented Development. It provides Information helping to overcome recurrent design challenges (problems). Recognition of patterns can be described as identification and representation of information based on knowledge obtained from statistical data derived from patterns. Detection of design patterns provides the advantages of an extensive investigation of object-oriented software applications. When using various pattern detection techniques depending on static research issues to identify patterns it detects similar pattern structures. For this, we seek to identify patterns in design of Software by using classification-based methods and information metrics. The JHotDraw, QuickUML, and Junit of object-oriented software are used to detect software problems in the patterns of designing a Software. The datasets are manual creations which are designed utilizing software criteria for classifying learners. It is carried out in two steps, namely the development of a statistics-oriented dataset and the identification of trends in software trends in software design. Tests are carried out by Usage of 3 open source computer programs to test the process, then the tests are examined.

LEGO Mindstorms robots are widely used as educational tools to acquire skills in programming complex systems involving the interaction of sensors and actuators, and they offer a flexible and modular workbench to design and evaluate user&ndash, machine interaction prototypes in the robotic area. However, there is still a lack of support to interoperability features and the need of high-level tools to program the interaction of a robot with other devices. In this paper, we introduce Legodroid, a new Java library enabling cross-programming LEGO Mindstorms robots through Android smartphones that exploits their combined computational and sensorial capabilities in a seamless way. The library provides a number of type-driven coding patterns for interacting with sensors and motors. In this way, the robustness of the software managing robot&rsquo, s sensors dramatically improves.

In cooperative driving, vehicles coordinate their actions as part of a system. Cooperative driving capabilities in vehicles are achieved by means of software, making this software safety critical. The current safety standard for vehicles, ISO 26262, is designed for individual vehicles and their software architecture, but not for cooperative driving settings. Moreover, the guidelines from the standard can only be used for generating safety goals and checking adherence to them. The standard's guidelines do not cover mechanisms to meet the unmet safety goals or provide designers with available architecture choices.This paper presents an extension of the ISO 26262 standard from a single vehicle setting to a cooperative vehicle setting. We also show that the use of safety tactics and design patterns, which enable designers to be aware of possible design choices, can seamlessly be integrated into the ISO 26262 process. The resulting methodology enables designers to make informed choices and cover safety goals. Our case study on the software architecture of a real-life cooperative driving prototype shows that the proposed approach can provide new insights about its safety and mechanisms to improve it.

It can be difficult to critically reflect on technology that has become part of everyday rituals and routines. To combat this, speculative and fictional approaches have previously been used by HCI to decontextualise the familiar and imagine alternatives. In this work we turn to Japanese Shinto narratives as a way to defamiliarise voice assistants, inspired by the similarities between how assistants appear to 'inhabit' objects similarly to kami. Describing an alternate future where assistant presences live inside objects, this approach foregrounds some of the phenomenological quirks that can otherwise easily become lost. Divorced from the reality of daily life, this approach allows us to reevaluate some of the common interactions and design patterns that are common in the virtual assistants of the present., Comment: 11 pages, 2 images. To appear in the Extended Abstracts of the 2020 CHI Conference on Human Factors in Computing Systems (CHI '20)

Design pattern is still actively discussed in software engineering academic research. The highlight of research that still gains attention is the use of design patterns as a learning medium to improve object-oriented design skills among fresh developers or novices. This paper focuses on the design of a learning model for design pattern selection. The main objective of the proposed model is to reduce the learning curve on design pattern application. Selected cognitive methods are implemented to minimize the cognitive complexity throughout the pattern selection process. This is aimed to assist novices in learning the process of matching the design problem to design pattern. This learning model will be utilized as a practice for novices to gain expert design skills from diverse design approaches through design patterns. The learning model simplifies the pattern selection process which comprises of three sub-processes; 1) Identify design strategy 2) Identify design scope and 3) Identify design intention. In each sub-process, potential words indicating design flaws are highlighted to guide novices in identifying the underlying design issues in the attended problem. The keywords highlight feature enables novices to highlight correct information within the design problem that leads to the identification of the right solution from design patterns.

This paper presents a level generation method for Super Mario by stitching together pre-generated "scenes" that contain specific mechanics, using mechanic-sequences from agent playthroughs as input specifications. Given a sequence of mechanics, our system uses an FI-2Pop algorithm and a corpus of scenes to perform automated level authoring. The system outputs levels that have a similar mechanical sequence to the target mechanic sequence but with a different playthrough experience. We compare our system to a greedy method that selects scenes that maximize the target mechanics. Our system is able to maximize the number of matched mechanics while reducing emergent mechanics using the stitching process compared to the greedy approach., 10 pages, 7 figures, submitted to Foundations of Digital Games Conference

Design patterns are tried and tested solutions that are used to tackle common object-oriented programming (OOP) problems. However, many computer science students struggle to learn and apply these patterns in large projects. Part of the challenge in learning design patterns is that the syntactic complexity of OOP languages can distract students from connecting the abstract design concepts to the code they are writing. A further challenge is that existing resources for teaching design patterns are often static and do not illustrate the dynamic nature of OOP. A review of the literature reveals a need for a greater focus on visual metaphors to teach design patterns, while still allowing students to interact with code. This paper describes a novel educational tool that teaches design patterns through a combination of real-world metaphors and scaffolded programming exercises. We evaluate our tool using a pre- and post-survey design and find that use of our tool leads to higher levels of confidence in applying design patterns in practice.

Design patterns (DPs) encapsulate valuable design knowledge of object-oriented systems. Detecting DP instances helps to reveal the underlying rationale, thus facilitates the maintenance of legacy code. Resulting from the internal similarity of DPs, implementation variants, and missing roles, approaches based on static analysis are unable to well identify structurally similar instances. Existing approaches further employ dynamic techniques to test the runtime behaviors of candidate instances. Automatically verifying the runtime behaviors of DP instances is a challenging task in multiple aspects. This paper presents an approach to improve the verification process of existing approaches. To exercise the runtime behaviors of DP instances in cases that test cases of legacy systems are often unavailable, we propose a markup language, TSML (Test Script Markup Language), to direct the generation of test cases by putting a DP instance into use. The execution of test cases is monitored based on a trace method that enables us to specify runtime events of interest using regular expressions. To characterize runtime behaviors, we introduce a modeling and specification method employing Allen's interval-based temporal relations, which supports variant behaviors in a flexible way without hard-coded algorithms. A prototype tool has been implemented and evaluated on six open source systems to verify 466 instances reported by five existing approaches with respect to five DPs. The results show that the dynamic analysis increases the F 1 -score by 53.6% in distinguishing similar DP instances.

Blockchain technology is an emerging technology that allows new forms of decentralized architectures, designed to generate trust among users, without the intervention of mediators or knowledge between the parties. Since 2015, thanks to the introduction of Smart Contracts by Ethereum, it is possible to run programs on the blockchain, greatly extending the potential of this technology. The programming of Smart Contract, through the Solidity language is different from the traditional one. First of all, any action that requires to modify the blockchain costs gas, which corresponds to a fraction of the currency used by that given blockchain, and therefore to real money. Gas optimization is a unique challenge in this context and has obvious implications. This document aims to provide a set of design patterns and tips to help gas saving in developing Smart Contracts on Ethereum. The provided patterns are presented divided into five main categories, based on their features.

The design space of human-robot interaction is large and multi-dimensional. A sound design requires a systematic theory-driven exploration, specification and refinement of design variables. There is a need for a practical method and tool to iteratively specify the content of the dialogue (e.g., speech acts) with the accompanying expressive behavior (e.g., gesture openness) as prescribed by social science theory, e.g., task- and person-oriented communication. This paper presents an iterative interaction-design (ID) method for multi-modal robot communication. Following the ID-method, a designer first creates his/her "own" individual design and, subsequently, provides an iteration to the evolving iterative design. To support the design method, we developed an ID-tool (available for download). The tool support entails (a) selecting the theory-based communication style; (b) creating and linking the dialogue act components for the concerning use case; and (c) setting the associated expression parameters.We conducted a study with Industrial Design students (N = 13) who followed the ID-method and used our tool to design person- and task-oriented communications for a reception robot. Our method produced distinctive task- and person-oriented dialogue styles, i.e., provided the predicted theory-based multi-modal communicative behaviors. The task-oriented style showed a more formal, shorter and less chatty communication. Overall, there was a rather smooth design convergence process, in which the individual designs were harmonized into the iterative design. For the selected design problem, the ID-tool had a satisfactory usability. Next steps include validation of the communication styles in an empirical study and, subsequently, identification of reusable design patterns.