Non-functional Properties Research Articles

Formal Specification of Non-Functional Properties of Context-Aware Systems

During the recent years, there is an increasing demand for software systems that dynamically adapt their behavior at run-time in response to changes in user preferences, execution environment, and system requirements, being thus context-aware. Authors are referring here to requirements related to both functional and non-functional aspects of system behavior since changes can also be induced by failures or unavailability of parts of the software system itself. To ensure the coherence and correctness of the proposed model, all relevant properties of system entities are precisely and formally described. This is especially true for non-functional properties, such as performance, availability, and security. This article discusses semantic concepts for the specification of non-functional requirements, taking into account the specific needs of a context-aware system. Based on these semantic concepts, we present a specification language that integrates non-functional requirements design and validation in the development process of context-aware self-adaptive systems.

Topology analysis of manufacturing service supply–demand hyper-network considering QoS properties in the cloud manufacturing system

• Cloud Manufacturing (CM) integrates distributed resources in the form of virtualized objects • The literature shows the service matching problem is only considered in operational perspective • A graph-based analysis of QoS properties in hyper-network-based model of manufacturing services is proposed. • The focus is to give insight for tactical/strategic planning of CM especially for engaging SME business models. • An insight for modeling the service demand matching problem capable of analyzing the complexity in CM is achieved. Cloud Manufacturing (CMfg), a new manufacturing paradigm, enables an opportunity for manufacturing enterprises to respond to a wide variety of demands. The CMfg concept integrates the distributed resources and capacities in a shared economy, transfers them to the virtual manufacturing services with various quality of service (QoS) properties. These services are invoked to collaborate in producing customized demands with specific functional and non-functional properties. The operational perspective of the service-demand matching problem is considered more in the literature; however, it is a challenging problem in the CMfg ecosystem. This paper evaluates the service-demand matching problem from a structural perspective to facilitate resilience and configurable system working well in the operational interactions. Therefore, a CMfg hyper-network-based model is proposed which is enriched with QoS properties. It employs the available capacities in all small and medium enterprises (SMEs) and large companies. The service-demand matching problem is a complex issue; so, it is impossible to analyze it with the current approaches. Here, the CMfg structure is examined through topological characteristics. It helps decision-makers to provide a robust and resilient service-demand matching model. It also proposes some investment opportunities for the SME. The proposed model and its capabilities are discussed through a real case study about the COVID-19 ventilator manufacturing systems in CMfg ecosystem.

Empirical Analysis of Re-Factoring Techniques

Abstract: The process or technique of Code Re-factoring is restructuring the existing source code by making changes in factoring without any changes in external behaviour. The main intention of re-factoring is to improve non-functional attributes of the software. The advantages include improving the code readability and reducing the complexity of any given source code, and these can overall enhance code maintainability and produce a much more elaborated internal architecture or objectoriented model to boost the extensibility of the code. The effect that re-factoring has on any software project is analysable and customisable. But, before customising the factoring techniques, it is essential to have a complete knowledge of all possible refactoring techniques, and all its possible effects. Our main focus will be on few main re-factoring techniques like Red-Green refactoring, preparatory re-factoring, Abstraction re-factoring, composing methods re-factoring etc. Every software project has both internal and external attributes, that highly influence the software’s maintainability, reusability, understandability, flexibility, testability, extensibility, reliability, efficiency, modularity, complexity and composition. The research mainly focuses on the effect of re-factoring on them. Study of researched data will give us comparative analysis, pointing out both the positive and negative impacts, re-factoring can have. Overall, the project aims to perform an empirical study to find out the impacts of refactoring techniques. The research aims to explore the change in the quality of the code after re-factoring. Improvement, decrement and stability are analysed. Study is also done to find the possibilities of applying more than one re-factoring techniques, independently or in an aggregation. Keywords: maintainability; extensibility; reliability; modularity

Integrating the analysis of multiple non-functional properties in model-driven engineering

Integrating the analysis of multiple non-functional properties in model-driven engineering

Fast Performance Modeling across Different Database Versions Using Partitioned Co-Kriging

