Architectural smells have been widely studied in the literature, and some approaches have been developed to assess their impact on software quality metrics. Yet, empirical evidence bridging architectural smells and software quality metrics, while jointly considering security and performance issues, is limited. In this study, we investigate whether refactoring architectural smells can improve software quality and address security and performance issues that frequently occur in open-source projects. To this end, we analyze software code across various application domains and automatically detect architectural smells, as well as security and performance issues, using a diverse set of tools. Then, we manually remove detected instances of architectural smells and check whether their removal affects quality, security, and performance metrics originally collected in the selected projects. Our results indicate that refactoring architectural smells improves software quality and performance indicators, but we observe a less significant impact on security vulnerabilities.

Time-critical systems must satisfy temporal constraints whose correctness depends not only on event ordering but also on precise timing. Metric Interval Temporal Logic (MITL) provides a formalism to express such requirements. Although robustness has been widely studied under signal-based interpretations, it remains largely unexplored for point-based semantics, where executions are sequences of timestamped facts. In this setting, small timing variations may arbitrarily change Boolean satisfaction, revealing the instability of temporal truth under uncertainty. We introduce a notion of time robustness for MITL over point-based semantics, interpreting robustness as a margin of validity of temporal interpretations. We define a quantitative semantics and prove soundness with respect to Boolean satisfaction together with a Lipschitz stability property with respect to timestamp perturbations, which induces a metric notion of proximity between interpretations. The semantics admits a polynomial-time evaluation procedure and is illustrated on two case studies (drone surveillance and smart hospital), where robustness empirically correlates with tolerance to temporal noise.

• We introduced a fully automated framework that quantifies the relationship between microservice architecture complexity, derived from multiple types of statically detected dependencies, and performance-related quality attributes. • We analyzed five complex benchmark systems, including four structurally distinct releases of the Train-Ticket microservice benchmark and one instance of the DeathStarBench suite. • Regarding the relationship between microservice-architecture complexity and overall performance, our analysis demonstrated that systems with poor structural complexity, reflected in high propagation cost and high Clique ratios, exhibited reduced scalability and supported fewer user requests. • Regarding the relationship between individual service complexity and their performance, our results show that endpoints with higher coupling scores tend to have longer response times. Using Spearman’s rank correlation to assess the correlation between each endpoint’s coupling score and its performance score, we find a statistically significant positive correlation. A microservice architecture is intended to promote modularity and evolvability. In this paper, we present an automated framework for assessing the relationship between microservice architecture complexity and performance-related quality attributes. In this framework, we use PPTAM, a performance testing tool, to evaluate system response time under varying user loads, and DV8, an architecture analysis tool, to assess architectural complexity and the complexity of individual services using coupling scores, propagation cost, and architectural antipatterns derived from various types of dependency relations. Using this approach, we evaluated five benchmark systems, including four releases of a microservice system that share similar functionalities but differ in structural design. The results show that microservice architectures with poor complexity scores also exhibited degraded performance outcomes. This automated framework, for the first time, enables a comprehensive measurement of microservice architecture complexity, formed through multiple types of statically extracted dependencies, and its correlation with dynamically obtained performance metrics.

Federated Learning has emerged as a promising paradigm that enables collaborative model training while preserving data privacy, thus contributing to enhance user trust. However, the design of Federated Learning systems requires non-trivial architectural choices to address several challenges, such as system efficiency and learning accuracy. Architectural patterns for Federated Learning systems have been defined in the literature to handle these challenges, but their experimentation is limited. The objective of this paper is to empower software architects in their task of evaluating the design of FL systems while deciding which architectural alternatives are more beneficial in their context of adoption. Our methodology consists of a tool-based approach that embeds the implementation of six architectural patterns defined in the literature. The advantage is that software architects can select design alternatives either in isolation or in a combined fashion, and the subsequent analysis provides the evaluation of some metrics of interest. The experimental results indicate that architectural patterns can enhance system efficiency, although we found a combination of patterns that added overhead and turned to limit its benefit. By quantifying these trade-offs, we aim to support software architects in designing Federated Learning systems by evaluating the benefits and drawbacks of applying architectural patterns.

