Detecting fraudulent behavior across diverse domains presents a significant challenge due to the adaptive and elusive activities of fraud agents. Furthermore, imbalanced data distributions and limited labeled examples increase the difficulty of detecting fraud agents. To address these challenges, we propose Catch Me If You Can—a Multi-Agent Framework to generate synthetic datasets and simulate various types of fraudulent behavior, including but not limited to anti-money laundering (AML), credit card fraud, bot attacks, and malicious traffic. Our framework comprises two core agent types: (1) Detectors, trained to identify suspicious patterns in scenarios, and (2) Transaction Agents, including both legitimate participants and adversarial fraud agents employing strategies to evade detection. In this framework, detectors iteratively refine their detection strategies while fraud agents evolve adaptive tactics to disguise illicit activities, creating an adversarial coevolutionary environment. This dynamic fosters the generation of high-dimensional and realistic datasets for training and testing. By integrating synthetic pre-training with transfer learning, the framework leverages a variety of real-world datasets—including IEEE-CIS Fraud Detection, Credit Card Fraud Detection, and Elliptic++—demonstrating its broad applicability across multiple fraud domains. Our approach significantly improves detection performance, bridging the gap between simulation and real-world applications. It enables robust training across heterogeneous fraud behaviors, contributing to the development of resilient, generalizable solutions for financial security and fraud prevention.

The cover image is based on the Original Article Verification Algebra for Multi-Tenant Applications in VaaS Architecture by Kan Luo et al., https://doi.org/10.1002/stvr.1763.

Summary This paper proposes an algebraic system, verification algebra (VA), for reducing the number of component combinations to be verified in multi‐tenant architecture (MTA). MTA is a design architecture used in SaaS (Software‐as‐a‐Service) where a tenant can customize its applications by integrating services already stored in the SaaS databases or newly supplied services. Similar to SaaS, VaaS (Verification‐as‐a‐Service) is a verification service in a cloud that leverages the computing power offered by a cloud environment with automated provisioning, scalability and service composition. In VaaS architecture, however, there is a challenging problem called ‘combinatorial explosion’ that it is difficult to verify a large number of compositions constructed by both quantities of components and various combination structures even with computing resources in cloud. This paper proposes rules to emerge combinations status for future verification, on the basis of the existing results. Both composition patterns and properties are considered and analysed in VA rules.

The published online cover has been updated.

Smart contracts (SCs) run on the distributed ledger technology (DLT) platform and can implement agreements between participants without a trusted third party. This paper uses the DLT and SC techniques to build distributed applications composed of existing services. In practice, there are many functionally-equivalent services on the Internet. To beat their competitors, the service providers usually offer flexible QoS and use dynamic pricing strategies. Moreover, the service providers can change at runtime, e.g., they may encounter problems so that their QoS drops suddenly. This makes achieving the optimization goal at runtime (e.g., the maximization of the utility) more difficult. To address this problem, first, this paper proposes an SC-based negotiation framework. The SCs can ensure that the transactions are automatically and reliably performed as agreed upon between the service requesters and providers. The DLTs can provide the reliable data of the requests and responses of the service requesters and providers to the SCs. In addition, the SCs can identify the troubled service providers, and find other service providers to replace them at runtime. Second, this paper proposes a Bayesian Nash equilibrium (BNE) of the service providers. In the BNE, the cost-efficient service providers offer the high QoS the service requester asks for and report their costs truthfully. This BNE enables the selection of the cost-efficient service providers and the achievement of the (near) maximization of the service requesters' utility. This paper implements the proposed negotiation framework on a DLT platform called Hyperledger Fabric. The experiment results demonstrate that the proposed approach outperforms the existing approaches and can adapt to the changes of the service providers.

A new algebraic system, test algebra (TA), is proposed for identifying faults in combinatorial testing for software-as-a-service (SaaS) applications. In the context of cloud computing, SaaS is a new software delivery model, in which mission-critical applications are composed, deployed, and executed on cloud platforms. Testing SaaS applications is challenging because new applications need to be tested once they are composed, and prior to their deployment. A composition of components providing services yields a configuration providing an SaaS application. While individual components in the configuration may have been thoroughly tested, faults still arise due to interactions among the components composed, making the configuration faulty. When there are k components, combinatorial testing algorithms can be used to identify faulty interactions with t or fewer components, for some threshold 2 ≤ t ≤ k on the size of interactions considered. In general, these methods do not identify specific faults, but rather indicate the presence or absence of some faults. To identify specific faults, an adaptive testing regime repeatedly constructs and tests configurations in order to determine, for each interaction of interest, whether it is faulty or not. In order to perform such testing in a loosely coupled distributed environment such as the cloud, it is imperative that testing results can be combined from many different servers. The TA defines rules to permit results to be combined, and to identify the faulty interactions. Using the TA, configurations can be tested concurrently on different servers and in any order. The TA always keeps the high reduction rate of potential faulty configurations in fault location analysis.

This paper characterizes Boolean expression faults as changes of the topological structures in terms of shrinking and/or expanding regions in K-map. A cell-covering is a set of cells (test cases) in K-map to cover the fault regions such that faults guarantee to be detected. Minimizing cell covering can be formulated as an Integer Linear Programming (ILP) problem. By analyzing the structures of the constraint coefficient matrix, the original problem can be decomposed into sub-programs that can be solved instead of the original problem, and this significantly reduces the time needed for ILP execution. An efficient approximate algorithm with a tight theoretical bound is used to address those complex Boolean expressions by corresponding the cell-covering problem to the set-covering problem. The optimal approach and the approximate approach are combined into a hybrid process to identify test cases based on the fraction analysis on the ILP relaxation. The proposed approach is evaluated by three sets of Boolean expressions and the results are compared with three leading approaches with respect to test sizes, time consumption and fault detection capabilities. For most Boolean expressions encountered, the proposed approach obtains optimal solutions quickly, and produces near-optimal solutions rapidly for those rare and complex expressions.

Blockchain is a radical innovation that has a significant impact on payments, stock exchanges, cybersecurity, and computational law. However, it has significant limitations regarding uncertainty for a transaction to be confirmed. This paper proposes a new system for exact confirmation of transactions in a block. Replacing original signature, a new Interactive Incontestable Signature (IIS) scheme is used between dealer and owner to confirm a transaction. By this signature, the dealer can assure the owner that a transaction will be included into blockchain in a non-repudiation way. The scheme is proved to be secure for owner's unforgeability and dealer's incontestability.

Context-aware applications often consist of a middleware and a collection of services, and run autonomously adaptive to changing environments with sensors installed in physical facilities and end-users moving around. Testing such applications is challenging due to the complex interactions with the environments. This paper proposes a model-based testing approach that extends a bigraphical sorting predicate logic to specify constraints and create a meta-model, then builds a domain-specific model with static structures and dynamic behaviors based on the bigraphical meta-model, and uses the domain-specific model to describe the environments. Tracing the interactions between the environment model and the application model generates test cases to verify the interactions between the environments and applications. To decrease the number of test cases, this paper proposes a bigraphical pattern-flow testing and a backward-derivation testing. A case study of airport applications demonstrates the fault detection capabilities and reductions of test cases by comparing with other test strategies.

There are lots of distributed computing styles, such as Cluster, Grid, Cloud Computing and so on, based on the larger scale network popular Infrastructure. It is becoming more and more complex to common users in terms of both massive nodes resources management and parallel applications optimization. Performance monitoring tools have received a great significant attention. On the one side, it is necessary to support managing increasingly complex hardware and software infrastructures; on the other side, it can provide user system load and application running information in real time so as to guide user's resource request scheme and program optimization. The hot research issues are associated with some important software properties, such as scalability, elasticity, adaptability and timeliness. Based on the ADS principle, to meet large-scale and continuous monitoring of applications online, this paper proposes a Web-based scalable performance monitoring system framework with a flexible configurable network to address the massive amounts performance data obtained in timeliness. An online transport network is constructed in charge of collecting and processing performance data during execution from different node. It can make the global information available at runtime. Several initialized strategies of Tree-based overlay network are discussed in different cases. A tool has been developed and experimented, and it has been to be effective by many statistics.

