Integrating the splitting rule into a saturation-based theorem prover may be highly beneficial for solving certain classes of fist-order problems. The use of splitting in the context of saturation-based theorem proving based on explicit case analysis (as implemented in SPASS) employs backtracking which is difficult to implement as it affects design of the whole system. Here we present a "cheap" and efficient technique for implementing splitting that does not use backtracking.

This report presents a new, automatic technique to assess whether replacing a component of a software system by a purportedly compatible component may change the behavior of the system. The technique operates before integrating the new component into the system or running system tests, permitting quicker and cheaper identification of problems. It takes into account the system’s use of the component, because a particular component upgrade may be desirable in one context but undesirable in another. No formal specifications are required, permitting detection of problems due either to errors in the component or to errors in the system. Both external and internal behaviors can be compared, enabling detection of problems that are not immediately reflected in the output. The technique generates an operational abstraction for the old component in the context of the system, and one for the new component in the context of its test suite. An operational abstraction is a set of program properties that generalizes over observed run-time behavior. Modeling a system as divided into modules, and taking into account the control and data flow between the modules, we formulate a logical condition to guarantee that the system’s behavior is preserved across a component replacement. If automated logical comparison indicates that the new component does not make all the guarantees that the old one did, then

We describe the ingredients of an intelligent agent (a broker) for configuration and execution of knowledge systems for customer requests. The knowledge systems are configured from reusable problemsolving methods that reside in digital libraries on the Internet. The approach followed amounts to solving two subproblems: (i) the configuration problem which implies that we have to reason about problem-solving components, and (ii) execution of heterogeneous components. We use CORBA as the communication infrastructure.

Transactions are contracts that guarantee a consistent, transparent, individual system state transition and their use is widespread in many different kinds of computing systems. Some well known standards (e.g. CORBA) include the specification of services that provide transactional properties. In this paper, we present a formal method for the systematic synthesis of transactional middleware based on the combination of the aforementioned services. The synthesis of transactional middleware is based on (i) the formal specification of transactional properties and (ii) stub code generation.

Abstract not found

. In this paper we present a mechanism for making specification-based component retrieval more efficient by limiting the amount of theorem proving required at query time. This is done by using a classification scheme to reduce the number of specification matching proofs that are required to process a query. Components are classified by assigning features that correspond to necessary conditions implied by the component specifications. We show how this method of feature assignment can be used to approximate reusability relationships between queries and library components. The set of possible classification features are formally defined, permitting automation of the classification process. The classification process itself is made efficient by using a specialized theorem proving tactic to prove feature implication. The retrieval mechanism was implemented and evaluated experimentally using a library of list manipulation components. The results indicate a better response time than existing ...

The World-Wide Web is changing the nature of software development to a distributive plug & play process. This requires a new way of managing software by so-called intelligent software brokers. The aim of the European IBROW3 project is to develop an intelligent brokering service that enables third party knowledge-component reuse through the World-Wide Web. Suppliers provide libraries of knowledge components adhering to some standard, and customers can consult these libraries -- through intelligent brokers -- to configure a knowledge system suited to their needs by selection and adaptation. IBROW3 integrates research on heterogeneous databases, interoperability and web technology with knowledge-system technology and ontologies. The aim is to develop a broker that can handle web requests for classes of knowledge system (e.g. diagnostic systems) by accessing libraries of reusable problem-solving methods on the Web, and selecting, adapting and configuring these methods in accor...

Software architectures have the potential to substantially improve the development and evolution of large, complex, multi-lingual, multi-platform, long-running systems. However, in order to achieve this potential, specific architecture-based modeling, analysis, and evolution techniques must be provided. This paper motivates and presents one such technique: a type theory for software architectures, which allows flexible, controlled evolution of software components in a manner that preserves the desired architectural relationships and properties. Critical to the type theory is a taxonomy that divides the space of subtyping relationships into a small set of well defined categories. The paper also investigates the effects of large-scale development and off-the-shelf reuse on establishing type conformance between interoperating components in an architecture. An existing architecture is used as an example to illustrate a number of different applications of the type theory to architectural modeling and evolution. 1 1.

Introduction Originally, the Web grew mainly around representing static information using the HTML language, which provided a standard for document layout and was interpreted by browsers in a canonical way to render documents. On the one hand, it was the simplicity of HTML that enabled the fast growth of the WWW. On the other hand, its simplicity seriously hampered more advanced Web application in many domains and for many tasks. The Semantic Web [Berners-Lee & Fischetti, 1999] will transform the current World-Wide Web into a network of resources structured with the annotations defining their meaning and relationships. In this context, computers not only provide more efficient access to Web resources, but are also able to perform intelligent tasks with those resources. The explicit representation of the semantics of data, accompanied with domain theories (i.e. ontologies), will enable a Web that provides a qualitatively new level of service. It

Abstract: The construction of dependable software systems is recognized as a complex task: the system developer has to address the usage of fault tolerance techniques in addition to the design of the functional aspects that are specific to the system. This paper proposes a framework aimed at easing the development of dependable systems by providing software designers with a repository of dependable software architectures. A dependable software architecture shows how to integrate a fault tolerance technique with a given system so as to make the system dependable. Furthermore, the dependability behaviors of architectures are formally specified, which allows to unambiguously interpreting the various fault tolerance techniques as well as to organize the repository of corresponding architectures into a refinement-based lattice structure. 1