Search

Migrating an application to the cloud environment requires non-functional properties consideration such as cost, performance and Quality of Service (QoS). Given the variety and the plethora of cloud offerings in addition with the consumption-based pricing models currently available in the cloud market, it is extremely complex to find the optimal deployment that fits the application requirements and provides the best QoS and cost trade-offs. In many cases the performance of these service offerings may vary depending on the congestion level, provider policies and how the application types that are intended to be executed upon them use the computing resources. A key challenge for customers before moving to Cloud is to know application behavior on cloud platforms in order to select the best-suited environment to host their application components in terms of performance and cost. In this paper, we propose a combined methodology and a set of tools that support the design and migration of enterprise applications to Cloud. Our tool chain includes: (i) the performance assessment of cloud services based on cloud benchmark results, (ii) a profiler/classifier mechanism that identifies the computing footprint of an arbitrary application and provides the best matching with a cloud service solution in terms of performance and cost, (iii) and a design space exploration tool, which is effective in identifying the deployment of minimum costs taking into account workload changes and providing QoS guarantees. A methodology and tools that support the design and migration of applications to Cloud.The performance advertised by cloud providers is to be used carefully.The proposed benchmark procedure for migrated Cloud applications leads to reduced costs.

Scientific knowledge embraces all the notions of the scientific subjects, such as mathematics, physics, chemistry and more. This knowledge requires to be visualized to various users and for different tasks. The purpose of this work is to improve the design of scientific knowledge visualization systems through the creation of User interface (UI) prototypes from the scientific knowledge to visualize. To achieve this purpose a methodology is proposed. The formal representation and visualization of this knowledge are the first research questions addressed by two reference models: Scientific Knowledge Model and Visual Model. A mapping language designed to declare abstract representations of the desired UI prototypes associates these two models. Algorithms to transform these abstract representations into concrete UI prototypes have been also developed. The methodology has been tested using various sources and the results, including the real use case of the CERN CMS High Level Trigger configuration management system, are presented.

Model-driven design (MDD) aims at elevating design to a higher level of abstraction than that provided by third-generation programming languages. Concurrently, assertion-based verification (ABV) relies on the definition of temporal assertions to enhance functional verification targeting the correctness of the design execution with respect to the expected behavior. Both MDD and ABV have affirmed as effective methodologies for design and verification of HW components of embedded systems. Nonetheless, MDD and ABV individually suffer some limitations that prevent their integration in the embedded-software (ESW) design and verification flow. In particular, MDD requires the integration of an effective methodology for monitoring specification conformance, and dynamic ABV relies on simulation assumptions, satisfied in the HW domain, but which cannot be straightforward guaranteed during the execution of ESW. In this work, we present a suitable combination of MDD and dynamic ABV as an effective solution for ESW design and verification. A suite composed of two off-the-shelf tools has been developed for supporting this integrated approach. The MDD tool, i.e., radCASE, is a rapid-application-development environment for ESW that provides the user with a comprehensive approach to cover the complete modeling and synthesis process of ESW. The dynamic ABV environment, i.e., radCHECK, integrates computer-aided and template-based assertion definition, automatic checker generation, and effective stimuli generation, making dynamic ABV really practical to check the correctness of the radCASE outcome.

Dieser Artikel schlägt eine modellbasierte domänen-spezifische Sprache zur Modellierung von Sicherheitsanalyse nach der STAMP/STPA Methode vor. Im Dokument werden die einzelnen Modellierungskonstrukte detailliert beschrieben, sowie deren Zusammenhänge definiert., The article proposes a model-based domain-specific language for the STAMP/STPA safety analysis technique. The document describes the modeling artefacts and their relationships in detail.

In this paper we focus on goal engineering by addressing issues such as goal elicitation, specification, structuring and operationalisation. Specification of business goals is regarded as a means to raise the level of abstraction (and automation) at which business logic is incorporated in model driven software design in the context of service oriented architectures. More specifically, the proposed goal modelling approach consists of an abstract syntax (metamodel) and a concrete syntax (graphical notation) for the specification of business goals. We also proposed a framework for the goal-driven design of service-oriented software applications. In particular, we illustrate our approach by means of a case study carried out in the healthcare sector and we explain the role business goals (operationalised in the form of business rules) can play in software design. This research also outlines a number of areas that have significant research potential.

