Product design patterns for agent-based modeling

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.

Software Design Patterns (SDPs) are core solutions to the recurring problems in software. However, adopting SDPs without taking into account their value implications may result in breach of social values and ultimately lead to user dissatisfaction, lack of adoption, and financial loss. An example is the airline system that overcharged people who were trying to escape from the Hurricane Irma. Although not intentional, overlsight of social values in the design of the airline system resulted in significant customer dissatisfaction and loss of trust. To mitigate such value breaches in software design we propose taking social values into account in SDPs explicitly. To achieve this, we outline a collaborative framework that allows for (i) specifying the value implications of SDPs, (ii) developing or extending SDPs for integrating social values, (iii) providing guidance on the value-conscious adoption of design patterns, (iv) collecting and analyzing insights from collaborators, (v) maintaining an up-to-date library of the valufied design patterns, and (vi) incorporating lessons learned from the real-world adoption of the valuefied design patterns into the proposed framework for its continuous improvement in integrating social values into software.

To address practical challenges in teaching "Software Design Patterns" courses-including complex content, disconnect between theory and practice, and implementation difficulties-this study explores an OBE (Outcome-Based Education) approach. Through discovery-based exploration with classroom implementation as the ultimate goal, we developed implementation-oriented projects that integrate software design patterns with commercial software development. These projects enable students to learn the advantages of modular programming through software development, cultivating design pattern thinking. By adopting OBE principles in teaching "Software Design Patterns," students gain precise understanding of design patterns' value in commercial software development, enhancing learning engagement and improving course effectiveness.

Software design patterns classification and selection using text categorization approach

Information Integrity(I*I) i.e. Accuracy, Consistency and Reliability of information is a fundamental requirement for strategic business advantage in complex and changing environment characterized by uncertainty. However, its implementation is a highly complex and costly activity. Software modeling and development techniques have by and large advocated divide and conquer as the typical approach to handle large and complex business systems. Object oriented modeling has been a major step towards building of large, flexible and evolving systems. Efforts and contributions to support flexibility have been made by database and programming language providers. The same can be witnessed if we trace down the evolution of databases and programming languages both now focusing on extensible and reusable patterns and components as main contributors to providing flexibility in otherwise statically designed software. Software patterns offer another area that has contributed significantly towards designing software with reasonable strengths and known weaknesses. Literature as well as practice has shown evidence of using design patterns, software patterns and business patterns for improved software quality. However, major focus of software and design patterns is still to meet functional and non-functional requirements of a software, whereas business patterns are largely implemented in a manual form. This paper adopts UML to define a framework built on I*I patterns that can be reused by system designers towards building systems that support I*I and its analysis. This paper is an attempt to further the knowledge area of I*I towards a way of implementing it in any size of software project thus reducing complexity as well as the cost of its implementation. Focus of the paper is not to offer a complete suite of I*I patterns but establish a guideline towards building one of such kind.

BackgroundInfectious disease modeling and computational power have evolved such that large-scale agent-based models (ABMs) have become feasible. However, the increasing hardware complexity requires adapted software designs to achieve the full potential of current high-performance workstations.ResultsWe have found large performance differences with a discrete-time ABM for close-contact disease transmission due to data locality. Sorting the population according to the social contact clusters reduced simulation time by a factor of two. Data locality and model performance can also be improved by storing person attributes separately instead of using person objects. Next, decreasing the number of operations by sorting people by health status before processing disease transmission has also a large impact on model performance. Depending of the clinical attack rate, target population and computer hardware, the introduction of the sort phase decreased the run time from 26 % up to more than 70 %. We have investigated the application of parallel programming techniques and found that the speedup is significant but it drops quickly with the number of cores. We observed that the effect of scheduling and workload chunk size is model specific and can make a large difference.ConclusionsInvestment in performance optimization of ABM simulator code can lead to significant run time reductions. The key steps are straightforward: the data structure for the population and sorting people on health status before effecting disease propagation. We believe these conclusions to be valid for a wide range of infectious disease ABMs. We recommend that future studies evaluate the impact of data management, algorithmic procedures and parallelization on model performance.Electronic supplementary materialThe online version of this article (doi:10.1186/s12859-015-0612-2) contains supplementary material, which is available to authorized users.

Object oriented design patterns (DP) are meant to provide a common structure for solving common software development problems. Applying those patterns is expected to improve the software systems maintainability, comprehensibility, and provide a common language for developers to understand and effectively communicate. However, this was not always the case, where some studies have shown that using design patterns may lead to a system harder to maintain and understand and more error prone; as compared to same systems without the use of design patterns. This variation is referred to the features of the system on hand, and the experience of the developers who are capable to know what design patterns to use and when. Considering the video game development, the use of software design pattern is still at low scale, and still; there is no recipe on what and when to use design patterns. In the meantime, there are different game design frameworks that define different aspects which need to be considered when developing a game. In this paper, we propose a framework that integrates some creational and behavioral DP, with a specific game design framework. In this way, we claim that the developers will have some hints on what DP to use with the main game aspects. This framework is suitable for games which can be developed after the first course of game design, regardless of the game engine used for development. The framework can be extended with more DP, for larger scale and more sophisticated game.

Software design patterns are used to improve the software quality. There are distinct kinds of software, as well as design patterns. One of them is patterns for enterprise application architecture. Although enterprise design patterns are said to be able to improve the software quality, there is a lack of literature that discusses the evidence of the impact. This preliminary study proposes a method to assess the impact of enterprise software design pattern on maintainability. We use the Academic Information System (AIS) of Institut Teknologi Sepuluh Nopember (ITS) as a case study. It is enterprise software which is frequently maintained and need to be evolved. The software maintainability is measured by using C&K metrics. Then we calculate the relative change and evaluate it based on viewpoints of the metrics. Transaction Script pattern is selected to verify the method. As a result, it decreases the maintainability instead of improving it. The result of this preliminary study shows that design patterns did not improve the software maintainability. Based on the previous researches, it depends on several factors which may be studied in the future work. Thus, we need to propose a method to select the appropriate patterns or whether we use design patterns or not.

