Search

The term Dark Pattern has been used to define design patterns intentionally created to deceive users or favor the interests of parties other than users. Dark Patterns present socio-technical characteristics as something that happens when humans interact with technical artifacts in a given environment, causing annoyance, frustration, anger, and other emotions in users. Comprehending Dark Patterns require us to look at them from different perspectives, in a multifocal way, considering social and technical aspects in an intertwined way. In this paper, we apply the Semiotic Framework to analyze and discuss Dark Patterns from a socio-technical perspective. We use a popular Dark Pattern called Roach Motel to exemplify our discussion, unraveling it with the Semiotic Framework. Results show the complexity of the topic and exemplify the potential of a socio-technical approach to understand, characterize and advance our knowledge on it.

In software development for people with Autistic Spectrum Disorder (ASD), it is necessary to consider specific design aspects that enable the use of web and mobile applications by such users. However, only a small part of current websites and applications is adequately designed considering the needs of these users. In this paper, we extracted quality user interface attributes regarding autistic users from guidelines found in human computer interaction literature. Based on these attributes, and through the analysis of real applications specifically designed for autistic users found in Brazil, we created new design patterns presenting practitioners with problems, solutions and examples in order to support the development of more appropriate user interfaces for ASD users. We evaluated these patterns from the point of view of practitioners involved in caring for autistic people and software engineers working in projects for autistic end-users. The results provide indicators of the usefulness and understandability of the proposed patterns, while allowing to identify improvement opportunities in their description. By providing a new set of user interface design patterns, we aim to contribute to the development of more accessible mobile and web applications for users with ASD.

This work aims to transfer design attributes and styles within and across visual documents such as slides, graphic designs, and non-photorealistic renderings. Consistent style across elements is a hallmark of good graphic design. Many visual stylistic design patterns exist throughout visualizations, presentations, and interactive media experiences (games, visual novels). These patterns often exist in visual style guides, brand guides, and concept art. However, except for structured document layouts (e.g., HTML/CSS), design tools often do not enforce consistent style decisions or must be manually maintained. Synchronizing style guides and designs require significant effort, discouraging exploration and the mixing of new ideas. This work introduces algorithms that recognize implicit patterns and structures in visual documents along with interfaces that let designers operate on these patterns, specifically, to view and apply design changes across pattern instances flexibly. The key benefits of visual redesign through implicit patterns are: (1) removing any dependence on upfront formal style declarations, (2) enabling extraction and distribution of implicit visual patterns, and (3) facilitating the exploration of novel visual design concepts through the mixing of styles.

Context: Static analysis tools (SATs) have become commonly used to locate defects in source code. Many SATs allow for development of custom static analysis rules, which intend to help users to find application-specific defects. However, custom static analysis rules are not well adopted in practice. One possible reason for the low adoption is the difficulty to develop custom rules. Aims: In this paper, we present Source Code Pattern Language (SCPL), a pattern-finding language which uses markups in code examples, instead of more complex abstractions, to facilitate development of custom static analysis rules. Method: SCPL uses markups in the source code and tree isomorphism methods to locate the patterns. In order to perform a proof-of-concept, we developed custom static analysis rules to automatically check four GoF design patterns. Result: We spent approximately 30 man-hours to develop 33 custom static analysis rules that automatically check the four design patterns. Conclusion: SCPL provide a rich feature set and potentially facilitates the programming of custom static analysis rules by using markups directly in source code. Video: https://youtu.be/B-Ovi3zurnM

Blockchain is a disruptive technology that offers a secure decentralized network, and allows for direct transactions between distributed entities, without the need for a trusted third party. Smart contracts are executable codes hosted on the blockchain and enable the implementation of several decentralized applications, in different domains. However, due to the complexity of contract construction, it is necessary to seek ways to facilitate and make this innovative development process robust. This paper presents Gifflar, a framework for generating smart contract code on the fly, in such a way that it allows a system to write, compile and implement blockchain contracts with a decentralized application still running. Gifflar is structured in components that implement design patterns to better define the responsibility of each one of the parts and exports a simple interaction module for contract modeling in JSON and automatic code writing using the TypeScript language. As far as we know, this framework is one of the first to generate contracts dynamically at run time. Thus, the work contributes to the state of the art by addressing a new paradigm, where systems can act as smart contract developers.

