In software engineering, system construction typically starts from a requirements specification that has been engineered from raw requirements in a natural language. The specification is used to derive intermediate requirements models such as structured or object-oriented models. Throughout the stages of system construction, these artefacts will be used as reference models. In general, in order to derive a design specification out of the requirements, the entire set of requirements specifications has to be analysed. Such models at best only approximate the raw requirements since these design models are derived as a result of the abstraction process according to the chosen software development methodology, and subjected to the expertise, intuition, judgment and experiences of the analysts or designers of the system. These abstraction models require the analysts to elicit all useful information from the requirements, and there is a potential risk that some information may be lost in the process of model construction. As the use of natural language requirements in system construction is inevitable, the central focus of this study was to use requirements stated in natural language in contrast to any other requirements representation (e.g. modelling artefact). In this thesis, an approach that avoids intermediate requirements models, and maps natural language requirements directly into architectural constructs, and thus minimises information loss during the model construction process, has been defined. This approach has been grounded on the adoption of a component model that supports incremental composition. Incremental composition allows a system to be constructed piece by piece. By mapping a raw requirement to elements of the component model, a partial architecture that satisfies that requirement is constructed. Consequently, by iterating this process for all the requirements, one at a time, the incremental composition to build the system piece by piece directly from the requirements can be achieved. In software engineering, system construction typically starts from a requirements specification that has been engineered from raw requirements in a natural language. The specification is used to derive intermediate requirements models such as structured or object-oriented models. Throughout the stages of system construction, these artefacts will be used as reference models. In general, in order to derive a design specification out of the requirements, the entire set of requirements specifications has to be analysed. Such models at best only approximate the raw requirements since these design models are derived as a result of the abstraction process according to the chosen software development methodology, and subjected to the expertise, intuition, judgment and experiences of the analysts or designers of the system. These abstraction models require the analysts to elicit all useful information from the requirements, and there is a potential risk that some information may be lost in the process of model construction. As the use of natural language requirements in system construction is inevitable, the central focus of this study was to use requirements stated in natural language in contrast to any other requirements representation (e.g. modelling artefact). In this thesis, an approach that avoids intermediate requirements models, and maps natural language requirements directly into architectural constructs, and thus minimises information loss during the model construction process, has been defined. This approach has been grounded on the adoption of a component model that supports incremental composition. Incremental composition allows a system to be constructed piece by piece. By mapping a raw requirement to elements of the component model, a partial architecture that satisfies that requirement is constructed. Consequently, by iterating this process for all the requirements, one at a time, the incremental composition to build the system piece by piece directly from the requirements can be achieved.

<p>The impact of computer programs in safety-critical systems has increased in the past decades and computer-based systems can now be found in a wide range of applications. </p><p>A new approach for developing dependable systems is documenting all design rationale that affects safety using Intent Specifications. A recent approach for developing complex systems efficiently and in an upgradeable manner is Component-Based System Engineering. In this thesis, these approaches are combined in the development and upgrade of a Remote Robot Control Unit by using the tool SpecTRM. </p><p>The case study showed that Intent Specifications and CBSE could successfully be combined. The tool SpecTRM was also studied during this work. It showed that traceability is of great importance during system upgrades. Since SpecTRM does not support formal verification of safety properties in design models, the SpecTRM-RL models were translated to Esterel code. Further analysis showed that functional verification can be efficient and useful when using the automatic model-checking tool available in Esterel Studio. This work also proposes a practical guideline for system upgrades in component-based systems, presented as the Sigma model. </p><p>The work also showed some shortcomings. First of all, the tool SpecTRM is at an early development stage and not yet mature for industrial use. Secondly, neither of the two languages SpecTRM-RL and Esterel was expressive enough for some of the numerical computations and data-exchange structures needed for navigation in the system. Finally, the verifier was not able to prove any data properties since valued signals are abstracted into pure signals during verification in Esterel Studio.</p>

The impact of computer programs in safety-critical systems has increased in the past decades and computer-based systems can now be found in a wide range of applications. A new approach for developing dependable systems is documenting all design rationale that affects safety using Intent Specifications. A recent approach for developing complex systems efficiently and in an upgradeable manner is Component-Based System Engineering. In this thesis, these approaches are combined in the development and upgrade of a Remote Robot Control Unit by using the tool SpecTRM. The case study showed that Intent Specifications and CBSE could successfully be combined. The tool SpecTRM was also studied during this work. It showed that traceability is of great importance during system upgrades. Since SpecTRM does not support formal verification of safety properties in design models, the SpecTRM-RL models were translated to Esterel code. Further analysis showed that functional verification can be efficient and useful when using the automatic model-checking tool available in Esterel Studio. This work also proposes a practical guideline for system upgrades in component-based systems, presented as the Sigma model. The work also showed some shortcomings. First of all, the tool SpecTRM is at an early development stage and not yet mature for industrial use. Secondly, neither of the two languages SpecTRM-RL and Esterel was expressive enough for some of the numerical computations and data-exchange structures needed for navigation in the system. Finally, the verifier was not able to prove any data properties since valued signals are abstracted into pure signals during verification in Esterel Studio.

