Interface Contracts Research Articles

Verifying contracts among software components: An ontology-based approach

The goal of Component-Based Software Engineering (CBSE) is the development of software systems in terms of an assembly of pre-fabricated software components. One of the main aims of CBSE is to increase software reuse whereby a software component becomes part of different software systems. Verification is an important task that ensures contract conformance among components. However, current techniques for verification of component matching are poorly used in industry due to the fact that the use of these techniques is complex since they require specialized expertise. Also, the use of such techniques can be time-consuming. In this paper, we present Moctezuma, a framework for verifying the matching of software components that does not require the user possessing highly specialized skills and is able to check contract conformance of functional semantics aspects. Our approach relies on a core ontology of software components, which captures the concepts, properties, relationships, requirements, and software component functionality. We make use of architecture description languages (ADLs) to specify configurations of component interconnections. Interface contracts are specified with a customized version of CORBA-IDL. We employ ontology reasoning engines to check conformance among interface contracts. The accuracy evaluation results have shown that our verifier has a high accuracy for detecting semantics errors. The scalability evaluation shows that our framework exhibits almost a linear behavior. It is concluded that our framework is suitable for verifying the conformance of interface contracts, involving semantics aspects, along a configuration of component interconnections.

Role of interfacial rheology on fingering instabilities in lifting Hele-Shaw flows.

The lifting Hele-Shaw cell setup is a popular modification of the classic, fixed-gap, radial viscous fingering problem. In the lifting cell configuration, the upper cell plate is lifted such that a more viscous inner fluid is invaded by an inward-moving outer fluid. As the fluid-fluid interface contracts, one observes the rising of distinctive patterns in which penetrating fingers having rounded tips compete among themselves, reaching different lengths. Despite the scholarly and practical relevance of this confined lifting flow problem, the impact of interfacial rheology effects on its pattern-forming dynamics has been overlooked. Authors of recent studies on the traditional injection-induced radial Hele-Shaw flow and its centrifugally driven variant have shown that, if the fluid-fluid interface is structured (i.e., laden with surfactants, particles, proteins, or other surface-active entities), surface rheological stresses start to act, influencing the development of the viscous fingering patterns. In this paper, we investigate how interfacial rheology affects the stability as well as the shape of the emerging fingered structures in lifting Hele-Shaw flows, at linear and early nonlinear dynamic stages. We tackle the problem by utilizing the Boussinesq-Scriven model to describe the interface and by employing a perturbative mode-coupling scheme. Our linear stability results show that interfacial rheology effects destabilize the interface. Furthermore, our second-order findings indicate that interfacial rheology significantly alters intrinsically nonlinear morphological features of the shrinking interface, inducing the formation of narrow sharp-tip penetrating fingers and favoring enhanced competition among them.

Interface Contracts for Workflow+ Models: an Analysis of Uncertainty across Models.

Interface Contracts for Workflow+ Models: an Analysis of Uncertainty across Models.

Mesoporous NiO nanosheet network as efficient hole transporting layer for stable inverted perovskite solar cells

Hole transporting layer (HTL) plays an important role in device stability and charge transport for inverted perovskite solar cells (PSCs). Here, a novel HTL consisted of mesoporous NiO nanosheet (NS) was fabricated via simple hydrothermal method. The contract region of HTL/perovskite was increased by using the mesoporous NiO NS network structure, resulting in the good interface contract and rapid charge transfer. Therefore, the corresponding devices exhibit an optimal power conversion efficiency of >12%, with hysteresis-less. Besides, the developed PSCs still maintain 75% efficiency after 500 h, implying its good stability. In a word, this mesoporous NiO NS structure can be a promising candidate for HTL of inverted PSCs.

OS Support for Adaptive Components in Self-aware Systems

The current pace of innovation in computing makes it difficult to assume a fixed set of requirements for the whole life span of a system. Aggressive technology scaling also imposes additional constraints to modern hardware platforms. An answer to this question are self-aware systems, which are capable of autonomously sensing and actuating upon themselves to cope with varying requirements. In this paper, we discuss the design and implementation of adaptive components in this scenario from the perspective of the OS. Components can exist in multiple avors that can by dynamically chosen according to current demands. The proposed framework supports this variability for components while preserving their interface contracts, even if avors exist in different domains (software, hardware, remote). The synthesis process delivers tailored wrapper for components according to their avors. Besides reconfiguration, we also support adaptations through dynamic power management and task remapping. The framework also supports component designers in terms of sensing via an event-based mechanism. The framework is validated through a case with three adaptive components in a telecommunication switch (AES, ADPCM, and DTMF) with little overhead both in terms of execution time and memory/silicon consumption.

