A modular package manager architecture

ContextThe success of modern software distributions in the Free and Open Source world can be explained, among other factors, by the availability of a large collection of software packages and the possibility to easily install and remove those components using state-of-the-art package managers. However, package managers are often built using a monolithic architecture and hard-wired and ad-hoc dependency solvers implementing some customized heuristics.ObjectiveWe aim at laying the foundation for improving on existing package managers. Package managers should be complete, that is find a solution whenever there exists one, and allow the user to specify complex criteria that define how to pick the best solution according to the user’s preferences.MethodIn this paper we propose a modular architecture relying on precise interface formalisms that allows the system administrator to choose from a variety of dependency solvers and backends.ResultsWe have built a working prototype–called MPM–following the design advocated in this paper, and we show how it largely outperforms a variety of current package managers.ConclusionWe argue that a modular architecture, allowing for delegating the task of constraint solving to external solvers, is the path that leads to the next generation of package managers that will deliver better results, offer more expressive preference languages, and be easily adaptable to new platforms.     

Static vulnerability detection in Java service-oriented components

Extensible component-based platforms allow dynamic discovery, installation and execution of components. Such platforms are service-oriented, as components may directly interact with each other via the services they provide. Even robust languages such as Java were not designed to handle safe code interaction between trusted and untrusted parties. Dynamic installation of code provided by different third parties leads to several security issues. The different security layers adopted by Java or component-based platforms cannot fully address the problem of untrusted components trying to tamper with other components via legitimate interactions. A malicious component might even use vulnerable ones to compromise the whole component-based platform. Our approach identifies vulnerable components in order to prevent them from threatening services security. We use static analysis to remain as exhaustive as possible and to avoid the need for non-standard or intrusive environments. We show that a static analysis through tainted object propagation is well suited to detect vulnerabilities in Java service-oriented components. We present STOP, a Service-oriented Tainted Object Propagation tool, which applies this technique to statically detect those security flaws. Finally, the audit of several trusted Apache Felix bundles shows that nowadays component-based platforms are not prepared for malicious Java interactions.     

支持构件演化的软件配置管理研究

基于构件的软件开发作为一种全新的软件开发方法,与传统的软件开发方式不同,配置管理的需求与传统的配置管理方法也有了很大的不同.在基于构件软件开发的过程中,如何以一种良好的风格和技术来对构件变化进行控制,保持构件系统的一致性、稳定性是软件开发者历来追求的目标.分析了基于构件软件开发过程中构件演化对配置管理技术的新需求,探讨了配置管理的几个关键技术,并提出了一种度量构件演化过程的方法,从而把构件的整个演化过程置于配置管理的支持之下.     

Enforceable component-based realtime contracts

We present enforceable component-based realtime contracts, the first extension of component-based software engineering technology that comprehensively supports adaptive realtime systems from specification all the way to the running system.To provide this support, we have extended component-based interface definition languages (IDLs) and component representations in repositories to express realtime requirements for components. The final software, which is assembled from the components, is then executed on a realtime operating system (RTOS) with the help of a component runtime system. RTOS resource managers and the IDL-extensions are based on the same mathematical foundation. Thus, the component runtime system can use information expressed in a component-oriented manner in the extended IDL to derive parameters for the task-based admission and scheduling in the RTOS. Once basic realtime properties can thus be guaranteed, runtime support can be extended to more elaborate schemes that also support adaptive applications (container-managed quality assurance).We claim that this study convincingly demonstrates how component-based software engineering can be extended to build systems with non-functional requirements.     

Design verification in model-based?��-controller development using an abstract component

Component-based software development is a promising approach for controlling the complexity and quality of software systems. Nevertheless, recent advances in quality control techniques do not seem to keep up with the growing complexity of embedded software; embedded systems often consist of dozens to hundreds of software/hardware components that exhibit complex interaction behavior. Unanticipated quality defects in a component can be a major source of system failure. To address this issue, this paper suggests a design verification approach integrated into the model-driven, component-based development methodology Marmot. The notion of abstract components—the basic building blocks of Marmot—helps to lift the level of abstraction, facilitates high-level reuse, and reduces verification complexity by localizing verification problems between abstract components before refinement and after refinement. This enables the identification of unanticipated design errors in the early stages of development. This work introduces the Marmot methodology, presents a design verification approach in Marmot, and demonstrates its application on the development of a μ-controller-based abstraction of a car mirror control system. An application on TinyOS shows that the approach helps to reuse models as well as their verification results in the development process.     