The microservice architecture (MSA) emerged as an evolution of existing architectural styles with the promise of improving software quality by decomposing an app into modules that can be maintained, deployed, and scaled independently. However, the transition from a monolithic to a microservice architecture is fraught with difficulties, especially when it comes to assessing qualitative aspects, as controversial results can arise. In this paper, we present an experience report on the migration of a monolithic web application and use performance, availability and energy efficiency as quality attributes to shed light on such an architectural transition. Horizontal scaling, i.e., distributing the workload across several service instances, is applied and we study its impact.Our main findings are: i) when no app component is replicated, MSA outperforms the monolithic architecture; ii) the monolithic architecture shows performance and availability improvement when replicating the entire app; iii) the replicated MSA version reaches a ceiling when not replicating its routing part (i.e., the API gateway), showing worse response times compared to the replicated monolith; iv) when replicating the API gateway, the MSA version reaches optimal performance with fewer replicates than the monolith; v) when not replicating services, MSA consumes more CPU resources than the monolithic architecture; vi) when scaling up, the MSA version is more efficient than the replicated monolith in terms of memory usage, and it can better exploit CPU resources; vii) when not replicating services, MSA consumes more energy than the monolithic architecture, whereas when scaling up, the MSA version is more efficient than the replicated monolith; MSA version reaches a good balance between CPU and memory usage.

Microservice architectures and design patterns enhance the development of large-scale applications by promoting flexibility. Industrial practitioners perceive the importance of applying architectural patterns but they struggle to quantify their impact on system quality requirements. Our research aims to quantify the effect of design patterns on system performance metrics, e.g., service latency and resource utilization, even more so when the patterns operate in real-world environments subject to heterogeneous workloads. We built a cloud infrastructure to host a well-established benchmark system that represents our test bed, complemented by the implementation of three design patterns: Gateway Aggregation, Gateway Offloading, Pipe and Filters. Real performance measurements are collected and compared with model-based predictions that we derived as part of our previous research, thus further consolidating the actual impact of these patterns. Our results demonstrate that, despite the difficulty to parameterize our benchmark system, model-based predictions are in line with real experimentation, since the performance behaviors of patterns, e.g., bottleneck switches, are mostly preserved. In summary, this is the first work that experimentally demonstrates the performance behavior of microservices-based architectural patterns. Results highlight the complexity of evaluating the performance of design patterns and emphasize the need for complementing theoretical models with empirical data.

Abstract The design of cyber-physical systems (CPS) is challenging due to the heterogeneity of software and hardware components that operate in uncertain environments (e.g., fluctuating workloads), hence they are prone to performance issues. Software performance antipatterns could be a key means to tackle this challenge since they recognize design problems that may lead to unacceptable system performance. This manuscript focuses on modeling and analyzing a variegate set of software performance antipatterns with the goal of quantifying their performance impact on CPS. Starting from the specification of eight software performance antipatterns, we build a baseline queuing network performance model that is properly extended to account for the corresponding bad practices. The approach is applied to a CPS consisting of a network of sensors and experimental results show that performance degradation can be traced back to software performance antipatterns. Sensitivity analysis investigates the peculiar characteristics of antipatterns, such as the frequency of checking the status of resources, that provides quantitative information to software designers to help them identify potential performance problems and their root causes. Quantifying the performance impact of antipatterns on CPS paves the way for future work enabling the automated refactoring of systems to remove these bad practices.

