Search

Security patterns are being used in software applications to mitigate attacks occurring due to software vulnerabilities. However, developer sometimes overlooks best practices while implementing the security pattern in the software application. In this paper, authors propose a formal approach to describe various security constraints using first order predicate logic. This will facilitate the detection of security vulnerabilities at the early stages of software development life cycle. The approach has been verified using Secure Factory Pattern. The effectiveness of the approach has been further validated using Library Management System as a case study. The proposed approach will help in detection of hidden vulnerabilities in software applications.

It is unrealistic to draw different auxiliary graphs manually for different virtual chemistry experiments, which is time-consuming, laborious and inefficient. We provide an automatic graph generation module based on GDI + for the virtual experiment platform, and use object-oriented method to analyze and classify the features of virtual experiment schematics. Chemical graphic library is designed and constructed, including basic primitives such as lines, triangles, curves and circles, as well as complex graph primitives combined by these basic primitives. Singleton pattern is used to design the auxiliary class, and simple factory pattern is used to manage all the primitives classes, and assembly sequence and assembly relation information combined with connection nodes are used to automatically generate the best matching combination graphics and experimental schematic diagram.

This paper presents the methods which make a design process of control system efficient. The Real-Time control framework makes writing Real-Time control programs easy. Real-Time control programs are generated from simulation program automatically. The idea of an object model and the Factory Method pattern are used for automatic generation of Real-Time control program. Separation of platform dependent parts makes non Real-Time parts can be independent from platform. We develop a platform integrated environment of the simulation and the Real-Time control for Control system using above methods., 4th IEEE International Conference on Mechatronics (ICM 2007), 8-10 May, 2007, Kumamoto, Japan

Function as a Service (FaaS) is a new popular cloud computing model in recent years, which has the characteristics of automatic scaling, on-demand billing and easy maintenance. However, the SDKs provided by different public FaaS platforms are inconsistent, increasing the cost of learning and application migration for developers. This paper proposes to build a unified development framework by encapsulating the SDKs of each FaaS platform, which uses the factory pattern of object-oriented design mode to define a set of unified abstract classes. This framework can help developers to operate across different FaaS platforms with a unified set of SDK, and has good scalability.

Silicon-based piezoresistive microelectromechanical systems (MEMS) pressure sensor is one of the best studied and commercialized devices among all MEMS devices due to simple structure, easy reading circuit, strong batch fabrication capability and low price. The biggest technical bottleneck of this sensor for high-end applications such as aerospace is long-term stability after packaging. Therefore, long-term stability improvement technologies, as the common key technologies, have been widely concerned by academia and industry. In this paper, three common enabling technologies including pulsating fatigue, thermal-cold cycling and vibration aging are adopted to evaluate the effect of long-term stability of silicon-based piezoresistive MEMS pressure sensors by using control variable method and orthogonal test (OT) method. The comparative test results indicate that all these three technologies can improve the long-term stability of the pressure sensor. In addition, an optimized combination of environmental stress parameters is found to improve the stability more than 90% higher than before the test. The long-term stability of the sensors through the optimal parameter combination aging method is better than the original factory method. The research results can be used for reference to improve the long-term stability of various silicon-based pressure sensors.

ContextThere are many claimed advantages for the use of design patterns and their impact on software quality. However, there is no enough empirical evidence that supports these claimed benefits and some studies have found contrary results. ObjectiveThis empirical study aims to quantitatively measure and compare the fault density of motifs of design patterns in object-oriented systems at different levels: design level, category level, motif level, and role level. MethodAn empirical study was conducted that involved five open-source software systems. Data were analyzed using appropriate statistical test of significance differences. ResultsThere is no consistent difference in fault density between classes that participate in design motifs and non-participant classes. However, classes that participate in structural design motifs tend to be less fault-dense. For creational design motifs, it was found that there is no clear tendency for the difference in fault density. For behavioral design motifs, it was found that there is no significant difference between participant classes and non-participant classes. We observed associations between five design motifs (Builder, Factory Method, Adapter, Composite and Decorator) and fault density. At the role level, we found that only one pair of roles (Adapter vs. Client) shows a significant difference in fault density. ConclusionThere is no clear tendency for the difference in fault density between participant and non-participant classes in design motifs. However, structural design motifs have a negative association with fault density. The Builder design motif has a positive association with fault density whilst the Factory Method, Adapter, Composite, and Decorator design motifs have negative associations with fault density. Classes that participate in the Adapter role are less dense in faults than classes that participate in the Client role.

