Search

The similarity measures such as Euclidean, Jaccard, Cosine, Manhattan etc present in the literature only consider the count of the features but does not consider the feature distribution and the degree of commonality. There is a significant research carried out for designing new similarity measures which can accurately find the similarity between any two software components. The distribution of component features in the software components has important contribution in evaluating their degree of similarity. This is the key idea for the design of the proposed measure. The main objective of this research is to first design an efficient similarity measure which essentially considers the distribution of the features over the entire input. We then carry out the analysis for worst case, average case and best case situations. The proposed measure is Gaussian based and preserves the properties of Gaussian function and can be used for clustering and classification of software components.

The evolution of software systems is an inevitable process which has to be managed effectively to enhance software quality. Change impact analysis (CIA) is a technique that identifies impact sets, i.e., the set of classes that require correction as a result of a change made to a class or artefact. These sets can also be considered as ripple effects and typically non-local: changes propagate to different parts of a system. Two classes are considered logically coupled if they have co-changed in the past; past research has shown that the precision of CIA techniques increases if logical and semantic coupling (i.e., the extent to which the lexical content of two classes is related) are both considered. However, the relationship between semantic and logical coupling of software artefacts has not been extensively studied and no dependencies established between these two types of coupling. Are two often co-changed artefacts also strongly connected from a semantic point of view? Are two semantically similar artefacts bound to co-change in the future? Answering those questions would help increase the precision of CIA. It would also help software maintainers to focus on a smaller subset of artefacts more likely to co-evolve in the future. This study investigated the relationship between semantic and logical coupling. Using Chi-squared statistical tests, we identified similarities in semantic coupling using class corpora and class identifiers. We then computed Spearman's rank correlation between semantic and logical coupling metrics for class pairs to detect whether semantic and logical relationships co-varied in OO software. Finally, we investigated the overlap between semantic and logical relationships by identifying the proportion of classes linked through both coupling types. Our empirical study and results were based on seventy-nine open-source software projects. Results showed that: (a) measuring the semantic similarity of classes by using their identifiers is computationally efficient; (b) using identifier-based coupling can be used interchangeably with semantic similarity based on their corpora, albeit not always; (c) no correlation between the strengths of semantic and change coupling was found. Finally, (d) a directional relationship between the two was identified; 70% of semantic dependencies are linked through change coupling but not vice versa. Based on our findings, we conclude that identifying more efficient methods of semantic coupling computation as well as a directional relationship between semantic and change dependencies could help to improve CIA methods that integrate semantic coupling information. This may also help to reveal implicit dependencies not captured by static source code analysis.

The orchestration of high performance computing (HPC) services to build scientific applications is based on complex workflows. A challenging task consists of improving the reliability of such workflows, avoiding faulty behaviors that can lead to bad consequences in practice. This paper introduces a certifier component for certifying scientific workflows in a certification framework proposed for HPC Shelf, a cloud-based platform for HPC in which different kinds of users can design, deploy and execute scientific applications. This component is able to inspect the workflow description of a parallel computing system of HPC Shelf and check its consistency with respect to a number of safety and liveness properties specified by application designers and component developers., This paper is a result of the project SmartEGOV: Harnessing EGOV for Smart Governance (Foundations, methods, Tools) / NORTE-01-0145-FEDER-000037, supported by Norte Portugal Regional Operational Programme (NORTE 2020), under the PORTUGAL 2020 Partnership Agreement, through the European Regional Development Fund (EFDR).

International audience; We target the problem of the safe control of reconfigurations in component-based software systems, where strategies of adaptation to variations in both their environment and internal resource demands need to be enforced. In this context, the computing system involves software components that are subject to control decisions. We approach this problem under the angle of Discrete Event Systems (DES), involving properties on events observed during the execution (e.g., requests of computing tasks, work overload), and a state space representing different configurations such as activity or assemblies of components. We consider in particular the potential of applying novel logico-numerical control techniques to extend the expressivity of control models and objectives, thereby extending the application of DES in component-based software systems. We elaborate methodological guidelines for the application of logico-numerical control based on a case- study, and validate the result experimentally.

Model-driven development is a pragmatic approach to software development that embraces domain-specific languages (DSLs), where models correspond to DSL programs. A distinguishing feature of model-driven development is that clients of a model can select from an open set of alternative semantics of the model by applying different model transformation. However, in existing model-driven frameworks, dependencies between models, model transformations, and generated code artifacts are either implicit or globally declared in build scripts, which impedes modular reasoning, separate compilation, and programmability in general.We propose the design of a new module system that incorporates models and model transformations as modules. A programmer can apply transformations in import statements, thus declaring a dependency on generated code artifacts. Our design enables modular reasoning and separate compilation by preventing hidden dependencies, and it supports mixing modeling artifacts with conventional code artifacts as well as higher-order transformations. We have formalized our design and the aforementioned properties and have validated it by an implementation and case studies that show that our module system successfully integrates model-driven development into conventional programming languages.