Testing-as-a-Service (TaaS) is a software testing service in a cloud that can leverage the computation power provided by the cloud. Specifically, a TaaS can be scaled to large and dynamic workloads, executed in a distributed environment with hundreds of thousands of processors, and these processors may support concurrent and distributed test execution and analysis. This paper proposes an autonomous decentralized combinatorial testing system based on Adaptive Reasoning (AR) and Test Algebra (TA) for Combinatorial Testing (CT). AR performs testing and identifies faulty interactions, and TA eliminates related configurations from testing and there can be carried out concurrently. By combining these two, it is possible to perform large CT. We performed experiments with 2^10 components and 98:34% of configurations have been eliminated out of total number of configurations by AR and TA analysis.

Sub-Tenancy Architecture (STA), is an extension of Multi-Tenancy Architecture (MTA), allows tenants to offer services for subtenant developers to customize their applications in the SaaS infrastructure [1]. In a STA system, tenants are autonomous decentralized entities who can create subtenants, and grant their resources (including private services and data) to their subtenants. The isolation and sharing relations between parent-child tenants, sibling tenants or non-related tenants are more complicated than those between tenants in MTA. It is important to keep resource private, and at the same time, allow them to be shared, and support application customizations for tenants. This paper provides a formal definition of a new tenant-based access control model based on Administrative Role-Based Access Control (ARBAC) for STA in SaaS. Autonomous Areas (AA) and AA-tree are proposed to describe the autonomy of tenants, including their isolation and sharing relationships. Different resource sharing methods are given out to create and deploy the access control scheme in STA models.

Monitoring is widely applied in problem diagnosis, fault localization, and system maintenance. And since the cloud infrastructure is complex, the applications on the cloud are therefore complex, which makes monitoring in cloud more difficult. Rich monitors that contain composite and heterogeneous probes are often used in service-oriented system monitoring. These rich monitors often involve multiple entities, and the interpretation may require expert opinions from multiple domains. This paper proposes a knowledge-based collaborative monitoring approach to find out minimal cost monitor deployment in a cloud environment. The approach contains two main phases. In the knowledge acquisition phase, three acquisition tables, monitor-probe relationship matrix, cost of monitoring, and probe-problem dependence matrix, are generated according to diagnosis ontology and monitor ontology acquired from domain experts. And then based upon the three acquisition tables and three consensus building strategies, we formulate the problem of optimizing the cost of monitoring as an Integer Linear Programming (ILP) problem, which is NP-Complete. In the monitor deployment phase, the proposed algorithm applies two heuristic rules to address the problem. Three experiments are conducted to evaluate the performance of the proposed approach. The results from the experiments show that our approach is effective and produce quality approximate solutions in monitor deployment.

Green computing and energy-saving have been important and hot research topics in mobile computing and cloud computing. In the recent years, many existing research results have been published to address energy saving issues and challenges in cloud computing or mobile computing. Today, the significant increase of mobile users and strong business interests in cloud computing and services drive an emergent opportunities and needs in mobile cloud computing. This brings a new attention to energy saving in mobile cloud computing and services. This paper first presents the research scope and classified issues in energy saving in mobile clouds. Then, it reviews the existing research results and techniques, and examines their strengths and weaknesses. Finally, the paper offers observations, and identifies the open issues and needs for future research.

SaaS (Software-as-a-Service) often uses multi-tenancy architecture (MTA) where tenant developers compose their applications online using the components stored in the SaaS database. Tenant applications need to be tested, and combinatorial testing can be used. While numerous combinatorial testing techniques are available, most of them produce static sequences of test configurations and their goal is often to provide sufficient coverage such as 2-way interaction coverage. But the goal of SaaS testing is to identify those compositions that are faulty for tenant applications. This paper proposes an adaptive test configuration generation algorithm AR (Adaptive Reasoning) that can rapidly identify those faulty combinations so that those faulty combinations cannot be selected by tenant developers for composition. The AR algorithm has been evaluated by both simulation and real experimentation using a MTA SaaS sample running on GAE (Google App Engine). Both the simulation and experiment showed show that the AR algorithm can identify those faulty combinations rapidly. Whenever a new component is submitted to the SaaS database, the AR algorithm can be applied so that any faulty interactions with new components can be identified to continue to support future tenant applications.

Cloud storage provides a virtually unlimited storage spaces for customers. Customers can combine their data storages from different types of cloud storage following their own requirements. End customers often stuck in choosing desirable configuration from different types of cloud storage. How to spend the minimum costs on using the highly efficient cloud storage? How to balance the relationship between the expenditures and performance? This paper proposes a cost-effective optimal configuration model using the repeated game model that can provide optimal configuration solutions to customers. The data mining techniques are used in provisioning on cloud storage. Classification helps users to find the related data and trend analysis assists users to mine the future trend on data storage. A simulate experiment is discussed and verify the correctness of the proposed model.

SUMMARY Modern software often uses ontologies as its key component to store data and their relationships. This is different from using an ontology as a stand‐alone tool for knowledge sharing and representation. The ontology component needs to work with other software components and needs to evolve as the software evolves. Ontology design has been a research topic for years; however, most of these studies focus on using ontologies as stand‐alone applications. This paper studies ontology patterns that can be applied to design ontologies as an integral part of a service‐oriented application. The paper first briefly reviews various ontology design issues including a brief survey of existing ontology design patterns. The paper then outlines general principles for using ontologies in software applications, including the needs to incorporate ontology design process as a part of software development processes, design ontologies as a component of an overall software architecture, and use ontologies to enhance software evolution and the role that ontologies can play in software validation. The paper then proposes some common ontology patterns that can be used to design ontologies in service‐oriented applications. This is followed by examining two international projects, SENSEI and FCINT, where ontologies are used in service‐oriented applications and several ontology design patterns are used. Copyright © 2011 John Wiley & Sons, Ltd.

As cloud services need a fair pricing for both service providers and customers. If the price is too high, the customer may not use it, if the price is too low, service providers have less incentive to develop services. This paper proposes a novel pricing framework for cloud services using game theory (Cournot Duopoly, Cartel, and Stackelberg models) and data mining techniques (clustering and classification, e.g., SVM (Support Vector Machine)) to determine optimal prices for cloud services. The framework is dynamic because the price is determined based on recent usage data and available resources, it is also intelligent as it takes into various economic models into consideration, it is benign because it considers two conflicting parties, service providers and consumers, into consideration at the same time, and it is customizable based on various pricing strategies proposed by service providers and usage patterns as exhibited by consumers. Linear regression is used in various game theory models to determine the optimal price. A global pricing union (GPU) framework is proposed to achieve the best practice of game theory models. Based on the proposed technique, this paper applies this pricing framework to a case study in cloud services, and demonstrates that the prices obtained meet the requirement of traditional supply-demand analysis. In other words, the price obtained is good enough.

The High-Level Architecture (HLA) is the de-facto standard in simulation interoperability. This paper presents a possible way for HLA to integrate with a service-oriented architecture (SOA) in the context of a smart building project. The paper discusses the design of an HLA federate for the inclusion of a service oriented smart building controller in the simulation loop.

With the fast advancements in cloud computing and software- as-a-service (SaaS), testing and evaluation of cloud-based software and SaaS applications became an important task for engineers. Since most existing tools are not developed to support cloud-based software testing and SaaS evaluation, there is a strong demand for a new cloud-based testing infrastructure and evaluation environment for SaaS applications. This paper proposes a testing-as-service (TaaS) infrastructure and reports a cloud-based TaaS environment with tools (known as CTaaS) developed to meet the needs in SaaS testing, performance and scalability evaluation. The paper presents TaaS concepts and CTaaS, including their infrastructure, design and implementation. In addition, the paper demonstrates the application results of our previously proposed graphic models and metrics for SaaS performance and scalability evaluation. Moreover, the paper reports one case study for a selected SaaS (OrangeHRM) using the developed TaaS environment.

This paper proposes key SaaS (Software-as-a-Service) design strategies for those SaaS systems that run on top of a commercial PaaS (Platform-as-a-Service) system such as GAE (Google App Engine)[1]. Specifically, this paper proposes a model-based approach for customization, multi-tenancy architecture, scalability, and redundancy & recovery techniques for GAE. The ACDATER (Actors, Conditions, Data, Actions, Timing, Events, and Relationship) model is used for various features, and then automated code generation is used to generate code based on the model specified. Simulation can be performed to ensure correctness before deployment.