Verifying that a software system shows certain non-functional properties is a primary concern for cloud applications. Given the heterogeneous technology offer and the pricing models currently available in the cloud market it is extremely complex to find the deployment that fits the application requirements and provides the best Quality of Service (QoS) and cost trade-offs. This task can be very challenging, even infeasible if performed manually, since the number of solutions may become extremely large depending on the number of possible providers and available technology stacks. Furthermore, with the increasing adoption of cloud computing, there is a need for fair evaluation of cloud systems. Today's cloud services differ among others by cost, performance, consistency guarantees, load-balancing, caching, fault tolerance, and SLAs. Moreover, cloud systems are inherently multi-tenant and their performance can vary over time, depending on the congestion level, provider policies, and the competition among running applications. System architects and developers are challenged with this variety of services and trade-offs. Hence, the purpose of a cloud benchmark should be to help developers when choosing the right architecture and services for their applications. In this paper we propose a joint benchmarking and optimization methodology to support the design and migration of legacy applications to Cloud. Our approach is effective in identifying the deployment of minimum costs, which provide also QoS guarantees.

Software that is used to control machines and robots must be predictable and reliable. Model-Driven Design (MDD) techniques are used to comply with both the technical and business needs. This paper introduces a CSP meta-model that is suitable for these MDD techniques. The meta-model describes the structure of CSP models that are designed; using this meta-model it is possible to use all regular CSP constructs when constructing a CSP model. The paper also presents a new tool suite, called TERRA, based on Eclipse and its frameworks. TERRA contains a graphical CSP model editor (using the new CSP meta-model), model validation tools and code generation tools. The model validation tools check whether the model conforms to the meta-model definition as well as to additional rules. Models without any validation problems result in proper code generation, otherwise the developer needs to address the found problems to be sure code generation will succeed. The code generation tools are able to generate CSPm code that is readable by FDR and to generate C++/LUNA code that is executable on embedded targets. The meta-model and the TERRA tool suite are tested by designing CSP models for several of our laboratory setups. The generated C++/LUNA code for the laboratory setups is able to control them as expected. Additionally, the paper contains an example model containing all supported CSP constructs to show the CSPm code generation results. So it can be concluded that the meta-model and TERRA are usable for these kind of tasks.

Software that is used to control machines and robots must be predictable and reliable. Model-Driven Design (MDD) techniques are used to comply with both the technical and business needs. This paper introduces a CSP meta-model that is suitable for these MDD techniques. The meta-model describes the structure of CSP models that are designed; using this meta-model it is possible to use all regular CSP constructs when constructing a CSP model. The paper also presents a new tool suite, called TERRA, based on Eclipse and its frameworks. TERRA contains a graphical CSP model editor (using the new CSP meta-model), model validation tools and code generation tools. The model validation tools check whether the model conforms to the meta-model definition as well as to additional rules. Models without any validation problems result in proper code generation, otherwise the developer needs to address the found problems to be sure code generation will succeed. The code generation tools are able to generate CSPm code that is readable by FDR and to generate C++/LUNA code that is executable on embedded targets. The meta-model and the TERRA tool suite are tested by designing CSP models for several of our laboratory setups. The generated C++/LUNA code for the laboratory setups is able to control them as expected. Additionally, the paper contains an example model containing all supported CSP constructs to show the CSPm code generation results. So it can be concluded that the meta-model and TERRA are usable for these kind of tasks.

Computing applications for among others well-being and health become increasingly advanced as a result of their sensor-based awareness of the context in which they are used. Context-aware applications have the potential of providing enriched services to their users, i.e. services that are appropriate for the context at hand. A challenge for the design of context-aware applications is to identify and develop service enrichments which are effective and useful while not being overly complex and costly. It is hard to imagine, both for the designer and end-user, all possible relevant contexts and best possible corresponding enriched services. An enriched service which is not appropriate for the context at hand can irritate or even harm the user, and (eventually) leads to avoiding the use of the service. This paper discusses a model-driven approach that incorporates domain knowledge concerning the causal relationship between context factors and human conditions. We believe that such an approach facilitates the identification and development of appropriate sensor-based context-aware services. We focus on context-aware applications for the well-being domain.

