Component-based Applications Research Articles

A formal approach for the correct deployment of cloud applications

The deployment of cloud applications is a complex task. It refers to the enablement of SaaS, PaaS or IaaS solutions that may be accessed on demand by end users. It encompasses all the activities from installation to uninstallation, including reconfiguration, etc. To facilitate the deployment of cloud applications, it is essential to design them as component-based applications in order to favor the design by reusing and reducing the development cost. However, assembling components can be a tedious and error-prone task if sufficient precautions are not taken regarding different constraints, dependencies, and conflicts between components. In this paper, we introduce a formal Event-B-based approach for the modeling and the verification of component-based applications deployment. Our goal is to build correct by-construction systems that fulfill the different constraints regarding the components, the cloud infrastructure, and the deployment process. Basically, our approach starts with an abstract model describing the main concepts of the system. Then different details are gradually introduced through refinement. For each refinement step, proof obligations are produced to ensure the model's correctness. The obtained formal model consists of a precise specification on which mathematical reasoning can be carried out to prove the correctness of our component-based application model and validate its deployment in a cloud environment by using ProB. The presented approach is illustrated through a case study.

Organizing Classification of Application Logic Attacks in Component-based E-Commerce Systems

This research paper addresses the topic of application logic attack taxonomy that is due to unclear and incorrect implementation in component-based applications. The issue addresses the detection and classification of two separate types of vulnerabilities in component-based applications. The paper completes this aim through organising the classification of each attack and then proposes the classification of logical vulnerabilities and discusses the two distinct forms of weakness and coding faults in the application software found in the mid-level of the framework. The most important argument is to desegregate awareness of attack patterns with boundary profile status relevant to an application logic vulnerability and possible threats. Having review of two different types of attack taxonomies, a logical vulnerability classification based taxonomy is proposed.

An Event-B-Based Approach to Model and Verify Behaviors for Component-Based Applications

Abstract Many disciplines have adopted component-based principles to avail themselves of the many advantages they bring, especially component reusability. In a short time, the component-based architecture became a renown branch in the IT world and the center of interest of many researchers. Much work has been conducted in this context for the verification of component-based applications (CBAs). However, the main focus has been on the structural aspect of such compositions, while the behavioral aspect has seldom been dealt with. In this paper, our goal is to close this gap and propose a formal approach to verify the behavioral correctness of CBAs. We first define a set of requirements to be satisfied by the structure and the behavior of a CBA, represented by a set of interactions that may occur between their components. Then, we build a formal Event-B model to represent these requirements in a rigorous and non-ambiguous way. The use of the Event-B refinement technique allows us to master the complexity of CBAs by introducing their elements in an incremental manner. The correctness of the development is ensured by establishing a set of proof obligations, under the Rodin platform, and also by animating it with the ProB animator/model checker. The approach is illustrated by a running example.

Model-Driven Engineering for End-Users in the Loop in Smart Ambient Systems

At the heart of cyber-physical and ambient systems, the user should permanently benefit from applications adapted to the situation and her/his needs. To do this, she/he must be able to configure her/his software environment and be supported as much as possible in that task. To this end, an intelligent “engine” assembles software components that are present in the ambient environment at the time and makes unanticipated applications emerge. The problem is to put the user “in the loop”, i.e., provide adapted and intelligible descriptions of the emerging applications, and present them so that the user can accept, modify or reject them. Besides, user feedback must be collected to feed the engine’s learning process. Our approach relies on Model-Driven Engineering (MDE). However, differently from the regular use of MDE tools and techniques by engineers to develop software and generate code, our focus is on end-users. Models of component assemblies are represented and made editable for them. Based on a metamodel that supports modeling and de- scription of component-based applications, a user interface provides multi-faceted representations of the emerging applications and captures user feedback. Our solution relies on several domain- specific languages and a transformation process, based on the established MDE tools (Gemoc studio, Eclipse Modeling Framework, EcoreTools, Sirius, Acceleo). It works in conjunction with the intelligent engine that builds the emerging applications and to which it provides learning data.

Scalable optimal deployment in the cloud of component-based applications using optimization modulo theory, mathematical programming and symmetry breaking