Many students find it difficult to understand the concept of algebra because it is abstract, so it is necessary that the abstract method of algebra become more concrete, one of the methods that can be used is Al-Khawarizmi method. This Research is intended to analyze students’ mistakes in working out factoring using Al-Khawarizmi, so that the mistakes can be minimized in the future. This research is a qualitative research with sampling through purposive sampling technique. The study was held in SMP (Junior High School) Negeri 2 Cileunyi. The subjects were 32 students of class IX. The main data was from the results of the factoring test by Al-Khawarizmi. Data analysis was carried out through reduction, presentation data, and withdrawal. This study describes the student’s mistakes in working out the factoring using Al-Khawarizmi method which includes counting error, visualization of equation, algorithm, measurement of answers, and student’s accuracy. From the result of research done by student in mathematical operation equal to 15.38 %, percentage of error in visualization equation 21.54 %, error in algorithm 4.62%, student error in answer is 29.23 %, and student error in accuracy is 29.23 %. This indicates that the error in the level of language is significant. As a whole this method is effective to use.

The System on Chip design industry relies heavily on functional verification to ensure that the designs are bug-free. As design engineers are coming up with increasingly dense chips with much functionality, the functional verification field has advanced to provide modern verification techniques. In this paper, we present verification of a wishbone compliant Serial Peripheral Interface (SPI) Master core using a System Verilog based standard verification methodology, the Universal Verification Methodology (UVM). The reason for using UVM factory pattern with parameterized classes is to develop a robust and reusable verification IP. SPI is a full duplex communication protocol used to interface components most likely in embedded systems. We have verified an SPI Master IP core design that is wishbone compliant and compatible with SPI protocol and bus and furnished the results of our verification. We have used QuestaSim for simulation and analysis of waveforms, Integrated Metrics Center, Cadence for coverage analysis. We also propose interesting future directions for this work in developing reliable systems., Comment: 5 pages, 6 figures

The structural complexity of design components (e.g. Classes) is proportional to design quality at the system level and is quantified via the object-oriented metrics. The frequent use of design patterns causes of too much abstraction and can increase the structural complexity of design components. Though, in our previous work, we have empirically investigated the impact of use intensity of design pattern on the system level quality attributes. However, the empirical investigation of the effect of usage of design patterns on the design properties is still required. In this regard, we conduct an empirical study and perform a case study which includes the analysis 1) the existence of a correlation between design pattern usage and design metrics, 2) the confounding effect of system size (number of classes) on the correlation, and 3) how the change in number of employed design pattern instances affects the structural complexity in the subsequent releases of a system. The result of this study suggests that structural complexity associated with aggregation, coupling, functional abstraction design properties has a significant relationship with the employed instances of Template, Adapter-Command, Singleton, and Factory Method design patterns.

Design patterns are general reusable solutions to common recurring problems in software projects. These solutions, when correctly applied, are supposed to enhance modular and flexible structures in software. The aim of this work is to study the occurrences of God Class and Long Method bad smells in software systems developed with design patterns. To achieve this aim, we carried out a study with five Java project, in order to: (i) investigate if the use of GOF design patterns avoid the occurrences of the bad smells God Class and Long Method, (ii) identify co-occurrences of the GOF design patterns with these bad smells, and (iii) identify the main situations that lead software systems to present these co-occurrences. The results obtained suggest that Composite and Factory Method have a low co-occurrence with these bad smells, and Template Method and Observer have a high co-occurrence with God Class and Long Method, respectively. In addition, we have identified that the misuse of design patterns and the scattering and crosscutting concerns has contributed to the emergence of such co-occurrences.