Integration for Heterogeneous Manufacturing Information Systems Based on Semantic Entity

To support semantic integration for heterogeneous information systems in manufacturing enterprises, based on semantic gateway, the concept of semantic entity is defined, and the semantic entity-based integration method is studied. Semantic entity sets up conceptual structure by aggregating semantic concept from semantic gateway, and builds dynamic conceptual structure through adding or removing its general concept. By means of key business data, semantic entity identifies business object and obtains business data from its application system, and then instantiates concept structure. Based on instantiation, semantic service can obtain parameters data from business object instant, and satisfies the interface contract. Semantic entity captures data changes of business object, and then establishes status-based integration rules, defines algorithm logic of rules. By instantiating concept structure aimed to specific application system and invoking semantic service, the integration activities among information systems come true. This work has been verified by prototype system, and attained expected integration effect.

Fifteen Years of Service-Oriented Architecture at Credit Suisse

Credit Suisse has been an adopter of service oriented architecture (SOA) principles and patterns since the beginnings of this architectural style, even before the term appeared. The authors reflect on the financial institution's journey from using tightly integrated mainframe programs to open SOA services, emphasizing the importance of interface contracts and service governance in corporate IT.

A Catalog of Bad Smells in Design-by-Contract Methodologies with Java Modeling Language

Bad smells are usually related to program source code, arising from bad design and programming practices. Refactoring activities are often motivated by the detection of bad smells. With the increasing adoption of Design-by-Contract (DBC) methodologies in formal software development, evidence of bad design practices can similarly be found in programs that combine actual production code with interface contracts. These contracts can be written in languages, such as the Java Modeling Language (JML), an extension to the Java syntax. This paper presents a catalog of bad smells that appear during DBC practice, considering JML as the language for specifying contracts. These smells are described over JML constructs, although several can appear in other DBC languages. The catalog contains 6 DBC smells. We evaluate the recurrence of DBC smells in two ways: first by describing a small study with graduate student projects, and second by counting occurrences of smells in contracts from the JML models application programming interface (API). This API contains classes with more than 1,600 lines in contracts. Along with the documented smells, suggestions are provided for minimizing the impact or even removing a bad smell. It is believed that initiatives towards the cataloging of bad smells are useful for establishing good design practices in DBC.

Cooperative runtime monitoring

Requirements on message-based interactions can be formalised as an interface contract that specifies constraints on the sequence of possible messages that can be exchanged by multiple parties. At runtime, each peer can monitor incoming messages and check that the contract is correctly being followed by their respective senders. We introduce cooperative runtime monitoring, where a recipient ‘delegates’ its monitoring task to the sender, which is required to provide evidence that the message it sends complies with the contract. In turn, this evidence can be quickly checked by the recipient, which is then guaranteed of the sender's compliance to the contract without doing the monitoring computation by itself. A particular application of this concept is shown on web services, where service providers can monitor and enforce contract compliance of third-party clients at a small cost on the server side, while avoiding to certify or digitally sign them.

Automatic generation of hardware/software interfaces

Enabling new applications for mobile devices often requires the use of specialized hardware to reduce power consumption. Because of time-to-market pressure, current design methodologies for embedded applications require an early partitioning of the design, allowing the hardware and software to be developed simultaneously, each adhering to a rigid interface contract. This approach is problematic for two reasons: (1) a detailed hardware-software interface is difficult to specify until one is deep into the design process, and (2) it prevents the later migration of functionality across the interface motivated by efficiency concerns or the addition of features. We address this problem using the Bluespec Codesign Language~(BCL) which permits the designer to specify the hardware-software partition in the source code, allowing the compiler to synthesize efficient software and hardware along with transactors for communication between the partitions. The movement of functionality across the hardware-software boundary is accomplished by simply specifying a new partitioning, and since the compiler automatically generates the desired interface specifications, it eliminates yet another error-prone design task. In this paper we present BCL, an extension of a commercially available hardware design language (Bluespec SystemVerilog), a new software compiling scheme, and preliminary results generated using our compiler for various hardware-software decompositions of an Ogg Vorbis audio decoder, and a ray-tracing application.

Automatic generation of hardware/software interfaces