Automated deployment of component-based applications in the Cloud consists in the allocation of virtual machines (VMs) offers from various Cloud Providers such that the constraints induced by the interactions between components and by the components hardware/software requirements are satisfied and the performance objectives are optimized (e.g. costs are minimized). It can be formulated as a constraint optimization problem, hence, in principle, the optimization can be carried out automatically. In the case the set of VM offers is large (several hundreds), the computational requirement is huge, making the automatic optimization practically impossible with the current general optimization modulo theory (OMT) and mathematical programming (MP) tools. We overcame the difficulty by methodologically analyzing the particularities of the problem with the aim of identifying search space reduction methods. These are methods exploiting: (i) the symmetries of the general Cloud deployment problem, (ii) the graph representation associated to the structural constraints specific to each particular application, and (iii) their combination. An extensive experimental analysis has been conducted on four classes of real-world problems, using six symmetry breaking strategies and two types of optimization solvers.As a result, the combination of a variable reduction strategy with a column-wise symmetry breaker leads to a scalable deployment solution, when OMT is used to solve the resulting optimization problem.

Heuristics-based mediation for building smart architectures at run-time

Smart architectures are increasingly being used in current software development. Smart user interfaces, smart homes, or smart buildings are becoming common examples in the new era of smart cities. Software architectures usually related to these domains need to be adapted and reconfigured at run-time, for example, to provide new services, react to user interaction, or due to changes decided from the business logic of the application. Component-based techniques are a suitable way to carry out this kind of adaptation, as dynamic reconfiguration operations can be applied to the architecture. In this paper, we address run-time generation of component-based applications, taking the abstract definitions of their architecture as a reference, in addition to a set of available components. The process calculates the best configuration of components from the abstract definition by applying a trading approach based on an adapted A* algorithm. This algorithm uses heuristics based on syntactic and semantic information obtained from the component definitions. A case study related to mashup user interfaces formed by coarse-grained components is also explained. In short, the results show the usefulness of heuristics and suitable execution times for building the best configurations.

Execution-history based reliability estimation for component-based software: considering reusability-ratio and interaction-ratio

Component-based software engineering emphasizes ‘development by means of reuse’ and ‘development meant for reuse’. Whether the system is simple or complex one, the estimation of better reliability remains a crucial concern. The main purpose of this work is to propose a method for reliability estimation and the computation of execution time of component-based software. In this work a metric named ‘reusability-ratio’ is introduced as a factor of reliability estimation. We focus on assessing and exploring reusability of components by defining reusability-ratio for newly developed, mutated (fully-qualified as well as partially-qualified) and off-the-shelf components. On the basis of interactions among components, one more metric is defined called ‘Interaction-ratio’. Interaction-ratio is used as another factor of reliability estimation. Based on the interactions made by components, a graph is constructed, namely ‘Component-Interaction Graph’. The structure of the component-interaction graph depends on the probability of interaction of components as well as the probability of the selection of different path execution-histories. Results obtained through experimental case study conclude that the reusability compete imperative function in the reliability of the component-based applications. Pre-tested, qualified and pre-configured artefacts consume lesser time and are more reliable as compared to the new component constructs. Metrics proposed in this work are well suited to estimate the reliability of component-based software and therefore proved promising to analyze the performance of the software.

A Method for Considering Error Propagation in Reliability Estimation of Component-Based Software Systems

Component-based software engineering has proved itself as a strong pillar in software engineering community. Large number of factors are involved in the success of software product developed using Component-based software engineering, for instance, security, reliability, quality, safety, and testability. As the component-based software is made up of large number of components put together, therefore components’ reliability influence the reliability of the complete software. Numerous models and principles have been established to estimate the reliability of software by applying information regarding architecture, quality and security attributes of the software. Many researchers overlooked a major factor while estimating reliability of component-based software and that is error-propagation. Although it can be a case that the components are not dependent on each other and they are supplemented with the wrappers. However it is not true for many component-based applications. In this paper, a framework for reliability estimation has been proposed. In our proposal we have considered error propagation. We have analyzed the program structure and also presented how they are handled in estimation process. Further sensitivity analysis is done to identify the most sensitive component of the system. A numerical simulation is also presented for better understanding of the proposed framework.