People nowadays would rather spend less time with their friends than on the services like Facebook or Twitter on their smartphones. Many business and enterprises start to use software robot to promote their products and interact with customers with less cost and more efficiency. Due to various APIs from different social platforms, developers have to follow specific rules while developing robots. Therefore, in this paper, we propose to develop integrated APIs by utilizing design patterns, including Adapter Pattern, Factory Pattern, for developers to create cross-platform social robots.

Complex conditional statement is one of the bad code smells, which affects the quality of the code and design of software. In the proposed approach, two commonly-used design patterns for handling complex conditional statements are selected, and they are the factory method pattern and the strategy pattern. Two pattern-directed refactoring approaches based on the two design patterns are proposed. Each approach contains a refactoring opportunities identification algorithm and an automated refactoring algorithm. After parsing the abstract syntax tree generated from source code, the refactoring opportunities are identified effectively and automatically. Then, for candidate code, refactoring algorithms are executed automatically, which are used to simplify or remove complex conditional statements. By empirical analysis and quality assessment, the code after refactoring has better maintainability and extensibility, and the proposed approach for automated pattern-directed refactoring succeeds to reduce code size and complexity of classes.

It is the status quo that the data from different earthquake emergency software applications cannot be exchanged and shared. The diverse business applications were constructed and operated in different earthquake departments. The construction scheme of the software framework based on WebService data exchange technology was proposed in this paper. To realize the system integration, several software design patterns, such as the observer pattern and the factory pattern, and the WebService technology was used. The earthquake emergency response system based on this architecture could make use of the data from other heterogeneous systems efficiently and automatically. As a result, the process of the earthquake emergency response and the decision-making would be more cooperative, scientific and comprehensive.

Design Patterns provide solutions to problems that are notably prevailing in software engineering. The paper targets the importance of design patterns, but also aims on how design patterns uncover and fortify good object oriented principles. A design pattern called Bout was discovered to maintain sessions for a specific period of time. The design is a generic solution to implementing web portals by storing session data of clients on the server. The Bout pattern comprises the design principle of Singleton and Prototype patterns, thus guaranteeing a more reusable design. The Bout pattern is documented in the Gang of Four pattern description template. The Bout pattern was tested with a Job Portal system with additional patterns, Factory Method, Decorator and Observer, with significant improvement in object oriented design metrics. Metrics which showed a significant enhancement were Depth of Inheritance Tree and McCabe Cyclomatic Complexity. The reusability of black box components was analyzed for the Job Portal system which shows a momentous rise in the metrics. The source code was analyzed for modularity traits such as size, complexity, cohesion and coupling, which in turn determines the class quality, package quality and hence the modularity index. These quality metrics showed a symbolic upswing with Bout pattern and supporting patterns. Thus software designers can enhance the quality of distributed systems with the exercising of Bout pattern.

The issues facing historical research into porcelain factories in the 19th Century and the problems facing Swansea and Nantgarw china works research: the absence of factory pattern books and work schedules for commissioned services is especially noteworthy for these two small factories in comparison with their larger contemporary competitors such as Worcester and Derby, where original records are still extant for consultation and study. The use of pattern numbers, absent for Nantgarw and sporadic for Swansea is discussed along with the presence of factory impressed and applied stencil and script marks, which especially for Nantgarw products were prone to mimicry and faking. Disputed attributions again illustrate the necessity for a holistic approach to vet and confirm genuine articles form spurious porcelain generated at other factories but bearing a Swansea or Nantgarw mark. The attribution of an artist to the decoration of ceramics has always been challenging and is no exception for these two factories and a list of artists who have been identified as working at Swansea and Nantgarw is provided.

Objectives: Implementation of Verification IP with randomized stimulus and coverage for Avalon Memory Mapped interface using Universal Verification Methodology (UVM). Methods/Statistical Analysis: The VIP is implemented using UVM. The unique feature of UVM is its reusability. All the UVM components are implemented to create the VIP for AValon Memory Mapped (AVMM) interface. The environment uses random stimuli to create different scenarios and improves coverage during regression. The coverage collection measures how much verification goal is achieved. Findings: The VIP created is unique and novel as it is flexible and scalable and allows user to modify according to the need. The factory pattern and phased test flow makes it versatile and reusable to plug and play in any SOC. The cover groups and coverage bins gives the report on what features has been covered and what needs to be exercised. The functional coverage achieved with implemented VIP is 91.6% Application/Improvements: AVMM interface is used to provide communicate between various components. The AVMM VIP can be used for verification in any SOC that uses AVMM interface. The random environment can be constrained to fill the coverage holes.

