Crowdsourced Machine Learning Based Recommender for Software Design Patterns

Software technology has become an essential part of human lives today. The role of software Engineers in making this technology as success is very fundamental. In software Engineering, the toughest stage is to design software as there is no particular rule or formula to covert requirements into design representation. A designer designs software using skills, critical thinking ability and previous experience only. To make this process easy, the design patterns came into existence which are the solutions that can be used repetitively to solve design problems. There have been several pieces of research presented regarding design Patterns but it is hard to find research regarding how the patterns are perceived and used in industries today and what nature of application uses which specific patterns. This paper uses a crowdsourced approach to acquire the finest practices that are being used in industries today including which quality attributes are affected most by the implementation of these patterns and which patterns are suitable for what type of applications. It also uses a machine learning supervised algorithm (Matchbox Recommender) to predict suitable design pattern for different nature of applications

MORE: A multi‐objective refactoring recommendation approach to introducing design patterns and fixing code smells

Peer Reviewedhttps://deepblue.lib.umich.edu/bitstream/2027.42/137556/1/smr1843.pdfhttps://deepblue.lib.umich.edu/bitstream/2027.42/137556/2/smr1843_am.pd

Formal specification of the variants and behavioural features of design patterns

The formal specification of design patterns is widely recognized as being vital to their effective and correct use in software development. It can clarify the concepts underlying patterns, eliminate ambiguity and thereby lay a solid foundation for tool support. This paper further advances a formal meta-modelling approach that uses first order predicate logic to specify design patterns. In particular, it specifies both structural and behavioural features of design patterns and systematically captures the variants in a well-structured format. The paper reports a case study involving the formal specification of all 23 patterns in the Gang of Four catalog. It demonstrates that the approach improves the accuracy of pattern specifications by covering variations and clarifying the ambiguous parts of informal descriptions

An exploratory study of the impact of software changeability

Antipatterns are poor design choices that make object-oriented systems hard to maintain by developers. In this study, we investigate if classes that participate in antipatterns are more change-prone than classes that do not. Specifically, we test the general hypothesis: classes belonging to antipatterns are not more likely than other classes to undergo changes, to be impacted when fixing issues posted in issue- tracking systems, and in particular to unhandled exceptions-related issues - a crucial problem for any software system. We detect 11 antipatterns in 13 releases of Eclipse and study the relations between classes involved in these antipatterns and classes change-, issue-, and unhandled exception-proneness. We show that, in almost all releases of Eclipse, classes with antipatterns are more change-, issue-, and unhandled-exception-prone than others. These results justify previous work on the specification and detection of antipatterns and could help focusing quality assurance and testing activities

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

Studying and Assisting the Practice of Java and C# Exception Handling

Programming languages provide features that handle exceptions. These features separate error-handling from regular code and aim to assist software maintenance. Nevertheless, their misuse can cause reliability degradation or even catastrophic failures. Prior studies on exception handling aim to understand the practices of exception handling and their anti-patterns. However, little knowledge was shared about the prevalence of these anti-patterns, nor the relationship between exception handling practices and software quality. In this thesis, I, first, study the exception handling features by enriching the knowledge of handling code with a flow analysis of exceptions. Second, I investigate the prevalence of exception handling anti-patterns. Finally, I investigate the relationship between software quality and: (i) flow characteristics and (ii) 17 handling anti-patterns. Our case study is conducted with over 10K handling blocks, and over 77K related flows from 16 Java and C# projects. I built statistical models of the chance of post-release defects using traditional software metrics and exception handling metrics. Our case study results show the complexity of exception handling. Moreover, I found that although exception handling anti-patterns widely exist in all of our subjects, only a few anti-patterns can be commonly identified. Finally, I conclude that exception flow characteristics in Java projects and some exception handling anti-patterns can provide significant explanatory power to the chance of post-release defects

Design Patterns in Erasmus

This thesis presents design patterns for the emerging programming language Erasmus that is based on a process-oriented paradigm. We have developed these patterns using the current version of Erasmus, μE, and its corresponding compiler MEC. The design patterns are inspired on some of the patterns presented in the book [GHJV95]. Also, we have followed the elements of documentation templates that appear in that book. The patterns are presented visually; the gures show the high-level structure of the design patterns. Since the tendency of software development is to shift to concurrent and distributed computation, new paradigms are emerging to accommodate this shift. Erasmus is one of these new developing paradigms. We try in this thesis, through developing design patterns for Erasmus, to demonstrate and prove that process-oriented programming is a viable and valid paradigm. We also compare process-oriented programming presented by Erasmus with object-oriented programming in the implementation of the design patterns. We have chosen a set of design patterns that represent the dierent categories that appear in the book [GHJV95] and we tried to preserve the essential concepts of the original designs. However, the designs are not a direct translation of their counterparts in OOP. Rather, the designs make use of the abstraction of POP and nd solutions from within the paradigm itself. That is why in some designs, for one pattern in OOP we have created two or three design patterns in μE