Database systems have a large number of configuration parameters that control functional and non-functional properties (e.g., performance and cost). Different configurations may lead to different performance values. To understand and predict the effect of configuration parameters on system performance, several learning-based strategies have been recently proposed. However, existing approaches usually assume a fixed database version such that learning has to be repeated once the database version changes. Repeating measurement and learning for each version is expensive and often practically infeasible. Instead, we propose the Partitioned Co-Kriging (PCK) approach that transfers knowledge from an older database version (source domain) to learn a reliable performance prediction model fast for a newer database version (target domain). Our method is based on the key observations that performance responses typically exhibit similarities across different database versions. We conducted extensive experiments under 5 different database systems with different versions to demonstrate the superiority of PCK. Experimental results show that PCK outperforms six state-of-the-art baseline algorithms in terms of prediction accuracy and measurement effort.

A model-driven approach for continuous performance engineering in microservice-based systems

Microservices are quite widely impacting on the software industry in recent years. Rapid evolution and continuous deployment represent specific benefits of microservice-based systems, but they may have a significant impact on non-functional properties like performance. Despite the obvious relevance of this property, there is still a lack of systematic approaches that explicitly take into account performance issues in the lifecycle of microservice-based systems.In such a context of evolution and re-deployment, Model-Driven Engineering techniques can provide major support to various software engineering activities, and in particular they can allow managing the relationships between a running system and its architectural model.In this paper, we propose a model-driven integrated approach that exploits traceability relationships between the monitored data of a microservice-based running system and its architectural model to derive recommended refactoring actions that lead to performance improvement. The approach has been applied and validated on two microservice-based systems, in the domain of e-commerce and ticket reservation, respectively, whose architectural models have been designed in UML profiled with MARTE.

Learning software configuration spaces: A systematic literature review

Most modern software systems (operating systems like Linux or Android, Web browsers like Firefox or Chrome, video encoders like ffmpeg, x264 or VLC, mobile and cloud applications, etc.) are highly configurable. Hundreds of configuration options, features, or plugins can be combined, each potentially with distinct functionality and effects on execution time, security, energy consumption, etc. Due to the combinatorial explosion and the cost of executing software, it is quickly impossible to exhaustively explore the whole configuration space. Hence, numerous works have investigated the idea of learning it from a small sample of configurations’ measurements. The pattern “sampling, measuring, learning” has emerged in the literature, with several practical interests for both software developers and end-users of configurable systems. In this systematic literature review, we report on the different application objectives (e.g., performance prediction, configuration optimization, constraint mining), use-cases, targeted software systems, and application domains. We review the various strategies employed to gather a representative and cost-effective sample. We describe automated software techniques used to measure functional and non-functional properties of configurations. We classify machine learning algorithms and how they relate to the pursued application. Finally, we also describe how researchers evaluate the quality of the learning process. The findings from this systematic review show that the potential application objective is important; there are a vast number of case studies reported in the literature related to particular domains or software systems. Yet, the huge variant space of configurable systems is still challenging and calls to further investigate the synergies between artificial intelligence and software engineering.

Verifying Time Complexity of Binary Search using Dafny

Formal software verification techniques are widely used to specify and prove the functional correctness of programs. However, nonfunctional properties such as time complexity are usually carried out with pen and paper. Inefficient code in terms of time complexity may cause massive performance problems in large-scale complex systems. We present a proof of concept for using the Dafny verification tool to specify and verify the worst-case time complexity of binary search. This approach can also be used for academic purposes as a new way to teach algorithms and complexity.

AI for System - Infusing AI into Cloud Computing Systems

In the past fifteen years, the most significant paradigm shift in the computing industry is the migration to cloud computing, which brings unprecedented opportunities of digital transformation to business, society, and human life. The implication of this is profound. It means that cloud computing platforms have become part of the basic infrastructure of the world. Therefore, the non-functional properties of cloud computing platforms, including availability, reliability, performance, efficiency, security, sustainability, etc., become immensely important. The distributed nature, massive scale, and high complexity of cloud computing platforms ranging from storage to networking, computing and beyond present huge challenges to achieve effective and efficient building and operation of such software systems. There is huge wealth of various types of data available throughout the entire development lifecycle of software systems. This is manifested even stronger with the paradigm shift to cloud computing as much more data are available on system runtime and workloads. Leveraging the amount of data, AI for System is to utilize AI/ML technologies to design and build high-quality cloud systems at scale. In this talk, I will first introduce the concept of AI for System and its research landscape. Then using a few projects at Microsoft as examples [1-10], I will talk about the work from Microsoft Research on AI for System and its impact. I will also discuss the research challenges and opportunities in AI for System moving forward.