Define an interface for creating an object, but let subclasses decide which class to instantiate. The factory method lets a class defer instantiation to subclasses.

The simple factory is not an design pattern you find in the original 90s Gang of Four design patterns book. Yet it is an extremely useful way to create objects—so useful that I made a chapter for it.

Design patterns are one of the most efficient ways of application development. Many developers are still reluctant to the use of design patterns and development is carried out with not enough attention paid to the reusability and extensibility of the code. Patterns are not to be restricted in the building of integrated development environments and language libraries. Proposed work presents a model which use combination of multiple design patterns for application development in object oriented programming. The model suggested in this proposed work uses hierarchical abstraction of objects created using factory pattern. Facade pattern is also used which makes functional encapsulation possible. Proposed work also presents the scenarios in which use of patterns is likely to improve the code efficiency and reusability. Along with the factory pattern, singleton pattern may also to be used together in the proposed model for their respective benefits.

According to the physical characteristics and safety requirements, the evaluation levels of special electromechanical equipment were created. The five-layer neural network model was created according to the multi-layer neural network model. The first layer is input layer, the last layer is output layer, and the others are hidden layers. The software structure of evaluation system was designed, and the main class diagram was designed with UML. The relations among views, data model and dispatch controller were designed with MVC pattern. The factory method was used to instantiate view objects according to the object creation pattern. The ITERATOR pattern of structural pattern was used to find out view objects in the view object aggregation. The strategy pattern of behavior pattern was used to encapsulate different neural network algorithms.

PurposeContinuous process flow is a prerequisite of lean systems as it helps to reduce throughput times, improve quality, minimize operational costs, and shorten delivery times. The purpose of this paper is to empirically demonstrate the application of a methodology that combines a time‐based study, discrete‐event simulation and the trial and error method to enable a leaner process through more efficient line balancing and more effective flow for a park homes production process. This method is replicable across other contexts and industry settings.Design/methodology/approachThe paper reviews the UK park homes production industry and, specifically, a major factory that builds these homes. It compares the factory method to traditional on‐site construction methods. An empirical study of production times was carried out to collect data in order to analyse the current workload distribution and the process flow performance of the park homes production process. Finally, seven discrete‐event simulation models were developed in order to test different scenarios and define the optimum line balance for every section of the production process.FindingsBy combining time study, discrete‐event simulation and trial and error methods, the workload distribution and process flow performance of the park homes production line were analysed and improved. A reduction of between 1.82 and 36.32 percent in balancing losses in some sections of the process was achieved.Practical implicationsThis paper supports current knowledge on process flow improvement and line balancing by exploring and analysing these issues in a real‐life context. It can be used to guide production management practitioners in their selection of methods and demonstrates how they are exploited when seeking to improve process flow, efficiency and line balancing of production operations.Originality/valueThe study uses a real industrial application to demonstrate how the methodological combination and deployment of process flow improvement strategies, such as time study, simulation, and trial and error, can help organisations achieve process flow improvements and, as a consequence, a leaner production process.

The paper analyzes the use of creational patterns in solving computational linguistics problems. The Factory Method, Prototype, and Singleton patterns are considered in detail. The basic properties of patterns and the nature and characteristics of their use are reviewed, and the comparative analysis with other creational patterns is carried out. The structure of patterns and their possible applications in software systems to solve computational linguistics problems is considered separately. For each pattern, the conditions are presented under which its use is most appropriate.

