Chi-Ming Chung

Task decomposition testing and metrics for concurrent programs

Software testing and metrics are two important approaches to assure the reliability and quality of software. The emergence of concurrent programming in recent years introduces new testing problems and difficulties that cannot be solved by testing techniques for traditional sequential programs. One of the difficult tasks is that concurrent programs can have many instances of execution for the same set of input data. Many concurrent program testing methodologies propose to solve controlled execution and determinism. There are few discussions of concurrent software testing from the inter-task viewpoints. Yet, the common characteristics of concurrent programming are explicit identification of the large grain parallel computation units (tasks), and the explicit inter-task communication via rendezvous-style mechanisms. In this paper, we focus on testing concurrent programs through task decomposition. We propose four testing criteria to test a concurrent program. The programmer can choose an appropriate testing strategy depending on the properties of the concurrent program. Associated with the strategies, four equations are provided to measure the complexity of concurrent programs.

A knowledge abstraction approach for multimedia presentation

The demonstration of multimedia presentation can be promoted by using multi-vendors tools. The more tools are used, the more complicated communication is needed among these tools. The integration of these multimedia presentation tools is thus important. This paper describes an architecture named tool integration platform (TIP) to integrate tools in a knowledge abstraction way. TIP is composed of a CID (control integration daemon), a CII (control integration interface) and some integration inference rules (IIR) that are applied by the integration inference engine (IIE). The IIR are stored in a repository and used to deduce tool knowledge dynamically. In this way, many tools can be integrated into a cooperative multimedia presentation developing environment. To verify this architecture, a number of multimedia tools are integrated into TIP. Finally, an integration assessing method is used to evaluate the integration status of tools in TIP.

Software testing and metrics for concurrent computation

Verification and validation are two important technologies to assure the reliability and quality of software. Software testing and metrics are two approaches to execute the verification and validation. In sequential computation, a fairly mature process exists, with various methodologies and tools available for use in building and demonstrating the correctness of a program being tested. The emergence of concurrent computation in recent years, however, introduces new testing problems and difficulties that cannot be solved by the traditional sequential program testing techniques. Many concurrent program testing methodologies have been proposed to solve controlled execution and determinism. There have been few discussions of concurrent software testing from the inter-task viewpoint, even though the common characteristics of concurrent programming are the explicit identification of the large-grain parallel computation units (tasks) and the explicit inter-task communication via a rendezvous-style mechanism. In this paper, we focus on testing concurrent programs through task decomposition. We propose four testing criteria to test a concurrent program. A programmer can choose an appropriate testing strategy depending on the properties of the concurrent programs. Associated with the strategies, four equations are provided to measure the complexity of concurrent programs.

Decomposition of inheritance hierarchy DAGs for object-oriented software metrics

Software metrics are widely used to measure software complexity and assure software quality. However, research in the field of software complexity measurement of a class hierarchy has not yet been carefully studied. The authors introduce a novel factor called unit repeated inheritance (URI) and an important method called the inheritance level technique (ILT) to realize and measure the object-oriented software complexity of a class hierarchy. The approach is based on the graph-theoretical model for measuring the hierarchical complexity in inheritance relations. The proposed metrics extraction shows that inheritance is closely related to the object-oriented software measurement and reveals that overuse of the repeated (multiple) inheritance will increase software complexity and be prone to implicit software errors.

On automatic generation of multimedia presentations

Abstract We propose a mechanism and system for the automatic generation of interactive multimedia presentations from their specifications. A presentation specification contains three parts: the resources, the temporal information, and the spatial information. We use an ICON programming technique, and a graphical user interface allows the presentation designer to quickly specify what he/she wants. Our system takes these requirements and relies on inference rules written in Prolog to generate interactive presentations. These inference rules are based on interval temporal logic and important issues in multimedia presentations,l such as the hardware limitations of an ordinary personal computer and the properties of a multimedia resource. Our prototype system runs under MS Windows. The early experience of using the system shows that it is feasible to use logic inference rules to assist the design of good multimedia presentations.

Object-oriented software testing and metric in Z specification

Software testing and metrics are key issues to improve software quality. They are important issues in the research of software engineering. In line with the methodologies of object-oriented analysis and design widely developed, many testing and metrics techniques have been proposed. However, not many focus on the testing criteria and metrics evaluation of an inheritance hierarchy. In this paper, we introduce a concept named unit repeated inheritance (URI) in Z to realize object-oriented testing and object-oriented metrics. The approach describes an inheritance level technique (ILT) method as a guide to test and measure the software complexity of an inheritance hierarchy. The measurement of inheritance metrics and some testing criteria thus can be formed based on the proposed mechanism.

Distributed monitoring architecture for movable objects over the GSM system

With the popularity of the network, many applications have been designed to be a distributed system. The more distance for communication, the more hardware and lines for communication are needed. As the GSM has been widely used for telecommunication, it can also be applied to the wireless communication. This paper proposes a wireless monitoring architecture based on the GSM system and takes a car system as a test case. The proposed architecture is divided into three parts. The first is that the data collected from the sensor are sent to the GSM provider by the simulated message of GSM. The second is that the GSM provider processes the received data. To reduce the transmission traffic, a dead-reckoning algorithm is applied to decide whether the process result should be sent to the monitoring center or not. The third is that the monitoring center receives the data which are sending from the GSM provider to give advises to the car driver. With the help of this proposed architecture, a wireless monitoring architecture based on GSM system is verified. In addition, the monitoring center can combine with the GIS to display the car status in an electronic map.

Tool integration in a knowledge abstraction environment

Abstract The productivity of a programmer can be promoted by using multi-vendors CASE tools. The more tools are used, the more complicated communication is needed. The integration of these tools is thus important. This paper describes an architecture named Tool Integration Platform (TIP) to integrate tools in a knowledge abstraction way. TIP is composed of a Control Integration Daemon (CID), a Control Integration Interface (CII) and some Integration Inference Rules (IIR) that are applied by the Integration Inference Engine (IIE). The IIR are stored in a Repisotory and used to deduce tool knowledge dynamically. In this way, many tools can be integrated into a cooperative software environment. To verify this architecture, a number of tools including an editor, a test analyzer, the existing compilers and tracers are integrated into TIP. Finally, a number of compared components are used to assess the TIP with other environments and standards.

Software testing and metrics for concurrent computation through task decomposition

Software testing is an important approach to assure the reliability and quality of software. Sequential programming testing is a fairly sophisticated process and concurrent programming has emerged in the past few years. Some concurrent program testing methodologies are proposed to solve controlled execution and determinism. However, there are few discussions of concurrent software testing from the inter-task viewpoint. The paper focuses the testing view on concurrent programming through task decomposition. Four testing criteria are proposed to test a concurrent program. The programmer can choose an appropriate testing strategy depending on the properties of concurrent programs. A coverage criteria hierarchy is provided. Moreover, two suggestions for concurrent programming based on rendezvous complexity are made.

Integration Object-Oriented Software Testing and Metrics

Software testing methodologies and metrics are key issues to improve and assure software quality. They are important areas in the research of Software Engineering. However, not many focus on the testing criteria and metrics evaluation of a class hierarchy. This paper introduces an important concept named URI (Unit Repeated Inheritance) to realize integrated object-oriented testing and object-oriented metrics. The approach describes an ILT (Inheritance Level Technique) method as a guide to test object-oriented software errors and measure the software complexity of a class hierarchy. The proposed technique shows that inheritance has a close relation to object-oriented software complexity and reveals that overuse of repeated(multiple) inheritance will increase software complexity and be prone to implicit software errors. Also, two test criteria: intra level first and inter level first are presented.