OOSA’98 ECOOP’98 Workshop on Object-Oriented Software Architectures Workshop Summary

From patterns to frameworks to parallel programs

The article presents SOLID as a system of constructive constraints that disciplines the degrees of freedom in design and transforms the evolution of software systems into a controlled process. It explains the relationship of the principles with the foundations of object-oriented programming, design patterns, and architectural styles. Non-obvious effects are examined, including premature abstractions under OCP, hidden configuration coupling under DIP/DI, class explosion and responsibility fragmentation under SRP/ISP, and semantic violations of LSP that are not captured by type signatures. An operational approach to decision validation is proposed through metrics, contract-based tests, and threshold controls for introducing abstractions, along with practical decision-making protocols.

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.

This paper presents the new architecture of the satellite simulator software for the third China-Brazil Earth Resources Satellite (CBERS-3). This architecture is flexible and scalable to comply with the new challenge imposed of making software reusable to reduce cost. The article discusses previous solutions adopted at INPE since the 90’s. Advantages and disadvantages of past simulator solutions are summarized, from simple satellites, like the Brazilian data collection SCD’s, up to the more complex earth resources observation satellites (CBERSs). The experience of purchasing a COTS (Commercial Off-The-Shelf) product to accelerate the simulator development for scientific satellites is also reported. The new simulator architecture, for CBERS3, is intended to serve as a framework also for the development of the scientific satellite simulators. Furthermore, the simulator development is to comply with INPE’s policy of improving and giving priority to the national space software industry. To achieve this, the architecture includes a common, reusable, real time command monitoring core software, which is based on software engineering concepts of objectoriented modeling and design patterns.

Design patterns have received a lot of attention recently, especially from the object-oriented community as a technique for design reuse. It has proved itself as an important piece that was missing from object-oriented design methods. Design patterns make it easier to reuse successful designs and architectures by providing solutions to common design problems at the abstract level. We have adopted an object-oriented development method complemented with design patterns in the development of a multimedia courseware system. The adoption of design patterns has helped us reuse software architectures and successful design experiences of design experts. In the system architectures, some design patterns are used only once, while others are used more than once in different places. This paper introduces some uses of design patterns in the design of a multimedia courseware system to obtain a flexible and reusable architecture as well as some of our experience in applying design patterns.

Based on the words about why we must study software architecture, this article analyzed what the idea of building software architecture based on design patterns acts on the process of software development, discussed the development trend of software architecture and design patterns, and pointed to the problems which need to pay your attention during the term of building software architecture based on design patterns. In addition this paper described how the MVC pattern works in J2EE and explained what responsibilities the various parts in MVC have.

One of the difficulties for the development and testing of data analysis applications used by IoT devices is the economic and temporary cost of building the IoT network, to mitigate these costs and expedite the development of IoT and analytical applications, it is proposed NIOTE, an IoT network emulator that generates sensor and actuator data from different devices that are easy to configure and deploy over TCP/IP and MQTT protocols, this tool serves as support in academic environments and conceptual validation in the design of IoT networks. The emulator facilitates the development of this type of application, optimizing the development time and improving the final quality of the product. Object-oriented programming concepts, architecture, and software design patterns are used to develop this emulator, which allows us to emulate the behavior of IoT devices that are inside a specific network, where you can add the number of necessary devices, model and design any network. Each network sends data that is stored locally to emulate the process of transporting the data to a platform, through a specific format and will be sent to perform Data Analysis.

Micro and macro workflow variability design techniques of component

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.

Embedded systems are highly optimised to operate in the physical world they are embedded to. Hence, dedicated peripheral devices are designed which need support by a device driver to raise the level of abstraction for the application programmer. Even with methods of hardware/software co-design, devices and drivers are still designed by two designer groups. This paper depicts a systematic approach to design the coarse grained structure of the device driver by reflection and mapping of the internal structure of the device hardware. Even though common operating systems are programmed in a functional programming language, means of object-oriented programming languages and design pattern are applied.

The aim of the paper is to investigate applicability of object-oriented software design patterns in the context of aspect-oriented design. The paper analyses which of the GoF 23 patterns have a meaning in this context and how they are affected by it. The main assumption is that there exist design patterns that solve software engineering paradigm independent design problems and that such patterns, in the contrast to the patterns solving paradigm-specific design problems, can be expressed in terms of any software engineering paradigm. However, the paper deals only with two paradigms: aspect-oriented (AO) paradigm and object-oriented (OO) paradigm. It proposes a classification of design problems based on this assumption and a technique for redesigning object-oriented patterns into pure aspect-oriented ones. It presents a number of examples how to apply this technique and discusses the results obtained. The results show that 20 of the GoF 23 design patterns solve such design problems that are common at least for both mentioned paradigms and demonstrate in which way these patterns can be adapted for the needs of aspect-oriented design.

Since Gamma et al. published their design patterns, patterns are very popular in the area of software engineering. They provide best practice to handle recurring problems during the software development phase. Three years later, security patterns appeared and provided solutions for security problems. Besides the name analogy, design and security patterns should be very similar except for the security factor. In research and industry software engineering with design patterns is widespread. However, some researchers suspect that security-pattern engineering is made difficult by some issues such as terminology or description form. Detecting adoption problems can help to improve security patterns in future. Thus, they can promote the awareness of security especially in the software maintenance phase where many programmers first give attention to security problems. Therefore, we will compare design and security patterns to find indicators for negative impact on security pattern engineering in software development. We address this issue on inspecting the aspects classification, description form, provided code examples, and usage in the software life-cycle. We determine the degree of maturity of software-security patterns by comparing them to the well-explored design patterns. To achieve the objective, we inspect the pattern terminology and conducted a study on the used description forms including provided UML diagrams and code examples. Moreover, a literature review is conducted to compare their state of research w.r.t. the software life-cycle. The maturity degree of security patterns compared to common design patterns differs and we depict further research opportunities on security patterns.

Software design patterns classification and selection using text categorization approach

Much work in software architecture has been inspired by work in physical architecture, in particular Alexander's work on 'design patterns'. By contrast, Alexander's work is little-used in town planning and architecture. In this paper, we examine some of the reasons that this is so, describe some parallels and differences between the fields of physical and software architecture, and identify areas in which future collaboration may be fruitful. The notion of 'participatory design' is important in software engineering and in urban regeneration, but the participatory mechanisms in each field are quite different.

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.