Using design patterns in the development of a planner-based courseware system

The application of object-oriented design patterns in transient simulation program for distributed generation systems and micro-grid is introduced in this paper, such as factory method pattern, adapter pattern, strategy pattern and singleton pattern. Taking the advantages of the object-oriented design, the low coupling between modules as well as high cohesion within the module are achieved and have applied in the transient simulation program. The theory of design pattern makes the software more flexible and extensible to the program functions. The universality of design patterns integration methods described in the paper proposes a reference for other simulation programs in power system.

A network simulator always is an important tool to observe and evaluate the study concept for wireless networks. Considering the restriction of the limited budget, the non-commercial open-source simulation software often becomes the top choice of academia. Since the natures of academic study are innovation and excellence, a simulator frequently encounters that the existing modular functions are inadequate and need to be appended or modified. If a selected simulator inherently has poor architecture, the maintenance, recondition, and expansion of functions will become more difficult and more time-consuming in the future, while it is difficult to understand and reuse by the successors. Therefore, how to select a most suitable simulator is an important issue. In order to make a simulator have flexible architecture and believable results, design patterns are proposed as the norms to design system architecture. To realize this idea, we surveyed six most used simulators, i.e., J-Sim, NS-2, NS-3, OMNet++, OPNET, and QualNet, to ponder their system architectures and design concepts from the source codes and the related literatures of the modular function expansion. We propose a network simulator architecture, named as CCGns, which is a discrete-event virtual network simulator and follows the IEEE 802.16-2009 standard. CCGns obeys the object-oriented design principles and is coded by the Java language. CCGns comprises eight packages for physical layer, medium access control layer, network layer, devices, topologies, events, scheduler, and reports, respectively. The main contribution includes three aspects which propose a scalable MAC messages management and the corresponding architecture, an applicable for multi-hop relay network topology architecture, and a two-stage minimum variance bandwidth allocation algorithm. To the best of our knowledge, this article is not the first one to apply the design patterns for the simulator architectures of wireless network, but we use more design patterns and types than the others and also provide the unified modeling language figures to explain the system architectures. We particularly focus on how the management procedure of control messages influences the time-related performance evaluation metrics, e.g., how the amount and processing time of different control messages affect throughput, packet delay, and packet drop ratio. By using mathematic calculation to verify the simulation results, the proposed system architecture has been proven to possess excellent fidelity.

Among the many commendable creations presented by game developers, the design of game mechanics generally shares common components. This observation can also be validated by using some less impressive works as counterexamples; however, there is currently a lack of comprehensive summarization of these systems. Through analysis, this paper extracts the game mechanic design patterns present in these successful games. The paper explores the practical application of a game design pattern that originates from a core game mechanism and progressively generates usable sub-mechanisms. This pattern involves selecting a specific core gameplay element and introducing auxiliary mechanisms to expand its dimensions. Through a systematic exploration of various combinations and interactions, this approach aims to create diverse sub-mechanisms that enrich gameplay and level design. The paper discusses the benefits and challenges of this design pattern and provides illustrative examples.

The unceasing change problem of land information systems can be resolved through the refactoring and design pattern. To promote the implementation of design pattern and refactoring methods in developing land information systems reusing software design, applying refactoring methods to the abstract factory and decorator design patterns in land information system development is discussed.

Software reusability is always the goal for the software people. It can improve the productivity and quality of software. Software architecture, design patterns, framework and components are the bases of application software reuse. Design patterns impenetrate into the whole process of software reuse, which is the important experience reference from software architecture to framework, form domain model to components. There are different domain models and frameworks in different domains. Referred to the shopping mall domain, the method of component design is introduced that domain model and framework can be obtained by domain analysis and then the design of components that are extracted from domain model could implement optimization to gain good system framework by the use of Strategy Pattern, Bridge Pattern and Abstract Factory Pattern.