In the context of building software systems, Service-oriented Systems (SOS) have become one of the major research topics in the past few years. In SOS, services are basic functional units that can be created, invoked, composed, and if needed deleted on-the-fly. Since these software systems are composed of different services there is no easy way to assure the Quality of Service (QoS), therefore, formal specification of both functional and extra-functional system behaviour, compatibility, and interoperability between different services have become important issues. As a way to address this issues, resource-aware timing behavioural language REMES was chosen to be extended towards service-oriented paradigm with service specific information, such as type, capacity, time-to-serve, etc., as well as Boolean predicate constraints on control flow guarantees. In this thesis we present a design framework that provides a graphical user interface for behaviour modelling of services based on REMES language. NetBeans Visual Library API is used to display editable service diagrams with support for graph-oriented models. A textual dynamic service composition language was implemented, together with means to automatically verify service composition correctness. We ensure also an automated traceability between service specification interfaces, where both modelling levels are combined in an efficient tool for designing SOS.

L'objectif de ce travail est de fournir des modèles et outils pour simplifier la construction des systèmes distribués à base de composants sécurisés, ainsi que la gestion des propriétés de sécurité, en utilisant des outils de haut niveau d'abstraction pour la configuration et la reconfiguration dynamique. En plus des propriétés d'accessibilité et de communications sécurisées classiques, nous focalisons notre travail sur une propriété des systèmes répartis plus générale : la non-interférence. Cette propriété atteste qu'il ne doit pas y avoir de flux d'information entre des parties publiques et privées du système. Ce qui implique le suivi de l'acheminement de l'information entre les différentes composantes du système distribué. Notre objectif principal est donc de proposer un modèle, accompagné d'un ensemble d'outils, garantissant la propriété de la non-interférence à la construction du système, et ce à une plus grosse granularité : celle des composants. Ces outils permettent de (1) configurer les paramètres de sécurité des composants et des liaisons entre eux, (2) vérifier la propriété de non-interférence dans le code d'un composant et entre les différents composants du système et (3) générer automatiquement le code nécessaire pour appliquer ces propriétés de sécurité. D'autre part, nous proposons une architecture permettant de vérifier dynamiquement la propriété de non-interférence dans un système réparti. / The goal of this thesis is to provide models and tools to simplify secured component-based distributed systems' construction and the management of their security properties, by using high-level tools for dynamic configuration and reconfiguration. In addition to the classic properties of accessibility and secured communications, we focus on a more general security property of distributed systems : the non-interference. This property says that there mustn't be information flow between secret and public parts of the system ; which requires information flow control across the system. Our main objective is to propose a model and set of tools guarantying the non-interference property at compiletime, and at a bigger granularity : the components. These tools are (1) tools for configuring security parameters of components and binding between components, (2) a compiler checking the non-interference property, and (3) tools for automatic generation of code assuring these security properties. On the other hand, we present an architecture enabling a dynamic verification of the non-interference property in a distributed system.

