EuroPLoP 2018 - List of published papers
A Collection of Multidomain Communication PatternsMichael Krisper, Johannes Iber, Jürgen Dobaj, Christian Kreiner
This paper presents a collection of patterns for multidomain communication. The collection is organized to handle different aspects of multidomain communication: decoupling of data formats, protocols, channels, timing, security, contracts, quality of service, and service discovery. For every category design patterns are depicted, which solve the problems in the context of a distributed multidomain environment. The goal is to present a concise guideline for developers and software architects and give hints which patterns may come in handy for the specific problems in the context of multidomain communication.
How to Root Effectuation Skills in Your Project TeamStefan Holtel, Erik Heinen-Konschak
Effectuation principles are a way to master situations of uncertainty. Researcher detected them by analyzing how entrepreneurs behave when pursuing business ideas. Some people intuitively perceive effectuation the way they are already working. Others consider them counterintuitive. Effectuation aficionados and practitioners either face the same predicament: People often intuitively understand how it might work. But they remain uncertain how to adapt them to working habits. They are caught by conventional mindsets. They forget about the principles while facing stress disorder, or just feel uncomfortable to change behavior from causation to effectuation. The authors' approach is two-fold: first, they summarize obstacles that hinder actually motivated people to migrate to an effectuative working style. Second, they focus on the domain of project work to match proven patterns of nudging against the core principles of effectuation. Thus, the authors create an instrument for project managers to ingrain effectuation principles into project work. For practical use, the results are provided as nine proto-pattern. Project leads could refer to this list to make effectuation thinking an integral part of daily project chores.
Wholeness Egg: Methodology of Designing Living Workshops by Differentiating the WholeTakashi Iba, Konomi Munakata
This paper introduces 'Wholeness Egg' as an effective technique for designing 'living' workshops. Christopher Alexander who explored the beauty of architecture emphasized that a creation is about making the design come to life as much as possible. He also put a significant emphasis on the wholeness and the fifteen fundamental properties which can be found in all living structures. Based on his design theory, we invented the Wholeness Egg as a methodology of designing living workshops by grasping the wholeness first and subsequently differentiating it into parts, in the way that it can achieve the properties. This paper presents how a living design is induced on a single egg-shaped diagram, by showing our Pattern-driven Dialogue Workshop as an example. It also shows that the application of this methodology helps people to externalize and open up the individuals' thinking processes and allows them to work collaboratively when designing things. We expect this paper to provide readers with a clear understanding of the Wholeness Egg with a view to using it effectively in their own practices of designing.
A Pattern Language for Blockchain-based ApplicationsXiwei Xu, Cesare Pautasso, Liming Zhu, Qinghua Lu, Ingo Weber, Sebastian Meixner
Blockchain is an emerging technology that enables new forms of decentralized software architectures, where distributed components can reach agreements on shared system states without trusting a central integration point. Blockchain provides a shared infrastructure to execute programs, called smart contracts, and to store data. Since blockchain technologies are at an early stage, there is a lack of a systematic and holistic view on designing software systems that use blockchain. We view blockchain as part of a bigger system, which requires patterns for using blockchain in the design of their software architecture. In this paper, we collect a list of patterns for blockchain-based applications. The pattern collection is categorized into four types, including interaction with external world patterns, data management patterns, security patterns and contract structural patterns. Some patterns are designed considering the nature of blockchain and how it can be specifically introduced within real-world applications. Others are variants of existing design patterns applied in the context of blockchain-based applications and smart contracts.
Microservice Patterns for Industrial Edge ApplicationsFei Li, Joachim Fröhlich, Daniel Schall, Markus Lachenmayr, Christoph Stückjürgen
The Industry 4.0 initiative is pushing traditional production systems and methodologies through fundamental changes. In traditional industries such as manufacturing, utilities, and infrastructure monitoring, customers are demanding more flexibility and greater efficiency. The software that oversees these systems addresses these demands by adopting novel architectural styles and patterns. Industrial edge systems are gaining momentum because they offer superior data security and better response time to field operations. Microservice style has been adopted from cloud services because it improves development efficiency. This paper presents architecture patterns that cover four phases in the life cycle of industrial software. In the deployment phase, DOWNSHIFTING moves microservices from the cloud to the edge. During runtime, MONITORING CONNECTORS oversee properties of microservices at the edge, such as performance and resource usage. When adaptation is needed, EDGE-TO-CLOUD LOAD BALANCING leverages cloud resources to fulfill performance expectations. When a new microservice version is deployed, TEST PROBE enables testing the microservice at the edge without interfering with ongoing operations. This paper is intended for architects, developers and practitioners who are involved in delivering software in industrial edge environments.
Patterns for Indexing Large DatasetsGarima Gaur, Sumit Kalra, Arnab Bhattacharya
Searching is one of the fundamental tasks in Computer Science. An intuitive way to search is to do it linearly, that is, start at the beginning of the dataset and continue till the searched-for item is found or nothing is found. However, as the volume of data increases, the response time of linear search is no longer acceptable. Indexes are designed to search through massive datasets quickly. There are a number of different ways of building complex and advanced indexes. Appropriate selection and modification of indexing structures according to dynamic business requirements is crucial for data-intensive applications. In this work, we present a few basic reusable indexing structures. These structures can be used to create advanced and complex indexing structures with lesser effort and time.
Engineering Software for the Cloud: Automated Recovery and SchedulerTiago Boldt Sousa, Hugo Sereno Ferreira, Filipe Correia, Ademar Aguiar
Cloud software continues to expand globally, highly motivated by how widespread the Internet is and the possibilities it unlocks with cloud computing. Still, cloud development has some intrinsic properties to it, making it complex to unexperienced developers. This research is capturing those intricacies in the form of a pattern language that gathers ten patterns for engineering software for the cloud. This paper elaborates on that research by contributing with two new patterns: AUTOMATED RECOVERY, which checks if a container is working properly, automatically recovering it in case of failure and SCHEDULER, which periodically executes actions within the infrastructure. The described patterns are useful for anyone designing software for the cloud, either to bootstrap or to validate their design decisions with the end goal of enabling them to create better software for the cloud.
Engineering Software for the Cloud: External Monitoring and Fault injectionTiago Boldt Sousa, Hugo Sereno Ferreira, Filipe Correia, Ademar Aguiar
Cloud software continues to expand globally, highly motivated by how widespread the Internet is and the possibilities it unlocks with cloud computing. Still, cloud development has some intrinsic properties to it, making it complex to unexperienced developers. This research is capturing those intricacies in the form of a pattern language, gathering ten patterns for engineering software for the cloud. This paper elaborates on that research by contributing with two new patterns: EXTERNAL MONITORING, which continuously monitors the system as a black box, validating its status and FAILURE INJECTION, which continuously verifies system reliability by injecting failures into the cloud environment and confirming that the system recovers from it. The described patterns are useful for anyone designing software for the cloud, either to bootstrap or to validate their design decisions with the end goal of enabling them to create better software for the cloud.
Patlet CardsRalf Laue
In this paper, we present the concept of patlet cards. A deck of patlet cards can be used in workshops with potential users of patterns. Each card contains the basic information about a pattern. Workshop participants can locate the cards (i.e. the patterns) that fit their needs by a simple selection system which is based on physical cards with punched-out holes or notches. We developed a set of patlet cards for the domain of didactic patterns. However, it should be possible to transfer the concept to pattern systems in other domains. Therefore, the intended audience of this paper are persons running face-to-face workshops with the purpose to select and discuss patterns that can be applied in a given context.
Patterns for Discussing and Modelling Variability in Business ProcessesRalf Laue, Kathrin Kirchner
Expressing variability in graphical process models can lead to large and complicated models even for expressing rather simple situations. However, expressing variability in process models is important in many processes. During the execution of a process, it is not uncommon that knowledge workers can decide for additional steps, change the execution order or skip a task. In this paper, we propose a set of business process variability patterns to express those situations. When communicating with business experts, the patterns can be used as building blocks which serve as placeholder for syntactically well-defined (but more complicated) model fragments in a formal language such as BPMN or CMMN. Those building bloc ks can be used for communication and later be transformed into a formal modelling language. We believe that the patterns can be useful for supporting the communication between process analysts and stakeholders who are not familiar with formal process modeling languages. If necessary, the informal models that are created in a lightweight modeling language can later be transformed into more formal models.
Interface Quality Patterns: Communicating and Improving the Quality of Microservices APIsMirko Stocker, Olaf Zimmermann, Daniel Lübke, Uwe Zdun, Cesare Pautasso
"The design and evolution of Application Programming Interfaces (APIs) in microservices architectures is challenging. General design issues in integration and programming have been covered in great detail in many pattern languages since the beginnings of the patterns movement, and service-oriented infrastructure design patterns have also been published in the last decade. However, the interface representations (i.e., the content of message payloads) have received less attention. We presented five structural representation patterns in our previous work
A Microservice Architecture for the Industrial Internet-Of-ThingsJügen Dobaj, Michael Krisper, Johannes Iber, Christian Kreiner
With the introduction of Internet-of-Things (IoT) and cyber-physical system (CPS) concepts the industrial automation sector is undergoing enormous change towards highly interconnected and globally distributed automation systems. Following this trend the industry is facing interoperability challenges between devices and systems, which origin in the market and technology fragmentation of the past years. However, established integration techniques from the IoT domain cannot be fully adapted in industrial Internet-of-Things (IIoT) environments due to stricter dependability and real time constraints. Since design patterns offer a practical means to gain a deeper understanding of the problem domain, patterns are applied in this paper to develop a software architecture that is suitable for the deployment in the upcoming IIoT environments. The resulting software architecture combines ideas from the IoT world, industrial automation systems, as well as modern information technology (IT) and cloud architectures. Its lightweight and flexible design, along with the support of state-of-the-art development approaches (containerization, continuous integration (CI), continuous deployment (CD)) make the architecture equally suitable for the deployment on cloud, fog and edge devices. All in all, these features facilitate the deployment of services and communication protocols on device level, to enable the transparent and automatic integration of heterogenous devices and protocols, on demand.
A Security Pattern for Key-Value NoSQL Database AuthorizationJulio Moreno, Eduardo Fernandez-Medina, Eduardo B. Fernandez, Manuel A. Serrano
Numerous authorization models have been proposed for relational databases. On the other hand, several NoSQL databases used in Big Data applications use a new model appropriate to their requirements for structure, speed, and large amount of data. This model protects each individual cell in key-value databases by labeling them with authorization rights following a Role-Based Access Control model or similar. We present here a pattern to describe this model as it exists in several Big Data systems.
Separation of processing and coordination in computer systemsJohannes Iber, Michael Krisper, Jürgen Dobaj, Christian Kreiner
"Systems are built for a purpose. The purpose transacted is usually handled by the processing part of a system and is observed and adjusted by coordination parts. In principle, these two kinds of system parts share the same target resource
Patterns for Implementing Uncertainty PropagationMichael Krisper, Johannes Iber, Jürgen Dobaj, Christian Kreiner
In this paper, the design patterns Uncertain Number and Propagation Strategy are presented. They are useful for storing uncertainties of values and propagating them throughout calculations in an application. Uncertain Number represents a numerical value and its respective uncertainty. Propagation Strategy represents the propagation method, to correctly propagate the uncertainty throughout an application. This is done according to the Law of Propagation of Uncertainty as defined in the Guide to Expression of Uncertainty in Measurements. This paper addresses software architects, designers and developers having to work with uncertain data e.g. coming from sensors or other measurements.
A Pattern Language for Manual Analysis of Runtime Events Using Design ModelsMichael Szvetits, Uwe Zdun
Modeling is an important activity in the software development process whose output are design artefacts that describe the resulting software from a high-level perspective. Recent research investigates the role of models at runtime and the results indicate that analysts perform better at observing the behaviour of a running system if they can utilize models during the analysis. However, setting up a system which allows the analysis of its behaviour at runtime using models involves many challenges regarding the modeling environment, the introspection infrastructure, the traceability management and the analysis integration. This paper summarizes design alternatives for implementing systems with manual analysis support by investigating recurring concepts like patterns, modeling habits, languages, middlewares and development techniques found in approaches that utilize models at runtime. We organize the gained knowledge as patterns in a pattern language which captures various issues and their solution alternatives, including their benefits and liabilities. The pattern language consists of modeling patterns for setting up the models and the environment for the analyst, introspection patterns for extracting data from the running system, traceability patterns for relating the extracted data with the models, and analysis patterns for processing the extracted data using the models. We demonstrate the application of the pattern language based on the implementation of a robot system.
A System of Privacy Patterns for Informing Users: Creating a Pattern SystemMichael Colesky, Julio Caiza
The General Data Protection Regulation mandates data protection in the European Union. This includes data protection by design and having privacy-preserving defaults. This legislation has been in force since May 2018, promising severe consequences for violation. Fulfilling its mandate for data protection is not trivial, though. One approach for realizing this is the use of privacy design patterns. We have recently started consolidating such patterns into useful collections. In this paper we improve a subset of these, constructing a pattern system. This helps to identify contextually appropriate patterns. It better illustrates their application and relation to each other. The pattern system guides software developers, so that they can help users understand how their information system uses personal data. To achieve this, we rewrite our patterns to meet specific requirements. In particular, we add implementability and interconnection, while improving consistency and organization. This results in a system of patterns for informing users.
Message Encapsulation PatternLukas Gressl, Christian Steger, Ulrich Neffe
How to change the communication behavior of devices participating in a network with an already defined topology? This question describes the fundamental problem, which the Message Encapsulation Pattern aims to solve. Network participants usually follow a client - server, or peer to peer based communication model. This model uses a dedicated application layer protocol, which defines the message types exchanged by the communicating devices. In client - server based models, the client sends requests to and receives responses from the server, thus constituting a one - way message exchange. This setup can be changed by using a different application layer protocol, or by tunneling the messages of the application layer protocol through an underlying bidirectional protocol layer. With both approaches, a peer to peer communication can be achieved. However, tunneling the existing application layer protocol has the advantage that the application does not need to change its message parsing. This tunneling approach can be found in various domains. It is not only used in the context of Internet services, but can also be found in the communication between the single components of System on Chips (SoCs), or the smart card to terminal interaction. This paper describes, how the Message Encapsulation Pattern works, its advantages and disadvantages, and how it can be used.
A Set of Patterns in Adult EducationJose Carlos Ciria Cosculluela
Adult learners have specific features that differentiate them from children and the young. This specificity has been overlooked by an overwhelming part of the theoretical and applied research on education, which focuses on the early stages of life. Consequently, adult educators face a scarcity of reference models, guidelines and training materials supporting their daily practice. This paper aims at contributing to fill this gap, by providing advice and spurring methodological and practical discussion. We discuss concerns that have arisen from our experience both as adult educators and adult learners, and propose a set of patterns to tackle them. In particular, we present a self-reference model which has guided our performance as adult educators: the Democratic Learning catalyst. Commitment to Agreement sets up a framework for the adoption of such a model and its adaptation to specific contexts. Leveraging Experience exploits experience, an invaluable asset amassed by adults, putting it at the service of the collective learning process. Awareness of Progress accounts to the participants for the outcomes of the course. It is reassuring and encouraging, strengthens their self-confidence and generates a supportive climate. Lastly, adults' knowledge gets richer and their convictions become more soundly founded by means of Enlightening Discussion.
Architecture BoardVictor Sauermann, Frank Frey, Michael Kopf
With multiple parallel running software development initiatives and products, the overview of what is going on has to be kept in sight to derive suitable architectural and technical decisions. In an environment without a proper decision-making process in several development teams, or without a clear definition of roles and responsibilities a centralized architecture board makes no sense. There is need of dedicated maturity steps to traverse through to reach the goal of a distributed realization environment with as few as possible bottlenecks due to mutual discussions with a centralized responsibility to gather knowledge about on goings even considering existing technical debts. This paper is worth considered by CTOs, chief or enterprise architects within greater software development organizations.
IoT Device Security the Hard(ware) wayMarkus Schuß, Johannes Iber, Jürgen Dobaj, Christian Kreiner, Carlo Alberto Boano, Kay Uwe Römer
"Numerous attacks on Internet of Things (IoT) devices have shown that security cannot be neglected, even when building devices with just a few kB of memory. While it is common sense to run regular software updates and use state-of-the-art security on embedded or general purpose systems, this is often not possible with IoT devices. While many of those devices have the facilities to perform over-the-air updates, their memory and processing capabilities limit the use of state-of-the-art cryptography. Additionally, these devices often lack the capabilities to secure the cryptographic keys, the foundation on which the device's security is built, which makes them even more vulnerable to attacks. In this work, we present a pattern that allows even constrained devices to utilize state-of-the-art cryptographic functions, providing the foundation for a secure Internet of Things. The identified pattern presents the following characteristics: (i) confidentiality, by offloading the cryptographic functions and key storage
Outside In and Inside Out - New hybrid education patternsChristian Kohls, Christian Köppe, Alex Young Pedersen, Christian Dalsgaard
This paper describes six patterns of hybrid education. Hybrid education is a way of overlapping and blending different concepts at the same time, such as online and offline, formal and informal. The patterns focus on bringing experience from the outside world into the classroom (outside in), and gaining experiences outside of the classroom (inside out). The patterns are part of a larger pattern language for hybrid education. In this paper, we describe the patterns Open Hybrid Classroom, Bring Your Own Assignment, Integrating Practitioners, Runaway Classroom, Street Task, and Public Exams. All of these patterns open and extend the boundaries of the traditional classroom. The classroom opens up to the public. The public becomes a classroom. Learning and applying, as well as learning from applying, are encouraged by these patterns.
Patterns of DesignJoseph Corneli, Simon Holland, Aloson Pease, Paul Mulholland, Dave Murray-Rust, Theodore Scaltsas
In a straightforward meta-level shift of focus, we use design patterns as a medium and process for capturing insight about the process of design. We survey mainstream design genres, and draw conclusions about how they can help inform the design of intelligent systems.
Business of Open Source: A Case Study of Integrating Existing Patterns Through NarrativesMichael Weiss
"This paper integrates previously published patterns (many of them documented by the author) for open source businesses through narratives. An open source business employs open source as a strategy to strengthen its business model. The paper makes three contributions: it links patterns by creating narratives of how they have been applied by different companies
And the Tool Created a GUI That was Impure and Without Form: Anti-Patterns in Automatically Generated GUIsApostolos Zarras, Georgios Mamalis, Aggelos Papamichail, Panagiotis Kollias, Panos Vassiliadis
A basic prerequisite for any daily development task is to understand the source code that we are working with. To this end, the source code should be clean. Usually, it is up to us, the developers, to keep the source code clean. However, often there are parts of the code that are automatically generated. A typical such case are Graphical User Interfaces (GUIs) created via a GUI builder, i.e., a tool that allows the developer to design the GUI by combining graphical control elements, offered in a palette. In this paper, we investigate the quality of the code that is generated by GUI builders. To assist tool-smiths in developing better GUI builders, we report anti-patterns concerning naming, documentation, design and implementation issues, observed in a study that involves four popular GUI builders for Java. The reported anti-patterns can further assist GUI developers/designers in selecting appropriate tools.
Applying Idioms for Synchronization Mechanisms. Synchronizing communication components for an N Body SimulationJorge Luis Ortega-Arjona
"The Idioms for Synchronization Mechanisms is a collection of patterns related with the implementation of synchronization mechanisms for the communication components of parallel software systems. The selection of these idioms take as input information (a) the design pattern of the communication components to synchronize, (b) the memory organization of the parallel hardware platform, and (c) the type of communication required. In this paper, it is presented the application of the Idioms for Synchronization Mechanisms to synchronize the communication components for an N Body Simulation, within the Detailed Design stage of the Pattern-based Parallel Software Design Method. In two previous papers, this method has been used in two previous stages: (a) in the Coordination Design stage, selecting the Manager-Workers architectural patterns as the coordination, which depends on the N- Body problem
Applying Architectural Patterns for Parallel Programming. Solving the Laplace EquationJorge Luis Ortega-Arjona
The Architectural Patterns for Parallel Programming is a collection of patterns related with a method for developing the coordination structure of parallel software systems. These architectural patterns take as input information (a) the available parallel hardware platform, (b) the parallel programming language of this platform, and (c) the analysis of the problem to solve, in terms of an algorithm and data. In this paper, it is presented the application of the architectural patterns along within the Coordination stage, as part of the Pattern-based Parallel Software Design Method, which aims for developing a coordination structure for solving the Laplace Equation. The Coordination stage here takes the information from the Problem Analysis presented in Section 2, selects an architectural pattern for the coordination in Section 3, and provides some elements about its implementationin Section 4.
Applying Design Patterns for Communication Components. Communicating Parallel Layer components for the Fast Fourier TransformJorge Luis Ortega-Arjona
The Design Patterns for Communication Components is a collection of patterns related with a method for developing the communication sub-systems of parallel software systems. The application of these design patterns take as input information (a) the architectural pattern of the overall parallel software system, (b) the memory organization of the parallel hardware platform, and (c) the type of synchronization required. In this paper, it is presented the application of the Design Patterns for Communication Components to communicate components for a parallel implementation of the the Fast Fourier Transform, within the Communication Design stage of the Pattern-based Parallel Software Design Method. In a previous paper, this method has been used in a previous stage, in the Coordination Design stage, selecting the Parallel Layers architectural patterns as the main coordination, which depends on the features of order in data and algorithm of the Fast Fourier Transform.
Pattern Experience Chart Generator function on a pattern language platform Patterns We Live ByYuki Kawabe, Haruka Mori, Aimi Burgoyne, Takashi Iba
"In this paper, we propose a function ""Pattern Experience Chart Generator"" necessary to realize the aim of the Pattern Language Platform ""Patterns We Live By"", which is a web application that supporting the ""practice"" of patterns by ensuring that they are always accessible. This function contributes to the long-term cycle of pattern practice. This function is the ability to generate a pattern experience chart that visualizes which patterns the user is practicing, not practicing and wants to practice. It will make the user aware of what patterns they should utilize by looking at the pattern experience chart, as well as showing the resulting growth by regenerating the chart after a certain period. By using the information obtained through this function as hints, we believe the user will become able to continuously and concretely design their ""practice"" through patterns."
A Program Backlog Story with Patterns: Expanding the Magic Backlog Pattern CollectionLise B. Hvatum, Rebecca Wirfs-Brock
This paper extends our Magic Backlog Patterns collection with three additional patterns for managing the work of a program- or rather how to deal with coordinating the work of projects which are part of a larger program and where there may be dependencies and shared deployment. While teams within a program may work fairly independently, their work still needs to be coordinated to produce a product. These three patterns, which represent alternative strategies for structuring the backlog of work, are introduced through a story of the correspondence of a business analyst as her hypothetical program moves through different backlog management strategies.
Architecture Reviews in Software Development OrganizationsFrank Frey, Victor Sauermann, Michael Kopf
Most companies developing an operating software systems reach a point of time when the architecture of one or more systems is questioned. Triggers are, for example, serious operational issues, like inconsistent data, failures, or high complexity of the system leading to costly workarounds and slow time-to-market. Furthermore, companies thriving for a higher efficiency by standardizing processes and the technology stack may consider compliance reviews of the systems' architectures as a useful means. Both motivations, current issues and conformity checks, are covered by two patterns introduced in this paper. They are supposed to introduce different objectives for architectural reviews and provide practical guidance for organizing and setting up architecture reviews. Thus, the patterns rather focus on motivation and organizational aspects than on details of architectural analysis. The target group entails IT architects, IT managers, chief developers and interested people from industry and academia. There exist other methods and patterns concerning architecture reviews. Some of them are considered or referenced, but this paper does not contain a comprehensive comparison. The authors would like to discuss commonalities, differences, insights from practical application, and potential links between of the introduced and existing architecture review patterns within the pattern community. This discussion may lead to a better overview or, on the long run, even to a pattern language for architecture reviews.
Using Design Patterns for Math Preservice Teacher EducationPaul Salvador Inventado, Sharris Gayle Francisco Inventado, Noboru Matsuda, Yeping Li, Peter Scupelli, Korinn Ostrow
Experienced teachers effectively address student misconceptions and learning difficulties by employing high-quality pedagogical strategies that they have developed through experience. It is difficult to discover effective strategies because it takes a lot of trial and error before a teacher can conclude that a particular approach improves student learning. Researchers have used educational design patterns to encapsulate high-quality strategies that facilitate the transfer of pedagogical knowledge. In this work, we investigated the feasibility of utilizing three educational design patterns as a teaching tool for math preservice teacher education: Feedback Sandwich, Pitfall Diagnosis and Prevention, and Worked Examples. Specifically, we used design patterns to investigate how preservice teachers provided feedback to students who gave common wrong answers to a given math problem and compared their feedback before and after they were introduced to educational design patterns. Results indicated that design patterns helped preservice teachers consider other aspects of feedback such as students' self-regard, common misconceptions, and prior knowledge into their feedback for common wrong answers on math problems. The limited set of three design patterns introduced in the study focused on feedback presentation. Results also indicated preservice teachers may benefit from design patterns that address other aspects of feedback such as content granularity, feedback length, and presentation medium. Implications of this study, including the potential of using educational design patterns to improve preservice teacher education, are discussed.
Three Patterns of Data Type CompositionRuslan Batdalov, Oksana Nikiforova
Data type composition is used in programming languages to build complex data types (known as compound types) from simpler ones. Various programming languages of ten use common approaches to type composition, but their particular implementation and provided opportunities may differ between languages. The paper uses the patterns methodology to describe three recurring themes in data type composition: traversing a set of values (the Traversable Once pattern), providing a slot to assign a value (the Assignable Once pattern) and variables that do not have to contain a value (the Optional Value pattern). These patterns are general cases of a number of constructs used for building compound data types in various programming languages. The described patterns may be used by designers of programming languages, libraries and frameworks to support the corresponding data type composition mechanisms directly in the language or their replacement at a higher level. Users of languages, libraries and frameworks may use the description of the patterns to understand underlying mechanisms and related benefits and liabilities.
Fogxy - An Architectural Pattern for Fog ComputingAndreas Seitz, Felix Thiele, Bernd Bruegge
Fog computing is an emergent approach that tries to overcome challenges the cloud faces by introducing a fog tier in between the cloud and the edge of the network. With the advent of the cloud, computing power shifted back again to centralized locations. In past decades, we have seen an alternation between centralization and decentralization. Although the cloud is highly scalable and performant, it exhibits limitations such as real-time capabilities. Fog computing is an approach that tries to overcome these shortcomings. The implementation guidelines for fog computing system are vague to be implemented in real-world applications. Smart objects at the edge benefit from low latency responses, location awareness, and higher availability provided by fog computing. In this paper, we present Fogxy, an architectural pattern for fog computing. It serves as an implementation guidance that describes a solution to a recurring problem in a given context. Fogxy is composed of different patterns and is based on the idea of the proxy pattern. Fogxy gives an overview of the implementation of fog computing applications and takes into account the integration of cloud computing and Internet of Things (IoT) technologies.
A misuse Pattern for DDoS in the IoTMadiha Syed, Eduardo Fernandez, Julio Moreno
Internet of Things(IoT) solutions have gained popularity by showing promising application in various domains. Large number of smart devices are connected to the internet and are producing huge amounts of data. While their usefulness cannot be denied, there are various reservations regarding the security implications of these systems. In order to utilize these systems to their full potential their security has to be handled properly. This work presents a misuse pattern for an attack that exploits security vulnerabilities of IoT devices to produce a Denial of Service(DoS) situation. We describe how this attack is performed and specify appropriate countermeasures for mitigating it.
The Monolithic Trunk, How and why to make itKlaus Marquardt
Trunk based development, a configuration management policy that avoids long-living branches, has gained attention and acceptance (references) mostly in projects and companies that focus on integration. A single-repository code base is mostly used for single project or set of connected, homogenous applications. In combination, a single-repository trunk makes for a monolithic trunk. This supports important goals: providing a defined place and state of integration and ‘truth’, supporting changes at any scale, and releasing across projects what needs to be released together. A monolithic trunk comes with a mindset of coupling for the purpose of integration and release. Most of separation and decoupling is out of scope here, and more adequately defined and handled by architecture, design, and requirements. Still, a monolithic trunk is not beneficial for everybody. It is most valuable when many applications are tightly coupled, by a shared code base or, more relevant, by common release and packaging. Examples include office suites like Microsoft’s, or web ecosystems like Google’s. This paper names the core concepts of a monolithic trunk and its underlying value system, and explores benefits and liabilities for projects and organizations. Then it describes the first steps, and leads into a pattern catalog for running the trunk beyond the scope of individual projects.
Implement Communities of Practice in an agile IT environmentMichael Kopf, Victor Sauermann, Frank Frey
Many IT companies face the challenge of keeping up with the fast pace of the markets and the rapid pace of technological progress. This manifest itself in the topic of digitization and cultural change. It is becoming increasingly important to be able to respond to external influences in an agile manner and to be able to assess technical progress appropriately for one's own needs. The appropriate toolbox -- a collection of methodologies, formats and patterns -- can help significantly in mastering these challenges. Therefore, it is essential for companies to have a working toolset in place. This paper describes patterns from the author's perspective and experience in implementing Communities of Practice (CoP) -- a well-known collaboration format to empower employees to engage with strategically important issues early on -- in an agile IT environment. This paper is for managers, team-leads, architects and members of self-organized development teams working for IT companies that are creating software.
Expand and Contract - A Pattern to Apply Breaking Changes to Persistent Data with Zero DowntimeTim Wellhausen
The Expand and Contract pattern provides a way to implement breaking changes to a system in a safe manner. The pattern is particularly helpful in an environment where maintenance downtime is unacceptable. This paper examines the details on how to apply the pattern when the structure of persistent data needs to be changed. The paper is supposed to be a useful read for every software developer who operates in such an environment.
Patterns for Returning Data from C FunctionsChristopher Preschern
Even the simple topic of returning data from functions becomes tricky, if the data to share becomes complex, or if the programmer has to cleanup the memory by himself or herself in case the programming language has no support in form of destructors or garbage collectors. To address this topic, this paper provides best practices in form of design patterns on the topic of returning data and the paper provides C code examples.
C Patterns on Data Lifetime and OwnershipChristopher Preschern
Design patterns are well known for object-oriented languages. However, when it comes to procedural programming languages, like for example C, then most of the knowledge documented in form of design patterns cannot be used, because these patterns focus on object-oriented languages and in C you do not have mechanisms like a constructor, a destructor, inheritance, or public and private variables in form of memory dedicated to an object. Despite of that, also C programmers group their functionality into object-like elements which have their own dedicated memory and in C the programmers then have to put special attention on the lifetime and ownership of these object-like elements. This paper shows in form of patterns how C programmers can do that. The pattern STATELESS FUNCTIONS describes, how related functions, which don't share any information between the function calls, can be put together. STATIC INSTANCE describes, how related functions can be put together as soon as they share information. CALLER-OWNED INSTANCE describes how multiple object-like elements can be created and distributed to di erent callers. SHARED INSTANCE describes how the same can be achieved with additionally making it possible to share object-like elements between callers. The four presented patterns are throughout the paper applied to a running code example, to give hands-on advice on how C programmers can apply these patterns.