Code refactoring is a technique that improves the existing code in order to make software easier to understand and more extensible without changing the external behavior. Software design patterns, programming language independent reusable solutions to comment problems, are well-known in Java communities. On one hand, the refactoring using design patterns brings many benefits such as cost saving, flexibilities, and maintainability. On the other hand, it potentially causes bugs or changes execution behavior of Java programs. This paper proposes a new approach to checking behavior preservation properties of Java programs after applying design patterns. We present new definitions to compute pre/post conditions of program behavior. In the next step, the paper makes use of Java Modeling Language (JML) to represent and check if the refactored program neglects to preserve the external behavior. A motivating example of Adaptive Road Traffic Control (ARTC) is given to illustrate the approach in detail.

Design patterns in software development have shown great promise in improving software quality. Traditionally, software developers utilize a set of design patterns to foster reusability and better software design. Recently, mobile applications (apps) have become a mainstay of modern computing, as well as, a challenging domain for software engineers. This is because mobile apps now target more critical domains such as health, banking, m-payments, and even military to mention just a few. Android is a very popular mobile platform, and has managed to take over the majority of mobile market. It is true that there are comprehensive studies in the area of design patterns detection in several object-oriented languages such as Java, C# and C++. However, little studies target design patterns in Android apps. As a step toward helping to measure and explore the application of design patterns in Android apps, we introduce PatRoid, an automated framework for detecting design patterns. PatRoid is a model-based approach that is able to detect design patterns laying inside Android apps source code. The model is based on a graph isomorphism approach, where design patterns are divided into sub-patterns that can be aggregated to formulate design patterns. We have conducted a preliminary evaluation and the results show that PatRoid can detect all of the 23 GoF design patterns.

Abstract: This paper describes the development of a prototype expert system for the selection of design patterns that are used in object‐oriented software. Design patterns provide one method of software reuse, which supports the goal of improved software development productivity. The prototype system represents an initial step towards providing an automated solution regarding the design pattern application problem, i.e. leading a designer to a suitable design pattern which is applicable to the problem at hand. The feasibility of using expert system technology to aid in the selection problem is demonstrated.

Adopting the traditional object-oriented and component-based methods, the software architecture design pattern can be applied in the concurrent, realtime and distributed fields, which will replace the kind of strong-coupling and process-oriented development predominant in the real-time embedded software to satisfy the needs of the fast development of hardware and communication technology. Combined with the mechanistic design pattern put forward by Gamma et al. (like layer, microkernel, component, etc.), in the light of the view between the subsystem and the component architecture and of the concurrency, correct design pattern is generated by means of pattern incubating, mining or instantiation, which is then applied to develop a robust and scalable architecture for real-time system. As the Component-based Software Engineering (CBSE) can effectively enhance the quality and efficiency of the software development process, the technology is introduced to architecture design, offering mature applications by means of framework instantiation. Based on the hybrid design pattern, the architecture and the process of the software become mutually reinforcing and complementary, and both the interior quality and the process quality of the software are guaranteed.

In this paper we present a software engineering approach for building hypermedia applications. Our approach combines the use of an object-oriented method with a system of design patterns for navigational and interface design. We first present the core activities in the Object-Oriented Hypermedia Design Method (OOHDM), namely conceptual design navigation design, abstract interface design and implementation, describing the modeling constructs we use to build high-level, abstract navigational and interface structures. Next we give the rationale for using design patterns in the process of building high quality hypermedia applications, and present some simple patterns solving recurrent design problems. We finally discuss some further issues.

