Assisting software architects in architectural decision-making using Quark

Non-Functional Requirements (NFRs) and constraints are among the principal drivers of architectural decision-making. NFRs are improved or damaged by architectural decisions (ADs), while constraints directly include or exclude parts of the architecture (e.g., logical components or technologies). We may determine the impact of an AD, or which parts of the architecture are affected by a constraint, but at the end it is hard to know if we are respecting the NFRs and the imposed constraints with all the ADs made. In the usual approach, architects use their own experience to produce software architectures that comply with the NFRs and imposed constraints, but at the end, especially for crucial decisions, the architect has to deal with complex trade-offs between NFRs and juggle with possible incompatibilities raised by the imposed constraints. In this paper we present Quark, a method to assist software architects in architectural decision-making, and the conceptualization of the relationship between NFRs and ADs defined in Arteon, an ontology to represent and manage architectural knowledge. Finally, we provide an overview of the Quark and Arteon implementation, the ArchiTech tool.Peer ReviewedPostprint (published version

A Framework for Interactive Development of Simulation Models with Strategical–Tactical–Operational Layering Applied to the Logistics of Bulk Commodities

CONTEXT–Simulation modelling provides insight into hidden dynamics underlying business processes. However, an accurate understanding of operations is necessary for fidelity of the model. This is challenging because of the need to extract the tacit nature of operational knowledge and facilitate the representation of complex processes and decision-making patterns that do not depend on classes, objects, and instantiations. Commonly used industrial simulation, such as Arena®, does not natively support the object-oriented constructs available for software development. OBJECTIVE–This paper proposes a method for developing simulation models that allow process-owners and modellers to jointly build a series of evolutionary models that improve conceptual validity of the executable computer model. APPROACH-Software and Systems Engineering principles were adapted to develop a framework that allows a systematic transition from conceptual to executable model, which allows multiple perspectives to be simultaneously considered. The framework was applied to a logistics case study in a bulk commodities distribution context. FINDINGS–The method guided the development of a set of models that served as scaffolds to allow the natural flow of ideas from a natural language domain to Arena® code. In doing so, modeller and process-owners at strategic, tactical, and operational levels developed and validated the simulation model. ORIGINALITY—This work provides a framework for structuring the development of simulation models. The framework allows the use of non-object-oriented constructs, making it applicable to SIMAN-based simulation languages and packages as Arena®

Conception architecturale des systèmes robotiques orientée services

Robotics has experienced an increasing evolution and interest from the society in recent years. Robots are no longer produced exclusively to perform repetitive tasks in factories, they have been designed to collaborate with humans in several important application domains. Robotic systems that control these robots are therefore becoming larger, more complex, and difficult to develop. In this scenario, Service-Oriented Architecture (SOA) has been investigated as a promising architectural style for the design of robotic systems in a flexible, reusable, and productive manner. Despite the existence of a considerable amount of Service-Oriented Robotic Systems (SORS), most of them have been developed in an ad hoc manner. The little attention and limited support devoted to the design of SORS software architectures may not only hamper the benefits of SOA adoption, but also reduce the overall quality of robotic systems, which are often used in safety-critical contexts. This thesis aims at improving the understanding and systematization of SORS architectural design.La Robotique a connu une évolution remarquable au cours des dernières années, couplée à un intérêt croissant de la société pour ce domaine. Les robots ne sont plus fabriqués exclusivement pour effectuer des tâches répétitives dans les usines, mais ils sont aussi créés pour collaborer avec les humains dans plusieurs domaines d'application d'importance. Les systèmes robotiques qui contrôlent ces robots sont donc de plus en plus larges, complexes et difficiles à développer. Dans ce contexte, l'Architecture Orientée Services (SOA) a été identifiée comme un style d'architecture logicielle prometteur pour concevoir des systèmes robotiques de manière flexible, réutilisable et productive. Cependant, malgré le nombre considérable de Systèmes Robotiques Orientées Services (SORS) existants aujourd'hui, la plupart d'entre eux ont été développés de manière ad hoc. Le peu d'attention et le soutien limité portés à la conception d'architectures logicielles SORS peuvent non seulement masquer les avantages de l'adoption de la SOA, mais aussi réduire la qualité globale des systèmes robotiques, qui sont souvent utilisés dans des contextes de sécurité critiques. Cette thèse vise à améliorer la compréhension et la systématisation de la conception architecturale SORS. Elle décrit une taxonomie des services pour le domaine de la robotique, puis propose un processus ainsi qu'une architecture de référence afin de systématiser la conception d'architectures logicielles SORS. Les résultats obtenus dans les études d'évaluation montrent qu'à la fois le processus et l'architecture de référence peuvent avoir un impact positif sur la qualité des architectures logicielles SORS et, par conséquent, contribuent à l'amélioration des systèmes robotique

Embedding requirements within the model driven architecture.

The Model Driven Architecture (MDA) is offered as one way forward in software systems modelling to connect software design with the business domain. The general focus of the MDA is the development of software systems by performing transformations between software design models, and the automatic generation of application code from those models. Software systems are provided by developers, whose experience and models are not always in line with those of other stakeholders, which presents a challenge for the community. From reviewing the available literature, it is found that whilst many models and notations are available, those that are significantly supported by the MDA may not be best for use by non technical stakeholders. In addition, the MDA does not explicitly consider requirements and specification. This research begins by investigating the adequacy of the MDA requirements phase and examining the feasibility of incorporating a requirements definition, specifically focusing upon model transformations. MDA artefacts were found to serve better the software community and requirements were not appropriately integrated within the MDA, with significant extension upstream being required in order to sufficiently accommodate the business user in terms of a requirements definition. Therefore, an extension to the MDA framework is offered that directly addresses Requirements Engineering (RE), including the distinction of analysis from design, highlighting the importance of specification. This extension is suggested to further the utility of the MDA by making it accessible to a wider audience upstream, enabling specification to be a direct output from business user involvement in the requirements phase of the MDA. To demonstrate applicability, this research illustrates the framework extension with the provision of a method and discusses the use of the approach in both academic and commercial settings. The results suggest that such an extension is academically viable in facilitating the move from analysis into the design of software systems, accessible for business use and beneficial in industry by allowing for the involvement of the client in producing models sufficient enough for use in the development of software systems using MDA tools and techniques

QoS Contract Negotiation in Distributed Component-Based Software

Currently, several mature and commercial component models (for e.g. EJB, .NET, COM+) exist on the market. These technologies were designed largely for applications with business-oriented non-functional requirements such as data persistence, confidentiality, and transactional support. They provide only limited support for the development of components and applications with non-functional properties (NFPs) like QoS (e.g. throughput, response time). The integration of QoS into component infrastructure requires among other things the support of components’ QoS contract specification, negotiation, adaptation, etc. This thesis focuses on contract negotiation. For applications in which the consideration of non-functional properties (NFPs) is essential (e.g. Video-on-Demand, eCommerce), a component-based solution demands the appropriate composition of the QoS contracts specified at the different ports of the collaborating components. The ports must be properly connected so that the QoS level required by one is matched by the QoS level provided by the other. Generally, QoS contracts of components depend on run-time resources (e.g. network bandwidth, CPU time) or quality attributes to be established dynamically and are usually specified in multiple QoS-Profiles. QoS contract negotiation enables the selection of appropriate concrete QoS contracts between collaborating components. In our approach, the component containers perform the contract negotiation at run-time. This thesis addresses the QoS contract negotiation problem by first modelling it as a constraint satisfaction optimization problem (CSOP). As a basis for this modelling, the provided and required QoS as well as resource demand are specified at the component level. The notion of utility is applied to select a good solution according to some negotiation goal (e.g. user’s satisfaction). We argue that performing QoS contract negotiation in multiple phases simplifies the negotiation process and makes it more efficient. Based on such classification, the thesis presents heuristic algorithms that comprise coarse-grained and fine-grained negotiations for collaborating components deployed in distributed nodes in the following scenarios: (i) single-client - single-server, (ii) multiple-clients, and (iii) multi-tier scenarios. To motivate the problem as well as to validate the proposed approach, we have examined three componentized distributed applications. These are: (i) video streaming, (ii) stock quote, and (iii) billing (to evaluate certain security properties). An experiment has been conducted to specify the QoS contracts of the collaborating components in one of the applications we studied. In a run-time system that implements our algorithm, we simulated different behaviors concerning: (i) user’s QoS requirements and preferences, (ii) resource availability conditions concerning the client, server, and network bandwidth, and (iii) the specified QoS-Profiles of the collaborating components. Under various conditions, the outcome of the negotiation confirms the claim we made with regard to obtaining a good solution

QoS Contract Negotiation in Distributed Component-Based Software

Currently, several mature and commercial component models (for e.g. EJB, .NET, COM+) exist on the market. These technologies were designed largely for applications with business-oriented non-functional requirements such as data persistence, confidentiality, and transactional support. They provide only limited support for the development of components and applications with non-functional properties (NFPs) like QoS (e.g. throughput, response time). The integration of QoS into component infrastructure requires among other things the support of components’ QoS contract specification, negotiation, adaptation, etc. This thesis focuses on contract negotiation. For applications in which the consideration of non-functional properties (NFPs) is essential (e.g. Video-on-Demand, eCommerce), a component-based solution demands the appropriate composition of the QoS contracts specified at the different ports of the collaborating components. The ports must be properly connected so that the QoS level required by one is matched by the QoS level provided by the other. Generally, QoS contracts of components depend on run-time resources (e.g. network bandwidth, CPU time) or quality attributes to be established dynamically and are usually specified in multiple QoS-Profiles. QoS contract negotiation enables the selection of appropriate concrete QoS contracts between collaborating components. In our approach, the component containers perform the contract negotiation at run-time. This thesis addresses the QoS contract negotiation problem by first modelling it as a constraint satisfaction optimization problem (CSOP). As a basis for this modelling, the provided and required QoS as well as resource demand are specified at the component level. The notion of utility is applied to select a good solution according to some negotiation goal (e.g. user’s satisfaction). We argue that performing QoS contract negotiation in multiple phases simplifies the negotiation process and makes it more efficient. Based on such classification, the thesis presents heuristic algorithms that comprise coarse-grained and fine-grained negotiations for collaborating components deployed in distributed nodes in the following scenarios: (i) single-client - single-server, (ii) multiple-clients, and (iii) multi-tier scenarios. To motivate the problem as well as to validate the proposed approach, we have examined three componentized distributed applications. These are: (i) video streaming, (ii) stock quote, and (iii) billing (to evaluate certain security properties). An experiment has been conducted to specify the QoS contracts of the collaborating components in one of the applications we studied. In a run-time system that implements our algorithm, we simulated different behaviors concerning: (i) user’s QoS requirements and preferences, (ii) resource availability conditions concerning the client, server, and network bandwidth, and (iii) the specified QoS-Profiles of the collaborating components. Under various conditions, the outcome of the negotiation confirms the claim we made with regard to obtaining a good solution

Understanding and Evaluating Assurance Cases

Assurance cases are a method for providing assurance for a system by giving an argument to justify a claim about the system, based on evidence about its design, development, and tested behavior. In comparison with assurance based on guidelines or standards (which essentially specify only the evidence to be produced), the chief novelty in assurance cases is provision of an explicit argument. In principle, this can allow assurance cases to be more finely tuned to the specific circumstances of the system, and more agile than guidelines in adapting to new techniques and applications. The first part of this report (Sections 1-4) provides an introduction to assurance cases. Although this material should be accessible to all those with an interest in these topics, the examples focus on software for airborne systems, traditionally assured using the DO-178C guidelines and its predecessors. A brief survey of some existing assurance cases is provided in Section 5. The second part (Section 6) considers the criteria, methods, and tools that may be used to evaluate whether an assurance case provides sufficient confidence that a particular system or service is fit for its intended use. An assurance case cannot provide unequivocal "proof" for its claim, so much of the discussion focuses on the interpretation of such less-than-definitive arguments, and on methods to counteract confirmation bias and other fallibilities in human reasoning

A methodology for component-based system integration

Component-based software based on software architectures is emerging to be the next generation software development paradigm. The paradigm shifts the development focus from lines-of-codes to coarser-grained components and the interconnections among them. It consists of system architecture design, architecture description, component search and system integration from components to generate a software system. However, one of the bottlenecks in this paradigm is the integration of the individual components into the overall system. In this dissertation a methodology for component-based system integration is proposed. It is based on an architectural aggregation view, a component model, flowgraphs and cyclomatic complexity. We introduce this view, model, and new ways to compute cyclomatic complexity based on flowgraphs. The methodology makes use of Jackson diagram to represent the detailed design of a system and decomposes the system into components and aggregations. An aggregation is a set of components glued together by one connector, and is represented as a flowgraph. Then an aggregation flowgraph is decomposed into prime flowgraphs called prime connections. An Implementation Description Language (IDL) is introduced to represent the aggregations and components. Finally a system synthesis mechanism is proposed that is responsible for translating prime connections, embedding functional units into them, and composing aggregations and the integrated system from them

Proposta de um método de verificação por tempo global com redes de Petri no desenvolvimento de software embarcado e em tempo real

Resumo: Sistemas embarcados de tempo real são sistemas restritos quanto às funcionalidades e recursos disponíveis. Nesses sistemas, requisitos temporais são tão importantes quanto requisitos funcionais. Nas fases de análise e projeto do software embarcado, um modelo analítico pode auxiliar em atividades de verificação, reduzindo o tempo de desenvolvimento e aumentando a garantia do comportamento correto do sistema. Este trabalho propõe a aplicação da técnica de tempo global de redes de Petri na verificação de software embarcado de tempo real. Um algoritmo da técnica de tempo global foi proposto e implementado. Um método geral de aplicação desta técnica e uma instanciação deste método foram propostos. Modelos de mapeamento de tarefas em redes de Petri foram desenvolvidos e um modelo de geração de cenários de comportamento para a análise de escalonabilidade para as políticas de prioridade fixa e earliest deadline first foi determinado e implementado. A execução e análise de experimentos permitiram observar o método e modelos. O método proposto neste trabalho objetiva identificar cenários de comportamento que não respeitam as restrições temporais do sistema modelado. No caso de sistemas embarcados e em tempo real esta é uma das principais preocupações das equipes de desenvolvimento de software. Como resultado, desenvolvemos um método que permite a verificação temporal de software embarcado de tempo real com relógios global e relativo, que é um passo relevante para facilitar a aplicação de redes de Petri no contexto do desenvolvimento destes sistemas