构件软件变更风险分析技术

构件软件相较于传统软件系统有更快的演化速度,对其变更进行有效的度量将有利于后期的维护活动.本文分别针对代码可见及不可见两种类型的构件,运用改进的构件依赖图建模,表示构件软件系统.分两步分析构件变更所带来的风险:首先在计算变更比例的基础上度量单个构件的变更风险,再通过将构件依赖图转化成构件依赖树来计算变更的构件集给系统所带来的风险.此外,结合实例系统的分析给出了所提出的变更风险度量的若干性质.     

Component-based software version management based on a Component-Interface Dependency Matrix

As much component-based software is developed, a software configuration management (SCM) tool for component-based software is necessary. In this paper, we propose a version management mechanism for impact analysis while components are upgraded. We separately version the components and interfaces based on a Component-Interface Dependency Matrix (CIDM), and analyze impacts according to their dependency relationship. The result of our simulation shows that CIDM is capable of managing large numbers of components without impedance mismatch. In addition, in a well-designed software system, using CIDM to analyze impacts can save resources in the software development phase.     

Testing component compatibility in evolving configurations

Software components are increasingly assembled from other components. Each component may further depend on others, and each may have multiple active versions. The total number of configurations—combinations of components and their versions—in use can be very large. Moreover, components are constantly being enhanced and new versions are being released. Component developers, therefore, spend considerable time and effort doing compatibility testing—determining whether their components can be built correctly for all deployed configurations–both for existing active component versions and new releases. In previous work we developed Rachet, a distributed, cache-aware mechanism to support large-scale compatibility testing of component-based software with a fixed set of component versions.In this paper, we observe that it is too expensive to perform compatibility testing from scratch each time a new version of a component is released. We thus add a new dimension to Rachet: to perform incremental and prioritized compatibility testing. We describe algorithms to compute differences in component compatibilities between current and previous component builds, a formal test adequacy criterion based on covering the differences, and cache-aware configuration sampling and testing methods that attempt to reuse effort from previous testing sessions. Because testers are often interested in focusing test effort on newly released and modified components and their versions, we have developed a prioritization mechanism that enhances compatibility testing by examining the configurations that test new or modified component versions first, while also distributing the work over a cluster of machines. We evaluate our approach using the 5-year evolution history of a scientific middleware component. Our results show that our methods can increase performance significantly over Rachet’s previous retest-all approach and also tests important component compatibilities early in the overall testing process, making the process of compatibility testing practical for evolving components.     

Multiple-parameter coupling metrics for layered component-based software

Coupling represents the degree of interdependence between two software components. Understanding software dependency is directly related to improving software understandability, maintainability, and reusability. In this paper, we analyze the difference between component coupling and component dependency, introduce a two-parameter component coupling metric and a three-parameter component dependency metric. An important parameter in both these metrics is coupling distance, which represents the relevance of two coupled components. These metrics are applicable to layered component-based software. These metrics can be used to represent the dependencies induced by all types of software coupling. We show how to determine coupling and dependency of all scales of software components using these metrics. These metrics are then applied to Apache HTTP, an open-source web server. The study shows that coupling distance is related to the number of modifications of a component, which is an important indicator of component fault rate, stability and subsequently, component complexity.

Superimposition: a component adaptation technique

Several authors have identified that the only feasible way to increase productivity in software construction is to reuse existing software. To achieve this, component-based software development is one of the more promising approaches. However, traditional research in component-oriented programming often assumes that components are reused “as-is”. Practitioners have found that “as-is” reuse seldom occurs and that reusable components generally need to be adapted to match the system requirements. Existing component object models provide only limited support for component adaptation, i.e. white-box techniques such as copy–paste and inheritance, and black-box approaches such as aggregation and wrapping. These techniques suffer from problems related to reusability, efficiency, implementation overhead or the self problem. To address these problems, this article proposes superimposition, a novel black-box adaptation technique that allows one to impose predefined, but configurable types of functionality on a reusable component. Three categories of typical adaptation types are discussed, related to the component interface, component composition and component monitoring. Superimposition and the types of component adaptation are exemplified by several examples.     

Analyzing and visualizing information flow in heterogeneous component-based software systems