Designing embedded control software for modern cyber-physical systems becomes more and more difficult, because of the increasing amount and complexity of their requirements. The regular requirements are extended with modern requirements, for example, to get a general purpose cyber-physical system capable of fulfilling a variety of different, ad-hoc tasks or to be suitable in environments with lots of human interactions. A typical example of modern cyber-physical systems, which have these modern requirements, are medical robotic systems used in surgeries. The essential goal of this research is to provide a way of working for the design of the control software for cyber-physical systems, and thereby providing a solution of the problem of the increasing complexity of the control software due to the modern requirements described above. The way of working makes use of model-driven design (MDD) techniques to reduce the complexity of the control software design. Additional objectives are to provide a component blue-print, an execution framework and tooling support, all to further decrease the complexity of the designs and to increase the usability of the provided way of working. In the end, it is concluded that the proposed way of working provides design steps for the complete design trajectory, starting at the initial designs up-to and including the deployment of the control software on the target system. It is also concluded that the supporting component blue-print (called Generic Architecture Component, or GAC) tightly matches the way of working and increases its value and usability. The execution framework (called LUNA Universal Network Architecture, or LUNA) and the tool-suite (called Twente Embedded Real-time Robotic Application, or TERRA) further increase the usability of the way of working by adding graphical model-driven design support to the way of working, with e.g. model validation and code generation. This all increases the understanding of the complex models and thus decreasing the complexity of the control software design. It is recommended to further evaluate the way of working, by using it to implement different control applications to steer all kinds of different cyber-physical systems. Furthermore it is recommended to add simulation capabilities and model management to the TERRA tool suite to increase its usability further.

In this paper we focus on goal engineering by addressing issues such as goal elicitation, specification, structuring and operationalisation. Specification of business goals is regarded as a means to raise the level of abstraction (and automation) at which business logic is incorporated in model driven software design in the context of service oriented architectures. More specifically, the proposed goal modelling approach consists of an abstract syntax (metamodel) and a concrete syntax (graphical notation) for the specification of business goals. We also proposed a framework for the goal-driven design of service-oriented software applications. In particular, we illustrate our approach by means of a case study carried out in the healthcare sector and we explain the role business goals (operationalised in the form of business rules) can play in software design. This research also outlines a number of areas that have significant research potential.

The success of software development projects to a large extent depends on the quality of the models that are produced in the development process, which in turn depends on the conceptual and practical support that is available for modelling, design and analysis. This paper focuses on model-driven support for service-oriented software development. In particular, it addresses how services and compositions of services can be designed, simulated and implemented. The support presented is part of a larger framework, called COSMO (COnceptual Service MOdelling). Whereas in previous work we reported on the conceptual support provided by COSMO, in this paper we proceed with a discussion of the practical support that has been developed. We show how reference models (model types) and guidelines (design steps) can be iteratively applied to design service compositions at a platform independent level and discuss what tool support is available for the design and analysis during this phase. Next, we present some techniques to transform a platform independent service composition model to an implementation in terms of BPEL and WSDL. We use the mediation scenario of the SWS challenge (concerning the establishment of a purchase order between two companies) to illustrate our application of the COSMO framework.

Rich and multifaceted domain specific specification languages like the Autonomic System Specification Language (ASSL) help to design reliable systems with self-healing capabilities. The GEAR game-based Model Checker has been used successfully to investigate properties of the ESA Exo- Mars Rover in depth. We show here how to enable GEAR���s game-based verification techniques for ASSL via systematic model extraction from a behavioral subset of the language, and illustrate it on a description of the Voyager II space mission.

The design and implementation of software for network systems of diverse physical assets is a continuing challenge to sensor network developers. The problems are often multiplied when adding new elements, and when reconfiguring existing systems. For software systems, like physical systems, explicit architectural descriptions increase system level comprehension. Coupled with well defined object oriented design practices, system extensibility is defined and software reuse and code composition are enabled. Our research is based on model driven design architecture. High level system models are defined in the Unified Modeling Language (UML), the language of the software engineer. However, since most experimental work is done by non-software specialists, (electronics Engineers, Mechanical Engineers and technicians) the model is translated into a graphical, domain specific model. Components are presented as domain specific icons, and constraints from the UML model are propagated into the domain model. Domain specialists manipulate the domain model, which then composes software elements needed at each node to create an aggregate system.

When modeling and implementing complex systems based on agents and artifacts, achieving semantic interoperability is not only useful, but often necessary. A commonly adopted solution to manage complex and real MASs is adopting a Model Driven methodology, which uses an ontology as the formal representation of the domain, and then exploiting some existing tool to automatically generate code for agents in the MAS, to let them interact according to the model. While this approach is satisfactorily supported when the target MAS environment is Jason, less support is provided to Jade MASs, despite Jade's large adoption for real MASs development. So, considering the great support given by the automatic code generation starting from a formal model, and the large community working on Jade MASs, in this work we present an extension of the OntologyBeanGenerator plugin for Protégé, used to generate a Java representation of an OWL ontology for Jade. We improved the OntologyBeanGenerator tool to support the modeling of exceptions, formalized at the ontology level, and of methods associated with ontology elements, to set the interface of concrete objects (artifacts) at design stage. This extension allows us to integrate in a Model Driven approach a support for the formal definition of artifacts and provide an automatic generation of Jade code/interfaces to interact with them respecting the model.