Strategy Design Pattern Research Articles

Strategy Design Pattern Applied on a Mobile App Building

This paper provides the importance and application of design patterns in software engineering, particularly focusing on the Strategy Design Pattern. It outlines how design patterns offer efficient, flexible, and reusable solutions to common problems in object-oriented software development. The paper presents a case study of Strategy Design Pattern’s application in a mobile app builder, emphasizing its role in creating adaptable and maintainable software architecture. Additionally incorporates commentary on the SOLID Open and Close principle, explaining how it allows software entities to be extendable without modifying existing code, thus enhancing the scalability and robustness of the application. The OC principle integration with the Strategy Design Pattern demonstrates its practicality in promoting flexible and stable software development.

Ontology Fixing by Using Software Engineering Technology

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

Modeling strong/weak discontinuities by local mesh refinement variable-node XFEM with object-oriented implementation

In this paper, we present a Matlab object-oriented implementation of the variable-node extended finite element method (XFEM), which is enhanced by local mesh refinement technique, for modeling strong and weak discontinuities such as cracks, inclusions, and voids. An easy-to-use local mesh refinement scheme is thus proposed, in which the variable-node elements play an important role as they are integrated into the model for the purpose of connecting/linking different scale meshes. For efficiency, the fine-scale mesh is generated near discontinuities, and the refinement is controlled by three parameters: the number of extension layers, the number of subdivision scales, and the number of refinement levels. We detail the implementation of integrating the variable-node elements into the local mesh refinement XFEM codes in a seamless way. The concept of object-oriented programming (OOP) and strategy design pattern promote the extensibility of computer codes. We consider several numerical examples to show the applicability and accuracy of the current computer codes for mutiple crack growths, crack-hole interactions, multiple inclusions, and a rock slope with one interface and two faults.

An object-oriented MATLAB toolbox for automotive body conceptual design using distributed parallel optimization

Appropriate structural analysis and optimization methods are of great significance for the conceptual design of automotive body-in-white (BIW) structure. This paper simplifies BIW structure as a spatial semi-rigid framed structure to provide early-stage predictions. Then a novel exact transfer stiffness matrix method (TSMM) is proposed for both static and dynamic analyses of three-dimensional semi-rigid framed structures. The matrix storage and equation solution techniques for large-scale engineering structures are also considered. Additionally, a size optimization mathematical model for BIW conceptual structure is formulated and solved by genetic algorithm (GA). Afterwards, to promote the conceptual design of BIW structure, an object-oriented MATLAB toolbox, based on TSMM, is developed. The Unified Modeling Language (UML) and strategy design pattern are employed to facilitate the development of the toolbox. Distributed parallel computing technique is adopted to speed up the former sequential optimization algorithm with simple modifications. Lastly, the validity of this easy-used toolbox is demonstrated by a benchmarking auto-body.

Implementation of Secure Software Design and their impact on Application

is associated with the system and it is a big risk for system and result in surplus maintenance cost. It is due to many reasons those are not considered during the stages of System Development Life Cycle (SDLC). During SDLC it may be reduced to minimum level. Millions of dollars waste due to vulnerable application and rescind working. Most of the software are not secure and cause Physical and Financial mutilation. It may not be possible to eliminate vulnerability completely but it might be reduced to the minimum level because it is the ongoing process. A web application using secure design patterns (SDPs) is presented in this paper. Two secure design patterns and their implementation are given. Secure Strategy Design Pattern (SSDP) and Secure Builder Design Pattern (SBDP) are purposed for two different forms SSDP is used for Driver information page and SBDP is used for Route information page. Special codes are used for inquiring whether valid user is using site or not. A class of encryption/decryption technique is added to add security. An encryption/decryption technique named SHA-1 is used. The result shows that SDPs are beneficial to all application developers especially for the developers of critical and sensitive systems. The system suits secure and design pattern makes it simple to understand its functionality. However, any other encryption/decryption techniques may also be applied on it in place of SHA-1. In future we plan to attach this class with other design patterns to make them secure from attackers and eliminate vulnerable points. Many features can be included in web application with the help of different design patterns and can be secured by attaching encryption/decryption class.

Automated refactoring to the Strategy design pattern

ContextThe automated identification of code fragments characterized by common design flaws (or “code smells”) that can be handled through refactoring, fosters refactoring activities, especially in large code bases where multiple developers are engaged without a detailed view on the whole system. Automated refactoring to design patterns enables significant contributions to design quality even from developers with little experience on the use of the required patterns. ObjectiveThis work targets the automated identification of refactoring opportunities to the Strategy design pattern and the elimination through polymorphism of respective “code smells” that are related to extensive use of complex conditional statements. MethodAn algorithm is introduced for the automated identification of refactoring opportunities to the Strategy design pattern. Suggested refactorings comprise conditional statements that are characterized by analogies to the Strategy design pattern, in terms of the purpose and selection mode of strategies. Moreover, this work specifies the procedure for refactoring to Strategy the identified conditional statements. For special cases of these statements, a technique is proposed for total replacement of conditional logic with method calls of appropriate concrete Strategy instances. The identification algorithm and the refactoring procedure are implemented and integrated in the JDeodorant Eclipse plug-in. The method is evaluated on a set of Java projects, in terms of quality of the suggested refactorings and run-time efficiency. The relevance of the identified refactoring opportunities is verified by expert software engineers. ResultsThe identification algorithm recalled, from the projects used during evaluation, many of the refactoring candidates that were identified by the expert software engineers. Its execution time on projects of varying size confirmed the run-time efficiency of this method. ConclusionThe proposed method for automated refactoring to Strategy contributes to simplification of conditional statements. Moreover, it enhances system extensibility through the Strategy design pattern.

