Unifying design and runtime software adaptation using aspect models

Software systems are seen more and more as evolutive systems. At the design phase, software is constantly in adaptation by the building process itself, and at runtime, it can be adapted in response to changing conditions in the executing environment such as location or resources. Adaptation is generally difficult to specify because of its cross-cutting impact on software. This article introduces an approach to unify adaptation at design and at runtime based on Aspect Oriented Modeling. Our approach proposes a unified aspect metamodel and a platform that realizes two different weaving processes to achieve design and runtime adaptations. This approach is used in a Dynamic Software Product Line which derives products that can be configured at design time and adapted at runtime in order to dynamically fit new requirements or resource changes. Such products are implemented using the Service Component Architecture and Java. Finally, we illustrate the use of our approach based on an adaptive e-shopping scenario. The main advantages of this unification are: a clear separation of concerns, the self-contained aspect model that can be weaved during the design and execution, and the platform independence guaranteed by two different types of weaving.     

Achieving dynamic adaptation via management and interpretation of runtime models

In this article, we present a generic model-centric approach for realizing fine-grained dynamic adaptation in software systems by managing and interpreting graph-based models of software at runtime. We implemented this approach as the Graph-based Runtime Adaptation Framework (GRAF), which is particularly tailored to facilitate and simplify the process of evolving and adapting current software towards runtime adaptivity. As a proof of concept, we present case study results that show how to achieve runtime adaptivity with GRAF and sketch the framework's capabilities for facilitating the evolution of real-world applications towards self-adaptive software. The case studies also provide some details of the GRAF implementation and examine the usability and performance of the approach.     

Unifying software engineering and systems engineering

The author describes CMMI (Capability Maturity Model Integration) and the emerging project methods which demonstrate the opportunities for process improvement gains open to organizations. The organization that changes from separated software and system engineering processes to a more unified approach will find itself far more suited to developing dynamically changing, software-intensive systems. Culture change is never easy, but the alternative is even less palatable     

Supporting runtime software architecture: A bidirectional-transformation-based approach

Runtime software architectures (RSA) are architecture-level, dynamic representations of running software systems, which help monitor and adapt the systems at a high abstraction level. The key issue to support RSA is to maintain the causal connection between the architecture and the system, ensuring that the architecture represents the current system, and the modifications on the architecture cause proper system changes. The main challenge here is the abstraction gap between the architecture and the system. In this paper, we investigate the synchronization mechanism between architecture configurations and system states for maintaining the causal connections. We identify four required properties for such synchronization, and provide a generic solution satisfying these properties. Specifically, we utilize bidirectional transformation to bridge the abstraction gap between architecture and system, and design an algorithm based on it, which addresses issues such as conflicts between architecture and system changes, and exceptions of system manipulations. We provide a generative tool-set that helps developers implement this approach on a wide class of systems. We have successfully applied our approach on JOnAS JEE system to support it with C2-styled runtime software architecture, as well as some other cases between practical systems and typical architecture models.     

Using architecture models for runtime adaptability

Every software system has architecture. The architecture strongly influences the software system's properties, including maintainability and runtime properties such as performance and reliability. By describing the architecture in models, we can make the architecture explicit. Developers typically use software architecture models at design time to capture the significant decisions about a software system's organization and to describe and establish a common understanding about the system's abstract properties. In the MADAM (mobility- and adaptation-enabling middleware) project, we aim to facilitate adaptive application development for mobile computing. We follow an architecture-centric approach where we represent architecture models at runtime to allow generic middleware components to reason about and control adaptation.     

Pattern-driven green adaptation of process-based applications and their runtime infrastructure

Business processes are a key aspect of modern organization. In recent years, business process management and optimization has been applied to different cross-cutting concerns such as security, compliance, or Green IT, for example. Based on the ecological characteristics of a business process, proper environmentally sustainable adaptation strategies can be chosen to improve the total environmental impact of the business process. We use ecological sustainable adaptation strategies that are described as green business process patterns. The application of such a green business process pattern, however, affects the business process layer, the application component and the infrastructure layer. This implies that changes in the application infrastructure also need to be considered. Hence, we use best practices of cloud application architectures which are described as Cloud patterns. To guide developers through the adaptation process we propose a pattern-based approach in this work. We correlate Cloud patterns relevant for sustainable business processes to green business process patterns and organize them within a classification. To provide concrete implementation support we further annotate these Cloud patterns to application component models that are described with the topology and orchestration specification for cloud applications (TOSCA). Using these annotations, we describe a method that provides the means to optimize business processes based on green business process patterns through adapting the implementation of application components with concrete TOSCA implementation models.     

Studying software evolution using topic models