Enabling new applications for mobile devices often requires the use of specialized hardware to reduce power consumption. Because of time-to-market pressure, current design methodologies for embedded applications require an early partitioning of the design, allowing the hardware and software to be developed simultaneously, each adhering to a rigid interface contract. This approach is problematic for two reasons: (1) a detailed hardware-software interface is difficult to specify until one is deep into the design process, and (2) it prevents the later migration of functionality across the interface motivated by efficiency concerns or the addition of features. We address this problem using the Bluespec Codesign Language~(BCL) which permits the designer to specify the hardware-software partition in the source code, allowing the compiler to synthesize efficient software and hardware along with transactors for communication between the partitions. The movement of functionality across the hardware-software boundary is accomplished by simply specifying a new partitioning, and since the compiler automatically generates the desired interface specifications, it eliminates yet another error-prone design task. In this paper we present BCL, an extension of a commercially available hardware design language (Bluespec SystemVerilog), a new software compiling scheme, and preliminary results generated using our compiler for various hardware-software decompositions of an Ogg Vorbis audio decoder, and a ray-tracing application.

Towards automatic generation of formal specifications to validate and verify reliable distributed systems

The validation and verification of reliable systems is a difficult and complex task, mainly for two reasons: First, it is difficult to precisely state which formal properties a system needs to fulfil to be of high quality. Second, it is complex to automatically verify such properties, due to the size of the analysis state space which grows exponentially with the number of components. We tackle these problems by a tool-supported method which embeds application functionality in building blocks that use UML activities to describe their internal behaviour. To describe their externally visible behaviour, we use a combination of complementary interface contracts, so-called ESMs and EESMs. In this paper, we present an extension of the interface contracts, External Reliability Contracts (ERCs), that capture failure behaviour. This separation of different behavioural aspects in separate descriptions facilitates a two-step analysis, in which the first step is completely automated and the second step is facilitated by an automatic translation of the models to the input syntax of the model checker TLC. Further, the cascade of contracts is used to separate the work of domain and reliability experts. The concepts are proposed with the background of a real industry case, and we demonstrate how the use of interface contracts leads to significantly smaller state spaces in the analysis.

Symbolic modular deadlock analysis

Methods in object-oriented concurrent libraries often encapsulate internal synchronization details. As a result of information hiding, clients calling the library methods may cause thread safety violations by invoking methods in an unsafe manner. This is frequently a cause of deadlocks. Given a concurrent library, we present a technique for inferring interface contracts that specify permissible concurrent method calls and patterns of aliasing among method arguments. In this work, we focus on deriving contracts that guarantee deadlock-free execution for the methods in the library. The contracts also help client developers by documenting required assumptions about the library methods. Alternatively, the contracts can be statically enforced in the client code to detect potential deadlocks in the client. Our technique combines static analysis with a symbolic encoding scheme for tracking lock dependencies, allowing us to synthesize contracts using a SMT solver. Additionally, we investigate extensions of our technique to reason about deadlocks in libraries that employ signaling primitives such as wait-notify for cooperative synchronization. Our prototype tool analyzes over a million lines of code for some widely-used Java libraries within an hour, thus demonstrating its scalability and efficiency. Furthermore, the contracts inferred by our approach have been able to pinpoint real deadlocks in clients, i.e. deadlocks that have been a part of bug-reports filed by users and developers of client code.

Runtime Verification of Web Service Interface Contracts

Asynchronous JavaScript and XML (Ajax) is a collection of technologies used to develop rich and interactive Web applications. A typical Ajax client runs locally in the user's Web browser and refreshes its interface on the fly in response to user input. Using this method with the AWS-ECS let us automatically generate test sequences and detect two deviations of their service implementation with respect to the online documentation provided, in less than three minutes of testing. We also provided a framework that allows the runtime monitoring of both client and server contract constraints with minimal modification to an existing Ajax application code. Experiments with the Amazon E-Commerce Service demonstrate the advantages of using a model-based approach for the runtime testing and monitoring of Web applications.

Scientific component framework for W7-X using service oriented GRID middleware