A COMPOSITE DESIGN PATTERN FOR SERVICE INJECTION AND COMPOSITION OF WEB SERVICES FOR PEER-TO-PEER COMPUTING WITH SERVICEORIENTED ARCHITECTURE

In this paper we present a Service Injection and composition Design Pattern for Unstructured Peer-to-Peer networks, which is designed with Aspect-oriented design patterns, and amalgamation of the Strategy, Worker Object, and Check-List Design Patterns used to design the Self-Adaptive Systems. It will apply self-reconfiguration planes dynamically without the interruption or intervention of the administrator for handling service failures at the servers. When a client requests for a complex service, Service Composition should be done to fulfil the request. If a service is not available in the memory, it will be injected as Aspectual Feature Module code. We used Service Oriented Architecture (SOA) with Web Services in Java to Implement the composite Design Pattern. As far as we know, there are no studies on composition of design patterns for Peer-to-peer computing domain. The pattern is described using a java-like notation for the classes and interfaces. A simple UML class and Sequence diagrams are depicted.

Software Framework for Parameter Updating and Finite-Element Response Sensitivity Analysis

The finite-element software framework OpenSees is extended with parameter updating and response sensitivity capabilities to support client applications such as reliability, optimization, and system identification. Using software design patterns, member properties, applied loadings, and nodal coordinates can be identified and repeatedly updated in order to create customized finite-element model updating applications. Parameters are identified using a Chain of Responsibility software pattern, where objects in the finite-element model forward a parameterization request to component objects until the request is handled. All messages to identify and update parameters are passed through a Facade that decouples client applications from the finite-element domain of OpenSees. To support response sensitivity analysis, the Strategy design pattern facilitates multiple approaches to evaluate gradients of the structural response, whereas the Visitor pattern ensures that objects in the finite-element domain make the proper contributions to the equations that govern the response sensitivity. Examples demonstrate the software design and the steps taken by representative finite-element model updating and response sensitivity applications.

Object-oriented design patterns in Fortran 90/95: mazev1, mazev2 and mazev3

This paper discusses the concept, application, and usefulness of software design patterns for scientific programming in Fortran 90/95. An example from the discipline of object-oriented design patterns, that of a game based on navigation through a maze, is used to describe how some important patterns can be implemented in Fortran 90/95 and how the progressive introduction of design patterns can usefully restructure Fortran software as it evolves. This example is complemented by a discussion of how design patterns have been used in a real-life simulation of Particle-in-Cell plasma physics. The following patterns are mentioned in this paper: Factory, Strategy, Template, Abstract Factory and Facade. Program summary Program title: mazev1, mazev2, mazev3 Catalogue identifier: AEAI_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEAI_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 1958 No. of bytes in distributed program, including test data, etc.: 17 100 Distribution format: tar.gz Programming language: Fortran 95 Computer: PC/Mac Operating system: Unix/Linux/Mac (FreeBSD)/Windows (Cygwin) RAM: These are interactive programs with small (KB) memory requirements Classification: 6.5, 20 Nature of problem: A sequence of programs which demonstrate the use of object oriented design patterns for the restructuring of Fortran 90/95 software. The programs implement a simple maze game similar to that described in [1]. Solution method: Restructuring uses versions of the Template, Strategy and Factory design patterns. Running time: Interactive.

A plug and play approach for developing environmental models

The need for better collaboration among scientists and different existing environmental models makes it necessary to find efficient ways of using and reusing functionalities or services provided by third parties. New advances in software engineering can be successfully used to develop environmental models that use an enabling architecture for a “plug and play” approach. In this study, the Kraalingen crop simulation model was used to demonstrate the concept and feasibility of the “plug and play” architecture for crop simulation models. Strategy and AbstractFactory design patterns are used as the basis for the “plug and play” approach. In addition to design patterns, Java's reflection was used to dynamically instantiate the appropriate Strategy instance. This paper focuses only on the issues dealing with design and implementation of the “plug and play” architecture. This architecture was successfully tested using several components providing polymorphic behavior in the Kraalingen model. Components for obtaining weather data from different sources were plugged into the system without requiring changes to the code. This approach creates the necessary technical environment for scientists to focus on what they know the best, save time and effort and subsequently, increase the cross-disciplinary interaction for creating better models.

Comparing the template method and strategy design patterns in a genetic algorithm application

We present a genetic algorithm software project that serves to give students direct experience with choosing among multiple potentially applicable design patterns. We carefully constructed this project to illustrate the power of design patterns in supporting encapsulation while at the same time providing a single context in which to compare and contrast similar design pattern alternatives.

Modular Statically Typed Multimethods

Multimethods offer several well-known advantages over the single dispatching of conventional object-oriented languages, including a simple solution to the binary method problem, a natural implementation of the strategy design pattern, and a form of open objects that enables easy addition of new operations to existing classes. However, previous work on statically typed multimethods whose arguments are treated symmetrically has required the whole program to be available in order to perform typechecking. We describe Dubious, a simple core language including first-class generic functions with symmetric multimethods, a classless object model, and modules that can be separately typechecked. We identify two sets of restrictions that ensure modular type safety for Dubious as well as an interesting intermediate point between these two. We have proved each of these modular type systems sound.