GoF Design Patterns (DPs) are optimal solutions for several recurring problems in software development. As maintenance accounts for a massive amount of development costs, understanding the impact of DPs on maintainability is key to decide whether their benefits outweigh their costs. To test the hypothesis that the Strategy DP impacts maintainability, we carried out a quasi-experiment with 19 final-year undergraduate students. Participants performed enhancement tasks in two identical versions of Java classes that differed only in that a version implemented the Strategy DP whereas another version did not. As recommended in the literature, we used effectiveness as a representative proxy of maintainability and correctness as a measure of effectiveness. We found a statistically significant correctness change between treatments. Moreover, the effect size shows that a participant is 47.7 percentage points more likely to succeed when the Strategy DP is not used. Conversely, a participant is 5.5 times more likely to fail when the DP is introduced. Unlike most related studies, our findings suggest that the Strategy DP may reduce software maintainability although these findings need to be confirmed by independent and extended replications.

Cognitive accessibility aims to make content more accessible for people with intellectual and learning disabilities. By following existing standards, it is possible to improve cognitive accessibility, making text content more readable and understandable while, at the same time, designing a more accessible user interface. In this work, cognitive accessibility design patterns and their application in the Easier web system's user interface are presented. The Easier web system, which is targeted at people with cognitive disabilities, provides a tool that assists in understanding text content. In addition to the monitoring of design techniques, user tests have been carried out in order to provide a preliminary evaluation of the level of cognitive accessibility of the Easier system's interface.

The integration of principles such as transparency and auditability in AI-systems is a challenging endeavour. The demand for guiding concepts is to be not too high-level and not too specific at the same time. In this paper, I will introduce design patterns as a promising method to meet this demand and as a guidance for the implementation of transparency and auditability in sociotechnical AI-systems. This will include the history of design patterns in urban planning and software engineering, as well as their distinguishing features. In extension to this, I outline a pattern approach for responsible AI-systems in a democratic society. This includes a sketch of possible design patterns for transparent and auditable AI-systems. Some early challenges and open questions are discussed at the end, together with the conclusion.

International audience; Variability-rich object-oriented systems are often not organized as fully-fledged software product lines, and implement their variability in a single code base using the mechanisms provided by the supporting language (e.g., inheritance overloading, design patterns). This makes variability identification and management very difficult. In this half-day tutorial open to both academics and industrials, we present how the symfinder toolchain can help one to better understand how variability is implemented in a single codebase Java system, relying solely on a specific code analysis and an adapted visualization. After presenting the underlying concepts on which symfinder is based (i.e., symmetries in code, density), the participants will be able to use the toolchain and visualize the potential variation points and variants identified by symfinder in their own projects or in provided large-scale open-source projects.

It is important to investigate effects of different interface designs not only for small sample systems but also for large real-world applications. However, it is not always possible for researchers to get direct access to these applications or relevant user data. Studies investigating possible negative effects such as keeping users occupied longer or making them spent more money might not get the consent of the application’s creator. We present a technical architecture and an open source implementation to conduct comparative studies on external apps by enabling researchers to turn specific interface elements on and off. The current implementation requires that the target app is available as a web app and that the study participants access it through a custom Android app. While the framework is not limited to a certain app, we use Instagram as an example and present results from a proof-of-concept study showcasing the framework.

Parser combinators are a popular and elegant approach for parsing in functional languages. The design and implementation of such libraries are well discussed, but having a well-designed library is only one-half of the story. In this paper we explore several reusable approaches to writing parsers in combinator style, focusing on easy to apply patterns to keep parsing code simple, separated, and maintainable.

Quests are a popular topic of study in many academic fields. However, literature has not settled on the elements in a quest, much less a specific definition or even debate between two or three definitions. The purpose of this paper is to take a preliminary quest definition from our previous work, and revise it to be more broadly applicable. To inform the revision, we analyze quests from a few published games. Then, we propose a few modifications to the definition which allows it to more fully explain some design patterns in games. Finally, we evaluate our definition against other definitions proposed in past research.