Topic models are generative probabilistic models which have been applied to information retrieval to automatically organize and provide structure to a text corpus. Topic models discover topics in the corpus, which represent real world concepts by frequently co-occurring words. Recently, researchers found topics to be effective tools for structuring various software artifacts, such as source code, requirements documents, and bug reports. This research also hypothesized that using topics to describe the evolution of software repositories could be useful for maintenance and understanding tasks. However, research has yet to determine whether these automatically discovered topic evolutions describe the evolution of source code in a way that is relevant or meaningful to project stakeholders, and thus it is not clear whether topic models are a suitable tool for this task.In this paper, we take a first step towards evaluating topic models in the analysis of software evolution by performing a detailed manual analysis on the source code histories of two well-known and well-documented systems, JHotDraw and jEdit. We define and compute various metrics on the discovered topic evolutions and manually investigate how and why the metrics evolve over time. We find that the large majority (87%–89%) of topic evolutions correspond well with actual code change activities by developers. We are thus encouraged to use topic models as tools for studying the evolution of a software system.     

Estimating software readiness using predictive models

In this study, defect tracking is used as a proxy method to predict software readiness. The number of remaining defects in an application under development is one of the most important factors that allow one to decide if a piece of software is ready to be released. By comparing predicted number of faults and number of faults discovered in testing, software manager can decide whether the software is likely ready to be released or not.The predictive model developed in this research can predict: (i) the number of faults (defects) likely to exist, (ii) the estimated number of code changes required to correct a fault and (iii) the estimated amount of time (in minutes) needed to make the changes in respective classes of the application. The model uses product metrics as independent variables to do predictions. These metrics are selected depending on the nature of source code with regards to architecture layers, types of faults and contribution factors of these metrics. The use of neural network model with genetic training strategy is introduced to improve prediction results for estimating software readiness in this study. This genetic-net combines a genetic algorithm with a statistical estimator to produce a model which also shows the usefulness of inputs.The model is divided into three parts: (1) prediction model for presentation logic tier (2) prediction model for business tier and (3) prediction model for data access tier. Existing object-oriented metrics and complexity software metrics are used in the business tier prediction model. New sets of metrics have been proposed for the presentation logic tier and data access tier. These metrics are validated using data extracted from real world applications. The trained models can be used as tools to assist software mangers in making software release decisions.     

Studying software logging using topic models

Software developers insert logging statements in their source code to record important runtime information; such logged information is valuable for understanding system usage in production and debugging system failures. However, providing proper logging statements remains a manual and challenging task. Missing an important logging statement may increase the difficulty of debugging a system failure, while too much logging can increase system overhead and mask the truly important information. Intuitively, the actual functionality of a software component is one of the major drivers behind logging decisions. For instance, a method maintaining network communications is more likely to be logged than getters and setters. In this paper, we used automatically-computed topics of a code snippet to approximate the functionality of a code snippet. We studied the relationship between the topics of a code snippet and the likelihood of a code snippet being logged (i.e., to contain a logging statement). Our driving intuition is that certain topics in the source code are more likely to be logged than others. To validate our intuition, we conducted a case study on six open source systems, and we found that i) there exists a small number of “log-intensive” topics that are more likely to be logged than other topics; ii) each pair of the studied systems share 12% to 62% common topics, and the likelihood of logging such common topics has a statistically significant correlation of 0.35 to 0.62 among all the studied systems; and iii) our topic-based metrics help explain the likelihood of a code snippet being logged, providing an improvement of 3% to 13% on AUC and 6% to 16% on balanced accuracy over a set of baseline metrics that capture the structural information of a code snippet. Our findings highlight that topics contain valuable information that can help guide and drive developers’ logging decisions.     

Robust design of nonlinear internal models without adaptation

We propose a solution to the problem of semiglobal output regulation for nonlinear minimum-phase systems driven by uncertain exosystems that does not rely upon conventional adaptation schemes to estimate the frequency of the exogenous signals. Rather, the proposed approach relies upon regression-like arguments used to derive a nonlinear internal model able to offset the presence of an unknown number of harmonic exogenous inputs of uncertain amplitude, phase and frequency. The design methodology guarantees asymptotic regulation if the dimension of the regulator exceeds a lower bound determined by the actual number of harmonic components of the exogenous input. If this is not the case, a bounded steady-state regulation error is ensured whose amplitude, though, can be arbitrarily decreased by acting on a design parameter of the regulator.     

Course design using software engineering methods

This paper describes a pedagogical project that was conducted to design a course on Dedicated Microcomputer Design. Based on the similarities which exist between the design of a course and the structured development of a computer program, an adaptation of some software engineering methodologies was used to design this new course. All the design tasks which were performed to realize this project are presented here in the context of the seven design phases of a Course Life Cycle model.     

Microcontroller software design using Petri Tables

