Component Based Development has emerged as economical, reusable, scalable way of developing enterprise as well as embedded software applications. Testing distributed component based systems is difficult when third party components are being used in the development. Many testing methodologies that have been proposed for testing object oriented programs in the literature are being imported into component domain directly or by tuning them. But testing components involves much manual work due to the lack of information of the component. Middleware architectures like, DCOM(Distributed COM), Jini and CORBA(Common Object Request Broker Architecture) are being used in developing the distributed component applications in different vertical domains. In this thesis, a language- Distributed Object Testing Language(DOTL) for specifying the testing process and generation of distributed testing environment for CORBA based applications has been proposed. The language captures required semantics for specifying dummy servers, clients, controlling the testing process, generation of test cases, activating and deactivating objects. Many existing testing techniques can be specified using the semantics provided by the language. Faults occurring in distributed object systems, in addition to the functional errors, can be identifiable using the tool. The language provides abstract types object, argument to specify variables in the testing environment, and operations dealing with these variables to conducts necessary tests. The DOTL has been implemented on MICO(Mico Is CORBA) orb on Linux OS, with mapping of DOTL to CORBA C++.

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.

This volume contains contribution form the refereed “MobIS 2010” main program and selected papers of its tracks. The conference on information systems modeling was held in Dresden September 15-17, 2010. The guiding theme for MobIS 2010 focused on modeling topics between model-based management and component and service engineering.

Les systèmes embarqués ont évolué d'une manière spectaculaire et sont devenus partie intégrante de notre quotidien. En réponse aux exigences grandissantes en termes de nombre de fonctionnalités et donc de flexibilité, les parties logicielles de ces systèmes se sont vues attribuer une place importante malgré leur manque d'efficacité, en comparaison aux solutions matérielles. Par ailleurs, vu la prolifération des systèmes nomades et à ressources limités, tenir compte de la performance est devenu indispensable pour bien les concevoir. Dans cette thèse, nous proposons une démarche rigoureuse et intégrée pour la modélisation et l'évaluation de performance tôt dans le processus de conception. Cette méthode permet de construire des modèles, au niveau système, conformes aux spécifications fonctionnelles, et intégrant les contraintes non-fonctionnelles de l'environnement d'exécution. D'autre part, elle permet d'analyser quantitativement la performance de façon rapide et précise. Cette méthode est guidée par les modèles et se base sur le formalisme $mathcal{S}$BIP que nous proposons pour la modélisation stochastique selon une approche formelle et par composants. Pour construire des modèles conformes au niveau système, nous partons de modèles purement fonctionnels utilisés pour générer automatiquement une implémentation distribuée, étant donnée une architecture matérielle cible et un schéma de répartition. Dans le but d'obtenir une description fidèle de la performance, nous avons conçu une technique d'inférence statistique qui produit une caractérisation probabiliste. Cette dernière est utilisée pour calibrer le modèle fonctionnel de départ. Afin d'évaluer la performance de ce modèle, nous nous basons sur du model checking statistique que nous améliorons à l'aide d'une technique d'abstraction. Nous avons développé un flot de conception qui automatise la majorité des phases décrites ci-dessus. Ce flot a été appliqué à différentes études de cas, notamment à une application de reconnaissance d'image déployée sur la plateforme multi-cœurs STHORM. / In the present work, we tackle the problem of modeling and evaluating performance in the context of embedded systems design. These have become essential for modern societies and experienced important evolution. Due to the growing demand on functionality and programmability, software solutions have gained in importance, although known to be less efficient than dedicated hardware. Consequently, considering performance has become a must, especially with the generalization of resource-constrained devices. We present a rigorous and integrated approach for system-level performance modeling and analysis. The proposed method enables faithful high-level modeling, encompassing both functional and performance aspects, and allows for rapid and accurate quantitative performance evaluation. The approach is model-based and relies on the $mathcal{S}$BIP formalism for stochastic component-based modeling and formal verification. We use statistical model checking for analyzing performance requirements and introduce a stochastic abstraction technique to enhance its scalability. Faithful high-level models are built by calibrating functional models with low-level performance information using automatic code generation and statistical inference. We provide a tool-flow that automates most of the steps of the proposed approach and illustrate its use on a real-life case study for image processing. We consider the design and mapping of a parallel version of the HMAX models algorithm for object recognition on the STHORM many-cores platform. We explored timing aspects and the obtained results show not only the usability of the approach but also its pertinence for taking well-founded decisions in the context of system-level design.

A Component Oriented Software Engineering (COSE) modeling environment is enhanced with the capability to import executable components and deliver applications through their composition. For this purpose, an interface layer that utilizes JAR libraries as components has been developed. Also, Domain Engineering process has been applied to Geographical Information Systems (GIS) domain and utilized towards converting the environment to a development framework. The interface layer imports JAR libraries into the COSECASE tool, which is a graphical tool supporting COSE approach and COSE Modeling Language (COSEML). As a result, systems can be designed using abstractions and then implemented by corresponding deployed components. Imported code is made available to the COSECASE environment through this interface layer. Also, Domain Analysis, Domain Design, and Domain Implementation phases of Domain Engineering process have been applied to the GIS domain. Components developed in this Domain Implementation phase have been imported into COSECASE. A simple GIS application has been designed and generated through the interface layer of COSECASE for demonstration purposes.