Smartphone apps such as Robinhood and Public that promise to “democratize investing” have risen in popularity over the past few years. These apps allow retail investors, who often possess little prior investing experience, to trade stocks, options, and other securities easily and inexpensively, often commission-free. It seems plausible that the interaction patterns of these new apps may significantly influence trading behaviors of their users. But so far, there is little formal design guidance on how such apps should be designed. This paper introduces a set of design guidelines for encouraging healthy investing behaviors by drawing on three bodies of related work: 1) findings from finance and economics literature on healthy investment practices, 2) the dual process theory from behavioral sciences, and 3) design metaphors used in interfaces with uncertain rewards. Using these guidelines, we qualitatively analyze the user interfaces of some popular investment platforms. Our analysis reveal that, unfortunately, popular trading apps generally do not follow design patterns that encourage healthier trading behaviors. We discuss design implications and opportunities for future design.

In this paper, we map out the CoCe design space - a design space for co-located collaborative games that use multi-display composition. The design space grew out of the analysis of game instances based on the 4in1 concept. First, we did a horizontal analysis of 16 game instances with 31 corresponding gameplay design patterns (GDP), followed by a vertical analysis of 89 GDPs occurring in the description of the GDP Cooperation. Through inductive analysis, we have identified four perspectives with corresponding dimensions that span the CoCe design space. By applying the CoCe design space with game instances, we illustrate how it can be used both as an analytic tool for analysis of games and also as a generative tool in the design or re-design of cooperative games that use multi-display composition.

We describe the software architecture of a toolbox of reusable components for the configuration of convolutional neural networks (CNNs) for classification and labeling problems. The toolbox architecture has been designed to maximize the reuse of established algorithms and to include domain experts in the development and evaluation process across different projects and challenges. In addition, we implemented easy-to-edit input formats and modules for XAI (eXplainable AI) through visual inspection capabilities. The toolbox is available for the research community to implement applied artificial intelligence projects.

I used to be enthusiastic about software. I liked clever, modular architectures; design patterns made for extensibility; virtualized, multi-application runtimes; seamless software updates; reusability in the harsh hardware-accelerated environments. And then, I was summoned to the automotive arena, which was in a desperate need for a centralized processing, artificial intelligence algorithms, service-oriented architectures and a fat software stack for the next-generation vehicles. It seemed like a dream job… at first. Only until I realized that to keep a promise I now need to adhere to the harsh world of reliability, safety and processes. This is a story of my software stack and me travelling, unscathed, following the challenging functional safety and reliability trail. In the keynote, I would give an initial proposal of a reliability estimation method for a Central Vehicle Computer which is dominated by software. The method would first address hardware reliability through the definition of key components, component failure rates and reliability block diagrams, which are based on current proposals of Central Vehicle Computer architectures with dual and triple redundancy, available in industry and research. Then, key software components are identified and positioned, with appropriate classification. Where appropriate, reliability of such components is estimated by means of test statistics obtained from field-trials and laboratory experiments, and also by applying software reliability growth models. Through a combined, flexible approach, inability of identifying systematic faults in modern software algorithms which are based on big data and artificial intelligence (AI) would be addressed, emphasizing the software upgrades as mandatory routine which shall be regularly performed. Finally, I would attempt to propose a common formula for easy reliability calculation in early safety case setup phases.

Many users take advantage of digital self-control tools to self-regulate their device usage through interventions such as timers and lockout mechanisms. One of the major challenges faced by these tools is the user reacting against their self-imposed constraints and abandoning the tool. Although lower-risk interventions would reduce the likelihood of abandonment, previous research on digital self-control tools has left this area of study relatively unexplored. In response, this paper contributes two foundational principles relating risk and effectiveness; four widely applicable novel design patterns for reducing risk of abandonment of digital self-control tools (continuously variable interventions, anti-aging design, obligatory bundling of interventions, and intermediary control systems); and a prototype digital self-control tool that implements these four low-risk design patterns.

Imagine buying flowers for a loved one. After selecting a bouquet, at checkout you discover that the site sneaked a paid greeting card into your shopping cart. This is an example of a dark pattern, an interface designed to manipulate a user into behavior that goes against their best interests. The notion of dark patterns has fostered a growing critical discussion about which interfaces go too far in exploiting the user. The first aim of this workshop at CHI 2021 is to bring together a transdisciplinary group of design practitioners and researchers to discuss dark patterns across domains. The second aim is to identify actions to address dark patterns from within the design community, which might include e.g., setting industry norms, articulating values during the design process, or incorporating dark patterns into design education curricula. The third aim is to look beyond the design community and consider what changes designers might advocate for via interactions with e.g., consumers, media, and policymakers.