Analyzing Energy Leaks of Android Applications Using Event-B

The number of mobile applications downloaded recently from Google stores increase steadily. It is believed that mobile applications market revenues will grow fast and receive more attention from software developers. Even though, hardware technologies and operating systems have made a big contribution to improve the battery capacity, power consumption is one of the most important and crucial non-functional properties of mobile applications. Many approaches have been dedicated for analyzing and optimizing the power consumption at different levels. This paper proposes a method for analyzing energy leaks of Android application at the design phase. First, it introduces a formalization of an event-based power consumption model. After that, the paper presents a method to translate this model to Event-B notations. Based on the target model, it is able to check if the application leads to energy leaks or violates the power consumption constraints based on formal proofs. Finally, the motivating examples are shown for the illustration purpose.

Adaptation of a Refactoring DSL for the Object-Oriented Paradigm

Many development environments offer refactorings aimed at improving non-functional properties of software, but we have no guarantees that these transformations indeed preserve the observable behavior of the source code they are applied on. An existing domain-specific language makes it possible to formalize automatically verifiable refactorings via instantiating predefined transformation schemes with conditional term rewrite rules.
 We present a proposal for adapting this language from the functional to the object-oriented programming paradigm, using Java instead of Erlang as a representative. The behavior-preserving property of discussed refactorings is characterized with a multilayered definition of equivalence for Java programs, including the conformity relation of class hierarchies. Based on the decomposition of a complex refactoring rule, we show how new transformation schemes can be identified, along with modifications and extensions of the description language required to accommodate them. Finally, we formally define the chosen base refactoring as a composition of scheme instances.

Analyzing the sensitivity of multi-objective software architecture refactoring to configuration characteristics

Abstract Context: Software architecture refactoring can be induced by multiple reasons, such as satisfying new functional requirements or improving non-functional properties. Multi-objective optimization approaches have been widely used in the last few years to introduce automation in the refactoring process, and they have revealed their potential especially when quantifiable attributes are targeted. However, the effectiveness of such approaches can be heavily affected by configuration characteristics of the optimization algorithm, such as the composition of solutions. Objective: In this paper, we analyze the behavior of E A S I E R , which is an Evolutionary Approach for Software archItecturE Refactoring, while varying its configuration characteristics, with the objective of studying its potential to find near-optimal solutions under different configurations. Method: In particular, we use two different solution space inspection algorithms (i.e., N S G A − I I and S P E A 2 ) while varying the genome length and the solution composition. Results: We have conducted our experiments on a specific case study modeled in AEmilia ADL, on which we have shown the ability of E A S I E R to identify performance-critical elements in the software architecture where refactoring is worth to be applied. Beside this, from the comparison of multi-objective algorithms, N S G A − I I has revealed to outperform S P E A 2 in most of cases, although the latter one is able to induce more diversity in the proposed solutions. Conclusion: Our results show that the E A S I E R thoroughly automated process for software architecture refactoring allows to identify configuration contexts of the evolutionary algorithm in which multi-objective optimization more effectively finds near-optimal Pareto solutions.

Parallel programs execution optimization using behavior control in LuNA system

In the paper, the problem of efficient parallel execution of numerical algorithms for supercomputers in the LuNA system is concerned. With LuNA, an application algorithm is represented in a hardware-independent high-level form. This allows implementing the algorithm by automatic construction of various parallel programs, which possess different non-functional properties, such as execution time, memory consumption, network workload. In the LuNA system, the efficiency problem of automatically constructed parallel programs is dealt with through the behavior concept. The presented approach allows controlling parallel program behavior without low-level programming of the desired behavior.

Predication of Quality of Service (QoS) in Cloud Services: A Survey