Les systèmes temps-réels sont des systèmes qui sont soumis à "des contraintes de temps", comme par exemple le délais de réponse d'un système à un événement physique. Souvent les temps de réponse sont de l'ordre du milliseconde et parfois même du microseconde. Construire des systèmes temps-réels nécessite l'utilisation de méthodologies de conception et de mise en œuvre qui garantissent la propriété de respect des contraintes de temps, par exemple un système doit réagir dans les limites définies par l'utilisateur tels que les délais et la périodicité. Un délai non respecté dans systèmes temps-réel critique est catastrophique, comme par exemple dans les systèmes automobiles. Si un airbag se déclanche tard dans un accident de voiture, même quelques millisecondes trop tard peuvent conduire à des répercussions graves. Dans les systèmes temps-réels non critiques, une perte significative de performance et de QoS peuvent se produire, comme par exemple dans les réseaux de systèmes multimédia. Contribution: Nous fournissons une méthode de conception rigoureuse des systèmes temps-réel. L'implèmentation est générée à partir d'une application logicielle temps-réel et une plate-forme cible, en utilisant les deux modèles suivants: * Un modèle abstrait représentant le comportement de l'application logicielle en temps réel sous forme d' un automate temporisé. Celui-ci décrit des contraintes temporelles définies par l'utilisateur qui sont indépendantes de la plateforme. Ses transitions sont intemporelles et correspondent à l'exécution des différentes instructions de l'application. * Un modèle physique représentant le comportement du logiciel en temps réel s'exécutant sur une plate-forme donnée. Il est obtenu par l'attribution des temps d'exécution aux transitions du modèle abstrait. Une condition nécessaire pour garantir l'implémentabilité dy système est la "time-safety", c'est à dire, toute séquence d'exécution du modèle physique est également une séquence d'exécution du modèle abstrait. "Time-safety" signifie que la plate-forme est assez rapide pour répondre aux exigences de synchronisation de l'application. Comme les temps d'exécution des actions ne sont pas connus avec exactitude, "time-safety" est vérifiée pour les temps d'exécution pire cas es actions en faisant l' hypothèse de la robustesse. La robustesse signifie que la "time-safety" est préservée lorsqu'on augmente la vitesse de la plate-forme d'exécution. Pour des logiciels et plate-forme d'exécution correspondant à un modèle robuste, nous définissons un moteur d'exécution qui coordonne l'exécution du logiciel d'application afin de répondre à ses contraintes temporelles. En outre, en cas de non-robustesse, le moteur d'exécution permet de détecter les violations de contraintes temporelles en arrêtant l'exécution. Nous avons mis en place le moteur d'exécution pour les programmes BIP. Nous avons validé la méthode pour la conception et la mise en œuvre du robot Dala. Nous montrons les avantages obtenus en termes d'utilisation du processeur et l'amélioration de la latence de la réaction. / Context: Real-time systems are systems that are subject to "real-time constraints"— e.g. operational deadlines from event to system response. Often real-time response times are understood to be in the order of milliseconds and sometimes microseconds. Building real-time systems requires the use of design and implementation methodologies that ensure the property of meeting timing constraints e.g. a system has to react within user-defined bounds such as deadlines and periodicity. A missed deadline in hard real-time systems is catastrophic, like for example in automotive systems, for example if an airbag is fined too late in a car accident, even one ms too late leads to serious repercussions. In soft real-time systems it can lead to a significant loss of performance and QoS like for example in networked multimedia systems. Contribution: We provide a rigorous design and implementation method for the implementation of real-time systems. The implementation is generated from a given real-time application software and a target platform by using two models: * An abstract model representing the behavior of real-time software as a timed automaton. The latter describes user-defined platform-independent timing constraints. Its transitions are timeless and correspond to the execution of statements of the real-time software. * A physical model representing the behavior of the real-time software running on a given platform. It is obtained by assigning execution times to the transitions of the abstract model. A necessary condition for implementability is time-safety, that is, any (timed) execution sequence of the physical model is also an execution sequence of the abstract model. Time-safety means that the platform is fast enough to meet the timing requirements. As execution times of actions are not known exactly, time-safety is checked for worst-case execution times of actions by making an assumption of time-robustness: time-safety is preserved when speed of the execution platform increases. For given real-time software and execution platform corresponding to a time-robust model, we define an execution Engine that coordinates the execution of the application software so as to meet its timing constraints. Furthermore, in case of non-robustness, the execution Engine can detect violations of time-safety and stop execution. We have implemented the execution Engine for BIP programs with real-time constraints. We have validated the method for the design and implementation of the Dala rover robot. We show the benefits obtained in terms of CPU utilization and amelioration in the latency of reaction.

Owing to advancements in component re-use technology, component-based software development (CBSD) has come a long way in developing complex commercial software systems while reducing software development time and cost. However, assembling distributed resource-constrained and safety-critical systems using current assembly techniques is a challenge. Within complex systems when there are numerous ways to assemble the components unless the software architecture clearly defines how the components should be composed, determining the correct assembly that satisfies the system assembly constraints is difficult. Component technologies like CORBA and .NET do a very good job of integrating components, but they do not automate component assembly; it is the system developer's responsibility to ensure thatthe components are assembled correctly. In this thesis, we first define a component-based system assembly (CBSA) technique called "Constrained Component Assembly Technique" (CCAT), which is useful when the system has complex assembly constraints and the system architecture specifies component composition as assembly constraints. The technique poses the question: Does there exist a way of assembling the components that satisfies all the connection, performance, reliability, and safety constraints of the system, while optimizing the objective constraint? To implement CCAT, we present a powerful framework called "CoBaSA". The CoBaSA framework includes an expressive language for declaratively describing component functional and extra-functional properties, component interfaces, system-level and component-level connection, performance, reliability, safety, and optimization constraints. To perform CBSA, we first write a program (in the CoBaSA language) describing the CBSA specifications and constraints, and then an interpreter translates the CBSA program into a satisfiability and optimization problem. Solving the generated satisfiability and optimization problem is equivalent to answering the question posed by CCAT. If a satisfiable solution is found, we deduce that the system can be assembled without violating any constraints. Since CCAT and CoBaSA provide a mechanism for assembling systems that have complex assembly constraints, they can be utilized in several industries like the avionics industry. We demonstrate the merits of CoBaSA by assembling an actual avionic system that could be used on-board a Boeing aircraft. The empirical evaluation shows that our approach is promising and can scale to handle complex industrial problems.

The thesis deals with the modeling of the Component Based Software (CBS) systems in the UML language and with extension of the UML language with using of meta-modeling techniques and with using of the UML Prodile technology. Thesis also deals with Component Based Development (CBD). The main part of this study deals with specifying of methodology for creating of UML Prodiles and with demonstration of this methodology on selected Component System meta-model by creating the profile including the OCL constraints and description of problems with creating of the prodile. Thesis also describes support of the UML Profile technology in existing UML CASE tools. For demonstration purposes thesis contains the case study with example which uses in this work created UML Profile. Profile is created in accordance with specification of UML version 2.3 and OCL in version 2.2. Demonstration is performed and profile itself is created using IBM Rational Software Architect version 8.0.2.