During the User interface (UI) design process, designers use UI design patterns for conceptualizing different UI wireframes for an application. This paper introduces Akin, a UI wireframe generator that allows designers to chose a UI design pattern and provides them with multiple UI wireframes for a given UI design pattern. Akin uses a fine-tuned Self-Attention Generative Adversarial Network trained with 500 UI wireframes of 5 android UI design patterns. Upon evaluation, Akin’s generative model provides an Inception Score of 1.63 (SD=0.34) and Frechet Inception Distance of 297.19. We further conducted user studies with 15 UI/UX designers to evaluate the quality of Akin-generated UI wireframes. The results show that UI/UX designers considered wireframes generated by Akin are as good as wireframes made by designers. Moreover, designers identified Akin-generated wireframes as designer-made 50% of the time. This paper provides a baseline for further research in UI wireframe generation by providing a baseline metric.

Most CS education initiatives focus primarily on teaching raw computational skills and domain knowledge. While this is certainly important, it ignores the creative and real-world aspects that are needed for applying skills to societal problems, and for attracting more diverse populations of students. One way to impart this type of learning is through undergraduate research. Unfortunately, these opportunities are limited and hard to scale due to their need for mentorship. In this paper, we introduce exploratory reading groups as a way to support creativity and intrinsic motivation in a scalable manner. In contrast to graduate journal clubs, exploratory reading groups are designed for broad exploration of ideas, and their lightweight, student-driven nature makes them easily scalable. We present design patterns for structuring groups learned over a two-year time period of running and iterating on exploratory reading groups through a user-centered process. This time period saw the program grow from a group of 6 students to having served over 260 students, all participating completely voluntarily. In surveys and interviews of participants, we found that students valued the experience tremendously, but that successful exploration took on diverse meanings. We found that surprisingly strong relational ties developed from a simple intervention, and describe three clusters of participant motivations and experiences that emerged.

This paper summarizes an experience in designing and delivering a course "Software Development Essentials", a second year computer science course designed to teach software engineering skills without a project component. This paper describes the motivation, design, and implementation of the course. This course was offered as a pilot course that enrolled approximately 65 students at the University of Virginia. The need for the course emerged as we found many later project-centric courses assumed students already had knowledge and skills related to build configuration, database usage, design, version control, and incremental development, despite none of them materials being covered in our intro programming sequence. Further, in the project-centric software engineering course (typically a third-year course), students often were expected to start on a project before concepts such as design principles, design patterns, and incremental development were covered. Thus, students were often learning these principles and techniques after they had already been working on a project for weeks, and often too late to implement these into the project naturally. This course is not intended to replace a software engineering course. Rather, this course is intended to prepare students for future project courses, including a software engineering course. In this paper, we describe our experience designing and delivering this course in the Spring semester 2020. We review both student and faculty feedback of the course, and what changes may be made when this course is made available in the future to a large population of students.

In a majority of Indian Engineering colleges, Software Engineering tends to be considered as a theoretical course. More specifically, software design is taught using traditional lecture based teaching methods with minimal hands-on experience on working with team based projects. As part of this paper, we share our experiences in teaching code smells and design patterns using project-based learning approach to students in a Software Engineering course. We tracked students’ ability to detect code smells and codify design patterns through code evaluation. A confidence survey conducted at the end of the course had a positive feedback. We believe the approach can be repeated across engineering colleges in India to teach Software Engineering design.

As Voice User Interfaces (VUIs) become widely popular, designers must handle new usability challenges. However, compared to other established domains such as Graphical User Interfaces (GUIs), VUI designers have fewer resources (training support, usability heuristics, design patterns) to guide them. On the other hand, GUI-trained designers may also be solicited upon to design VUIs given the increased demand for such interfaces. This raises the question: how can we best support such designers as they transition from GUI to VUI design? To answer this, we focus on usability heuristics as a key resource, and conduct several workshops with GUI design experts, exploring how they map their design experience onto VUI design. Based on this, we suggest that the “path of least resistance” to transitioning designers from GUI to VUI may be the adaptation of familiar resources and concepts (such as GUI heuristics) to the VUI design space, instead of the imposition of novel VUI-specific heuristics on GUI-trained designers. This finding can inform the development of design resources that can support the increase demand for VUIs.

