A Taxonomy for a Constructive Approach to Software Evolution

In many software design and evaluation techniques, either the software evolution problem is not systematically elaborated, or only the impact of evolution is considered. Thus, most of the time software is changed by editing the components of the software system, i.e. breaking down the software system. The software engineering discipline provides many mechanisms that allow evolution without breaking down the system; however, the contexts where these mechanisms are applicable are not taken into account. Furthermore, the software design and evaluation techniques do not support identifying these contexts. In this paper, we provide a taxonomy of software evolution that can be used to identify the context of the evolution problem. The identified contexts are used to retrieve, from the software engineering discipline, the mechanisms, which can evolve the software software without breaking it down. To build such a taxonomy, we build a model for software evolution and use this model to identify the factors that effect the selection of software evolution\ud mechanisms. Our approach is based on solution sets, however; the contents of these sets may vary at different stages of the software life-cycle. To address this problem, we introduce perspectives; that are filters to select relevant elements from a solution set. We apply our taxonomy to a parser tool to show how it coped with problematic evolution problems

Co-Occurrence of Design Patterns and Bad Smells in Software Systems: An Exploratory Study

A design pattern is a general reusable solution to a recurring problem in software design. Bad smells are symptoms that may indicate something wrong in the system design or code. Therefore, design patterns and bad smells represent antagonistic structures. They are subject of recurring research and typically appear in software systems. Although design patterns represent good design, their use is often inadequate because their implementation is not always trivial or they may be unnecessarily employed. The inadequate use of design patterns may lead to a bad smell. Therefore, this paper performs an exploratory study in order to identify instances of co-occurrences of design patterns and bad smells. This study is performed over five systems and discovers some co-occurrences between design patterns and bad smells. For instance, we observed the co-occurrences of Command with God Class and Template Method with Duplicated Code. The results of this study make it possible to understand in which situations design patterns are misused or overused and establish guidelines for their better use

A Survey on Design Pattern Recovery Techniques

The evaluation of design pattern recovery techniques and tools is significant as numbers of emergent techniques are presented and used in the past to recover patterns from source code of legacy applications. The problem of very diverse precision and recall values extracted by different pattern recovery techniques and tools on the same examined applications is not investigated thoroughly. It is very desirable to compare features of existing techniques as abundance of techniques supplemented with different tools has been presented in the last decade. We believe that new innovations for this discipline can be based on the empirical evaluation of existing techniques. The selected techniques cover the whole spectrum of state of the art research in design pattern recovery. The major contribution of this paper is a comprehensive discussion on state of the art in design pattern recovery research in the last decade followed by a proposed framework for classification and evaluation of existing design pattern recovery techniques. Finally we listed our observations as lessons learned which hamper design pattern recovery research and these observations can be used for future research directions and guidelines for this discipline

An Empirical Assessment of the Software Design Pattern Concept

Context: The publication of the milestone textbook on design patterns by the ‘Gang of Four’ (GoF) in 1995, introduced a set of 23 design patterns that are largely concerned with improving the practices and products of software development. However, there has been no comprehensive assessment of the effectiveness of design patterns, nor is there any evidence about any claims and factors that are made for pattern reuse in software development. Aims: The aims of this thesis are to assess the design patterns systematically in a sequence of studies, and to identify the claims and factors to determine how well they reflect experiences of pattern reuse in practice. Method: This thesis describes four studies: a document survey to identify claims for patterns, a mapping study to identify empirical studies about patterns, an online survey, and a narrative synthesis. The mapping study and the online survey together provide quite comprehensive and thorough evidence for the narrative synthesis. In the narrative synthesis, we check whether there is any consistency or not in the evidence about specific patterns, and also to see how the claims and factors influence pattern reuse. Results: The mapping study found 20 primary studies, and the online survey had 206 usable responses. In the 20 primary study of the mapping study 17 design patterns were examined. In the online survey 175 respondents considered patterns were useful, and 155 respondents reported on patterns that they considered not to be useful. Conclusion: From the synthesis results, the specific patterns Composite and Observer are evaluated as being generally useful, but the Visitor and Singleton patterns, while useful, have possible negative aspects. And also four of the claims and the effect of one factor are demonstrated to be generally true. But the others are either unsupported or have no effect