Quality of Service (QoS) in cloud computing and web service has been commonly used as an essential measure for evaluating services of nonfunctional attributes. However, QoS prediction has become one of the key factors in services recommendation and selection to build high-quality software systems, so it becomes an urgent and crucial research area in both academia and industry. Therefore, several methods and techniques of service recommendation based on collaborative filtering (CF) have been exist for optimizing service selection. We investigate the different exist methods to solve challenging problems. Thence, we discuss and compare these approaches to provide an overview of the latest researches in the field.

Composable Finite State Machine-based Modeling for Quality-of-Information-aware Cyber-physical Systems

Time plays a major role in the specification of Cyber-physical Systems (CPS) behavior with concurrency, timeliness, asynchrony, and resource limits as their main characteristics. In addition to timeliness , the specification of CPS needs to assess and unambiguously define its behavior with respect to the other Quality-of-Information (QoI) properties: (1) Correctness, (2) Completeness, (3) Consistency, and (4) Accuracy. Very often, CPS need to handle these QoI properties, and any combination thereof, multiple times when performing computation and communication processes. However, a model-driven and systematic approach to specify CPS behavior that jointly considers combined QoI aspects is possible but missing in existing methodologies. As the first contribution of this work, we provide an extension to an established model of computation (MoC) based on “Functions driven by Finite State Machine” (FunState) to enable a model-driven composition mechanism to create CPS behavior specifications from reusable components. Second, we present a novel set of design patterns to illustrate the modeling of QoI-aware CPS specifications that can be applied in several state-of-the-art Electronic System Level (ESL) methodologies. The time semantics of the MoC are formalized using the tagged-signal-model, and the presented model-driven approach enables the composition of multiple design patterns. The main benefits of the presented model-driven approach and design patterns to create CPS specifications are as follows: (a) reduce modeling effort, errors, and time through the reuse of known recipes to re-incurring tasks and allow to automatically generate repetitive control flows based on extended Finite State Machines; (b) increase system robustness and facilitate the creation of holistic QoI management allowing to unambiguously define system behavior for scenarios with single/multiple QoI requirement violations in different models of computation; (c) dynamically validate timing behavior of system implementations to enable a multi-objective optimization of nonfunctional properties that influence CPS timing. We demonstrate the aforementioned benefits through the modeling and evaluation of an infrastructure-assisted automated driving case study using Infrastructure-to-Vehicle (I2V) communications to distribute QoI critical road environment information.

A Hybrid Harmony Search and Particle Swarm Optimization Algorithm (HSPSO) for Testing Non-functional Properties in Software System

An important aspect of improving software system is testing. However, it is time demanding and sometimeslabour intensive if done manually. In this paper, we developed an automatic search-based approach for testing the nonfunctional properties of a software system using hybrid harmony search and particle swarm optimization algorithms. The approach birthed a new algorithm named HSPSO, which is proposed based on the strength of HS over Genetic algorithm (GA) in terms of less adjustable parameters, quick convergence and smooth implementation. On the other hand, we propose the PSO to complement the drawback of HS in terms of time consumption problem. Besides, we used four programs for the comparative efficiency analysis of the proposed algorithm in relation to competing algorithms based on average branch coverage and execution time. The results from the analysis showed that the HSPSO algorithm was able to achieve 100% average coverage with a fewer number of generated test cases and under limited execution time.

A Platform-Aware Model-Driven Embedded Software Engineering Process Based on Annotated Analysis Models

In this work a platform-aware model-driven engineering process for building component-based embedded software systems using annotated analysis models is described. The process is supported by a framework, called MICOBS, that allows working with different component technologies and integrating different tools that, independently of the component technology, enable the analysis of non-functional properties based on the principles of composability and compositionality. An actor, called Framework Architect, is responsible for this integration. Three other actors take a relevant part in the analysis process. The Component Provider supplies the components, while the Component Tester is in charge of their validation. The latter also feeds MICOBS with the annotated analysis models that characterize the extra-functional properties of the components for the different platforms on which they can be deployed. The Application Architect uses these components to build new systems, performing the trade-off between different alternatives. At this stage, and in order to verify that the final system meets the extra-functional requirements, the Application Architect uses the reports generated by the integrated analysis tools. This process has been used to support the validation and verification of the on-board application software for the Instrument Control Unit of the Energetic Particle Detector of the Solar Orbiter mission.