In this thesis we present a novel approach to the analysis of dependency graphs of object-oriented programs, and we describe a tool that has been implemented for this purpose. A graph-theoretical clustering algorithm is used in order to compute the modular structure of programs. This can be used to assist software engineers to redraw component boundaries in software in order to improve the level of reuse and maintainability. The analysis of the dependency graph of an object-oriented program is useful for assessing the quality of software design. The dependency graph can be extracted from a program using various different methods, including source code, byte code, and dynamic (behavioral) analysis. The nodes in the dependency graph are classes, members, packages and other artifacts, while the edges represent uses and extends relationships between those artifacts. Once the dependency graph has been extracted, it can be analysed in order to quantify certain characteristics of the respective program. Examples include the detection of circular dependencies and measurements of the responsibility or independence of units based on their relationships. Tools like JDepend1 implementing these principles have become very popular in recent years. Our work includes grouping types in dependency graphs using di erent clustering methods: Grouping into namespaces; Grouping into clusters using graph clustering algorithms; Grouping into clusters using rules. The detected mismatches are candidates for refactoring. We have developed a tool for processing dependency graphs clustering and producing results where users can outline possible design violations.

Made available in DSpace on 2014-12-17T15:47:46Z (GMT). No. of bitstreams: 1 AndreGDA.pdf: 982503 bytes, checksum: 1c9c31b9670edd5ef9e3e725bb8f680b (MD5) Previous issue date: 2008-02-12 / This work presents a proposal of a multi-middleware environment to develop distributed applications, which abstracts different underlying middleware platforms. This work describes: (i) the reference architecture designed for the environment, (ii) an implementation which aims to validate the specified architecture integrating CORBA and EJB, (iii) a case study illustrating the use of the environment, (iv) a performance analysis. The proposed environment allows interoperability on middleware platforms, allowing the reuse of components of different kinds of middleware platforms in a transparency away to the developer and without major losses in performance. Also in the implementation we developed an Eclipse plugin which allows developers gain greater productivity at developing distributed applications using the proposed environment / Este trabalho apresenta a proposta de um ambiente multi-middleware para desenvolvimento de aplica??es distribu?das, o qual abstrai diferentes plataformas de middleware subjacentes. O trabalho descreve: (i) a arquitetura de refer?ncia especificada para o ambiente, (ii) uma implementa??o que valida tal arquitetura integrando CORBA e EJB, (iii) um estudo de caso ilustrando o uso do ambiente, (iv) a an?lise de desempenho. O ambiente proposto permite alcan?ar interoperabilidade de plataformas de middleware, promovendo o reuso de componentes de diferentes plataformas de forma transparente para o desenvolvedor e sem perdas expressivas em termos de desempenho. Na implementa??o desenvolvemos um plugin para IDE Eclipse que permite que os eventuais desenvolvedores obtenham maior produtividade ao desenvolver aplica??es usando o ambiente

Made available in DSpace on 2014-12-17T15:48:09Z (GMT). No. of bitstreams: 1 SarahRRS_DISSERT.pdf: 1954614 bytes, checksum: ba3eee36fc3f3f1030a71fa2ad2f605a (MD5) Previous issue date: 2013-12-13 / Universidade Federal do Rio Grande do Norte / The component-based development of systems revolutionized the software development process, facilitating the maintenance, providing more confiability and reuse. Nevertheless, even with all the advantages of the development of components, their composition is an important concern. The verification through informal tests is not enough to achieve a safe composition, because they are not based on formal semantic models with which we are able to describe precisally a system s behaviour. In this context, formal methods provide ways to accurately specify systems through mathematical notations providing, among other benefits, more safety. The formal method CSP enables the specification of concurrent systems and verification of properties intrinsic to them, as well as the refinement among different models. Some approaches apply constraints using CSP, to check the behavior of composition between components, assisting in the verification of those components in advance. Hence, aiming to assist this process, considering that the software market increasingly requires more automation, reducing work and providing agility in business, this work presents a tool that automatizes the verification of composition among components, in which all complexity of formal language is kept hidden from users. Thus, through a simple interface, the tool BST (BRIC-Tool-Suport) helps to create and compose components, predicting, in advance, undesirable behaviors in the system, such as deadlocks / O desenvolvimento de sistemas baseados em componentes revolucionou o processo de desenvolvimento de software, facilitando a manuten??o, trazendo mais confiabilidade e reutiliza??o. Por?m, mesmo com todas as vantagens atribu?das ao componente, ? necess?rio uma an?lise detalhada de sua composi??o. Realizar verifica??o a partir de testes de software n?o ? o suficiente para se ter uma composi??o segura, pois esses n?o s?o baseados em modelos sem?nticos formais nos quais podemos descrever precisamente o comportamento do sistema. Nesse contexto, os m?todos formais oferecem a possibilidade de especificarmos sistemas de forma precisa, atrav?s de nota??es com forte base matem?tica, trazendo, entre outros benef?cios, mais seguran?a. O m?todo formal CSP possibilita a especifica??o de sistemas concorrentes e verifica??o de propriedades inerentes a tais sistemas, bem como refinamento entre diferentes modelos. Existem abordagens que aplicam restri??es usando CSP, para verificar o comportamento da composi??o entre componentes, auxiliando a verifica??o desses componentes antecipadamente. Visando auxiliar esse processo, tendo em vista que o mercado de software busca cada vez mais automa??o, minimizando trabalhos e trazendo agilidade nos neg?cios, este trabalho apresenta uma ferramenta que automatiza a verifica??o da composi??o entre componentes, onde o conjunto de verifica??es CSP impostas ? gerado e verificado internamente, oculto para o usu?rio. Dessa forma, atrav?s de uma interface simples, a ferramenta BTS (BRIC-Tool-Suport) ajuda a criar e compor componentes, prevendo, com anteced?ncia, comportamentos indesej?veis no sistema, como deadlocks