For computer-network education, hands-on laboratories are essential in addition to lectures. Existing laboratory solutions are usually expensive to build, configure and maintain, while still lacking reusability, flexibility and scalability. This paper presents a cloud-based virtual laboratory education solution, called V-Lab, where instructors can use an interactive web GUI to configure computer network testbeds based on a set of dedicated virtual computers interconnected through VLAN-based virtual networks. The established virtual network system can be accessed by students via remote access using standard Secure Shell (SSH), Virtual Network Computing (VNC), or Remote Desktop Protocol (RDP). By using a flexible and re-configurable design, V-Lab greatly reduces the effort needed to establish and maintain a physical laboratory, while providing a secure and reliable environment that encourages students to use the resources based on their own schedule. V-Lab also helps re-design laboratory curriculum to focus on six educational factors, and the survey results show that V-Lab system is easy to use and setup and has satisfactory performance and reliability. It is also indicated that V-Lab helps students understand and solve real-world problems with sufficient laboratory resources and improved efficiency.

In cloud computing, security is an important issue due to the increasing scale of users. Current approaches to access control on clouds do not scale well to multi-tenancy requirements because they are mostly based on individual user IDs at different granularity levels. However, the number of users can be enormous and causes significant overhead in managing security. RBAC (Role-Based Access Control) is attractive because the number of roles is significantly less, and users can be classified according to their roles. This paper proposes a RBAC model using a role ontology for Multi-Tenancy Architecture (MTA) in clouds. The ontology is used to build up the role hierarchy for a specific domain. Ontology transformation operations algorithms are provided to compare the similarity of different ontology. The proposed framework can ease the design of security system in cloud and reduce the complexity of system design and implementation.

As cloud services proliferate, it becomes difficult to facilitate service composition and testing in clouds. In traditional service-oriented computing, service composition and testing are carried out independently. This paper proposes a new approach to manage services on the cloud so that it can facilitate service composition and testing. The paper uses service implementation selection to facilitate service composition similar to Google's Guice and Spring tools, and apply the group testing technique to identify the oracle, and use the established oracle to perform continuous testing for new services or compositions. The paper extends the existing concept of template based service composition and focus on testing the same workflow of service composition. In addition, all these testing processes can be executed in parallel, and the paper illustrates how to apply service-level MapReduce technique to accelerate the testing process.

The current implementations of cloud environment do not have suitable mechanism through which services can be managed to make use of cloud resources. The services in these environments can passively serve users' request only. If a service receives more requests than it can handle in a certain time period, it is subject to malfunctioning. This paper proposes a new approach to service replications that allows a cloud to adjust its service instance deployments in response to existing and projected service request loads. This approach defines an optimal service replication strategy based on MapReduce, a processing model used extensively in GAE (Google App Engine) to solve huge data processing tasks. This service replication strategy is implemented by Service Level MapReduce (SLMR). To better support for SLMR, service replication technology is introduced, which include dynamic service replication and pre-deployed service replication. Furthermore, a passive SLMR approach that depends on the cloud management service (CMS) and a positive SLMR approach that does not need the support from CMS will be introduced.

Software-as-as-Service (SaaS) is a new approach for developing software, and it is characterized by its multi-tenancy architecture and its ability to provide flexible customization to individual tenant. However, the multi-tenancy architecture and customization requirements have brought up new issues in software, such as database design, database partition, scalability, recovery, and continuous testing. This paper proposes a hybrid test database design to support SaaS customization with two-layer database partitioning. The database is further extended with a new built-in redundancy with ontology so that the SaaS can recover from ontology, data or meta-data failures. Furthermore, constraints in metadata can be used either as test cases or policies to support SaaS continuous testing and policy enforcement.

Cloud computing has received significant attention recently. This paper presents real-time issues related to cloud computing, such as multi-tenancy architecture, scheduling, paralleled computing and proposes a framework for real-time service-oriented cloud computing. Specially, we propose a novel real time architecture which solve the new challenges in Cloud Computing.

The Internetware is a new initiative to develop software on the web for web applications. The open and dynamic nature of Internet applications suggest new ways of thinking will be needed for this initiative. This paper discusses several important issues in Internetware and put forward to some relevant research directions. The relevant issues include lifecycle models, ontology and context systems, modeling and simulation, social networking, and adaptive control.

This paper proposes a collaborative runtime monitoring framework to enhance the dependability of the software developed in traditional Web services architecture. The enabling mechanism is an active service broker (ASB) architecture which allows the service broker not only to serve as a passive service repository, but also to involve itself in service interactions and thus to play an active role in service execution and monitoring. The ASB communicates remotely with the distributed monitoring agents deployed at the service providerspsila sites. Sensors are instrumented in services at different levels, including the composition level, interface level, and component level. The model-based approach is discussed for automatic sensor generation and runtime enforcement based on service's process model and verification model. A prototype is implemented for the research of the user and science data center of the astronomic satellite system at Tsinghua University.

Testing is useful to establish trust between service providers and clients. To test the service-oriented applications, automated and specification-based test generation and test collaboration are necessary. The paper proposes an ontology-based approach for Web services (WS) testing. A test ontology model (TOM) is defined to specify the test concepts, relationships, and semantics from two aspects: test design (such as test data, test behavior, and test cases) and test execution (such as test plan, schedule and configuration). The TOM specification using OWL (Web ontology language) can serve as test contracts among test components. Based on the WS semantic specification in OWL-S, the paper discusses the techniques to generate the sub-domains for input partition testing. Data pools are established for each parameter of the specified service. Data partitions are derived by class property and relationship analysis. Completeness and consistency (C&C) checking can be performed on the data partitions and data values, both within the TOM and against the OWL-S, by ontology class computation and reasoning. A prototype tool is implemented to support OWL-S analysis, test ontology generation and C&C checking.

This paper proposes a new approach to teach the STEM (Science, Technology, Engineering, and Mathematics) knowledge informally via robotic games. In this approach, a robotic playground is built to provide a hands-on programming and playing experience with robots controlled by Service-Oriented Computing (SOC) software, which is based on a new approach that uses reusable services (components) with standard interfaces and platform-independent interoperability. Services in the repository are annotated with STEM knowledge to enforce the required contents. In this way, students can learn computing and STEM in an entertaining manner.

Service-oriented architecture (SOA) techniques are being increasingly used for developing critical applications, especially network-centric systems. While the SOA paradigm provides flexibility and agility to better respond to changing business requirements, the task of assessing the reliability of SOA-based systems is challenging, especially for composite services. However, deriving high confidence reliability estimates for mission- critical systems can require huge costs and time. This paper presents a reliability assessment and prediction model for SOA-based systems. The services are assumed to be realized with reuse and logical composition of components. The model uses AI reasoning techniques on dynamically collected failure data of each service and its components as one of the evidences together with results from random testing. Memory-Based Reasoning technique and Bayesian Belief Networks are used as reasoning tools to guide the prediction analysis. The least tested and "high usage " input subdomains are identified and necessary remedial actions are taken depending on the predicted results from the proposed model. The model is illustrated using a simulated case study based on a real-time dataset from the NASA software repository.

Governance by policies is an important feature in service-oriented architecture (SOA). This paper introduces a collaboration policy generation technique to govern dynamic collaboration in SOA systems. Dynamic collaboration allows two parties not knowing each other establish their collaboration protocol at runtime. Traditional SOA allows parties to collaborate but with a known collaboration protocol before execution. In dynamic collaboration, as collaboration protocols will be negotiated and determined at runtime, policies need to be generated at runtime to manage the interaction. This paper presents the concepts, architecture, and illustrative examples that demonstrate the dynamic collaboration policy generation technique

Due to the dynamic nature, such as runtime composition and evaluation, it is critical for an SOA system to consider its data provenance, which concerns security, reliability, and integrity of data as it is routed in the system. In a traditional software system, one can focus on the software itself to determine the security, reliability, and integrity; however, in an SOA system, one also needs to consider the origins and routes of data and their impact, i.e., data provenance. This paper first analyzes the unique natures and characteristics of data provenance in an SOA system. Then it proposes a new framework to classify data provenance and collect data in SOA systems. Finally, this paper uses an example to illustrate these concepts and techniques

Service-oriented architecture (SOA) is a system architecture in which a collection of loosely coupled services communicate with each other using standard interfaces and message-exchanging protocols. As an emerging technology in software development, the SOA presents a new paradigm, and it affects the entire software development cycle including analysis, specification, design, implementation, verification, validation, maintenance and evaluation. This paper proposes several testability evaluation criteria for SOA software, which serves as a reference for both service providers and application builders to evaluate the test support to SOA software. The proposed evaluation criteria are illustrated in a stock-trading case study