The development of software for dynamic simulation of electrical power systems requires a comprehensive range of complex studies, which encompasses many areas of electrical engineering as well as software engineering. This study aims at to develop an efficient strategy applied to the development of software tools for dynamic power systems simulations studies. The proposed strategy is based on the object-oriented creational pattern. This approach has the advantage of makes easy the application development process, by performing a mapping between block diagram model representation and the corresponding specialized classes. Firstly, a conceptual mapping between block diagram and the object-oriented paradigm, based on the Factory Method, is carried out. After that, some flexible strategies are presented in order to obtain an improved efficiency for the numerical routines, based on the Builder standard. This allows for the parameterization of the selected numerical integration techniques. The proposed strategy was evaluated by using a 4-generator multi-machine power system. The simulation results shown that the proposed strategy was able to provides a good power system dynamic performance.

This paper presents object-oriented design patterns in the context of object construction and destruction. The examples leverage the newly supported object-oriented features of Fortran 2003. We describe from the client perspective two patterns articulated by Gamma et al. [1]: abstract factory and factory method. We also describe from the implementation perspective one new pattern: the object pattern. We apply the Gamma et al. patterns to solve a partial differential equation, and we discuss applying the new pattern to a quantum vortex dynamics code. Finally, we address consequences and describe the use of the patterns in two open-source software projects: ForTrilinos and Morfeus.

Three-tier knowledge management system based on .NET architecture is designed according to requirement specification, characteristics of and relationship between enterprise electronic archives and knowledge management. This system using three-tier design based on factory pattern has good encapsulation and portability, with clearer and more concise structure. It degrades the costs of system development and maintenance and upgrades system’s high reusability and development efficiency.

TDD is usually associated with the phrase “Write tests first, and then implement.” However, this is a rather distorted and reduced view of TDD.

GoF Definition: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

Design patterns are a set of common programming design elements that can be used to simplify the solution of recurring problems. With the use of OO techniques, design patterns can be cleanly implemented as a set of classes that work toward the solution of a common goal. These designs can then be reused and shared across applications.

This paper presents the methods which make a design process of control system easy. The real-time control framework makes writing real-time control programs easy. The framework reduces the dependency on the platform, such as OS and hardware, by using not only C but also Java. Simulation programs are transformed into Java programs, and that can execute platform independent simulation. The idea of the object model is used for the transformation of the codes. Real-time control programs are generated from simulation program automatically. Factory method pattern is used for automatic generation of real-time control programs. We develop a platform independent integrated environment for the simulation and the real-time control using above methods. The integrated environment has the facility of remote control by using distributed objects, 2006 SICE-ICASE International Joint Conference, 18-21 Oct. 2006, Busan, South Korea

Software "design patterns" seek to package proven solutions to design problems in a form that makes it possible to find, adapt, and reuse them. A common claim is that a design based on properly applied patterns will have fewer defects than more ad hoc solutions. This case study analyzes the weekly evolution and maintenance of a large commercial product (C++, 500,000 LOC) over three years, comparing defect rates for classes that participated in selected design patterns to the code at large. We found that there are significant differences in defect rates among the patterns, ranging from 63 percent to 154 percent of the average rate. We developed a new set of tools able to extract design pattern information at a rate of 3/spl times/10/sup 6/ lines of code per hour, with relatively high precision. Based on a qualitative analysis of the code and the nature of the patterns, we conclude that the Observer and Singleton patterns are correlated with larger code structures and, so, can serve as indicators of code that requires special attention. Conversely, code designed with the Factory pattern is more compact and possibly less closely coupled and, consequently, has lower defect numbers. The Template Method pattern was used in both simple and complex situations, leading to no clear tendency.

The detector description is an essential component that has to be used to analyse and simulate data resulting from particle collisions in high energy physics experiments. Based on the DD4hep detector description toolkit a flexible and data driven simulation framework was designed using the Geant4 tool-kit. We present this framework and describe the guiding requirements and the architectural design, which was strongly driven by ease of use. The goal was, given an existing detector description, to simulate the detector response to particle collisions in high energy physics experiments with minimal effort, but not impose restrictions to support enhanced or improved behaviour.Starting from the ROOT based geometry implementation used by DD4hep an automatic conversion mechanism to Geant4 was developed. The physics response and the mechanism to input particle data from generators was highly formalized and can be instantiated on demand using known factory patterns. A palette of components to model the detector response is provided by default, but improved or more sophisticated components may easily be added using the factory pattern. Only the final configuration of the instantiated components has to be provided by end-users using either C++ or python scripting or an XML based description.