Autoscaling systems provide means to automatically change the resources allocated to a software system according to the incoming workload and its actual needs. Public cloud providers offer a variety of autoscaling solutions, ranging from those based on user-written rules to more sophisticated ones. Originally, these solutions were conceived to manage clusters of virtual machines, while more recently, they have also been employed in the operation of containers. This paper analyses the autoscaling solutions provided by three major cloud providers, namely Amazon Web Services, Google Cloud Platform, and Microsoft Azure, and compares them against two solutions we develop based on control theory (ScaleX) and queuing theory (QN-CTRL). We evaluate the different approaches using both an in-house simulation engine and cloud deployments by feeding them with various synthetic and real-world workloads. Our extensive evaluation collects both simulation results and real measurements by which we can assess that both scaleX and QN-CTRL outperform industrial techniques in most cases when considering the trade-offs between the service-level-agreement (SLA) violations and the optimal usage of resources.

Architectural smells have been studied in the literature looking at several aspects, such as their impact on maintainability as a source of architectural debt, their correlations with code smells, and their evolution in the history of complex projects. The goal of this paper is to extend the study of architectural smells from a different perspective. We focus our attention on software performance, and we aim to quantify the impact of architectural smells as support to explain the root causes of system performance hindrances. Our method consists of a study design matching the occurrence of architectural smells with performance metrics. We exploit state-of-the-art tools for architectural smell detection, software performance profiling, and testing the systems under analysis. The removal of architectural smells generates new versions of systems from which we derive some observations on design changes improving/worsening performance metrics. Our experimentation considers two complex open-source projects, and results show that the detection and removal of two common types of architectural smells yield lower response time (up to ) with a large effect size, i.e., for - of the hotspot methods. The median memory consumption is also lower (up to ) with a large effect size for all the services.

The adoption of design patterns in the microservice architecture and cloud-native development scope was recently reviewed to investigate the industry practice. Interestingly, when considering performance-related aspects, practitioners focus on specific metrics (e.g., the time taken to handle requests) to identify sources of performance hindrance. This paper investigates a subset of seven design patterns that industrial practitioners indicate as relevant for system performance. We are interested to quantify the impact of these patterns while considering heterogeneous workloads, thus supporting software architects in understanding the root causes of performance issues. We use queuing networks to build the performance models of the seven design patterns and extract quantitative insights from model-based performance analysis. Our performance models are flexible in their input parameterization and reusable in different application contexts. We find that most design patterns confirm the expectation of practitioners, and our experimental results assess the identified performance gains and pains. One design pattern (i.e., Gateway Offloading) shows the peculiar characteristic of contributing to performance pains in some cases, leading to novel insights about the impact of design patterns in microservice systems.

Abstract Non-functional properties of collective adaptive systems (CAS) are of paramount relevance practically in any application. This paper compares two recently proposed approaches to quantitative modelling that exploit different system abstractions: the first is based on generalised stochastic Petri nets, and the second is based on queueing networks. Through a case study involving autonomous robots, we analyse and discuss the relative merits of the approaches. This is done by considering three scenarios which differ on the architecture used to coordinate the distributed components. Our experimental results assess a high accuracy when comparing model-based performance analysis results derived from two different quantitative abstractions for CAS.

Performance evaluation of multi-agent systems (MAS) embraces several challenges due to uncertain operational environments, such as software/hardware failures and unfaithful communications that facilitate the spread of deceptive messages. One way to smooth the impact of reliability and security potential issues in MAS is to enforce different coordination mechanisms among agents (i.e., coordinating multiple agents that need to perform a sequence of actions to maximize a system-level reward), and evaluate their efficiency. In this paper, we propose a tool-based approach, namely COORDINATE, that simulates and compares the performance characteristics of different coordination mechanisms for MAS while considering fault-tolerant and corrupted agents. A Smart Hospital is adopted as illustrative example to show the need of performance-based analysis results pointing out which coordination mechanism is more efficient. Experimental results indicate that the inter-arrival time of tasks to be accomplished, the failure probability of agents, and the ratio of faithful to malicious agents contribute to determining the efficiency of different coordination mechanisms. When varying these parameters in the considered scenarios, the system latency can be reduced up to 4.2× by selecting the optimal coordination mechanism. This way, software developers are informed on the system peculiarities that trigger the switching among such coordination mechanisms for a performance-based optimal solution.