Analysis and design of information systems news portal citizen journalism Sumba-Indonesia as local content promotion media

Citizen journalism is a journalistic activity undertaken by a person or group. So far, information on the potential of the Sumba Island has not been evenly distributed because there is unequal information on the Sumbanese community and information on potential in eastern Sumba. The purpose of this research is to provide media for the citizens of Sumba in providing any information about local content in Sumba Island such as information on agriculture, plantation, forestry, tourism, cultural information, social information, political information, law, and human rights. The methodology used to build this system is the Waterfall Model. This model is an approach to software development, with several stages, namely: System Engineering, Analysis, Design, Encoding, Testing, and Maintenance. The development concept used is Model-View-Controller or MVC is a method to create an application with separate data (see) and the corresponding way (Controller). In the implementation of framework in the application of website-based architecture MVC. MVC is developing a major component-based application that builds an application such as data manipulation, user interface, and parts that become controls in a web application.

A DSL for elastic component-based cloud application

The deployment of component-based applications in cloud systems environment is becoming more and more complex. It is expected to provide elasticity in order to allow a deployed application to scale dynamically and meet variation in demand while ensuring a certain level of quality of service (QoS). However, there are still some open issues associated with the elasticity management. A conceptual model of elasticity management enabling the description of deployment and application constraints, properties and elasticity strategies at different levels (depending on the internal application architecture or on the cloud infrastructure and platform) in an automatic way is needed. In this paper, we propose a domain specific language (DSL) based on a metamodel, which precisely specifies three main views: the cloud service models, the automatic elasticity management strategies and the internal cloud application architecture. We illustrate through a case study, the MAPE-K-based approach using different scenarios of automatic elasticity management.

A DSL for elastic component-based cloud application

A DSL for elastic component-based cloud application

A recommender system for component-based applications using machine learning techniques

Software designers are striving to create software that adapts to their users’ requirements. To this end, the development of component-based interfaces that users can compound and customize according to their needs is increasing. However, the success of these applications is highly dependent on the users’ ability to locate the components useful for them, because there are often too many to choose from. We propose an approach to address the problem of suggesting the most suitable components for each user at each moment, by creating a recommender system using intelligent data analysis methods. Once we have gathered the interaction data and built a dataset, we address the problem of transforming an original dataset from a real component-based application to an optimized dataset to apply machine learning algorithms through the application of feature engineering techniques and feature selection methods. Moreover, many aspects, such as contextual information, the use of the application across several devices with many forms of interaction, or the passage of time (components are added or removed over time), are taken into consideration. Once the dataset is optimized, several machine learning algorithms are applied to create recommendation systems. A series of experiments that create recommendation models are conducted applying several machine learning algorithms to the optimized dataset (before and after applying feature selection methods) to determine which recommender model obtains a higher accuracy. Thus, through the deployment of the recommendation system that has better results, the likelihood of success of a component-based application is increased by allowing users to find the most suitable components for them, enhancing their user experience and the application engagement.

Reliability Assessment of Time-Critical Software: A Case Study on Stepper Motor Application

Although reliability is an important attribute of quality for mission-critical systems, there does not exist any versatile model even today for the reliability assessment of various time-critical component-based software applications. The existing Black Box models are found to make various assumptions which may not always be realistic in depicting the actual behavior of software. Many of them focus on observing the manner in which the system behaves without considering the structure of the system, the components composing the system, their interconnections, dependencies, usage frequencies, temporal dependencies etc. The failure data used in many of these Black Box models are inconsistent with today’s multitasking operating environment with varying system loads. Hence, the uncertainty in prediction using Black Box models is found to be much higher. Although there are some models based on operation profile, sometimes it becomes extremely difficult to obtain the exact operational profile concerned with a given operation. Considering the above-mentioned issues, this paper presents a suitable approach in the presence of timing bugs for the reliability assessment of time-critical software and performs a case study on stepper motor application which works in real time. The used approach considers various aspects like software architecture, the components composing the system, their interconnection and interdependency for various execution scenarios with respect to a given operational profile, in the presence of timing bugs to find the reliability value of the stepper motor application.