The architecture of SOA-based applications is different from traditional software architecture where the architecture is mainly static. The architecture of an SOA-based application is dynamic, i.e., the application may be composed at runtime using existing services. Thus SOA has provided a new direction for software architecture study, where the architecture is determined at runtime and architecture can be dynamically changed at runtime to meet the new software requirements. This paper proposes an architecture classification scheme for SOA-based applications. Using this classification, several well-known SOA-based applications are reviewed including the architectures proposed and adopted by major computer companies and standard organizations. The architecture classification provides a unified way to evaluate a variety of architectures for SOA-based applications.

Patching technologies are commonly applied to improve the dependability of software after release. This paper proposes an autonomous hot patching (AHP) framework to fully automate the reasoning for the causes of failures, and to patch the binary code of Web-based applications. AHP admits the hardness for rooting out all faults before product release, and autonomously patches problems of application programs. By directly operating on binary code, AHP is universal to virtually all applications. A promising application of AHP is to shortcut the remote maintenance center (RMC) and hence to reduce the turn around time for patches.

Web services and service-oriented architecture are emerging technologies that are changing the way we develop and use computer software. Due to the standardization of Web services related description languages and protocols, as well as the open platforms, for the same Web service specification, many different implementations can be offered from different service providers. This paper presents an adaptive group testing technique that can test large number Web services simultaneously and effectively. Based on a case study, experiments are performed to validate the correctness and effectiveness of the technique.

This paper presents an integrated development process for Web services. The key differences with the traditional software development are that this new process involves collaboration and cooperation among all parties involved: developers, brokers, and clients. The process defines a new way of developing trustworthy Web services based on the existing Internet infrastructure. The paper serves as a roadmap to research on Web services specification, discovery, ontology, composition, re-composition, testing, reliability assessing, ranking, and collaboration and cooperation among all parities involved in Web services research, development, and application.

Web services are emerging technologies that are changing the way we develop and use computer systems and software. Current Web services testing techniques are unable to assure the desired level of trustworthiness, which presents a barrier to WS applications in mission and business critical environments. This paper presents a framework that assures the trustworthiness of Web services. New assurance techniques are developed within the framework, including specification verification via completeness and consistency checking, specification refinement, distributed Web services development, test case generation, and automated Web services testing. Traditional test case generation methods only generate positive test cases that verify the functionality of software. The Swiss cheese test case generation method proposed in this paper is designed to perform both positive and negative testing that also reveal the vulnerability of Web services. This integrated development process is implemented in a case study. The experimental evaluation demonstrates the effectiveness of this approach. It also reveals that the Swiss cheese negative testing detects even more faults than positive testing and thus significantly reduces the vulnerability of Web services.

Web services emerge as a new paradigm for distributed computing. Model checking is an important verification method to ensure the trustworthiness of composite WS. Boolean abstraction and counterexample driven refinement are major techniques for model checking software and WS. In most of the literature, the refinement is governed by the precision of the abstraction. In this paper, we present an innovative technique to distribute the precision information among proof slices, which can be selectively reused by future proofs and hence improve the performance by reducing excessive invocations of theorem provers. Moreover, the reuse approach is flexible for virtually arbitrary future extension. Our theoretical framework subsumes several existing abstraction-based model checking techniques, e.g., lazy abstraction. Besides the correctness and termination proofs, we also conducted theoretical analysis on the performance of the proof slicing algorithm.

Web services form a new distributed computing paradigm. Collaborative verification and validation are important when Web services from different vendors are integrated together to carry out a coherent task. This paper presents a new approach to verify Web services by model checking the process model of OWL-S (Web ontology language for Web services) and to validate them by the test cases automatically generated in the model checking process. We extend the BLAST, a model checker that handles control flow model naturally, to handle the concurrency in OWL-S. We also propose enhancement in OWL-S and PDDL (Planning Domain Definition Language) to facilitate the automated test case generation. Experiments on realistic examples are provided to illustrate the process.

Recently service-oriented architecture (SOA) has received significant attention and one reason is that it is potentially survivable as services are located, bound, and executed at runtime over the Internet. However, this is not enough for dependable computing because the system must also be able to reconfigure once a system failure or overload is detected, and this reconfiguration must be done in real-time at runtime with minimum disruption to the current operation. This work presents reconfiguration requirements for building dependable SOA, and proposes a dynamic reconfiguration framework based on distributed monitoring, synchronization, and runtime verification with distributed agents.

Verification pattern (VP) is a new technique to test embedded systems rapidly, and it has been used to test industrial safety-critical embedded systems successfully. The key concept of this approach is to classify system scenarios into patterns, and use the same code template to test all the scenarios of the same pattern. In this way, testing effort can be greatly reduced. This paper extends VPs so that they can fully interoperate with a formalized scenario model ACDATE. In this way, various static and dynamic analyses can be performed on system scenarios as well as on system patterns. Furthermore, this paper provides a mapping from system scenarios into temporal logic expressions. In this way, a practitioner can specify system constraints in scenarios, and follow the mapping to obtain the temporal logic expressions easily to perform formal model checking. This paper also provides an OO framework to support automated test script development from VPs. In this way, VPs can be used in an integrated process where both semi-formal analyses and formal techniques can be used together to develop mission-critical embedded applications.

To reduce testing cost and effort, the paper proposes a systematic approach to generate test cases for state-based embedded systems. This process first derives a state/event tree based on a scenario specification, with a node of the tree representing a state, and a link a transition between two states. Once the tree is obtained, it is possible to generate test inputs based on partition testing, random testing and boundary value testing. It is also possible to perform various analyses such as completeness and consistency analysis, dependency analysis and relationship analysis. An XML-based tool has been developed to automate many of the steps in the process. Whenever there is a change to the system, the tester needs to modify the state/event tree, and the tool automatically re-generates the new test cases to test those changed parts as well as perform selective regression testing to test those affected parts. To illustrate the ideas, the paper uses a wireless mobile phone system as an example. The system consists of three parts: a mobile station center server, several base station servers, and clients.

This paper presents a process to develop adaptive object-oriented scenario-based test frameworks for testing embedded systems. Embedded systems often require rigorous testing due to the mission-critical nature of their applications, and they are often developed as a family of products. The process uses techniques such as design-for-change, design patterns, scenarios, ripple effect analysis, and regression testing. This paper then uses an example to illustrate this process by applying it to test a mobile phone system, and the framework constructed can facilitate generation of numerous test cases quickly with minimum effort, and it can also accommodate many changes suggested by another party without changing the overall structure of the framework.

One of the most important issues in the software development is how to guarantee that the software satisfies the quality defined in the requirement specification. This paper proposes that the issue can be solved, first the number of test cases is statistically calculated from the failure density defined in the requirement specification, then the selected test cases are executed basing on the hypothesis testing. This paper also presents how our method can be used for debugging. When the number of the test cases is calculated, we applied the statistical behavior of the software quality to the integration testing. We, however, did not consider the ripple effect since it is unable to measure. In order to guarantee the quality of 4/spl sigma/, and 5/spl sigma/, we found that many more test cases are needed than is previously believed enough.

Regression testing has been a popular quality-assurance technique. Most regression testing techniques are based on code or software design. This paper proposes a scenario-based functional regression testing, which is based on end-to-end (E2E) integration test scenarios. The test scenarios are first represented in a template model that embodies both test dependency and traceability. By using test dependency information, one can obtain a test slicing algorithm to detect the scenarios that are affected and thus they are candidates for regression testing. By using traceability information, one can find affected components and their associated test scenarios and test cases for regression testing. With the same dependency and traceability information one can use the ripple effect analysis to identify all affected, including directly or indirectly, scenarios and thus the set of test cases can be selected for regression testing. This paper also provides several alternative test-case selection approaches and a hybrid approach to meet various requirements. A web-based tool has been developed to support these regression testing tasks.

Integration testing has always been a challenge especially if the system under test is large with many subsystems and interfaces. This paper proposes an approach to design End-to-End (E2E) integration testing, including test scenario specification, test case generation and tool support. Test scenarios are specified as thin threads, each of which represents a single function from an end user's point of view. Thin threads can be organized hierarchically into a tree with each branch consisting of a set of related thin threads representing a set of related functionality. A test engineer can use thin-thread trees to generate test cases systematically, as well as carry out other related tasks such as risk analysis and assignment, regression testing, ripple effect analysis. A prototype tool has been developed to support E2E testing in a distributed environment on the J2EE platform.