The detection of performance issues in Java-based applications is not trivial since many factors concur to poor performance, and software engineers are not sufficiently supported for this task. The goal of this manuscript is the automated detection of performance problems in running systems to guarantee that no quality-based hinders prevent their successful usage. Starting from software performance antipatterns, i.e., bad practices (e.g., extensive interaction between software methods) expressing both the problem and the solution with the purpose of identifying shortcomings and promptly fixing them, we develop a framework that automatically detects seven software antipatterns capturing a variety of performance issues in Java-based applications. Our approach is applied to real-world case studies from different domains, and it captures four real-life performance issues of Hadoop and Cassandra that were not predicted by state-of-the-art approaches. As empirical evidence, we calculate the accuracy of the proposed detection rules, we show that code commits inducing and fixing real-life performance issues present interesting variations in the number of detected antipattern instances, and solving one of the detected antipatterns improves the system performance up to 50%.

Understanding the performance characteristics of software systems is particular relevant when looking at design alternatives. However, it is a very challenging problem, due to the complexity of interpreting the role and incidence of the different system elements on performance metrics of interest, such as system response time or resources utilisation. This work introduces JSIMutate, a tool that makes use of queueing network performance models and enables the analysis of mutations of a model reflecting possible design changes to support designers in identifying the model elements that contribute to improving or worsening the system's performance.

Performance models have been used in the past to understand the performance characteristics of software systems. However, the identification of performance criticalities is still an open challenge, since there might be several system components contributing to the overall system performance. This work combines two different areas of research to improve the process of interpreting model-based performance analysis results: (i) software performance engineering that provides the ground for the evaluation of the system’s performance; (ii) mutation-based techniques that nicely supports the experimentation of changes in performance models and contribute to a more systematic assessment of performance indices. We propose mutation operators for specific performance models, i.e., queueing networks, that resemble changes commonly made by designers when exploring the properties of a system’s performance. Our approach consists in introducing a mutation-based approach that generates a set of mutated queueing network models. The performance of these mutated networks is compared to that of the original network to better understand the effect of variations in the different components of the system. A set of benchmarks is adopted to show how the technique can be used to get a deeper understanding of the performance characteristics of software systems.

Android is nowadays the most popular operating system in the world, not only in the realm of mobile devices, but also when considering desktop and laptop computers. Such a popularity makes it an attractive target for security attacks, also due to the sensitive information often manipulated by mobile apps. The latter are going through a transition in which the Android ecosystem is moving from the usage of Java as the official language for developing apps, to the adoption of Kotlin as the first choice supported by Google. While previous studies have partially studied security weaknesses affecting Java Android apps, there is no comprehensive empirical investigation studying software security weaknesses affecting Android apps considering (and comparing) the two main languages used for their development, namely Java and Kotlin. We present an empirical study in which we: (i) manually analyze 681 commits including security weaknesses fixed by developers in Java and Kotlin apps, with the goal of defining a taxonomy highlighting the types of software security weaknesses affecting Java and Kotlin Android apps; (ii) survey 43 Android developers to validate and complement our taxonomy. Based on our findings, we propose a list of future actions that could be performed by researchers and practitioners to improve the security of Android apps.

Architecting Cyber-Physical Systems is not trivial since their intrinsic nature of mixing software and hardware components poses several challenges, especially when the physical space is subject to dynamic changes, e.g., paths of robots suddenly not feasible due to objects occupying transit areas or doors being closed with a high probability. This paper provides a quantitative evaluation of different architectural patterns that can be used for cyber-physical systems to understand which patterns are more suitable under some peculiar characteristics of dynamic spaces, e.g., frequency of obstacles in paths. We use stochastic performance models to evaluate architectural patterns, and we specify the dynamic aspects of the physical space as probability values. This way, we aim to support software architects with quantitative results indicating how different design patterns affect some metrics of interest, e.g., the system response time. Experiments show that there is no unique architectural pattern suitable to cope with all the dynamic characteristics of physical spaces. Each architecture differently contributes when varying the physical space, and it is indeed beneficial to switch among multiple patterns for an optimal solution.

