Wei-Chuan Lin

A forwarding model for Voronoi-based Overlay Network

An approach to build highly scalable and robust networked virtual environments (NVEs) is using the peer-to-peer overlay networks. Voronoi-based overlay network (VON) has been proposed to maintain a highly overlay topology consistency in a bandwidth- efficient manner. However, the related research requires all nodes to connect directly with their relevant neighbors. This limits the number of neighbors should appear within the area of interest (AOI) of a given node. A new forwarding model for VON is proposed to solve this problem by connecting only with the nearest neighbors that is called the enclosing neighbors (EN), and propagating the position updates information to other nodes by message forwarding. In this way, the AOI of a given node may be more flexibly expanded and different bandwidth capacities may be more efficiently utilized.

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.

Indoor Surveillance Security Robot with a Self-Propelled Patrolling Vehicle

Self-propelled patrolling vehicles can patrol periodically in the designed area to ensure the safety like men do. The proposed vehicle cannot only save manpower, but also ensure the performance without mistakes caused by man. It is different from the traditional patrolling system which is limited by the manpower and the fixed camera positions. To improve such situation, this paper proposes a self-propelled patrolling vehicle which can move automatically to a wider range and record the monitored image by IPCAM within a predefined patrolling route. Besides, the user can use the mobile device or website to connect to the vehicle at anytime and anywhere and control it to move to the position to get the indoor image user wants. The position of self-propelled vehicles can be detected by the RFID reader as a feedback and be shown on the PC screen and smart phone. The recorded images can be also transmitted back to the server via WiFi system for face tracking and discriminating analysis. On the other hand, the self-propelled vehicle patrolling routes can be modified by the Android smart-phone remote-control module. When some defined events occur, the build-in MSN module will notice users by sending messages to PC and smart phone. Experimental results are given in the paper to validate its performance.

Constructing an intelligent behavior avatar in a virtual world: a self-learning model based on reinforcement

In this paper, a novel method for personal intelligent behavior avatar (IBA) is proposed to acquire autonomous behavior based on the interactions between user and smart objects in the virtual environment. In this method, the behavior decision model and the self-learning model are integrated by Bayesian networks and reinforcement learning. The Bayesian networks can treat interaction experiences using statistical processes, and the sureness of decision making is represented by certainty factors using stochastic reasoning. The reinforcement learning is implemented by learning experimentation or trial and error mechanisms to improve the performance of IBA through feedback. Therefore, the IBA makes a strategic decision that is approximated and appropriate to the user through the self-learning process by reinforcement learning. Finally, the feasibility of this method is investigated by imitating users behavior and the results of self-learning process. The results of simulation show that the method is successful in imitating users behavior and improving the performance of IBA.

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.

Tools cooperation in an integration environment by message-passing mechanism

Many CASE (computer aided software engineering) tools have been developed to increase software productivity. Therefore, tool integration needed more investigation. This paper proposes an architecture based on a control integration platform for exchanging messages among different tools. This platform supports different tools to integrate into a cooperative software development environment easily. Some tools including a compiler, editor and testing path analyzer are integrated into this environment. Some evaluation criteria are illustrated to assess the proposed platform and their integrated tools.<<ETX>>