This work presents an experience report on the architectural decisions taken in the evolution of a Software Product Line (SPL) of Model-based Testing tools (PLeTs). This SPL was partially designed and developed with the intention of minimizing effort and time-to-market during the development of a family of performance testing tools. With the evolution of our research and the addition of new features to the SPL, we identified limitations in the initial architectural design of PLeTs’ components, which led us to redesign its Software Product Line Architecture (SPLA). In this paper, we discuss the main issues that led to changes in our SPLA, as well as present the design decisions that facilitate its evolution in the context of an industrial environment. We will also report our experiences on architecture modifications in the evolution of our SPL with the intention of allowing easier maintenance in a volatile development environment.

In this paper, we have designed and implemented cluttering classification systems- unsupervised classifiers-for the processing of satellite remote sensing images. Implemented systems adopt various design patterns which include a factory pattern and a strategy pattern to support various satellite images`formats and to design compatible systems. The clustering systems consist of sequential clustering, K-Means clustering, ISODATA clustering and Fuzzy C-Means clustering classifiers. The systems are tested by using a Landsat TM satellite image for the classification input. As results, these clustering systems are well designed to extract sample data for the classification of satellite images of which there is no previous knowledge. The systems can be provided with real-time base clustering tools, compatibilities and components` reusabilities as well.

In this chapter, I describe the abstract factory pattern. This pattern is similar to the factory method pattern that I described in Chapter 9 but allows a calling component to obtain a family or group of related objects without needing to know which classes were used to create them. Table 10-1 puts the abstract factory pattern in context.

The factory method pattern is used when there is a choice to be made between classes that implement a common protocol or share a common base class. This pattern allows implementation subclasses to provide specializations without requiring the components that rely on them to know any details of those classes and how they relate to each other. Table 9-1 puts the factory method into context.

Most of existing Business process management (BPM) technologies have their own graphical user interfaces (GUIs), whereas users in different organizations who involved in business processes are more likely to work with a different set of GUIs. Consequently, developers have to build the specific set of GUIs in enterprise application which is appropriate for each business process, and they use BPM API to create communication between the enterprise application and BPM. However, different BPM vendors have different APIs integrated into the system. When developers need to change BPM vendor for corresponding to existing resources and devices of a new customer, the developers have to rewrite codes to interact with such new API every time. Thus a framework that is easy to plug into further enterprise application for connecting to any BPM systems and reusable is necessary. Design patterns idea is applied in object oriented design principle in order to provide an efficient way in creating more reusable software. In this paper, a new framework for enterprise application is created by applying three types of design pattern which are Bridge pattern, Decorator pattern and Factory pattern. This framework aims to be reusability, flexibility and maintainability in order to easily support BPM vendor changing.

In this and the following three chapters, I’m going to explain the priniples of design patterns and code architecture pattern for large-scale JavaScript applications that will keep your code sensibly organized and easy to understand, making the job of maintaining and adding to your code a lot simpler. By implementing one or more of the patterns and techniques found in these chapters, you’ll find much of your code files look, at a glance, very similar to each other, which breeds instant familiarity for a number of developers working together on the same project. In fact, if you choose to adopt any of these techniques across multiple projects, you’ll likely find the same patterns and architecture idioms work across them all, making it easier to get new developers up to speed on different projects and freeing up those developers to concentrate on writing excellent code.

This paper introduces the Model-View-Controller (MVC) pattern, Factory Method Pattern (FMP), and Strategy Pattern (SP) into hybrid traffic simulation modeling based on Multi-Resolution Modeling (MRM). It designs the framework of the Traffic Multi-Resolution Simulation System (TMRSS) using MRM theory and develops the architecture of TMRSS based on the MVC pattern. In addition, it founds the data structure models of TMRSS, which include route, segment, and event structures. They are implemented by the FMP and SP, respectively. Furthermore, the paper presents three patterns to implement structures of data and logic, which include framework design, architecture design, and data structure design in TMRSS. Finally, a case is exemplified to prove that the architecture and structures are available, suitable, and scalable in TMRSS.