Context: Coupling and cohesion concepts support the object-oriented (OO) design activity. A better design implies less coupled and more cohesive classes. Thus, it is expected studies on OO design investigate issues impacting the good application of these concepts. However, most studies in the area have focused on high-level metaphors, such as code smells and design patterns; or software metrics. Objective: This study aims to build empirical evidence reinforcing that basic concepts deserve more attention towards better OO design. The study investigates the application of coupling and cohesion concepts during programming activity. Two topics are addressed: i) how developer characteristics (“previous knowledge on the concepts” and “developers experience”) impact on software design during programming activity; and ii) the differences in applying the concepts, independently. Method: A quasi-experiment with 17 participants. The participants were graduate and undergraduate students, but all have professional experience in software development. The software they programmed was compared with the experiment’s oracle in terms of the application of coupling and cohesion concepts. Result: One finding is previous knowledge on the concepts impacts on design quality, in some way; while developers experience doesn’t. Another finding is: application of cohesion is significantly easier than application of coupling. Conclusion: A conjecture based on these findings is training on basic OO principles (including formal education) might be more relevant than developer experience towards better software design. At last, the topic needs more investigation. We suggest this approach brings a complementary perspective of analysis to discuss the topic.

Software Design Patterns (DP) are formal approaches that propose generic reusable solutions to different design problems. Building DP automatic recommendation system is one of the most challenging topics in the field of software industry to improve the final software quality. Proposing a DP for a design problem requires good base knowledge about each DP and its functionality. In this paper, we propose an approach that automatically recommends the appropriate design pattern category. The proposed approach is a Goal Question Metric (GQM) based tree model of questions. The software engineer answers these questions based on the user requirements, and finally the approach recommends the category of the suitable DP category based on our designed tree model. The GQM is responsible for weight calculation process at each node based on the questions' answers. The software engineer is responsible for delivering the user requirements to our system, via answering the proposed model. The precision and accuracy obtained by our system is 80\% while the recall is 100\%.

A fundamental requirement for both realistic modeling and immersive presence is spatial audio, correctly rendering the presentation of each object with aural characteristics. Auditory attributes involve perceived directions, distances, and the propagation paths from complex sound sources to each listener in a potentially complex 3D scene. Many long-running efforts in both hardware and software have improved the ability to aurally render high-fidelity spatialized sound in real time. Motivated by current progress, this work proposes integrating acoustic properties associated with geometric shapes together with 3D spatial sound in the X3D Graphics standard. This combination is possible by exploiting the structure and functionality of Web Audio API, an effective framework for processing and synthesizing audio in Web applications. The paper describes design patterns and initial implement work for this spatial composition of audio graphs and scene graphs. Both specifications are device neutral, without dependencies on specific platforms or audio hardware. Examples for evaluation lead to useful conclusions and areas for future model development.

Design is typically envisioned as aiming to improve situations for users, but this can fail. Failure can be the result of flawed design solutions, i.e. anti-patterns. Prior work in anti-patterns has largely focused on their characteristics. We instead concentrate on why they occur by outlining two processes that result in anti-patterns: 1) backfiring, and 2) favouring. The purpose of the paper is to help designers and researchers better understand how design processes can lead to negative impacts and to repentant designers by introducing a richer vocabulary for discussing such processes. We explore how anti-patterns evolve in HCI by specifically applying the vocabulary to examples of social media design. We believe that highlighting these processes will help the HCI community reflect on their own work and also raise awareness of the opportunities for avoiding anti-patterns. Our hope is that this will result in fewer negative experiences for designers and users alike.

Superlight clients enable the verification of proof-of-work-based blockchains by checking only a small representative number of block headers instead of all the block headers as done in simplified payment verification (SPV). Such clients can be embedded within other blockchains by implementing them as smart contracts, allowing for cross-chain verification. One such interesting instance is the consumption of Bitcoin data within Ethereum by implementing a Bitcoin superlight client in Solidity. While such theoretical constructions have demonstrated security and efficiency in theory, no practical implementation exists. In this work, we put forth the first practical Solidity implementation of a superlight client which implements the NIPoPoW superblocks protocol. Contrary to previous work, our Solidity smart contract achieves sufficient gas-efficiency to allow a proof and counter-proof to fit within the gas limit of a block, making it practical. We provide extensive experimental measurements for gas consumption. The optimizations that enable gas-efficiency heavily leverage a novel technique which we term hash-and-resubmit, which almost completely eliminates persistent storage requirements, the most expensive operation of smart contracts in terms of gas. Instead, the contract asks contesters to resubmit data and checks their veracity by hashing it. Other optimizations include off-chain manipulation of proofs in order to remove expensive look-up structures, and the usage of an optimistic schema. We show that such techniques can be used to bring down gas costs significantly and may be of independent interest. Lastly, our implementation allows us to calculate concrete cryptoeconomic parameters for the superblocks NIPoPoWs protocol and in particular to make recommendations about the monetary value of the collateral parameters. We provide such parameter recommendations over a variety of liveness settings.