Context: Component-based software engineering is aimed at managing the complexity of large-scale software development by composing systems from reusable parts. To understand or validate the behavior of such a system, one needs to understand the components involved in combination with understanding how they are configured and composed. This becomes increasingly difficult when components are implemented in various programming languages, and composition is specified in external artifacts. Moreover, tooling that supports in-depth system-wide analysis of such heterogeneous systems is lacking.Objective: This paper contributes a method to analyze and visualize information flow in a component-based system at various levels of abstraction. These visualizations are designed to support the comprehension needs of both safety domain experts and software developers for, respectively, certification and evolution of safety-critical cyber-physical systems.Method: We build system-wide dependence graphs and use static program slicing to determine all possible end-to-end information flows through and across a system’s components. We define a hierarchy of five abstractions over these information flows that reduce visual distraction and cognitive overload, while satisfying the users’ information needs. We improve on our earlier work to provide interconnected views that support both systematic, as well as opportunistic navigation scenarios.Results: We discuss the design and implementation of our approach and the resulting views in a prototype tool called FlowTracker. We summarize the results of a qualitative evaluation study, carried out via two rounds of interview, on the effectiveness and usability of these views. We discuss a number of improvements, such as more selective information presentations, that resulted from the evaluation.Conclusion: The evaluation shows that the proposed approach and views are useful for understanding and validating heterogeneous component-based systems, and address information needs that could earlier only be met by manual inspection of the source code. We discuss lessons learned and directions for future work.     

Generating CAM aspect-oriented architectures using Model-Driven Development

Aspect-Oriented Software Development promotes the separation of those concerns that cut across several components and/or are tangled with the base functionality of a component, through all phases of the software lifecycle. The benefit of identifying these crosscutting concerns (aspects) at the architectural level in particular is to improve the architecture design and its subsequent evolution, before moving onto detailed design and implementation. However, software architects are not usually experts on using specific AO architecture notations. Therefore, the aim of this paper is to provide support to define and specify aspect-oriented (AO) architectures using non-AO ones as the source. We will use the Model-Driven Development approach to transform a component-based architecture model into an AO architecture model. The CAM (component and aspect model) model and the DAOP–ADL language are the proposals used for modelling and specifying AO architectures. We will show how we automated part of the process and the tool support.     

Models and temporal logical specifications for timed component connectors

Component-based software engineering advocates construction of software systems through composition of coordinated autonomous components. Significant benefits of this approach include software reuse, simpler and faster construction, enhanced reliability, and dramatic reductions in the complexity of construction of provably correct critical systems, many of which involve real-time concerns. Effective, flexible component composition by itself still poses a challenge today and yet the special nature of real-time constraints makes component-based construction of real-time systems even more demanding. The coordination language Reo supports compositional system construction through connectors that exogenously coordinate the interactions among the constituent components which unawarely comprise a complex system, into a coherent collaboration. The simple, yet surprisingly rich, calculus of channel composition that underlies Reo offers a flexible framework for compositional construction of coordinating component connectors with real-time properties. In this paper, we present an operational semantics for the channel-based component connectors of Reo in terms of Timed Constraint Automata and introduce a temporal-logic for specification and verification of their real-time properties.      

构件动态演化内部一致性保证方法

基于构件的软件开发已成为软件开发的主流方法,针对构件式软件动态演化后的一致性保持问题,目前大多数学者主要是从构件式软件的外部一致性角度进行分析和研究。为此,从构件内部的角度出发,提出一种保证构件式软件动态演化构件内部一致性的方法。首先,对构件及其相关模型进行建模,并给出了构件内部类有向图的同态映射关系的判定算法;其次,给出构件式构件动态演化内部一致性的标准,基于进程代数的强模拟理论和图论中的同态映射关系,分别从全局和局部的角度定义了构件式软件动态演化前后构件内部一致性标准的充分条件和必要条件,并对其进行了证明;然后,基于上述工作,给出了构件动态演化内部一致性保证方法的流程;最后,通过案例研究表明该方法的可行性和有效性。     

A design flow for supporting component-based software development in multiprocessor real-time systems