Software developing organizations nowadays have a wide choice when it comes to sourcing software components. This choice ranges from developing or adapting in-house developed components via buying closed source components to utilizing open source components. This study aims at structured decision support in this type of decision. As a basis for this study an initial set of criteria is taken, that has been identified and validated in a particular software development environment in a previous study on the subject (Kusters et al, 2016). In the paper at hand we report on the results of the application and validation of the initial set of sourcing criteria in a completely different case study environment, namely a software environment in that. medical embedded software is being developed. In addition, and based on the outcomes of our case study, a further step is made towards structured decision support for sourcing decisions by the development of an initial sourcing criteria framework.

This paper addresses the verification of software components in the context of their orchestration to build cloud-based scientific applications with high performance computing requirements. In such a scenario, components are often supplied by different sources and their cooperation rely on assumptions of conformity with their published behavioral interfaces. Therefore, a faulty or ill-designed component, failing to obey to the envisaged behavioral requirements, may have dramatic consequences in practice. Certifier components, introduced in this paper, implement a verification as a service framework and are able to access the implementation of other components and verify their consistency with respect to a number of functional, safety and liveness requirements relevant to a specific application or a class of them. It is shown how certifier components can be smoothly integrated in HPC Shelf, a cloud-based platform for high performance computing in which different sorts of users can design, deploy and execute scientific applications., SmartEGOV: Harnessing EGOV for Smart Governance (Foundations, methods, Tools) / NORTE-01-0145-FEDER000037, supported by Norte Portugal Regional Operational Programme (NORTE 2020), under the PORTUGAL 2020 Partnership Agreement, through the European Regional Development Fund (EFDR

Software developing organizations nowadays have a wide choice when it comes to sourcing software components. This choice ranges from developing or adapting in-house developed components via buying closed source components to utilizing open source components. This study aims at structured decision support in this type of decision. As a basis for this study an initial set of criteria is taken, that has been identified and validated in a particular software development environment in a previous study on the subject (Kusters et al, 2016). In the paper at hand we report on the results of the application and validation of the initial set of sourcing criteria in a completely different case study environment, namely a software environment in that. medical embedded software is being developed. In addition, and based on the outcomes of our case study, a further step is made towards structured decision support for sourcing decisions by the development of an initial sourcing criteria framework.

International audience; Software components are a valuable programming abstraction that enables a compositional design of complex applications. In distributed systems, components can also be used to provide an abstraction of locations: each component is a unit of deployment that can be placed on a different machine. In this article, we consider this kind of distributed components that are additionally loosely coupled and communicate by asynchronous invocations. Components also provide a convenient abstraction for verifying the correct behaviour of systems: they provide structuring entities easing the correctness verification. This article provides a formal background for the generation of behavioural semantics for asynchronous components. It expresses the semantics of hierarchical distributed components communicating asynchronously by requests, futures, and replies; this semantics is provided using the pNet intermediate language. This article both demonstrates the expressiveness of the pNet model and formally specifies the complete process of the generation of a behavioural model for a distributed component system. The purpose of our be-havioural semantics is to allow for verification both by finite instantiation and model-checking, and by techniques for infinite systems.

This report briefly describes an ongoing research related to optimization of allocating software components to heterogeneous computing platform (which includes CPU, GPU and FPGA). Research goal is also presented, along with current hot topics of the research area, related research teams, and finally results and contribution of my research. It involves mathematical modelling which results in goal function, optimization method which finds a suboptimal solution to the goal function and a software modeling tool which enables graphical representation of the problem at hand and help developers determine component placement in the system design phase.

In this thesis we introduce an approach for rigorous design and development of distributed hierarchical component-based systems. The core idea of the presented work is to combine the well-known among the programmers techniques for modeldriven software design and the powerful formal verification methods able to ensure the functional properties of a distributed system and to detect errors at the early design stage. First, we introduce a UML-based graphical formalism for modelling architecture and behaviour of hierarchical components. Second, we formally specify a set of constraints that ensure the correct components composition with a focus on separation between the functional and non-functional aspects. Third, we explain how the graphical models can be automatically translated into an input for a model-checker. For this aim, we rely on a formally specified intermediate structure encoding the semantics of components behaviour as a network of synchronised parametrised label transition systems. We focus here on encoding the advanced features of distributed components such as one-to-many communications, reconfiguration, and asynchronous communications based on request-reply. Finally, we implement the approach in an integrated model-driven environment which comprises a set of graphical editors, an architecture static correctness validation plug-in, a plug-in translating the conceptual model into an input for a verification toolsuite CADP, and a generator of the implementation code; Dans cette thèse, nous proposons une approche rigoureuse pour la conception et le développement de systèmes à base de composants hiérarchiques distribués. L’idée de base du travail présenté est de combiner les techniques de conception de logiciels dirigées par les modèles, bien connues des programmeurs, avec des méthodes de vérification formelles puissantes, capables d’assurer les propriétés fonctionnelles d’un système distribué et de détecter les erreurs dès le stade de la conception. Tout d’abord, nous introduisons un formalisme graphique basé sur UML pour l’architecture et le comportement des composants hiérarchiques de modélisation. Deuxièmement, nous spécifions formellement un ensemble de contraintes qui assurent la correction de la composition des composants, en mettant l’accent sur la séparation entre les aspects fonctionnels et non-fonctionnels. Troisièmement, nous expliquons comment nos modèles graphiques peuvent être traduits automatiquement dans le formalisme d’entrée d’un model-checker. Nous nous concentrons ensuite sur le codage des fonctionnalités avancées de composants distribués, comme communications de 1 vers N, la reconfiguration et les communications asynchrones basées sur les appels de procédures distants. Enfin, nous mettons en oeuvre cette approche dans une plateforme intégrée orienté modèle qui comprend un ensemble d’éditeurs graphiques, un module de validation de la décision correcte de l’architecture statique, un module traduisant le modèle conceptuel dans une entrée pour la plateforme de vérification CADP, et enfin un générateur de code exécutable

In this thesis we introduce an approach for rigorous design and development of distributed hierarchical component-based systems. The core idea of the presented work is to combine the well-known among the programmers techniques for modeldriven software design and the powerful formal verification methods able to ensure the functional properties of a distributed system and to detect errors at the early design stage. First, we introduce a UML-based graphical formalism for modelling architecture and behaviour of hierarchical components. Second, we formally specify a set of constraints that ensure the correct components composition with a focus on separation between the functional and non-functional aspects. Third, we explain how the graphical models can be automatically translated into an input for a model-checker. For this aim, we rely on a formally specified intermediate structure encoding the semantics of components behaviour as a network of synchronised parametrised label transition systems. We focus here on encoding the advanced features of distributed components such as one-to-many communications, reconfiguration, and asynchronous communications based on request-reply. Finally, we implement the approach in an integrated model-driven environment which comprises a set of graphical editors, an architecture static correctness validation plug-in, a plug-in translating the conceptual model into an input for a verification toolsuite CADP, and a generator of the implementation code; Dans cette thèse, nous proposons une approche rigoureuse pour la conception et le développement de systèmes à base de composants hiérarchiques distribués. L’idée de base du travail présenté est de combiner les techniques de conception de logiciels dirigées par les modèles, bien connues des programmeurs, avec des méthodes de vérification formelles puissantes, capables d’assurer les propriétés fonctionnelles d’un système distribué et de détecter les erreurs dès le stade de la conception. Tout d’abord, nous introduisons un formalisme graphique basé sur UML pour l’architecture et le comportement des composants hiérarchiques de modélisation. Deuxièmement, nous spécifions formellement un ensemble de contraintes qui assurent la correction de la composition des composants, en mettant l’accent sur la séparation entre les aspects fonctionnels et non-fonctionnels. Troisièmement, nous expliquons comment nos modèles graphiques peuvent être traduits automatiquement dans le formalisme d’entrée d’un model-checker. Nous nous concentrons ensuite sur le codage des fonctionnalités avancées de composants distribués, comme communications de 1 vers N, la reconfiguration et les communications asynchrones basées sur les appels de procédures distants. Enfin, nous mettons en oeuvre cette approche dans une plateforme intégrée orienté modèle qui comprend un ensemble d’éditeurs graphiques, un module de validation de la décision correcte de l’architecture statique, un module traduisant le modèle conceptuel dans une entrée pour la plateforme de vérification CADP, et enfin un générateur de code exécutable

Web services are self-described, loosely coupled software components that are network-accessible through standardized web protocols, whose characteristics are described in XML. One of the key promises of Web services is to provide better interoperability and to enable a faster integration between systems. In order to generate robust service oriented architectures, automatic composition algorithms are required in order to combine the functionality of many single services into composite services that are able to respond to demanding user requests, even when there is no single service capable of performing such task. Service composition consists of a combination of single services into composite services that are executed in sequence or in a different order, imposed by a set of control constructions that can be specified using standard languages such as OWL-s or BPEL4WS. In the last years several papers have dealt with composition of web services. Some approaches treat the service composition as a planning problem, where a sequence of actions lead from a initial state to a goal state. However, most of these proposals have some drawbacks: high complexity, high computational cost and inability to maximize the parallel execution of web services. Other approaches consider the problem as a graph search problem, where search algorithms are applied over a web service dependency graph in order to find a solution for a particular request. These proposals are simpler than their counterparts and also many can exploit the parallel execution of web services. However, most of these approaches rely on very complex dependency graphs that have not been optimized to remove data redundancy, which may negatively affect the overall performance and scalability of these techniques in large service registries. Therefore, it is necessary to identify, characterize and optimize the different tasks involved in the automatic service composition process in order to develop better strategies to efficiently obtain optimal solutions. The main goal of this dissertation is to develop a graph-based framework for automatic service composition that generate optimal input-output based compositions not only in terms of complexity of the solutions, but also in terms of overall quality of service solutions. More specifically, the objectives of this thesis are: (1) Analysis of the characteristics of services and compositions. The aim of this objective is to characterize and identify the main steps that are part for the service composition process. (2) Framework for automatic graph-based composition. This objective will focus on developing a framework that enables the efficient input-output based service composition, exploring the integration with other tasks that are part of the composition process, such as service discovery. (3) Development of optimal algorithms for automatic service composition. This objective focuses on the development of a set of algorithms and optimization techniques for the generation of optimal compositions, optimizing the complexity of the solutions and the overall Quality-of- Service. (4) Validation of the algorithms with standard datasets so they can be compared with other proposals.

The main principles of creating programs for trucking companies using ready-made components and software intelligent agents based on object assembly programming are examined. The model presented as a finished program, consists of software components, software agents and intuitive interface that allows the end user to transport enterprise reconfigure the program in accordance with the current requirements of current legislation and orders the company, without further involvement of programmers to write code. Writing a program is based on the principles of using assembly programming software agents, tracking user actions repeatability, offering automate these actions. Also in case of violation of repetition, there is a warn of a possible error. Each component is fully independent software product which can work both independently and in interaction with other components, allowing the use of only those components that are required. It significantly speeds up the calculations for the company, and does not require available expensive equipment for these calculations., Розглянуто головні принципи створення програм для автотранспортних підприємств з використанням готових компонент і програмних інтелектуальних агентів на основі складального об’єктного програмування. Запропонована модель представлена у вигляді готової програми, що складається з програмних компонент, програмних агентів і інтуїтивно зрозумілого інтерфейсу, що дозволяє кінцевому користувачеві автотранспортного підприємства перенастроювати програму відповідно до поточних вимог діючого законодавства і наказів підприємства, без подальшого залучення програмістів для написання програмного коду. В основу написання програми покладено принципи складального програмування з використанням програмних агентів, які, відстежуючи повторюваність дій користувача, пропонують автоматизувати дані дії. Також, у разі порушення повторюваності, попереджають про можливу помилку. Кожен з компонентів є повністю самостійним програмним продуктом, що може працювати як самостійно, так і у взаємодії з іншими компонентами, що дозволяє використовувати лише необхідні компоненти. Це значно прискорює виконання розрахунків по підприємству, а також не вимагає наявності дорогого обладнання для проведення цих розрахунків.

Software developing organizations nowadays have a wide choice when it comes to sourcing software components. This choice ranges from developing or adapting in-house developed components via buying closed source components to utilizing open source components. This study seeks to determine criteria that software developers can use to make this choice. Answering this question will result in a list of criteria that can, after further validation, be used to develop structured decision support in this type of decision. A first step is a literature search resulting in an initial list. Since the literature used was not specifically targeted at the question at hand, it was decided to separately conduct interviews to obtain an independently derived list of criteria. In a second part of the interview the respondents were confronted with the list resulting from literature. Together this resulted in a preliminary proposal for decision criteria for software sourcing.

Software developing organizations nowadays have a wide choice when it comes to sourcing software components. This choice ranges from developing or adapting in-house developed components via buying closed source components to utilizing open source components. This study seeks to determine criteria that software developers can use to make this choice. Answering this question will result in a list of criteria that can, after further validation, be used to develop structured decision support in this type of decision. A first step is a literature search resulting in an initial list. Since the literature used was not specifically targeted at the question at hand, it was decided to separately conduct interviews to obtain an independently derived list of criteria. In a second part of the interview the respondents were confronted with the list resulting from literature. Together this resulted in a preliminary proposal for decision criteria for software sourcing.

Deliverable D4.2 describes the Context Awareness and Activity Recognition system implemented as part of the research and development activities in tasks 4.1 (second part), 4.2, 4.3, 4.4. This deliverable includes both the released software system, available through WP4 code repository, as well as the present document. This document provides an up-to-date architectural view of the released system and provides a description of the implementation level details of the developed software. This includes both a specification of the software components, the description of the application programming interface implementing them as well as system deployment information, including hardware and software requirements. Further, it is provided a preliminary account of the experimental validation of the system components on data collected in the DOREMI laboratories and pilot site. A complete report on the experimental validation of the system will be provided in Deliverable D4.3 at M33.

�� ������������������������������������ �������������������� ���������������� ������������ �������� ������ �������� ������������������������������ ������������ ������ �������������� �������� ���������� ������ ������������������������ ������ ������ ������������������ ��������������������. �������� �������������� ���������������������� �������������� �������������������������� ������ ���������������� �������������������� �������������������������� �������� ���������� ������ �������������������������������������� �������������������� ���������� ������ ������������������ ������������ ������ �������� ���������� ������������������������ ������ ���������������� �������������� ���������������� ������ ������ ������������������������������������ �������������������� (ICSR) 2015. ������ �������������� ������ ������������������������ ���������������� ���������������������� ������ ���������������������� ���������������� �������������������� ���������������������� ������ ������������ ���������� �� �������������� PHP ������ Java ���������� ������ �� �������������������� �������� ������������ ���� ���������������� ������ �������� ������ ������������ online, �� ������������ ������������������ �������������������������������� ������ ������������������ �������������������������� ���������������� (metrics). �� ���������������� ���������������������� ���������������� ������������������ ���� �������������������� cloud ���� ���������������������� server. ������ ������ ������������������ ������ ������������������������������ ������������ �� ������������ ������������������������������ PHP, ���� ���������������� ������������ �� ������������ ������������������������������ Java ���������� ������ ���������������������� �������� HTML, MySQL, jQuery,CSS. ������ ���� �������������������� �� �������������� �������������� �������������������� ���� ������������ �������������� ������������������������ ������ ���������������������� ����/������ �������� ������ ������������������������ PHP Depend., Software reuse is currently one of the major areas of research in Information Technology and Software Engineering. This thesis presents a recent literature review in software reuse and modern trends as introduced in the recent International Conference on Software Reuse (ICSR) 2015 in Miami, Florida. Within the thesis a web application was implemented, main objects of which are the analysis of PHP and Java projects and the ability of a user to upload online his/her own source code that is being automatically analyzed and specific metrics are exported. The aforementioned web application is uploaded to a cloud environment in a test server. For the implementation of this application it was mainly used PHP programming language, Java programming language and technologies such as HTML, MySQL, jQuery, CSS. To create this work FLOSS programs and technologies such as PHP Depend had been used.

International audience; Although web personalisation has been studied for the last two decades, there remains a need to address current challenges: context-awareness and the inclusion in a business environment. The wide variety of mobile devices and their continuous technological evolution demands the permanent development of new personalisation strategies. Additionally, two factors complicate the inclusion of personalised web applications in a business environment: the frequent change of personalisation strategies for each business, and the technical complexity to integrate these strategies in a short time. We propose a reference architecture as a tool to favour their modifiability. Moreover, our proposal facilitates the opportunity for enterprises to adopt web-personalised systems into their business as a strategic tool. A controlled experiment validates our approach; we compare five change scenarios that are implemented under two architectures: experimental and control architecture. We used change scenarios derived from a real Brazilian e-commerce enterprise. 352 L-V. Cobaleda et al.

In component-based development, software components are taken as units of composition. Nevertheless, to achieve the widely disseminated status of components being plugged together as simple ‘Lego Pieces’, the integration of components must be carefully designed, systematised and verified; only this can ensure reliable architectures. In this work, we propose some conformance notions to predict the precise nature of some forms of composition, considering coordination patterns used in the integration. These notions are formalised in terms of the denotational semantics of the process algebra CSP, and assist the designer in common activities during integration, such as the substitution of component specifications by implementations, contract adaptations, and system extensions. To support mechanical verifications using FDR (a model-checker for CSP), we derive test characterisations from the denotational definitions of conformance. We illustrate the application of these notions through a systematic composition strategy of software frameworks, and we mechanically verify the preservation of behavioural component properties in these compositions. Moreover, we characterise the well-formedness of a coordination pattern used in this strategy at the design stage, before components are assembled.

In software component verification, one of the challenges is model checking of isolated components. The environment of an isolated component is unknown, and therefore a part of an input to a model checker is missing. This problem can be addressed via automated generation of an artificial environment — component and its environment form a complete program that can be verified using common model checkers.Focusing on concurrency errors in Java components, we propose to automatically generate a reasonable artificial environment that makes efficient detection of concurrency errors with Java PathFinder possible. Such an environment executes in parallel those component's methods that interact via concurrency constructs of Java and thus likely contain concurrency errors. We employ static code analysis to identify sets of methods to be executed in parallel and a metric to order the sets according to the degree of interaction. Benefits of the technique are illustrated on results of experiments performed on real-life Java components.

Many future software systems will be distributed across a network, extensively providing different kinds of services for their users. These systems must be highly reliable and provide services when required. Reliability and availability must be engineered into software from the onset of its development, and potential problems must be detected in the early stages, when it is easier and less expensive to implement modifications. The software architecture design phase is the first stage of software development in which it is possible to evaluate how well the quality requirements are being met. For this reason, a method is needed for analyzing software architecture with respect to reliability and availability. In this paper, we define a framework for comparing reliability and availability analysis methods from the viewpoint of software architecture. Our contribution is the comparison of the existing analysis methods and techniques that can be used for reliability and availability prediction at the architectural level. The objective is to discover which methods are suitable for the reliability and availability prediction of today’s complex systems, what are the shortcomings of the methods, and which research activities need to be conducted in order to overcome these identified shortcomings. The comparison reveals that none of the existing methods entirely fulfill the requirements that are defined in the framework. The comparison framework also defines the characteristics required of new reliability and availability analysis methods. Additionally, the framework is a valuable tool for selecting the best suitable method for architecture analysis. Furthermore, the framework can be extended and used for other evaluation methods as well.

Performance prediction methods for component-based software systems aim at supporting design decisions of software architects during early development stages. With the increased availability of multicore processors, possible performance gains by distributing threads and processes across multiple cores should be predictable by these methods. Many existing prediction approaches model concurrent behaviour insufficiently and yield inaccurate results due to hard underlying assumptions. In this paper, we present a formal performance prediction approach for component-based systems, which is parameterisable for the number of CPUs or CPU cores. It is able to predict the response time of component services for generally distributed execution times. An initial, simple case study shows that this approach can accurately predict response times of multithreaded software components in specific cases. However, it is limited if threads change the CPU during their execution, if the effect of processor cache thrashing is present, and if the memory bus is heavily used.

Even with todays hardware improvements, performance problems are still common in many software systems. An approach to tackle this problem for component-based software architectures is to predict the performance during early development stages by combining performance specifications of prefabricated components. Many existing methods in the area of component-based performance prediction neglect several influence factors on the performance of a component. In this paper, we present a method to calculate the performance of component services while including influences of external services and different usages. We use stochatic regular expressions with non-Markovian loop iterations to model the abstract control flow of a software component and probability mass functions to specify the time consumption of internal and external services in a fine grain way. An experimental evaluation is reported comparing results of the approach with measurements on a component-based webserver. The evaluation yields that using measured data as inputs, our approach can predict the mean response time of a service with less than 2 percent deviation from measurements taken when executing the service in our scenarios.

Component-based software development is being identified as the emerging method of developing complex applications consisting of heterogeneous systems. Although more research attention has been given to Commercial Off The Shelf (COTS) components, original software components are also widely used in the software industry. Original components are smaller in size, they have a narrower functional scope and they usually find more uses when it comes to specific and dedicated functions. Therefore, their need for interoperability is equal or greater, than that of COTS components. A quality framework for developing and evaluating original components is proposed in this paper, along with an application methodology that facilitates their evaluation. The framework is based on the ISO9126 quality model which is modified and refined so as to reflect better the notion of original components. The quality model introduced can be tailored according to the organization-reuser and the domain needs of the targeted component. The proposed framework is demonstrated and validated through real case examples, while its applicability is assessed and discussed. © 2006 Elsevier B.V. All rights reserved.

This paper explores the link between exports and total factor productivity in Brazilian manufacturing firms over the period 2000–08. The Brazilian experience is instructive, as it is a case of an economy that expanded aggregate exports significantly, but with stagnant aggregate growth in total factor productivity. The paper first estimates firm-level total factor productivity under alternative assumptions (exogenous and endogenous law of motion for productivity) following a GMM procedure. In turn, the analysis uses stochastic dominance techniques to assess whether the ex ante most productive firms are those that start exporting (self-selection hypothesis). Finally, the paper tests whether exporting boosts firms’ total factor productivity growth (learning-by-exporting hypothesis) using matching techniques to control for the possibility that selection into exports may not be a random process. The results confirm the self-selection hypothesis and show that starting to export yields additional growth in total factor productivity that emerges since the firm’s first year of exporting but lasts only one year. Further, this extra total factor productivity growth is much higher under the assumption of an endogenous law of motion for productivity, which reinforces the importance of accounting for firm export status to study the evolution of productivity.

This thesis describes the primary goal of the HelenOS microkernel multiserver operating system. The primary goal of the HelenOS project is to create a comprehensive research and development platform in the domain of general-purpose operating systems that would support state-of-the-art approaches and methods (such as verification of correctness) while at the same time focusing on practical relevance. The text of the thesis describes what specific means in terms of design (based on software components), implementation, development process and verification are used to achieve the primary goal. The thesis also evaluates the current state of HelenOS. Powered by TCPDF (www.tcpdf.org)

Large component-based systems are often built from many of the same components. As individual component-based software systems are developed, tested and maintained, these shared components are repeatedly manipulated. As a result there are often significant overlaps and synergies across and among the different test efforts of different component-based systems. However, in practice, testers of different systems rarely collaborate, taking a test-all-by-yourself approach. As a result, redundant effort is spent testing common components, and important information that could be used to improve testing quality is lost. The goal of this research is to demonstrate that, if done properly, testers of shared software components can save effort by avoiding redundant work, and can improve the test effectiveness for each component as well as for each component-based software system by using information obtained when testing across multiple components. To achieve this goal I have developed collaborative testing techniques and tools for developers and testers of component-based systems with shared components, applied the techniques to subject systems, and evaluated the cost and effectiveness of applying the techniques. The dissertation research is organized in three parts. First, I investigated current testing practices for component-based software systems to find the testing overlap and synergy we conjectured exists. Second, I designed and implemented infrastructure and related tools to facilitate communication and data sharing between testers. Third, I designed two testing processes to implement different collaborative testing algorithms and applied them to large actively developed software systems. This dissertation has shown the benefits of collaborative testing across component developers who share their components. With collaborative testing, researchers can design algorithms and tools to support collaboration processes, achieve better efficiency in testing configurations, and discover inter-component compatibility faults within a minimal time window after they are introduced.

This paper characterises refinement of state-based software components modelled as pointed coalgebras for some Set endofunctors. The proposed characterisation is parametric on a specification of the underlying behaviour model introduced as a strong monad. This provides a basis to reason about (and transform) state-based software designs. In particular, it is shown how refinement can be applied to the development of the inequational subset of a calculus of generic software components.

The consideration of non-functional properties in the component-oriented approach to software development is important for its success. The COMQUAD project defines a system architecture and a development methodology for component-based software with quantitative properties and adaptivity, thereby respecting non-functional properties from design to provision at runtime. Based on an elementary model of software components, we show how response time as an exemplary property is treated: Its relation to available resources is investigated and it is shown how resource requirements of the whole system can be derived from knowledge about the constituent components.

最近の情報通信技術を保健・医療・福祉に応用し、医療機関間の連携あるいは医療と保健・福祉の連携を支援する新しい医療情報システムの必要性が強く認識されてきている。これまでも、ビデオ会議システムや遠隔医療システムが開発され利用されてきているが、異なるメーカーのシステム間の互換性、既存のシステムやデータとの整合性、導入にかかる費用などに関して問題があった。本研究では、既存のシステムの問題点を解決するための一つのアプローチとして、特定のシステムに依存しない形で既存のソフトウェアやシステムに統合することを可能にする、（a）X線、CT、MRI、超音波診断装置などのモダリティから発生する医用画像や、患者のリハビリテーション時、介護認定調査時の様子を記録した画像を動画像/静止画像ファイルとして保存管理し、画像以外の保健・医療・福祉情報とともに共有化するためのマルチメディア・データベース・コンポーネント、（b）物理的に距離が離れている場合に動画像や静止画像を使った協調作業を支援するコラボレーションツール、の開発と試験を行った。Recent development in medical information and communication technologies （ICT）certainly facilitated rapid implementation of ICT in health care, public health and social service. It is essential for medical and social service sectors to seamlessly share the data, in particular in remote regions. ICT supported health care has an enormous capacity to enhance the delivery of medical service, sharing of knowledge, increased access and thereby improve the quality of care. A growing number of medical institutions and professionals have been using video-conferencing units and Telemedicine equipment to exchange data and knowledge. Although they have a range of applications, there are barriers associated with use of technology; inter-operability and interconnectivity based on product models, network platforms and proprietary software. Our approach was to develop new software components that can be integrated into any existing systems or software. Our software has the following characteristics: （a）multimedia database components to store medical images from modalities such as X-ray, CT, MRI and Ultrasound, and to store patients' data and images during rehabilitation and evaluation of patients' for Japanese long term care insurance for the purpose of health promotion, medical and social service. （b）a multimedia collaboration tool to share data and dynamic images regardless of distance between people.

International audience; The Fast Fourier Transform (FFT) is a widely-used building block for many high-performance scientific applications. Efficient computing of FFT is paramount for the performance of these applications. This has led to many efforts to implement machine and computation specific optimizations. However, no existing FFT library is capable of easily integrating and automating the selection of new and/or unique optimizations.To ease FFT specialization, this study evaluates the use of component-based software engineering, a programming paradigm which consists in building applications by assembling small software units. Component models are known to have many software engineering benefits but usually have insufficient performance for high-performance scientific applications.This talk uses the L²C model, a general purpose high-performance component model, and studies its performance and adaptation capabilities on 3D FFTs. Experiments show that L²C, and components in general, enables easy handling of 3D FFT specializations while obtaining performance comparable to that of well-known libraries.; La transformée de Fourier rapide (FFT) est un élément fondamentale fréquemment utilisé dans de nombreuses applications scientifiques de haute performance. Calculer efficacement des FFT est ainsi primordial pour la performance de ces applications. Cela a conduit à de nombreux efforts pour implémenter des optimisations spécifiques à un matériel ou à une classe d'algorithmes donnée. Cependant, aucune bibliothèque de FFT existante permet facilement d'intégrer et d'automatiser la sélection de nouvelles optimisations et / ou d'optimisations uniques.Cette étude vise à évaluer l'utilisation de techniques de génie logicielle à base de composants, un paradigme de programmation qui consiste à construire des applications en assemblant de petites briques logiciels. Les modèles de composants sont connus pour avoir de nombreux avantages de génie logiciel, mais ont généralement des performances insuffisantes pour les applications scientifiques de haute performance.Cette étude s'intéresse à l'utilisation du modèle L²C, un modèle de composants de haute performance, et étudie ses performances et sa capacités à pouvoir adapter les applications de FFT 3D. Les expériences montrent que L²C et les composants en général, permettent de manipuler facilement la structure des applications de FFT 3D via une spécialisations d'assemblage, tout en obtenant des performances comparables à celle des bibliothèques bien connues.

This article provides formal definitions characterizing well-formed composition of components in order to guarantee their safe deployment and execution. Our work focuses on the structural aspects of component composition; it puts together most of the concepts common to many component models, but never formalized as a whole. Our formalization characterizes correct component architectures made of functional and non-functional aspects, both structured as component assemblies. Interceptor chains can be used for a safe and controlled interaction between the two aspects. Our well-formed components guarantee a set of properties ensuring that the deployed component system has a correct architecture and can run safely. Finally, those definitions constitute the formal basis for our Eclipse-based environment for the development and specification of component-based applications., Comment: In Proceedings FOCLASA 2014, arXiv:1502.03157

Sistemas distribuídos têm se mostrado altamente heterogêneos e dinâmicos, mudanças acontecem constantemente e rapidamente. Uma abordagem largamente adotada no desenvolvimentode sistemas distribuídos é a do desenvolvimento baseado em componentes, que permite desenvolver softwares flexíveis através da composição de componentes individuais.Mas, com a grande diversidade de modelos de componentes, cada modelo possui sua especificidade de desenvolvimento e nativamente estes não possuem interoperabilidade. O desenvolvimento de métodos de comunicação remota e o deployment distribuído são tarefas difíceis que contribuem no aumento da complexidade. Considerando toda essa complexidade, os esforços destinados ao desenvolvimento de código técnico para sistemas distribuídos são obstáculos que desencorajam desenvolvedores. Neste cenário apresentamos o HighFrame - uma solução integrada para desenvolvimento em alto nível e deployment automático que tem como propósito reduzir a complexidade do desenvolvimento de sistemas distribuídos baseados em componentes heterogêneos. Com esta solução o desenvolvedor mantém o foco de desenvolvimento no negócio da aplicação. Ele utiliza anotações e um planejador gráfico para definir componentes e a arquitetura do sistema distribuído. O HighFrame desempenha o processo de deployment automaticamente e abstrai do desenvolvedor a complexidade de modelos de componentes, métodos de comunicação remota e interoperabilidade entre componentes heterogêneos.

Developing software to undertake complex, compute-intensive scientific processes requires a challenging combination of both specialist domain knowledge and software development skills to convert this knowledge into efficient code. As computational platforms become increasingly heterogeneous and newer types of platform such as Infrastructure-as-a-Service (IaaS) cloud computing become more widely accepted for HPC computations, scientists require more support from computer scientists and resource providers to develop efficient code and make optimal use of the resources available to them. As part of the libhpc stage 1 and 2 projects we are developing a framework to provide a richer means of job specification and efficient execution of complex scientific software on heterogeneous infrastructure. The use of such frameworks has implications for the sustainability of scientific software. In this paper we set out our developing understanding of these challenges based on work carried out in the libhpc project., Comment: 4 page position paper, submission to WSSSPE13 workshop

This paper presents a novel approach for future robotic spacecraft by utilizing a modular and robust software architecture based on the time and space partitioning (TSP) concept. Classic satellites are characterized by a strict separation between platform and payload subsystems, both in hardware resources as well as in control software. Novel space-robotic applications such as on-orbit servicing (OOS) feature dexterous robotic devices attached onto the satellite that impose a direct physical feedback on their floating base. Through the high degree of interdependencies, the whole satellite turns into a space robot. Hence, the robot becomes an integral part of the spacecraft itself and needs to be integrated into the existing control and operations approach. The developed embedded on-board framework represents a modular and robust control and communication environment that allows both classic satellite as well as real-time and autonomous robotic operations. The framework features an integral fault detection, isolation and recovery (FDIR) concept in order to prevent overall system shutdown upon single-point failure. Single software components reside in separate logical modules, i.e. partitions, in order to avoid resource violations. Upon critical failure, partitions can be restarted without detracting the rest of the system. By applying explicit time scheduling of partitions, system resources can be optimally distributed and deterministic behavior be achieved. Core system functionality has been implemented by ECSS-tested components that are configurable and thus re-usable over multiple missions. As demonstrator, a realistic on-orbit servicing simulation was set up that comprises autonomous target satellite capture and fault management. The presented architecture follows an integrated approach that is required for safely operating future robotic spacecraft. Through re-usability of software components, fewer resources for the implementation and verification process are required as only additional, mission-specific components need to be taken care of. Application developers can use the core functionality and communication API and concentrate on their own task at hand.