Virtual Conference; International audience; Variability is present in most modern object-oriented software-intensive systems, despite that they commonly do not follow a product line approach. In these systems, variability is implicit and hardly documented as it is implemented by different traditional mechanisms, namely inheritance, overloading, or design patterns. This hampers variability management as automatic identification of variation points (vp-s) with variants is very difficult. symfinder is a symmetry-based tooled approach that enables automatic identification of potential vp-s with variants in such systems. Then, it visualizes them relying on their density in code assets. From the Java-only version presented at SPLC'2019, we present here several notable improvements. They concern an added support for C ++ systems, the identification of vp-s implemented by Decorator and Template pattern instances, an enhanced visualization (e.g., to display all variants, and package coloring), as well as automation of the mapping of potential vp-s to domain features.

UI design pattern-driven prototyping introduces the idea of utilizing UI design patterns to create rapid prototypes. In this paper, we investigated the impact of using UI design pattern-driven approach on the subjective workload of rapid prototyping. We conducted a between-group workload study (NASA-TLX) for the pattern-driven and traditional approach of rapid prototyping smartphone applications to compare the subjective workload, physical demand, mental demand, temporal demand, performance, effort, and frustration experienced by UI/UX designers. Within the pattern-driven approach, we explored the impact of using pattern libraries with and without pattern standard. Our results indicate that the subjective workload, physical demand, and effort experienced by UI/UX designers using the pattern-driven approach is significantly less than the traditional approach of rapid prototyping. However, there is no significant difference in subjective workload experienced while using UI design pattern libraries with and without pattern standard for documenting UI design patterns.

With increasing heterogeneity, the importance of data organization within a compute node has grown immensely. Recently, industry vendors have introduced technology that can present a unified shared address space for multiple physical pools of memory. In this paper, we leverage unified memory technology and characterize the performance trade-offs of host and device placement across a range of hybrid application design patterns. We perform a Roofline analysis to establish fundamental performance bounds in collaborative applications and then develop an analytical model that makes profitable placement decisions at the individual data structure level. We integrate the placement model into a runtime system and enable transparent data placement in CUDA/C++ applications. Preliminary experiments yield the following results: (i) placement policies have significant performance impact across hybrid application design paradigms (ii) placement decisions are impacted by the sparsity of data access, page re-migration, amount of latency hiding opportunities and design specific attributes such as the number of pipeline stages, and (iii) intelligent data placement can improve node performance by up to 5x on applications with sparse access patterns.

Software design patterns are solutions to common software problems that are proven to work adequately in particular scenarios. Deciding which design pattern to use for a given software problem often requires practical knowledge acquired with experience in a similar domain and can be highly subjective and error-prone. Further, for novice programmers, an automated approach would be of tremendous help as it would provide practical knowledge required for deciding which design pattern to use for a particular software problem. The majority of research in software design pattern prediction involves using software structure and features in determining which design pattern to implement. However, there are circumstances where software engineers would prefer to know which design pattern to be used by looking at the design problem during or before the implementation phase. Existing design pattern prediction tools cannot be utilized in this scenario due to the absence of code and class structures. To address this issue, this paper proposes a new approach that analyzes the context of the software problem from text and predicts a suitable design pattern for the given problem context using feature learning, neural embedding, and classification. We evaluate our approach on a case study from Stack Overflow with more than 66,000 questions that discuss problems and consequences related to 23 design patterns. Results show that our approach can predict design patterns from the text with 82% overall accuracy.

Prior research has explored potential applications of video games in programming education to elicit computational thinking skills. However, existing approaches are often either too general, not taking into account the diversity of genres and mechanisms between video games, or too narrow, selecting tools that were specifically designed for educational purposes. In this paper we propose a more fundamental approach, defining beneficial connections between individual design patterns present in video games and computational thinking skills. We argue that video games have the capacity to elicit these skills and even to potentially train them. This could be an effective method to solidify a conceptual base which would make programming education more effective.

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.

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

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.

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.

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.