Modern software systems operate in complex and changing environments and are exposed to multiple sources of uncertainty. Testing methods shall be tailored to uncertainty as a first-class concern in order to quantify it and deliver increased confidence in the level of assurance of the final product. In this paper, we introduce novel model-based exploration strategies that generate test cases targeting uncertain components of the system under test. Our testing framework leverages Markov Decision Processes as modeling formalism of choice. The tester explicitly specifies uncertainty by means of beliefs attached to transition probabilities. The structural properties of the model and the uncertainty specification are then exploited to drive the test case generation process. Bayesian inference is used to achieve this objective by updating the initial beliefs through the evidence collected by testing. The proposed uncertainty-aware test selection strategies have been systematically evaluated on three realistic benchmarks and nine synthetic systems exhibiting up to 10k model transitions. We demonstrate the effectiveness of the novel strategies with well-established metrics. Results show they outperform existing testing methods with a gain up to 2.65× in terms of accuracy of the inference process.

Context. Software Performance Antipatterns (SPAs) research has focused on algorithms for the characterization, detection, and solution of antipatterns. However, existing algorithms are based on the analysis of runtime behavior to detect trends on several monitored variables (e.g., response time, CPU utilization, and number of threads) using pre-defined thresholds. Objective. In this paper, we introduce a new approach for SPA characterization and detection designed to support continuous integration/delivery/deployment (CI/CDD) pipelines, with the goal of addressing the lack of computationally efficient algorithms.

Identifying performance problems in modern software systems is nontrivial, even more so when looking at specific application domains, such as cyber-physical systems. The heterogeneity of software and hardware components makes the process of performance evaluation more challenging, and traditional software performance engineering techniques may fail while dealing with interacting and heterogeneous components. The goal of this paper is to introduce a model-based approach to understand software performance problems in cyber-physical systems. In our previous work, we listed some common bad practices, namely software performance antipatterns, that may occur. Here we are interested in shedding light on these antipatterns by means of performance models, i.e., queuing network models, that provide evidence of how antipatterns may affect the overall system performance. Starting from the specification of three software performance antipatterns tailored for cyber-physical systems, we provide the queuing network models capturing the corresponding bad practices. The analysis of these models demonstrates their usefulness in recognizing performance problems early in the software development process. This way, performance engineers are supported in the task of detecting and fixing the performance criticalities.

We study a probabilistic variant of binary session types that relate to a class of Finite-State Markov Chains. The probability annotations in session types enable the reasoning on the probability that a session terminates successfully, for some user-definable notion of successful termination. We develop a type system for a simple session calculus featuring probabilistic choices and show that the success probability of well-typed processes agrees with that of the sessions they use. To this aim, the type system needs to track the propagation of probabilistic choices across different sessions.

Refactoring is often needed to ensure that software systems meet their performance requirements in deployments with different operational profiles, or when these operational profiles are not fully known or change over time. This is a complex activity in which software engineers have to choose from numerous combinations of refactoring actions. Our paper introduces a novel approach that uses performance antipatterns and stochastic modelling to support this activity. The new approach computes the performance antipatterns present across the operational profile space of a software system under development, enabling engineers to identify operational profiles likely to be problematic for the analysed design, and supporting the selection of refactoring actions when performance requirements are violated for an operational profile region of interest. We demonstrate the application of our approach for a software system comprising a combination of internal (i.e., in-house) components and external third-party services.