Development of a Smart Technique for Mobile Web Services Discovery

Web service (WS) presents a good solution to the interoperability of different types of systems that aims to reduce the overhead of high processing in a resource-limited environment. With the increasing demand for mobile WS (MWS), the WS discovery process has become a significant challenging point in the WS lifecycle that aims to identify the relevant MWSs that best match the service requests. This discovery process is a resource-consuming task that cannot be performed efficiently in a mobile computing environment due to the limitations of mobile devices. Meanwhile, a cloud computing can provide rich computing resources for mobile environments given its unlimited and easily scalable resources. This paper proposes a semantic WS discovery and invocation framework in mobile environments based on cloud and a relationship-aware matchmaking algorithm. The discovery algorithm enriches MWS and user requests semantically with the functional and non-functional properties of Ontology Web Language for Services, such as Quality of Web Service, device context, and user preferences. The WS repository is filtered based on logical reasoning and a parameter-based matching algorithm to minimize the matching space and improve runtime performance. The cosine similarity between the user request and services repository is then assessed to generate the most relevant WS. The relationships among concepts in the ontology are considered to improve the recall and precision ratio. After the WS discovery process, users can invoke and test these services in a mobile environment through a dynamic user interface. The interface of the invocation process is changed according to the WS description document. An application prototype is also developed to evaluate the framework based on a Cordova cross-mobile development framework.

Function analysis: going forward in value analysis

Stakeholders are key elements of complex technical projects. They can determine orientation, evolution and success of the project. They can cause uncertainties, changes in objectives and lead the project to failure. In this context, it is always more important to involve them in project decisions. Value Analysis (VA) is a means to introduce management and decision-making in design of complex projects, based on stakeholder needs. A method named Function Analysis aims at identifying and treating functions that the system has to complete. However, this functional approach does not allow some non-functional attributes to be included in the design phases. This is a lack identified by some engineering companies. The proposed paper aims at identifying the challenges encountered by the Stakeholder approaches to translate their needs into nonfunctional dimensions to deal with VA practices to design technical solutions. The research methodology combines a classical bibliographical analysis on VA that led us to show FA limits. Thus, we propose a Stakeholder-based “Non-Functional Analysis” to determine the non-functional attributes to characterize for the design of complex projects, and an industrial company’s feedback practices on a case study. This will allow practitioners to have a systems approach to Value in the context of a VA but it will also allow scientists to compare theory and lack of practice around the identification and characterization of the needs of a set of stakeholders.

Multiclock Constraint System Modelling and Verification for Ensuring Cooperative Autonomous Driving Safety

CADS (cooperative autonomous driving systems) are software-intensive and safety-critical reactive systems and give great promise to our daily life, but system errors may not be identified in the design stage until the implement stage, and the cost to correct them will be more expensive later than the early stage. For designing trustworthy autonomous software systems, we have to deal with multiclock constraint models. SysML (System Modeling Language) meets increasing adoption in order to carry out system-level modelling and verification against abstract representations, but it suffers from semantic ambiguities in the design of safety-critical autonomous systems. The main objective is to investigate methods for coping with the design and analysis models simultaneously and to achieve semantic consistency based on mathematical foundations and formal model transformation. In this paper, we propose a method to combine the requirement modelling process with analysis process together for CADS safety and reliability guarantee. Firstly, we extend SysML metamodels and construct SysML profile for the CADS domain that could improve modelling correctness and enhance reusability. An instantiated CADS model has been designed by means of adopting a profile containing different key functional and nonfunctional attributes and behaviors. Secondly, we define formal syntax and semantic notations for modelling elements in the SysML state machine diagram and show transformation rules between the state machine diagram and the CCSL (Clock Constraint Specification Language) model. Semantic preservation is also proved using the bisimulation relation between them for rigorous mapping correctness. Thirdly, a cooperative autonomous overtaking driving case study on the highway scenario is used for illustration, and we use the tool TimeSquare to simulate CCSL specification execution traces at the system design stage.