Testing is the primary means for quality assurance for enterprise systems, and integration testing is often the most time consuming and expensive part of testing. Recently Department of Defense proposed an End-to-End (E2E) integration testing process to address the challenge of testing large integrated information systems. The E2E testing activities include test thin-thread tree construction, condition tree specification, test configuration management, risk analysis, regression testing, ripple effect analysis, test scenario/case generation, rest result analysis, statistical analysis, and project management. A tool has been developed to support this E2E testing on J2EE using EJB and XML with Cloudscape relational database management system. This web-based tool also allows distributed collaboration and remote project management by the E2E testing participants including project managers, contractors, designers and testers.

Message framework sequence specifications (MFSS) have been proposed to specify message sequences for object-oriented (OO) frameworks. This paper adds additional sequence constraints such as loop constraints, object relationship constraints, static and dynamic data constraints to MFSS. These additions are useful in generating test scenarios using various testing strategies such as partition testing, random testing, and stress testing. The enhanced MFSS, MFSS+, can be viewed graphically so to facilitate programmer understanding as well. This paper also presents computation rules that can be useful in generating test scenarios automatically. The syntax and semantics of MFSS+ are also presented. Finally, this paper uses MFSS+ to test an example OO framework. The test scenarios generated successfully detect all the bugs initially seeded.

Design patterns have been used in object-oriented frameworks. This paper first discusses the issues in testing applications developed with design patterns using an object-oriented framework. Two kinds of design patterns are available, extensible and static patterns, and this paper focuses on testing applications using the latter. Applications developed using extensible design patterns are difficult to test due to dynamic typing, dynamic binding, extensibility, and communication complexity. This paper then presents a technique, message framework sequence specifications (MfSS), for generating scenario templates that can be used to generate various kinds of test scenarios to test applications developed using extensible design patterns and an object-oriented framework. Finally, this paper uses the MfSS technique to test a small bank framework. The test scenarios generated successfully detected numerous faults that were seeded in the program.

VSAM database systems are widely used on IBM mainframe systems. COBOL is the most frequently used host language to access VSAM databases. To fix the Year 2000 bug and migrate to new client/server technology, business organizations are re-engineering their legacy COBOL programs and converting VSAM databases to SQL databases. This paper addresses two important problems in VSAM conversion: database schema conversion and SQL query generation. It proposes a semi-automatic approach to the conversion of VSAM data sets to SQL tables and the conversion of VSAM operations to embedded SQL statements. The proposed approach and a prototype tool have been tested on COBOL programs from industry. Copyright © 1999 John Wiley & Sons, Ltd.

Knowledge-based systems (KBSs) are being used in many applications areas where their failures can be costly because of losses in services, property or even life. To ensure their reliability and dependability, it is therefore important that these systems are verified and validated before they are deployed. This paper provides perspectives on issues and problems that impact the verification and validation (V&V) of KBSs. Some of the reasons why V&V of KBSs is difficult are presented. The paper also provides an overview of different techniques and tools that have been developed for performing V&V activities. Finally, some of the research issues that are relevant for future work in this field are discussed.

Recently object oriented frameworks have become popular. Application development using frameworks still need analysis, design, coding and testing. The paper presents analysis techniques, Framework-Oriented Analysis (FOA), for application development using frameworks and related techniques. The FOA is an extension of object oriented analysis (OOA), but it explores the reuse of software architecture, design, code and test cases of frameworks. The key features of the FOA include comparison based analysis, feature comparison, hierarchical framework/application (F/A) scenario diagrams, cross reference checking between framework and application objects and methods, multi-level requirement checking.

This paper presents the agent architecture of an Internet application development tool called Distributed Interactive Web-site Builder (DIWB). Together with the component object model and a layering framework, the agent architecture can be used to build Internet applications that support individualized services. The DIWB can construct pages dynamically at runtime and can be easily customized for individual users. The architecture consists of two cooperating agents that compose pages at runtime using components and data stored in various databases (agencies). The page agent composes a page by retrieving page definition and requesting the component agent to construct individual components. The component agent retrieves user preferences, and page component definitions from the databases and returns the results to the page agent.

Many real time systems evolve over time due to new requirements and technology improvements. Each revision requires regression resting to ensure that existing functionality is not affected by such changes. Testing these systems often require specialized hardware and software, and both are expensive. While the overall regression testing process is similar across different organizations, the strategies and tools used by them vary according to their product needs. Hence a good framework for regression testing should provide the flexibility to configure it depending on the particular organization's needs while at the same time maximizing utilization. Manual processes are typically slow and error prone and result in under-utilization of valuable test resources. The paper proposes an automated distributed regression testing framework that provides flexibility to the user to configure it to their needs while at the same time optimizing resource usage.

Modeling synchronization among threads is important for the specification, design, and testing of concurrent object-oriented applications such as those written in Java. This paper proposes Synchronized Method Sequence Specification (SMtSS), a mechanism for specifying synchronization requirements among multiple threads sharing a common object. SMtSS identifies two kinds of synchronization among the sharing threads, internal and external ones, and explicitly specifies the synchronization scenarios. SMtSS also proposes notations for specifying different data integrity constraints on method executions. This paper also proposes specification-slicing techniques to obtain specific behavior of certain threads from SMtSS specifications. Finally, this paper discusses how SMtSS specifications can be useful in the design and testing of concurrent object-oriented applications in Java.

Business rules are operational rules, often coded into software, that business organizations follow to perform various activities, such as transaction processing, quality control, business planning and database management. Over time, business rules evolve and the software that implemented them are also changed and maintained. As the encompassing software becomes large and aged, the business rules embedded are difficult to extract and understand, evolving with the encompassing software over time. Furthermore, the encompassing software is changed without changing the corresponding text documents, and thus, often, the business organization trusts the code more than any other documents. This paper proposes several techniques to extract business rules from legacy code. It is possible to use a generic software maintenance tool to extract business rules; however this can be an expensive exercise. We propose a tailored solution approach for the business rule extraction (BRE) problem, which combines variable classifications, program slicing, heuristics for identifying slicing criteria, multiple representations of business rules, bottom-up data flow analysis and hierarchical abstraction, among other maintenance techniques. The proposed solution approach has been implemented as a system and successfully tried with a number of industrial programs. © 1998 John Wiley & Sons, Ltd.

Software has made more progress during the last few years than any years before that. New technology is coming every day and it is impossible for every one to catch up with it. Two technologies and their impacts on software development are presented: software reusability, which can significantly improve software productivity; and Internet computing, which provides a new testbed for software applications as well as their development. Software reusability and Internet computing change the way software will be developed. We discuss some of their impacts.

The data-centered approach uses variable classifications, dependence analysis, generalised program slicing and ripple effect analysis. In the Year 2000 problem, this approach can be useful. Variable classification is used to identify all input and output variables, and once the initial set of variables that are Year 2000 related is identified, dependence analysis can be used to identify all the variables that are potentially affected by the initial set of variables. The second set of variables is then examined to see if they are Year 2000 related. This process is repeated until all the Year 2000 related variables are identified. This process is essentially ripple effect analysis and uses generalized program slicing and dependence analysis. Once Year 2000 related variables are identified, generalized program slicing is performed to identify all the statements that potentially need to be changed. Once a statement is changed, it may induce additional changes. Ripple effect analysis can be used to ensure that all the parts that need to modified are examined. Finally, the changed software should be validated and regression testing can be used in this stage. Ripple effect analysis can be used in this stage by identifying the relevant test cases that needed to evaluated. This is done by maintaining traceability links between the software and its test cases.

In this interview, Takashi Sano reviews the origin and history of the year 2000 problem in Japan, and summarizes its status in Japan as of late 1996. He presents a way for software vendors to make this problem known to the software community because the problem is very serious, with far reaching impacts on an organization's economics, demand for talent and workforce scheduling. Then, he discusses the core techniques used at Fujitsu to tackle the year 2000 problem when a re-engineering approach is used. Finally, he provides an overview of a relevant software tool developed by Fujitsu. © 1997 John Wiley & Sons, Ltd.