Component-based software development established as an effective technique to cope with the increasing complexity of modern computing systems. In the context of real-time systems, the M-BROE framework has been recently proposed to efficiently support component-based development of real-time applications on multiprocessor platforms in the presence of shared resources. The framework relies on a two-stage approach where software components are first partitioned upon a virtual multiprocessor platform and are later integrated upon the physical platform by means of component interfaces that abstract from the internal details of the applications. This work presents a complete design flow for the M-BROE framework. Starting from a model of software components, a first method is proposed to partition applications to virtual processors and perform a synthesis of multiple component interfaces. Then, a second method is proposed to support the integration of the components by allocating virtual processors to physical processors. Both methods take resource sharing into account. Experimental results are also presented to evaluate the proposed methodology.     

Distributed and Collaborative Software Evolution Analysis with Churrasco

Analyzing the evolution of large and long-lived software systems is a complex problem that requires extensive tool support due to the amount and complexity of the data that needs to be processed. In this paper, we present Churrasco, a tool to support collaborative software evolution analysis through a web interface. After describing the tool and its architecture, we provide a usage scenario of Churrasco on a large open source software system, and we present two collaboration experiments performed with, respectively, 8 and 4 participants.     

Design of a Software Component Bank for Distribution

Recently, component-based software development technology is recognized as a new methodology that can overcome the problems of the traditional methodology at developing the software. It removes the problems by supporting fast development, easy maintenance, good quality, easy creation/upgrade of application, low cost, etc. It also creates new software business area such as business component developer, sales and distribution vendors. Many research institutes report that the market related with software component industry will grow with high rate. For the highly growing component market, a component distribution model is necessary to activate developing components, to promote the utilization, and to support distribution of them. In this paper, we propose a component distribution model through the requirement analysis. We also propose the UML model based on the requirement analysis, developed a prototype. We presented the developed system using several graphic user interfaces.     

Partial model checking via abstract interpretation

Nowadays the emphasis in software engineering research is on the evolution of pre-existing sub-systems and component development. In this context, we tackle the following problem: given the formal specification of the system P, already built, how to characterize possible collaborators of P, through a given communication interface L, to the satisfaction of a given property φ. We propose an abstract interpretation framework to reason about this problem in a systematic way. Given P and L, the set of all transition systems that, composed with P and restricted by L, satisfy φ, is modeled as the abstract semantics of φ, parametric with respect to P and L. We show that the algorithm developed by Andersen (1995) [1] can be formulated in our framework.     

Trends in databases: reasoning and mining

We propose a temporal dependency, called trend dependency (TD), which captures a significant family of data evolution regularities. An example of such regularity is “Salaries of employees generally do not decrease.” TDs compare attributes over time using operators of {<,=,>,⩽,⩾,≠}. We define a satisfiability problem that is the dual of the logical implication problem for TDs and we investigate the computational complexity of both problems. As TDs allow expressing meaningful trends, “mining” them from existing databases is interesting. For the purpose of TD mining, TD satisfaction is characterized by support and confidence measures. We study the problem TDMINE: given a temporal database, mine the TDs that conform to a given template and whose support and confidence exceed certain threshold values. The complexity of TDMINE is studied, as well as algorithms to solve the problem     

Mapping Filtering Streaming Applications

In this paper, we explore the complexity of mapping filtering streaming applications on large-scale homogeneous and heterogeneous platforms, with a particular emphasis on communication models and their impact. Filtering applications are streaming applications where each node also has a selectivity which either increases or decreases the size of its input data set. This selectivity makes the problem of scheduling these applications more challenging than the more studied problem of scheduling “non-filtering” streaming workflows. We address the complexity of the following two problems:

Evaluation: Given a mapping of nodes to processors, how can one compute the period and latency?

Optimization: Given a filtering workflow, how can one compute the mapping and schedule that minimize the period or latency? A?solution to this problem requires generating both the mapping and the associated operation list—the order in which each processor executes its assigned tasks.

We address this general problem in two steps. First, we address the simplified model without communication cost. In this case, the evaluation problems are easy, and the optimization problems have polynomial complexity on homogeneous platforms. However, we show that the optimization problems become NP-hard on heterogeneous platforms. Second, we consider platforms with communication costs. Clearly, due to the previous results, the optimization problems on heterogeneous platforms are still NP-hard. Therefore we come back to homogeneous platforms and extend the framework with three significant realistic communication models. Now even evaluation problems become difficult, because the mapping must now be enriched with an operation list that provides the time-steps at which each computation and each communication occurs in the system: determining the best operation list has a combinatorial nature. Not too surprisingly, optimization problems are NP-hard too. Altogether, this paper provides a comprehensive overview of the additional difficulties induced by heterogeneity and communication costs.