We introduce a structure-aware parallel technique for context-bounded analysis of concurrent programs. The key intuition consists in decomposing the set of concurrent traces into symbolic subsets that are separately explored by multiple instances of the same decision procedure running in parallel. The decision procedures work on different partitions of the search space without cooperating, whence distribution follows effortlessly. Our experiments on a selection of complex multi-threaded programs show significant analysis speedups and scalability, and greater performance gains than with general-purpose parallel solvers.

Abstract The process of engineering cyber‐physical systems (CPS) is inevitably challenging because of the intrinsic problem of merging the specification of different ensembles that indicate hardware, software, and physical aspects of such systems. This intrinsic complexity is exacerbated when modelling and analysing the performance characteristics of CPS since multiple models need to coexist in order to get meaningful performance indicators. In this paper, we present a case study, a delivery robots system, whose experience is exploited towards building a guided process for engineering CPS through performance‐based modelling and analysis. Model‐based performance results are provided while analysing different design alternatives, thus to support architects in the process of better understanding the performance characteristics of CPS under development.

The modeling and analysis of Cyber Physical Systems (CPS) is inevitably challenging due to the intrinsic problem of merging the specification of different ensembles that indicate hardware, software and physical aspects of such systems. This intrinsic complexity is exacerbated in performance engineering since multiple models need to co-exist in order to get meaningful performance indicators. In this paper we introduce a guided process called IMPACt (multI Modelling PerformAnce Cps),which helps architects during the design phase, to better understand the behavior of the system under development and the design choices they made, through performance analysis on results obtained by runnable models derived from system high-level specification.

A key challenge in software systems that are exposed to runtime variabilities, such as workload fluctuations and service degradation, is to continuously meet performance requirements. In this paper we present an approach that allows performance self-adaptation using a system model based on queuing networks (QNs), a well-assessed formalism for software performance engineering. Software engineers can select the adaptation knobs of a QN (routing probabilities, service rates, and concurrency level) and we automatically derive a Model Predictive Control (MPC) formulation suitable to continuously configure the selected knobs and track the desired performance requirements. Previous MPC approaches have two main limitations: i) high computational cost of the optimization, due to nonlinearity of the models; ii) focus on long-run performance metrics only, due to the lack of tractable representations of the QN's time-course evolution. As a consequence, these limitations allow adaptations with coarse time granularities, neglecting the system's transient behavior. Our MPC adaptation strategy is efficient since it is based on mixed integer programming, which uses a compact representation of a QN with ordinary differential equations. An extensive evaluation on an implementation of a load balancer demonstrates the effectiveness of the adaptation and compares it with traditional methods based on probabilistic model checking.

Summary Modern software systems are required to dynamically adapt to changing workloads, scenarios, and objectives and to achieve a certain Quality of Service (QoS). Guaranteeing QoS requirements is not trivial, as run‐time uncertainty might invalidate the design‐time rationale, where software components have been selected by means of off‐line analysis. In this work, we propose a QoS‐based feedback approach that makes a combined use of design‐time predictions and run‐time measurements to manage QoS data over time and support software architects while selecting software components that best fit QoS requirements. We illustrate the feasibility and efficacy of the approach on a case study, where the quantitative evaluation shows how the analysis effectively identifies the sources of QoS violations and indicates possible solutions to achieve QoS requirements.

Performance assessment of cloud-based applications requires new methodologies to deal with the complexity of software systems and the variability of cloud resources. In this paper, we address the problem of reducing the total costs for running cloud-based applications while fulfilling service-level objectives (SLOs). To this end, we define an approach to refactor a cloud application in such a way that, when it is deployed, it requires less computational capacity and therefore less resources. We experimented our approach on top of a modified optimal provisioning heuristic designed for preemptible cloud resources and the results show that it reduces deployment costs, up to 60% when compared to the same approach, but without model-driven application refactoring.