Software hazard analysis involves identifying safety faults in software and mitigating their causes. Designing safe systems is a creative process and there are no systematic guidelines for generating safe designs. Here, the authors present some patterns of safety fault mitigation in medical devices, which were identified from a case study at the Guidant Corporation. These patterns prescribe appropriate fault mitigation processes and techniques for different safely situations. The patterns are classified into two major categories. Process Patterns and Technique Patterns. The process patterns are the patterns found in the process and decisions taken by engineers during safety analysis. The technique patterns are patterns found in the various mitigation techniques used to mitigate faults. The factors affecting the usage of these patterns and the process of mitigation are also discussed here.

The authors discuss issues in designing run-time mechanisms for enhancing the dependability of safely-critical systems. Such mechanisms are aimed at failure avoidance and failure detection and can complement the other design methods in achieving higher dependability. The authors introduce a safety-constraint centered transformation methodology that is based on a system's safety constraint specification and the development of techniques for analyzing the constraints to derive the run-time checking schemes. The authors also discuss other issues that are important in designing run-time checks, such as the types of safety constraints that can arise, features that specification languages must have to specify such constraints, how such safety constraints can be violated, and run-time support required for the mechanisms.

Business rules are operational rules that business organizations follow to perform various activities. Over time, business rules evolve and the software that implemented them are also changed. As the encompassing software becomes large and aged the business rules embedded are difficult to extract and understand. Furthermore, the encompassing software is changed without changing the corresponding documents, so the business organization often trusts the code more than any other documents. It is possible to use a generic tool to extract business rules, but this can be an expensive exercise. The paper proposes a tailored solution approach to the business rule extraction problem, which combines variable classifications, program slicing, and hierarchical abstraction among other maintenance techniques. The proposed approach has been implemented as a system and successfully experimented with a number of industrial programs. The prototype has been demonstrated at several industrial software maintenance sites since June 1995.

This paper discusses an integrated software development and maintenance environment, Opusdei, built and used for the past seven years at Hitachi Software Engineering (HSK) for its various projects. Industrial software is usually large, has many versions, undergoes frequent changes, and is developed concurrently by multiple programmers. Opusdei was developed by HSK to handle the various problems that arise in such an industrial environment. In Opusdei, all information needed for development is stored using an uniform representation in a central repository, and the various documentation and views of the software artifacts can be generated automatically using the tool repository. The innovative capabilities of this tool are: (1) Uniform software artifacts representation; (2) Inter-relation and traceability maintenance among software artifacts; (3) Tools repository and integration using tool composition scenarios; (4) Automatic documentation and versioning control. Opusdei was used in various software engineering projects and was found to improve productivity to a great extent.

Proposes several new object-oriented (OO) software-specific techniques that are useful in the maintenance of OO software, especially C++ programs. The proposed techniques include: (1) new OO-specific dependence relations (such as class, message and declaration dependence); (2) algorithms to construct a hierarchical C++ dependence graph (C++DG) to capture these dependences from the source code; (3) several new slicing techniques (such as class, message, constrained and recursive slicing), besides the existing slicing techniques (such as program, variable and condition slicing) for OO programs. Next, the paper discusses the application of the dependence and slicing concepts to other maintenance activities such as ripple effect analysis (REA) and regression testing. Finally, the paper presents the design of an integrated environment, Omega, that implements many of these techniques for C++ program maintenance. Omega has been demonstrated in various industrial sites in the USA and Japan since May 1995.

The paper describes a framework for designing safety-critical software systems, in the context of a software safety analysis process that is based on fault tree analysis. This software design process has four steps: 1) software design fault tree generation, 2) fault tree verification, 3) safe software design, and 4) design safety verification. Approaches to safe software design, and verification of the safe design against the safety requirements have also been presented.

Abstract This paper gives an overview of the software maintenance process of Hitachi Software Engineering (HSK) Co., Ltd in Japan‐including its success and failure cases. It discusses HSK's software processes, issues, use of specific tools and techniques such as IMOZU diagrams, and approaches in solving problems. These include the requirement capturing process, reverse‐engineering techniques, environmental changes, change management, and project management. By discussing actual project experiences, we point to certain lessons and their implications for research in software maintenance. We also present the latest re‐engineering CASE tools, such as RE‐ENGINEERING and SEWB3, used at HSK.

There are many software development processes defined in the literature that address the particular needs for the type of software being developed. However, for software in safety-critical systems, most of the existing processes do not address safe software development and delivery. We propose a software development process for developing safe software, consisting of four basic activities; forward engineering, safety analysis, reliability analysis and program management.>

Program understanding is crucial during software maintenance. Variable classification has been found to be useful for program understanding. We present an automatic variable classification technique for COBOL programs and how this has been implemented as component of the Data-centered Program Understanding Tool Environment (DPUTE) (J.K. Joiner et al., 1994). We have experimented on both small and large COBOL programs using our tool to determine if our methods are useful for program understanding and software maintenance.>

Software maintainers use a variety of techniques and representations for understanding programs. Most of these representations first focus on the control structure of a program such as call graphs, control flow graphs and paths. We propose a new approach for program understanding that is data-centered-it first focuses on data and data relationships. We have experimented on both small and large Cobol programs from industry to determine if our methods are useful for program understanding and software maintenance. We have developed DPUTE (Data-centered Program Understanding Tool Environment) that is currently being evaluated and enhanced by our industrial partners.>

We introduce a detailed process for software requirements safety analysis. The approach for identification of safety faults in this process is based on fault tree analysis. This process consists of four main steps: software requirements fault tree generation; software requirements fault tree verification and validation; software safety requirements generation and safety fault mitigation; and software requirements safety verification and validation. We have defined a set of rules that can automatically generate the software requirements fault tree given the software requirements specified in Statemate, and the software fault tree top events identified in the system safety analysis. Statemate CASE tool is used in this process for specification of software requirements, and execution and analysis of the software requirements to verify and validate safety. Essential tree analysis is introduced as a method for dependency analysis of the software fault tree top event. The outcome of essential tree analysis is captured in an essential tree which we introduce as a graphical representation of the dependencies and their interrelations.>

Object-oriented (OO) database systems are becoming popular for CAD, VLSI, and CASE applications. One of the reasons is the support of prototyping through inheritance and/or scheme evolution. In this paper, we propose another rapid prototyping technique: object prototyping. It assumes that a database schema is fixed and rapid prototyping is achieved by applying alternative values into attributes of an object. This is useful especially for design applications in which determining a design object's properties is not straightforward. We design a specification language based on the what-for-if construct for modeling the object prototyping. This specification language can (1) help the designer to simulate alternative design parameters to find out the optimal design parameters, (2) reduce the need for writing database programs, (3) support the development and construction of complex applications on top of the database, and (4) test the functionality and performance of design objects.>

Three object-oriented analysis techniques: Shlaer & Mellor, Coad & Yourdon, and Document-Driven Analysis were evaluated. Criteria for comparison of analysis techniques were developed. These criteria state that an analysis technique should (1) cover data, transformation, and control perspectives of the problem, (2) address large problems through partitioning, bounding the problem, and supporting prototypes and incremental analysis, (3) provide approaches for verification and validation, and (4) support configuration control. A case study in a software engineering class was conducted using the three OOA techniques. Through the case study we found that (1) identifying objects is affected by notation and flexibility of object models, (2) visualizing global data, transformations, and control are necessary to capture end-user’s processes, (3) emphasizing hierarchical structures and third normal form divert the analyst’s attention from analysis to implementation, (4) an explicit representation of relationships is necessary, (5) peer review is useful in improving selection of objects and methods to support end-user processes, and (6) supporting a standard document from OOA products is not easy.

Concurrent execution of transactions in database management systems (DBMSs) may lead to contention for access to data, which in a multilevel secure DBMS (MLS/DBMS) may lead to insecurity. Security issues involved in database concurrency control for MLS/DBMSs are examined, and it is shown how a scheduler can affect security. Data conflict security, (DC-security), a property that implies a system is free of covert channels due to contention for access to data, is introduced. A definition of DC-security based on noninterference is presented. Two properties that constitute a necessary condition for DC-security are introduced along with two simpler necessary conditions. A class of schedulers called output-state-equivalent is identified for which another criterion implies DC-security. The criterion considers separately the behavior of the scheduler in response to those inputs that cause rollback and those that do not. The security properties of several existing scheduling protocols are characterized. Many are found to be insecure.>