A microservice-based architecture for enhancing the user experience in cross-device distributed mashup UIs with multiple forms of interaction

Mobility and continuous connection entail the emergence of heterogeneous devices with multiple forms of interaction. However, it is challenging for developers and corporations to keep up with the devices and provide applications adapted to them. Besides, better user experiences attuned to users’ needs and desires are increasingly in demand. User interfaces play a major role because they must be distributed through different devices and offer a customized experience for each user–device combination. We take advantage of the component-based applications easiness to build customized interfaces that can give optimal solutions to fulfill the requirements for adapting themselves to cross-device applications with multiple forms of interaction. User interaction on mashup interfaces can generate a great deal of data, which can be analyzed for improving the interaction and usefulness of the applications. In our paper, we have created a microservice-based architecture that generates datasets which contain the user behavior for further analysis. Therefore, the user experience and usability in distributed user interfaces may be improved through prediction models generated from the data. Each microservice autonomously fetches its own data and performs consistently so that it can transform datasets optimally by using feature engineering techniques. Thus, data analysis and algorithms can create accurate yet simple prediction models that provide useful knowledge to enhance the user experience. A REST API web service is added to each microservice to facilitate their communication with other microservices and/or third-party clients. The entire microservice architecture, including feature engineering and RESTful API web services for each microservice, offers an infrastructure to handle and process data interaction of cross-devices applications with multiple forms of interaction. This approach has been deployed in a real mashup application where new datasets have been created, processed and validated.

Approximate optimal AUTOSAR software components deploying approach for automotive E/E system

The AUTOSAR has been developed as the worldwide standard for automotive E/E software systems, making the electronic components of different suppliers to be employed universally. However, as the number of component-based applications in modern automotive embedded systems grows rapidly and the hardware topology becomes increasingly complex, deploying such large number of components in automotive distributed system in manual way is over-dependent on experience of engineers which in turn is time consuming. Furthermore, the resource limitation and scheduling analysis make the problems more complex for developers to find out an approximate optimal deploying approach in system integration. In this paper, we propose a novel method to deploy the AUTOSAR components onto ECUs with the following features. First, a clustering algorithm is designed for deploying components automatically within relatively low time complexity. Second, a fitness function is designed to balance the ECUs load. The goal of our approach is to minimize the communication cost over all the runnable entities while meeting all corresponding timing constraints and balancing all the ECUs load. The experiment results show that our approach is efficient and has well performance by comparing with other existing methods in specific and synthetic data set.

Designing of dynamic function for quality prediction of component-based software

Dynamic metrics must be designed and developed to measure size, complexity, quality and other factors of components in Component-Based Software Engineering (CBSE) because dynamic metrics affects the overall quality of Component-Based Software (CBS). In this paper new metric function is designed to measure the components execution dependency based on the some input parameters. These input parameters passed at the time of integration of components during the execution of the component based software In this paper, the relationship between component usage and functioning for a component is proposed. This paper describes the impact of the component interaction and focuses on the dynamic measurement of components in order to evaluate the performance in CBS. The aim of the paper is to improve the quality of component-based real-time applications dynamically.

A genetic algorithm-based approach for automated refactoring of component-based software