Performance assessment of cloud-based big data applications require new methodologies and tools to take into consideration on one hand the volume, the variability and the complexity of big data, and on the other hand the intrinsic dynamism of cloud environments. To this end, we introduce software performance antipatterns as reference knowledge to capture the well-known bad design practices that lead to software products suffering by poor performance. This paper discusses some of the challenges and opportunities of research while introducing software performance antipatterns in cloud computing environments. We present a model-based framework that makes use of software performance antipatterns to improve the Quality-of-Service (QoS) objectives of cloud-based big data applications.

This paper discusses the challenges and opportunities of Software Performance Engineering (SPE) research in smart-grid (SG) environments. We envision to use SPE techniques to optimise the quality of information and communications technology (ICT) applications, and thus optimise the quality of the overall SG. The overall process of Monitoring, Analysing, Planning, and Executing (MAPE) is discussed to highlight the current open issues of the domain and the expected benefits.

The problem of interpreting the results of performance analysis is quite critical, mostly because the analysis results (i.e. mean values, variances, and probability distributions) are hard to transform into feedback for software engineers that allows to remove performance problems. Approaches aimed at identifying and removing the causes of poor performance in software systems commonly fall in two categories: (i) bottleneck analysis, aimed at identifying overloaded software components and/or hardware resources that affect the whole system performance, and (ii) performance antipatterns, aimed at detecting and removing common design mistakes that notably induce performance degradation.

Engineering high quality software is a tough task. In order to know whether a certain quality attribute has been achieved or degraded, it has to be quantified by analysis or measured. However, determining what to quantify and how these quantities are related to each other is the difficult part. Early analysis of the quality attributes of a software system on the basis of the system's planned architecture allows informed decisions on design trade-offs. Such decisions can be later validated by measurements on the running system.

Antipatterns are conceptually similar to patterns in thatthey document recurring solutions to common design problems.Performance Antipatternsdocument, from a performance perspective, common mistakes madeduring software development as well as their solutions.The definition of performance antipatterns concerns softwareproperties that can include static, dynamic, and deploymentaspects. Currently, such knowledge is only used by domain experts;the problem of automatically detecting and solving antipatternswithin an architectural model has not been experimented yet.In this paper we present an approach to automatically detect and solvesoftware performance antipatterns within the Palladio architectural models:the detection of an antipattern providesa software performance feedback to designers, since it suggeststhe architectural alternatives that actually allow to overcomespecific performance problems. We implemented theapproach and a case study is presented todemonstrate its validity. The system performance under studyhas been improved of 50\% by applying antipatterns' solutions.

The problem of interpreting the results of performance analysis is quite critical in the software performance domain. Mean values, variances, probability distributions are hard to interpret for providing feedback to software architects. Instead, what architects expect are solutions to performance problems, possibly in the form of architectural alternatives (e. g. split a software component in two components and re-deploy one of them). In a software performance engineering approach this path from analysis results to software alternatives still lacks of automation and is based on the skills and experience of analysts. In this paper we propose an automated approach for the performance feedback generation process based on performance antipatterns. To this aim, we model performance antipatterns as logical predicates and we provide a java engine, based on such predicates, that is able to detect performance antipatterns in an XML representation of the software system. Finally, we show the approach at work on a simple case study.

In this paper we introduce SMILE (simple middleware independent layer), a framework whose main purpose is to facilitate the development of distributed applications. In the SMILE abstraction an application is composed by a set of processes that exchange information. The interfaces of these processes are described using WSDL or by an equivalent UML definition. Using the open source AndroMDA tool and starting from the UML interface specification we are able to generate the skeleton of SMILE applications and most part of their business logic. An application developed using SMILE can run on different middleware platforms just changing its binding, i.e. the code that adapts SMILE to a given middleware. We have implemented bindings to CORBA, JAVA- RMI, JADE, JXTA and to an our own communication mechanism based on SIP suitable for mobile devices. At the end we hint at the usage of SMILE in service composition and present some prototype applications.