A new methodology for high-level, microcontroller software design is presented utilizing the concept of a Colored Petri Net as implemented in a Petri Table. This approach is implementation independent and more general than earlier finite state machine approaches in that interrupts are handled more naturally as token-originating places rather than exceptions to the normal program flow. Commercial software packages are available for simulating Petri Nets allowing for the testing and evaluating of the software design before it is implemented. The tabular form of the Petri Table also makes it easier to document the software using normal word-processing packages, and there is a direct transformation possible from transitions in the Petri Table to modules of code. Since the high-level design is already in text-file form, it can easily be incorporated in the source code and selectively printed along with it using conditional compiles yielding printouts which contain only the source code, only the comments, or the two merged together.     

Prediction of software reliability using connectionist models

The usefulness of connectionist models for software reliability growth prediction is illustrated. The applicability of the connectionist approach is explored using various network models, training regimes, and data representation methods. An empirical comparison is made between this approach and five well-known software reliability growth models using actual data sets from several different software projects. The results presented suggest that connectionist models may adapt well across different data sets and exhibit a better predictive accuracy. The analysis shows that the connectionist approach is capable of developing models of varying complexity     

QoS metrics-in-the-loop for endowing runtime self-adaptation to robotic software architectures

Multimedia Tools and Applications - The design of robots capable of operating autonomously in changing and unstructured environments, requires using complex software architectures in which,...     

Safer asynchronous runtime monitoring using compensations

Asynchronous monitoring relieves the system from additional overheads induced through online runtime monitoring. The price paid with such monitoring approaches is that the system may proceed further despite having reached an anomalous state. Any actions performed by the system after the error occurring are undesirable, since for instance, an unchecked malicious user access may perform unauthorized actions. In this paper we investigate the use of compensations to enable the undoing of such undesired actions, thus enriching asynchronous monitoring with the ability to restore the system to the original state just after the anomaly had occurred. Furthermore, we show how adaptive synchronisation and desynchronisation of the monitor with the system can also be achieved and report on the use of the proposed approach on an industrial case study of a financial transaction handling system.     

Calculation of adsorption equilibria using CALPHAD models and software

The utility of CALPHAD (CALculation of PHAse Diagrams) models and software for calculation of gas-on-solid adsorption equilibria is demonstrated. Thermodynamic models formulated in CEF (Compound Energy Formalism) are constructed that account for adsorption on single site, several sites as well as for adsorption in pores and multilayers. Site blocking (the case where the adsorption of a single molecule on a single site also blocks some adjacent sites) may be emulated by the ionic-liquid model within CEF. The parameters of these thermodynamic models may be determined by fitting to experimental results or to results of ab-initio calculations. Alternatively, the parameters may be calculated from already-fitted adsorption isotherm equations such as Langmuir, dual site Langmuir, Nitta and Ruthven's model for adsorption in pores. Pure-gas adsorption models may be extrapolated to mixed-gas adsorption. The thermodynamic consistency of such extrapolation is ensured by the CALPHAD method of modeling and the CEF formalism. Examples include adsorption of various gases on carbon as well as on zeolites and MOF (Metal Organic Framework).     

A self-learning approach for validation of runtime adaptation in service-oriented systems

Ensuring that service-oriented systems can adapt quickly and effectively to changes in service quality, business needs and their runtime environment is an increasingly important research problem. However, while considerable research has focused on developing runtime adaptation frameworks for service-oriented systems, there has been little work on assessing how effective the adaptations are. Effective adaptation ensures the system remains relevant in a changing environment and is an accurate reflection of user expectations. One way to address the problem is through validation. Validation allows us to assess how well a recommended adaptation addresses the concerns for which the system is reconfigured and provides us with insights into the nature of problems for which different adaptations are suited. However, the dynamic nature of runtime adaptation and the changeable contexts in which service-oriented systems operate make it difficult to specify appropriate validation mechanisms in advance. This paper describes a novel consumer-centered approach that uses machine learning to continuously validate and refine runtime adaptation in service-oriented systems, through model-based clustering and deep learning.     

Developing flexible productivity measurement models using spreadsheet software

This paper discusses the development of a series of interactive computer models for measuring productivity. By using LOTUS 123, a series of flexible models were developed which can easily be modified to fit the productivity measurement system used by most companies. Rather than force the company's productivity measurement system to fit an available computer model, a company can now tailor the computer model to exactly fit its productivity measurement system.     

基于PSO的软件可靠性模型参数估计方法

软件可靠性建模是一个重要的研究领域,现有的软件可靠性模型基本上是非线性函数模型,估计这些模型的参数比较困难。粒子群优化是一类适合求解非线性优化问题的随机优化方法,提出一种基于粒子群优化的软件可靠性模型估计参数方法,该方法的关键是构造合适的适应函数。用该方法分别估计了5个实际软件系统的指数软件可靠性模型以及对数泊松执行时间模型,实验结果表明：该方法参数估计的精度高,对模型的适应性强。