Petri nets (PNs) are frequently used in modeling, designing, and analyzing concurrent systems. A problem with PNs, in the general case, is that they require high computational complexity to analyze their properties, such as reachability, liveness, and boundedness. To avoid this problem, synthesis techniques for constructing large PNs are presented. Using these techniques, the behavior of the constructed PN can be determined by local analysis that uses known properties of the given nets. Thus, the high computational complexity of global analysis is bypassed. A synthesis technique that explores dependency relations in PNs is presented. It synthesizes large PNs by combining smaller PNs of arbitrary topology structures, and the combination is verified efficiently by dependency analysis. A large system based on a PN can be built up by repeated applications of the technique.>

The authors describe a life-cycle approach for testing expert systems. They comment on the difficulties associated with testing of an expert system. Pragmatic testing methods of conventional software engineering are proposed as a solution to these problems. The application of these techniques is illustrated through an extended example for the expert system, MAPS, which diagnoses faults in a bipolar transistor induced to process defects in a VLSI manufacturing environment.>

Quadtree data structure has been used in a number of applications. However, VLSI embedding of quadtree based parallel architecture using grid model has not been studied. This paper studies VLSI embedding of quadtree using grid model. H-tree layout for binary tree is extended for trivial quadtree layout, followed by two layout strategies for rectangular grids. Two generic layout styles (standard layout and X-layout) are proposed for higher order grids (e.g., hexagonal and octagonal grids). Base tile layout patterns are proposed for area compaction with recursive X-layout. In each case, layout dimensions and I/O bandwidth are computed. The authors demonstrate how the two generic layouts can be mixed to obtain higher I/O bandwidth and estimate the area sacrifice. An improved recursive layout mixing strategy is proposed.>

Effective testing (validation, verification and evaluation) for expert systems is becoming important. A comparative evaluation of black-box, white-box, consistency, and completeness testing methods is performed based on the criteria of effectiveness, robustness, and cost. Testing methods are evaluated using life-cycle mutation testing on a VLSI manufacturing diagnostic expert system. The results indicate that dynamic-flow testing can be used to catch faults in all phases of software development.>

This paper presents a software maintenance environment for assembly programs, SAMEA. It presents an object-oriented database support for displaying, understanding, modifying and configuring assembly programs for software maintenance. Understanding of assembly programs is based on the theory of explicit representation of various structural and functionality elements of code and multiple relationships among them. Modification of program is based on an object-oriented incremental editor and a set of rules to check the correctness of instruction format. The characteristics of SAMEA are: integration of multiple tools, on-line information, ease of adoption of new tools, and finally, support of software maintenance activities such as program understanding, ripple effect analysis, and program redocumentation. The ripple effect of a contemplated change is the parts of the code that need to be reexamined for possible modification. Assembly code elements and relations among code elements are represented as objects in SAMEA which is built on top of an object-oriented database GemStone. SAMEA consists of 26K lines of C code and 4K lines of GemStone code. We have successfully populated 18K lines of BAL code in SAMEA.

Object-oriented analysis is the activity of understanding a problem domain and developing a specification for it within an object-oriented paradigm. In this paper we propose object-oriented analysis can be viewed as a design task that consists of analysis, synthesis and internal and external completeness and consistency checking. We postulate a blackboard based design framework and propose several alternative theories within this framework. Data from an expert analyst is collected and analyzed for relative explanatory power of the alternative theories. Basic findings are that viewed as a design activity, object-oriented analysis is neither top-down nor completely opportunistic in nature, Rather, (1) analysis (the process of finding objects and processes) and synthesis (constructing the object model and state-transition diagrams) are complementary activities while internal completeness and consistency checking is coupled with synthesis and (2) construction of objects and processes are cyclic and complementary processes. The findings are compared with both descriptive and normative research in automated software design.

A cluster management scheme for dynamic networks, the purpose of which is to maintain the cluster structure of the hierarchical network as a balanced-tree topology is presented. The theoretical time complexity bounds of the cluster management scheme for node birth and death are derived. The effects of the cluster management on gate-connected fixed-node networks under heavy intercluster traffic situations are discussed. In order to show that the scheme can handle realistic communication networks, routing tables and OD pair shortest path routing are used. The settle-down time, throughput, and end-to-end link delays of a network that uses cluster management and a network of the same topology that only uses flooding are compared.>

This paper describes a software engineering experiment designed to confirm results from an earlier project which measured fault detection rates in user requirements documents (URD). The experiment described in this paper involves the creation of a standardized URD with a known number of injected faults of specific type. Nine independent inspection teams were given this URD with instructions to locate as many faults as possible using the N-fold requirements inspection technique developed by the authors. Results obtained from this experiment confirm earlier conclusions about the low rate of fault detection in requirements documents using formal inspections and the advantages to be gained using the N-fold inspection method. The experiment also provides new results concerning variability in inspection team performance and the relative difficulty of locating different classes of URD faults.

A rollback recovery scheme for distributed systems is proposed. The state-save synchronization among processes is implemented by bounding clock drifts such that no state-save synchronization messages are required. Since the clocks are only loosely synchronized, the synchronization overhead can be negligible in many applications. An interprocess communication protocol which encodes state-save progress information within message frames is introduced to checkpoint consistent system states. A rollback recovery algorithm that will force a minimum number of nodes to roll back after failures is developed.>

A transaction model for active databases is introduced. Concurrent execution of rules needs to be carefully managed to ensure consistent semantics. It is shown that serializability is not always sufficient for correctness. A new criterion, conditional conflict serializability (CCS) is developed and shown to ensure the desired correctness. A graph-based scheduler for it is presented. Practical schedulers should also be recoverable, which the graph-based scheduler is not. The authors prove that conventional two-phase locking also achieves CCS, and can thus be used in practice.>

The authors propose a VLSI layout strategy for a full binary tree. This layout can support more border leaf processing elements (PEs) and thus can give a higher I-O bandwidth. It is superior to the H-tree layout in terms of the number of boundary leaves. The approach uses H-tree pattern for constructing subtree layouts and then combines a number of such subtrees following standard tree style to get a larger sized tree layout. Finally at the top level H-tree layout style is used to get the overall tree layout. Different I/O bandwidths can be obtained varying the subtree height. The authors derive expression for layout area, longest link and aspect ratio of the chip. It is observed that I/O bandwidth can be significantly increased without much area overhead using this approach.>

Cube connected cycles (CCC), a popular and layout/efficient alternative to hypercube, can emulate the performance of hypercube for many parallel algorithms. Recently, interconnection networks based on simplex links rather than duplex have been proposed. The uni-directional architectures have layout advantages and reduces complexity of each processing element (PE). The authors propose directed cube connected cycles (DCCC) as a uni-directional alternative to CCC. They have developed PE-to-PE routing algorithm for DCCC. A method for porting algorithms (designed to run on bi-directional CCC) to DCCC is provided. The extent of slowdown due to using simplex links is evaluated. They also provide loop embedding on DCCC. DCCC is found competitive to CCC in algorithmic performance though DCCC is much layout inexpensive.>

H-Tree layout for binary trees can utilize only 50% of the available nodes. Improved binary tree layout techniques have been developed only after relaxing the rectangular grid model assumptions. The authors propose an area-efficient VLSI layout strategy for full binary trees without relaxing the rectangular grid model assumptions. For a height-5 full binary tree they developed a (5*8) layout pattern on an ad hoc basis. This tile is more area efficient than an equivalent H-Tree layout of a height-5 full binary tree. Using this tile, higher level trees are built in a way identical to H-Tree. The area efficiency remains for any level of tree construction. The proposed layout has an improved aspect ratio compared with H-Tree and features a reduced length of the longest link.>

In this panel session, the following topics are discussed: artificial intelligence in business; artificial intelligence in multimedia; neural networks as a tool for artificial intelligence: software engineering for knowledge-based systems: and artificial intelligence as a solution for software engineering.>

The implications of multilevel security on database concurrency control are explored. Transactions are vital for multilevel secure database management systems (MLS/DBMSs) because they provide transparency to concurrency and to failure. Concurrent execution of transactions may lead to contention among subjects for access to data, which in MLS/DBMSs may lead to security problems. An abstraction of security models in terms of the transactions which they produce is presented. The notion of DC-Security which identifies a class of covert channels that are caused by contention for access to shared data, is introduced. This notion is useful for evaluating the security of transaction schedulers. A framework for multilevel secure schedulers which allows analysis of a schedulers' security properties at the protocol level is presented. Necessary and sufficient conditions are developed for DC-Security in this framework and proved using noninterference. A wide range of schedulers is evaluated against these conditions.>