Future fusion experiments, aiming to demonstrate steady state reactor operation, require physics driven plasma control based on increasingly complex plasma models. A precondition for establishing such control systems is widely automated data analysis, which can provide integration of multiple diagnostic on a large scale. Even high quality online data evaluation, which is essential for the scientific documentation of the experiment, has to be performed automatically due to the huge data sets being recorded in long discharge runs. An automated system that can handle these requirements will have to be built on reusable software components that can be maintained by the domain experts: diagnosticians, theorists, engineers and others. For Wendelstein 7-X a service oriented architecture seems to be appropriate, in which software components can be exposed as services with well defined interface contracts. Although grid computing has up to now been mainly used for remote job execution, a more promising service oriented middleware has emerged from the recent grid specification, the open grid service architecture (OGSA). It is based on stateful web services defined by the web service resource framework (WSRF) standard. In particular, the statefulness of services allows to setup complex models without unnecessary performance losses by frequent transmission of large and complex data sets. At present, the usability of this technology in the W7-X CoDaC context is under evaluation by first service implementations.

Hysteresis during contact angles measurement

A theory, based on the presence of an adsorbed film in the vicinity of the triple contact line, provides a molecular interpretation of intrinsic hysteresis during the measurement of static contact angles. Static contact angles are measured by placing a sessile drop on top of a flat solid surface. If the solid surface has not been previously in contact with a vapor phase saturated with the molecules of the liquid phase, the solid surface is free of adsorbed liquid molecules. In the absence of an adsorbed film, molecular forces configure an advancing contact angle larger than the static contact angle. After some time, due to an evaporation/adsorption process, the interface of the drop coexists with an adsorbed film of liquid molecules as part of the equilibrium configuration, denoted as the static contact angle. This equilibrium configuration is metastable because the droplet has a larger vapor pressure than the surrounding flat film. As the drop evaporates, the vapor/liquid interface contracts and the apparent contact line moves towards the center of the drop. During this process, the film left behind is thicker than the adsorbed film and molecular attraction results in a receding contact angle, smaller than the equilibrium contact angle.

Gaining confidence in scientific applications through executable interface contracts

Interface contract enforcement is intended to help scientists gain confidence in software built from third-party components. Unfamiliar components present increased risk of incorrect or unanticipated usage patterns and unexpected component behavior. Executable interface contracts can address these issues but may incur unacceptable overhead. Research into techniques for performance-driven contract enforcement pursues practical solutions to adapting the level of contract enforcement to performance constraints.

Resettable vector clocks

Vector clocks (VC) are an inherent component of a rich class of distributed applications. In this paper, we first consider the problem of realistic implementation—more specifically, bounded-space and fault-tolerant—of applications that use vector clocks (VC). To this end, we generalize the notion of VC to resettable vector clocks (RVC), and provide a realistic implementation of RVC. Further, we identify an interface contract under which our RVC implementation can be substituted for VC in client applications, without affecting the client's correctness. This interface contract is designed for phase-based applications that provide certain communication guarantees. Based on such substitution and the use of the interface contract, we show how to transform the client so that it is itself realistically implemented. We illustrate our method in the context of Ricart–Agrawala's mutual exclusion program and Garg–Chase's predicate detection program.

Contract-checking wrappers for C++ classes

Two kinds of interface contract violations can occur in component-based software: A client component can fail to satisfy a requirement of a component it is using, or a component implementation can fail to fulfill its obligations to the client. The traditional approach to detecting and reporting such violations is to embed assertion checks into component source code, with compile-time control over whether they are enabled. This works well for the original component developers, but it fails to meet the needs of component clients who do not have access to source code for such components. A wrapper-based approach, in which contract checking is not hard-coded into the underlying component but is "layered" on top of it, offers several relative advantages. It is practical and effective for C++ classes. Checking code can be distributed in binary form along with the underlying component, it can be installed or removed without requiring recompilation of either the underlying component or the client code, it can be selectively enabled or disabled by the component client on a per-component basis, and it does not require the client to have access to any special tools (which might have been used by the component developer) to support wrapper installation and control. Experimental evidence indicates that wrappers in C++ impose-modest additional overhead compared to inlining assertion checks.

Rye House combined-cycle gas-turbine power-station project

The 700 MW Rye House combined-cycle gas-turbine power-station project, owned by the UK electricity-generating company PowerGen, was constructed using a turnkey-contract strategy on the site of the old Rye House power station. The main turnkey contract was placed with Siemens, while PowerGen retained the role of informed client, and took responsibility for delivering the key interface contracts for fuel supply and grid connection. The project was completed almost three months ahead of schedule, only 30 months after the turnkey contract was placed at the end of April 1991. It was completed at below the sanctioned cost, and to the satisfaction of the final client, which was PowerGen's UK Electricity Division. Almost 2M man hours of effort were expended in the construction of the station, and the project's success was achieved through close cooperation between the client and the contractor. The client was proactive in the overall coordination and control of the project.