Enterprise application integration (EAI) is cooperation of disparate systems and components to implement business rules in a distributed environment. "Systems and components" can be computer-aided design (CAD) or software engineering (CASE) tools, enterprise databases, COTS applications, or in-house software. Ad hoc software interfacing (AHSI) is a special kind of EAI. A tradeoff analysis classifies an EAI problem as an AHSI problem when middleware solutions are seen as heavy-handed, i.e., the planned EAI is not expected to become broad enough to justify the generality of a middleware solution or the client is unwilling to pay for a unified data model. AHSI seeks to "wire" extant software applications as components in new, larger software applications. We call applications-as-components "appliponents". AHSI seeks to minimize appliponent modification to the greatest extent possible. We demonstrate solutions to AHSI problems using XML toolkits, domain-specific language toolkits, and Microsoft BizTalk Server.

Siddhartha applies the domain-specific language (DSL) paradigm to solve difficult problems in specification-based testing (SBT). Domain-specific test case data specifications (TestSpecs) and difficult-to-test program design styles engender difficult SBT problems, which are the essential phenomena of interest to Siddhartha. Difficult-to-test program design styles are explicitly represented by domain-specific, unit test driver reference designs that accommodate the problematic program design styles. DSLs are developed to represent both TestSpecs and Driver reference designs. A DSL language processing tool (a translator) is developed that maps TestSpecs into Drivers. We developed a prototype implementation of Siddhartha via Reasoning SDK (formerly known as Software Refinery) and developed two domain-specific TestSpec/spl rarr/Driver translators. Each translator generated Drivers that revealed new failures in a real-world digital flight control application program.

Describes a system that improves testing quality by supporting automatic test data selection, execution and result verification. The system tests poorly-encapsulated Ada units against formal specifications. This task is difficult partly because the unit's interface is not explicit, but rather is buried in the body/implementation code. We attack this problem by making the unit's interface explicit and complete. This is accomplished via automatic and manual analysis of the body. The complete interface is represented using an extended algebraic signature notation. Once the signature has been discovered, it can be reformulated so that a collection of well-defined, static mappings are established between it and the signature of the unit's formal specification. These mappings guide the development of test artifact transformers and oracles, which support automatic test data selection, execution and result verification. This paper discusses problems that arise as a result of testing under low encapsulation, discusses our solution using an ongoing example, and compares our solution to earlier solutions.