Consideration is given to the application of multiversion schedulers in multilevel secure database management systems (MLS/DBMSs). Transactions are vital for MLS/DBMSs because they provide transparency to concurrency and failure. Concurrent execution of transactions may lead to contention among subjects for access to data, which in MLS/DBMSs may lead to security problems. Multiversion schedulers reduce the contention for access to data by maintaining multiple versions. A description is given of the relation between schedules produced in MLS/DBMSs and those which are multiversion serializable. The authors also propose a secure multiversion scheduler. They show that the scheduling protocol gives correct schedules and is free of covert channels due to contention for access to data, i.e. the scheduler is data-conflict-secure.>

Abstract This paper presents a model for understanding assembly programs for software maintenance. It is based on the theory that explicit representation of various structural and functional elements of code and multiple relationships among them will aid program understanding and thus software maintenance. We present a parsing technique to extract all the required elements from assembly code to populate the model. The model is a reverse engineering technique. We use the term reverse engineering in its broad sense to include specification as well as design recovery. Most features of this model have been implemented in a tool named “RETA” for Reverse Engineering Tool for Assembly programs. The model is useful for software maintenance activities such as program understanding, ripple effect analysis, and program re‐documentation. The ripple effect of a contemplated change is the parts of code that depend on the variable or a piece of code to be changed. Once the change is made, those parts need to be re‐examined for possible modification. The model generates a functional menu for a given application. The menu describes the functionality of each routine. It is a hierarchical presentation of major program routines, the sub‐routines supporting each major routine and so on. A routine at any level of detail consists of one or more paths through the code. Paths are presented as control flow sequences between code blocks. Code blocks, and hence functionalities, use and modify data. The maintainer locates the routine to be modified at the lowest level of detail within the functional menu. This automatically slices out the set of paths, and hence the set of code blocks, that have a role in the functionality to be changed. The code blocks in the slice determine the data that are used and modified within the routine to be changed. Path analysis and associated data‐used and data‐modified information are used to determine which code blocks are to be changed and which data roles are to be modified. The same set of relations are applied in reverse to identify the ripple effect.

The evolution support environment (ESE) system, which provides a framework for capturing and making available semantic information about software components of an evolving software system, is described. The goal in the design of the ESE system was to provide integrated support for management of software architecture configuration, life-cycle configuration, and version control. Software architecture configuration management allows tracking of interconnections among software components that make up a system. Life-cycle management allows traceability among specifications, design, code, and test cases during software development. Adding version control allows specific versions of software objects and their associated objects, such as specifications and test cases, to be retrieved. The authors' experience with the use of the system is discussed.>

Black-box software testing requires test cases to be generated from specifications alone. However, it is impossible to automate the process completely for arbitrary specifications. Specifications are thus restricted to being written entirely in terms of relational algebra expressions. An automated test case generation method is developed for such specifications.>

Examines three techniques for evaluating the logical consistency of an object-oriented Database security model. The first technique consists of judging the model with respect to a set of general consistency properties for database security models. The second technique compares the SODA model against two other database security models. The third technique consists of defining a set of entities and mechanisms fundamental to the object-oriented model and considering the effect on them by the security model. Each of these techniques are applied to the Secure Object-Oriented Database (SODA) security model and are evaluated with respect to their applicability difficulty and usefulness. Using the results of this analysis the authors characterize the consistency of the SODA security model.>

Currently there is a great deal of interest concerning polyinstantiation in database management systems (DBMSs). However, polyinstantiation is a specific solution to a problem faced by all secure systems, and the problem itself is not well characterized. The problem stems from the interference between subjects of different security compartments. The authors focus on this problem, which they call multiparty update conflict (MUC). They discuss and evaluate some solutions to the MUC problem, such as polyinstantiation and rigid classification. A framework for a class of MUC solutions based on polyinstantiation is described, and several intermediate solutions between rigid classification and polyinstantiation are enumerated.>

A major obstacle in implementing a rollback recovery scheme for fault tolerance in a concurrent distributed system is the domino effect. A low overhead checkpointing scheme is proposed to prevent this effect. Each process saves its state periodically. The state-save synchronization among processes is implemented by bounding clock drifts. A communication protocol that assures that all saved states are consistent is developed.>

An adaptive hierarchical routing protocol based on the extension of the new Arpanet scheme is proposed and its simulated performance is presented. The protocol can adapt to rapidly changing environments and works for arbitrarily large networks. A number of existing schemes as well as the proposed scheme are simulated under many different environments and clustering structures. The proposed protocol is found to be superior to the other protocols tested in many different types of network traffic and topological configurations. The results indicate that intercluster links must be reliable, because (1) the failure of these links can significantly degrade the routing performance, even though the protocol does not degrade as badly as the existing scheme and (2) hierarchical routing protocols usually prefer small clusters, which means that there will be many intercluster links. The tradeoff between two conflicting performance criteria, response speed and communication overhead, is shown.>

An analysis is conducted of the complexity of placing recovery points where the computation is modeled as a reverse binary tree task model. The objective is to minimize the expected computation time of a program in the presence of faults. The method can be extended to an arbitrary reverse tree model. For uniprocessor systems, an optimal placement algorithm is proposed. For multiprocessor systems, a procedure for computing their performance is described. Since no closed form solution is available, an alternative measurement is proposed that has a closed form formula. On the basis of this formula, algorithms are devised for solving the recovery point placement problem. The estimated formula can be extended to include communication delays where the algorithm devised still applies.>

The authors address the problem of error recovery in a system of distributed communication processes. They show that if each process can detect its local computation errors while establishing the recovery points, then the amount of process dependencies can be reduced by exploiting the temporal ordering of message communication among the processes. The proposed approach allows processes to proceed independently during normal computation, and can be further improved to accommodate independent rollback without explicit coordination. The authors also discuss the handling of messages that are originated from, or received by, tasks that later abort. Simulation studies indicate that the approach taken achieves a much higher throughput than the synchronous approach.>

Designing concurrent systems has been shown to be difficult due to state explosion problems. A synthesis technique using Petri nets is proposed to tackle the problem. A set of rules has been proposed to guide designers incrementally expanding Petri nets under design while maintaining the logical correctness. These rules cover the semantics of concurrency, exclusiveness, cyclicity, and interactions.>

The authors: develop mapping rules from the relational algebra to linear predicates defining relations in the (output) domain; describe how these predicates can be interpreted in the (input) domain using f/sub Q/, a specified query relation; describe a translation from these predicates to sets of systems of linear inequalities; and discuss the use of a set of systems of linear inequalities to generate complete test cases, inputs, and expected outputs from the queries using the domain testing theory. The proposed techniques support software development based on specification testing, specification-directed testing, and rapid prototyping.>

Summary form only given. Considers the kinds of software-engineering problems that can be solved by expert systems, as well as how to acquire and represent software knowledge. Other questions addressed are: (1) can expert systems development benefit from the experience in software engineering; (2) is a special design methodology required for expert systems developed; and (3) how to apply current software engineering techniques to facilitate the development of expert systems.>

Summary form only given. Discusses the applicability of the object-oriented paradigm to the stage of problem specification. The authors define some criteria that can be used to assess this applicability and show how the object-oriented approach measures up based on these criteria.>

Issues that need to be addressed concerning the application of expert-system technology to software engineering are discussed. It is concluded that one should approach expert system use in software engineering with great caution, realizing that software engineering problems are ill-structured. A strong relationship abides between the specificity of software development methodology and the applicability of expert technology. If the methodology is to be very specific, no probable need for an expert system exists due to the availability of stronger methods. If the methodology is too weak, on the other hand, the problem is likely to be too ill-defined for expert system solutions.>

The authors present a procedure for computing the cycle time of concurrent systems modeled by a restricted class of Petri nets, i.e. decision-free and safe persistent nets. The procedure is based on formulating the cycle time computation as a minimal cost-to-time ratio cycle problem. The result is an efficient algorithm with a computational complexity of O(n/sup 3/log/sub 2/ n). By using an example with a stochastic counterpart, it is shown that the results are consistent with those obtained by more complex Markov analysis.>