Understanding the Impact of Cloud Computing Patterns on Performance and Energy Consumption

RÉSUMÉ Les patrons infonuagiques sont des solutions abstraites à des problèmes récurrents de conception dans le domaine de l'infonuagique. Bien que des travaux antérieurs aient prouvé que ces patrons peuvent améliorer la qualité de service des applications infonuagiques, leur impact sur la consommation d'énergie reste encore inconnu. Pourtant l'efficacité énergétique est un défi majeur pour les systèmes infonuagiques. Actuellement, 10\% de l'électricité mondiale est consommée par les serveurs, les ordinateurs portables, les tablettes et les téléphones intelligents. La consommation d'énergie d'un système dépend non seulement de son infrastructure matérielle, mais aussi de ses différentes couches logicielles. Le matériel, le firmware, le système d'exploitation, et les différentes composantes logicielles d'une application infonuagique, contribuent tous à déterminer son empreinte énergétique. De ce fait, pour une meilleure efficacité énergétique, il est important d’améliorer l’efficacité énergétique de toutes les couches matérielles et logicielles du système infonuagique, ce qui inclut les applications déployées dans le système infonuagique. Dans ce mémoire, nous examinons l'impact de six patrons infonuagiques (Local Database proxy, Local Sharding Based Router, Priority Queue, Competing Consumers, Gatekeeper and Pipes and Filters) sur la consommation d'énergie de deux applications multi-traitement et multi-processus déployées dans un système infonuagique. La consommation d'énergie est mesurée avec l’outil Power-API, une interface de programmation d'application (API) écrite en Java et permettant de mesurer la consommation d'énergie au niveau du processus. Les résultats de nos analyses montrent que les patrons étudiés peuvent réduire efficacement la consommation d'énergie d'une application infonuagique, mais pas dans tous les contextes. D'une manière générale, nous prouvons qu'il y a un compromis à faire entre performance et efficacité énergétique, lors du développement d'une application infonuagique. De plus, nos résultats montrent que la migration d'une application vers une architecture de micro-services peut améliorer les performances de l'application, tout en réduisant considérablement sa consommation d'énergie. Nous résumons nos contributions sous forme de recommandations que les développeurs et les architectes logiciels peuvent suivre lors de la conception et la mise en œuvre de leurs applications.----------ABSTRACT Cloud Patterns are abstract solutions to recurrent design problems in the cloud. Previous work has shown that these patterns can improve the Quality of Service (QoS) of cloud applications but their impact on energy consumption is still unknown. Yet, energy consumption is the biggest challenge that cloud computing systems (the backbone of high-tech economy) face today. In fact, 10% of the world’s electricity is now being consumed by servers, laptops, tablets and smart phones. Energy consumption has complex dependencies on the hard- ware platform, and the multiple software layers. The hardware, its firmware, the operating system, and the various software components used by a cloud application, all contribute to determining the energy footprint. Hence, increasing a data center efficiency will eventually improve energy efficiency. Similarly, software itself can affect the internal design of cloud-based applications to optimize hardware utilization to lower energy consumption. In this work, we conduct an empirical study on two multi-processing and multi-threaded cloud- based applications deployed in the cloud, to investigate the individual and the combined impact of six cloud patterns (Local Database proxy, Local Sharding Based Router, Priority Queue, Competing Consumers, Gatekeeper and Pipes and Filters) on the energy consumption. We measure the energy consumption using Power-API; an application programming interface (API) written in Java to monitor the energy consumed at the process-level. Results show that cloud patterns can effectively reduce the energy consumption of a cloud application, but not in all cases. In general, there appear to be a trade-off between an improved response time of the application and the energy consumption. Moreover, our findings show that migrating an application to microservices architecture can improve the performance of the application, while significantly reducing its energy consumption. We summarize our contributions in the form of guidelines that developers and software architects can follow during the implementation of the cloud-based applications