Client-Server (C/S) application is always used in the existing Human Resource Management System (HRMS) as the system architecture, which has the problems of complex maintenance and poor compatibility; and cannot use professional database and development system, making the system development difficult and the data security low. To solve the above problems, the overall demand is analyzed, as well as feasibility and key technologies of the enterprise HRMS system. Then a HRMS is designed and developed, based on the user’s key functional requirements and related technologies, which is reasonable and easy to maintain. The system is supported by Browser-Server (B/S) structure, with the current popular Java 2 Platform Enterprise Edition (J2EE) multi-level structure as the overall architecture. The mature Microsoft SQL Server 2008 introduced by Microsoft is used as the database platform. Combined with Model View Controller (MVC) design pattern, this system can be used by users without geographical restrictions and system maintenance. In this system, performance logic and business logic are separated, which makes it convenient for the development and maintenance of the system. The system mainly includes six modules: personnel management, organizational management, recruitment management, training management, salary management and system management, which integrates enterprise information and realizes the functions of easy access and easy query of information database. Its interface is simple, easy to understand, and easy to operate, with low investment, low cost, high safety, good performance and easy maintenance, which help to improve the work efficiency and modern management level of enterprises. In the end, the operation performance of the system is tested. The results show that the throughput of the main functional modules in the system is greater than 100 times/s when dealing with the business, and the success rate of event processing is greater than 99%. The average response time of the business end is less than 0.4 s, and the average response time of the terminal side is less than 0.5 s, which all meet the standards. System CPU occupancy rate can be basically controlled below 30%, and memory usage rate is below 30%. In summary, the system designed here has the basic functions but also to ensure good performance, suitable for enterprise personnel management, organizational management, recruitment management, training management and salary management. The design and development of this system aims to provide technical support for the service quality of enterprise human resource management business, to improve the overall efficiency, promote the pace of enterprise strategic development, and enhance the market competitiveness of enterprises.

A methodology to assess the impact of design patterns on software quality

Recently, one can recognize an increased awareness in the object-oriented research community with respect to the role of software architectures. Examples of this can, among others, be found in object-oriented frameworks and design patterns. In the call for papers for the workshop, the following topics were identified where software architecture, patterns and frameworks should be studied in more detail: Building OO software architectures: How can design patterns, frameworks and components be included in the traditional object-oriented analysis and design? How are architecture constraints processed to build OO software architectures? Which techniques can help to build an OO architecture that supports reuse and is scalable? Language role in architecture: What is the role of a particular object-oriented language when designing an architecture? Architecture documentation: It has been suggested that design patterns can be used to document the design and rationale of an object-oriented architecture. How well does this work in practice? OO architectural styles: What is the relation between the architectural styles of Garlan and Shaw and OO design? Composition of architectures: Since object-oriented frameworks are an accepted technology within the software industry, the composition of two or more frameworks in an application occurs increasingly often. The composition may be far from trivial and the problems that may appear as well as solutions should be investigated.

Design pattern detection is a popular re-engineering job in software development. It provides essential information to the developers to recognize, sustain, and recycle the software. This article proposes a graph matching algorithm using a correlation-based feature selection technique to discover the design pattern (DP) instances from the software or system design. Usually, the feature selection method is used to choose the best instances from the dataset, which mostly matches the target feature. However, this paper has applied a correlation feature selection method to match the system design to the design pattern. We have taken three DPs comparing examples for this intention:•the first example for an entire match•the second example for a partial match•the third example of a not matchIn this experiment, we took the Abstract factory DP as a model graph, and the remaining twenty-two DPs are system or DPs. Software instances groups lots of classes and objects we converted into a graph. We observed that three of the 22 DPs are completely matched to the model DP, one pattern is not matched, and the remaining 18 patterns are only partially matched.

Design patterns are a common strategy employed in software development to promote several aspects of software quality, including code maintainability. Game development is a multidisciplinary field that includes not only software development but also animations, interactivity, sound design and others. Given the short deadlines in which game developers commonly operate, on top of the intrinsic complexity of the field itself, code maintainability is often overlooked by game developers. Hence, this work investigates how design patterns can impact the code maintainability of games. First, we performed a review to understand how (and which) design patterns can be applied to different game mechanics. Next, we selected two small games and refactored the code by applying design patterns to some of the games’ mechanics. By leveraging static analysis to assess the games’ code maintainability before and after the application of the design patterns, we observed an overall code maintainability improvement of 5.5%. The preliminary results indicate the potential to use design patterns as a strategy to improve code maintainability in the context of game development.