Les systèmes embarqués ont évolué d'une manière spectaculaire et sont devenus partie intégrante de notre quotidien. En réponse aux exigences grandissantes en termes de nombre de fonctionnalités et donc de flexibilité, les parties logicielles de ces systèmes se sont vues attribuer une place importante malgré leur manque d'efficacité, en comparaison aux solutions matérielles. Par ailleurs, vu la prolifération des systèmes nomades et à ressources limités, tenir compte de la performance est devenu indispensable pour bien les concevoir. Dans cette thèse, nous proposons une démarche rigoureuse et intégrée pour la modélisation et l'évaluation de performance tôt dans le processus de conception. Cette méthode permet de construire des modèles, au niveau système, conformes aux spécifications fonctionnelles, et intégrant les contraintes non-fonctionnelles de l'environnement d'exécution. D'autre part, elle permet d'analyser quantitativement la performance de façon rapide et précise. Cette méthode est guidée par les modèles et se base sur le formalisme $mathcal{S}$BIP que nous proposons pour la modélisation stochastique selon une approche formelle et par composants. Pour construire des modèles conformes au niveau système, nous partons de modèles purement fonctionnels utilisés pour générer automatiquement une implémentation distribuée, étant donnée une architecture matérielle cible et un schéma de répartition. Dans le but d'obtenir une description fidèle de la performance, nous avons conçu une technique d'inférence statistique qui produit une caractérisation probabiliste. Cette dernière est utilisée pour calibrer le modèle fonctionnel de départ. Afin d'évaluer la performance de ce modèle, nous nous basons sur du model checking statistique que nous améliorons à l'aide d'une technique d'abstraction. Nous avons développé un flot de conception qui automatise la majorité des phases décrites ci-dessus. Ce flot a été appliqué à différentes études de cas, notamment à une application de reconnaissance d'image déployée sur la plateforme multi-cœurs STHORM. / In the present work, we tackle the problem of modeling and evaluating performance in the context of embedded systems design. These have become essential for modern societies and experienced important evolution. Due to the growing demand on functionality and programmability, software solutions have gained in importance, although known to be less efficient than dedicated hardware. Consequently, considering performance has become a must, especially with the generalization of resource-constrained devices. We present a rigorous and integrated approach for system-level performance modeling and analysis. The proposed method enables faithful high-level modeling, encompassing both functional and performance aspects, and allows for rapid and accurate quantitative performance evaluation. The approach is model-based and relies on the $mathcal{S}$BIP formalism for stochastic component-based modeling and formal verification. We use statistical model checking for analyzing performance requirements and introduce a stochastic abstraction technique to enhance its scalability. Faithful high-level models are built by calibrating functional models with low-level performance information using automatic code generation and statistical inference. We provide a tool-flow that automates most of the steps of the proposed approach and illustrate its use on a real-life case study for image processing. We consider the design and mapping of a parallel version of the HMAX models algorithm for object recognition on the STHORM many-cores platform. We explored timing aspects and the obtained results show not only the usability of the approach but also its pertinence for taking well-founded decisions in the context of system-level design.

This thesis focused on the modelling of a pulping process. The purpose was to see if an accurate model can be crated based on relatively simple premises and if the errors can be identified or analysed. To realise this, the authors conducted a literature study to identify the current state of the art regarding the chemical pulping process. In addition, flow charts and sample data from a case study were examined. Based on the literature review and case study, model assumptions were derived. The model is divided into sixteen components. Where mixing occurs, lumped conditions are assumed. The model has five validation points, four of which are temperatures and a mass flowrate. These are shown as deviations from the measured values. In conclusions, it was the model could produce stable results over a narrow time frame. More so if the transition period at the start of the simulation is overlooked. Several new model assumptions are presented with the purpose to increase accuracy e.g. account for the components ability to store mass.