Context: During its lifecycle, a software system undergoes repeated modifications to quickly fulfill new requirements, but its underlying design is not properly adjusted after each update. This leads to the emergence of bad smells. Refactoring provides a de facto behavior-preserving approach to eliminate these anomalies. However, manually determining and performing useful refactorings is a formidable challenge, as stated in the literature. Therefore, framing object-oriented automated refactoring as a search-based technique has been proposed. However, the literature shows that search-based refactoring of component-based software has not yet received proper attention.Objective: This paper presents a genetic algorithm-based approach for the automated refactoring of component-based software. This approach consists of detecting component-relevant bad smells and eliminating these bad smells by searching for the best sequence of refactorings using a genetic algorithm.Method: Our approach consists of four steps. The first step includes studying the literature related to component-relevant bad smells and formulating bad smell detection rules. The second step involves proposing a catalog of component-relevant refactorings. The third step consists of constructing a source code model by extracting facts from the source code of a component-based software. The final step seeks to identify the best sequence of refactorings to apply to reduce the presence of bad smells in the source code model using a genetic algorithm. The latter uses bad smell detection rules as a fitness function and the catalog of refactorings as a means to explore the search space.Results: As a case study, we conducted experiments on an unbiased set of four real-world component-based applications. The results indicate that our approach is able to efficiently reduce the total number of bad smells by more than one half, which is an acceptable value compared to the recent literature. Moreover, we determined that our approach is also accurate in refactoring only components suffering from bad smells while leaving the remaining components untouched whenever possible. Furthermore, a statistical analysis shows that our genetic algorithm outperforms random search and local search in terms of efficiency and accuracy on almost all the systems investigated in this work.Conclusion: This paper presents a search-based approach for the automated refactoring of component-based software. To the best of our knowledge, our approach is the first to focus on component-based refactoring, whereas the state-of-the-art approaches focus only on object-oriented refactoring.

A verification and deployment approach for elastic component-based applications

Abstract Cloud environments are being increasingly used for the deployment and execution of complex applications and particularly component-based ones. They are expected to provide elasticity, among other characteristics, in order to allow a deployed application to rapidly change the amount of its allocated resources in order to meet the variation in demand while ensuring a given Quality of Service (QoS). However, establishing a correct elastic component-based application is not guaranteed in Cloud. Indeed, applying elasticity mechanisms should preserve functional properties and improve non-functional properties related to QoS, performance and resource consumption. In this paper, we propose an approach for the verification and deployment of elastic component-based applications. Our approach is based on the Event-B formal method. In fact, we formally model the component artifacts using Event-B and we define the Event-B events that model the elasticity mechanisms (scaling up and down) for component-based applications. Furthermore, we formally verify that our approach preserves the semantics of the component-based applications by using the proof obligations and the ProB animator. Once the elastic component-based applications are validated, they can be deployed in a Cloud environment using an elastic deployment framework which we have developed.

ViSel-TR: A Novel Approach for Developing Component-based Vision Systems Working in Unstructured Environments

One of the main tasks of vision systems is to support autonomous vehicle navigation in unstructured environments, where unexpected objects can suddenly appear. For this, they can use various information sources (cameras, ultrasonic sensors, GPS systems, LIDAR, etc.) to model the environment in which they operate. All these data are combined to extract all the information needed to guide their movement through the environment. The complexity of this task prevents the integration of vision systems into real-time control systems (autonomous vehicles, mobile robots, etc.). This is because most of the research carried out within the computer vision field focuses on hardware development or on creating new algorithms and methods for performing the analysis and manipulation of the image data. However, system development issues are treated as secondary. Consequently, designs are very efficient but very little reusable. On the other hand, real-time systems possess features that make them particularly sensitive to whatever architectural decisions are made. The use of software frame works and components has demonstrated its effectiveness in improving software productivity and quality. This work proposes a novel approach, called ViSel-TR, for developing vision systems seeking two main objectives: (1) efficient interpretation and reasonable response time in an unstructured environment and (2) use of different development paradigms offered by software engineering that allow their integration in realtime systems. In order to achieve these objectives, ViSel-TR uses model driven software development techniques in order to separate the description of component-based real-time applications from their possible implementations for different platforms.

Reconfigurable Applications Using GCMScript

Today's applications are commonly deployed in distributed environments using multiple computational resources from elastic cloud infrastructures. Environmental conditions, however, can vary among providers or at runtime, and the applications must be able to quickly adapt to new conditions. Component-based applications and autonomic computing appear to be flexible solutions for making applications reconfigurable and more adaptable. However, programming autonomic behavior isn't easy. This article describes a component-based framework for building reconfigurable and distributed applications, as well as a scripting language to facilitate the programming of autonomic behavior. The authors show the approach's effectiveness using a distributed master-slave application that can self-adjust its load.