Software design patterns are documented best practice solutions that can be applied to recurring problems. Although well documented, there are often opportunities to apply them which are overlooked by software designers. This can be the result of inexperience, the sheer complexity of the system, or the fact that design patterns do not always constitute intuitive designs. In this paper, we present a structured methodology for semi-automating the detection of areas within a UML design of a software system that are good candidates for the use of design patterns. This is achieved by the definition of detection rules formalized using the OCL and using a decision tree model. The approach is illustrated on an example GoF design pattern. A prototype tool was developed to show the feasibility of the approach in practical situations, and is used on a case study, producing encouraging results

Agent-Based Modeling has been recently recognized as a method for in-silico multi-scale modeling of biological cell systems. Agent-Based Models (ABMs) allow results from experimental studies of individual cell behaviors to be scaled into the macro-behavior of interacting cells in complex cell systems or tissues. Current generation ABM simulation toolkits are designed to work on serial von-Neumann architectures, which have poor scalability. The best systems can barely handle tens of thousands of agents in real-time. Considering that there are models for which mega-scale populations have significantly different emergent behaviors than smaller population sizes, it is important to have the ability to model such large scale models in real-time. In this paper we present a new framework for simulating ABMs on programmable graphics processing units (GPUs). Novel algorithms and data-structures have been developed for agent-state representation, agent motion, and replication. As a test case, we have implemented an abstracted version of the Systematic Inflammatory Response System (SIRS) ABM. Compared to the original implementation on the NetLogo system, our implementation can handle an agent population that is over three orders of magnitude larger with close to 40 updates/sec. We believe that our system is the only one of its kind that is capable of efficiently handling realistic problem sizes in biological simulations.

Present day software engineering concept gives emphasis on the use of design patterns for developing software which are recurring in nature. Detection of design pattern is one of the emerging field of Software Reverse Engineering. In this work, an attempt has been made to present an approach for design pattern detection with the help of Graph Isomorphism and Normalized Cross Correlation techniques. In this study, system and design pattern are presented in the form of graphs. The Graph Isomorphism technique finds the pattern subgraph in the system graph and Normalized Cross Correlation provides a way to formulate the percentage existence of the design pattern in the system. An Eclipse Plug-in i.e., ObjectAid is used to extract Unified Modeling Language (UML) class diagrams as well as eXtensible Markup Language (XML) files from the software system and design patterns. An algorithm is proposed to identify relevant information from the XML files. Then Graph Isomorphism and Normalized Cross Correlation techniques are used to find the pattern subgraph and its percentage existence in the system. This approach has been applied on four open source software tools for the evaluation of five design patterns, such as Composite, Facade, Flyweight, State, and Template Method.

Design patterns are common solutions to specific design problems. There are many claimed benefits of the application of design patterns on design quality. This paper empirically evaluates and compares the modularity of design patterns in object-oriented software. Coupling and cohesion of classes that participate in design patterns were compared with those that do not participate. We used CBO and LCOM metrics as proxy measures for coupling and cohesion respectively. Data were collected from five open source systems, and analyses were conducted at both the design and pattern levels. At the design level, we compared the modularity of participant versus non-participant classes in design patterns, whereas at the pattern level, we compared the modularity of the classes in each pattern. The results indicate that the classes that participate in design patterns are more coupled and less cohesive than the non-participant classes at both levels.

This paper introduces the concepts of design patterns and demonstrates the potential of applying this technique for power system modeling. Captured by experienced object-oriented designers, design patterns solve specific design problems and make object-oriented designs more flexible, extensible and elegant. This technique has been successfully applied in the design of a generic distribution circuit object model. Some of the more powerful design patterns, such as object composition, delegation, recursive composition and proxy etc., have been effectively used to help determine modeling granularity, find appropriate objects and achieve modeling flexibility. When properly applied, the design patterns can help solve many of the design problems in the object-oriented modeling of power systems.

Agents and design patterns are commonly used to support component-based software development (CBSD). They provide schemes for refining subsystems and agent components. Since software agents are considered as advanced technology abstractions of objects and component design, new design patterns need to be developed for software agents to support e-business systems. Design patterns are a new methodology used to support other systems such as realtime systems and knowledge management systems. However, there are still insufficient schemas established to support e- business and the B2B, B2C, and C2C paradigms. Design patterns help both designers and developers to integrate their ideas and experiences into better formulations for software system architectures. We put our effort to establishing a new agent-based design that we call a design pattern (FDP). This design uses the master-slave design for mobile agents with a static agent called facilitator agent. The design is used to improve the B2C e-market place in e- business scenarios.

Software Design Patterns are reusable designs providing common solutions to the similar kind of problems in software development. Creational patterns are that category of design patterns which aid in how objects are created, composed and represented. They abstract the creation of objects from clients thus making the application more adaptable to future requirements changes. In this work, it has been proposed and implemented the creation of objects involved in Decorator Design Pattern. (Decorator Pattern Adds Additional responsibilities to the individual objects dynamically and transparently without affecting other objects). This enhanced the reusability of the application design, made application more adaptable to future requirement changes and eased the system maintenance. Proposed DMS (Development Management System) web application is implemented using .NET framework, ASP.NET and C#.