Search

The HTTP adaptive streaming technique opened the door to cope with the fluctuating network conditions during the streaming process by dynamically adjusting the volume of the future chunks to be downloaded. The bitrate selection in this adjustment inevitably involves the task of predicting the future throughput of a video session, owing to which various heuristic solutions have been explored. The ultimate goal of the present work is to explore the theoretical upper bounds of the QoE that any ABR algorithm can possibly reach, therefore providing an essential step to benchmarking the performance evaluation of ABR algorithms. In our setting, the QoE is defined in terms of a linear combination of the average perceptual quality and the buffering ratio. The optimization problem is proven to be NP-hard when the perceptual quality is defined by chunk size and conditions are given under which the problem becomes polynomially solvable. Enriched by a global lower bound, a pseudo-polynomial time algorithm along the dynamic programming approach is presented. When the minimum buffering is given higher priority over higher perceptual quality, the problem is shown to be also NP-hard, and the above algorithm is simplified and enhanced by a sequence of lower bounds on the completion time of chunk downloading, which, according to our experiment, brings a 36.0% performance improvement in terms of computation time. To handle large amounts of data more efficiently, a polynomial-time algorithm is also introduced to approximate the optimal values when minimum buffering is prioritized. Besides its performance guarantee, this algorithm is shown to reach 99.938% close to the optimal results, while taking only 0.024% of the computation time compared to the exact algorithm in dynamic programming.

With internet video gaining increasing popularity and soaring to dominate network traffic, extensive studies are being carried out on how to achieve higher Quality of Experience (QoE) with the delivery of video content. Associated with the chunk-based streaming protocol, Adaptive Bitrate (ABR) algorithms have recently emerged to cope with the diverse and fluctuating network conditions by dynamically adjusting bitrates for future chunks. This inevitably involves predicting the future throughput of a video session. Some of the session features like Internet Service Provider (ISP), geographical location, and so on, could affect network conditions and contain helpful information for this throughput prediction. In this article, we consider how our knowledge about the session features can be utilized to improve ABR quality via customized parameter settings. We present our ABR-independent, QoE-driven, feature-based partition method to classify the logged video sessions so that different parameter settings could be adopted in different situations to reach better quality. A variation of Decision Tree is developed for the classification and has been applied to a sample ABR for evaluation. The experiment shows that our approach can improve the average bitrate of the sample ABR by 36.1% without causing the increase of the rebuffering ratio where 99% of the sessions can get improvement. It can also improve the rebuffering ratio by 87.7% without causing the decrease of the average bitrate, where, among those sessions involved in rebuffering, 82% receives improvement and 18% remains the same.

Generating contextually coherent responses has been one of the most critical challenges in building intelligent dialogue systems. Key issues are how to appropriately encode contexts and how to make good use of them during the generation. Past works either directly use (hierarchical) RNN to encode contexts or use attention-based variants to further weight different words and utterances. They tend to learn dispersed focuses over all contextual information, which contradicts the facts that humans tend to respond to certain concentrated semantics of contexts. This leads to the results that generated responses are only show semantically related to, but not precisely coherent with the given contexts. To this end, this paper proposes a contextually coherent dialogue generation (ConDial) method by first encoding contexts into structured semantic vectors using self-attention, and then adaptively choosing key semantic vectors to guide the response generation. Based on the structured semantics, it also develops a calibration mechanism with a dynamic vocabulary during decoding, which enhances exact coherent expressions by adjusting word distribution. According to the experiments, ConDial shows better generative performance than state-of-the-arts and is capable of generating responses that not only continue the topics but also keep coherent contextual expressions.

Dental informatics is a relatively new research field, but its publication has been steadily increasing in the past decade. Altmetric is a platform that collects information from different web sources and combines it together into a citation-based metric for researchers, publishers, and institutions. It tracks the attention that research outputs (such as scholarly articles and datasets) receive online. Altmetric Explorer is an easy-to-use web-based platform that enables users to browse and report on all attention data for a given scholarly output (including journal articles and dataset). Given the nature of dental informatics, research is quite practical. The purpose of this study is to perform an Altmetric analysis to systematically study research trends on dental informatics. The study identifies various aspects of research outputs on dental informatics (attention scores, a timeline of mentions, yearly publication total, top ten journals, top 15 affiliation of first authors, and top five mention categories) that would be of interest to both researchers and practitioners in the field. In conclusion, dental informatics needs more publicity. Although there is an increase in multiple aspects (such as social media mentions and publications) in dental informatics research, it is not enough to match other popular fields.

Present military forces need to prepare for increasingly varied and complex situations and maintain the readiness of their warfighters for several different scenarios. There is a constant challenge of working with limited resources people, time, and funding. Military leaders are seeking new training technologies that can meet their goals better, faster, and cheaper. Virtual Reality (VR) and Augmented Reality (AR) have emerged as extremely useful technologies for developing new training tools since they allow for easy creation and maintenance of multiple scenarios and environments. Using AR/VR for training lowers the travel and living costs associated with bringing the trainees to a central training facility, while still completely immersing the trainees in the environment. Another advantage of using AR/VR compared to traditional tools is that by using AR/VR, trainees are completely immersed in the environment, which makes it much more natural for them to consume the training material. At GE Research, we are exploring technologies to incorporate Artificial Intelligence (AI) methodologies in an immersive VR based training environment for warfighters. We have developed an AI assisted VR system for ground soldier training. In this VR training environment, the soldier (Blue Team/Blue Force) is teamed up with an AI assistant that will help them navigate an urban setting and successfully reach their goal in a stealth mode while escaping the gaze of enemy soldiers (Red Team/Red Force). We have used AI enabled virtual humans for the enemy soldiers. In addition, we have created an AI enabled, VR drone simulation to assist the dismounted soldier to move undetected through the environment.

Information Extraction (IE) from scientific texts can be used to guide readers to the central information in scientific documents. But narrow IE systems extract only a fraction of the information captured, and Open IE systems do not perform well on the long and complex sentences encountered in scientific texts. In this work we combine the output of both types of systems to achieve Semi-Open Relation Extraction, a new task that we explore in the Biology domain. First, we present the Focused Open Biological Information Extraction (FOBIE) dataset and use FOBIE to train a state-of-the-art narrow scientific IE system to extract trade-off relations and arguments that are central to biology texts. We then run both the narrow IE system and a state-of-the-art Open IE system on a corpus of 10K open-access scientific biological texts. We show that a significant amount (65%) of erroneous and uninformative Open IE extractions can be filtered using narrow IE extractions. Furthermore, we show that the retained extractions are significantly more often informative to a reader.

In the era of big data, the vast majority of the data are not from the surface Web, the Web that is interconnected by hyperlinks and indexed by most general purpose search engines. Instead, the trove of valuable data often reside in the deep Web, the Web that is hidden behind query interfaces. Since numerous applications, like data integration and vertical portals, require deep Web data, various crawling methods were developed for exhaustively harvesting a deep Web data source with the minimal (or near-minimal) cost. Most existing crawling methods assume that all the documents matched by queries are returned. In practice, data sources often return the top k matches. This makes exhaustive data harvesting difficult: highly ranked documents will be returned multiple times, while documents ranked low have small chance being returned. In this paper, we decompose this problem into two orthogonal sub-problems, i.e., query and ranking bias problems, and propose a document frequency based crawling method to overcome the ranking bias problem. The rational of our method is to use the queries whose document frequencies are within the specified range to avoid the effect of search ranking plus return limit and significantly reduce the difficulty of crawling ranked data source. The method is extensively tested on a variety of datasets and compared with two existing methods. The experimental result demonstrates that our method outperforms the two algorithms by 58 % and 90 % on average respectively.

While Internet video control and data planes have received much research attention, little is known about the video management plane. In this paper, using data from more than a hundred video publishers spanning two years, we characterize the video management plane and its evolution. The management plane shows significant diversity with respect to video packaging, playback device support, and CDN use, and current trends suggest increasing diversity in some of these dimensions. This diversity adds complexity to management, and we show that the complexity of many management tasks is sub-linearly correlated with the number of hours a publisher's content is viewed. Moreover, today each publisher runs an independent management plane, and this practice can lead to sub-optimal outcomes for syndicated content, such as redundancies in CDN storage and loss of control for content owners over delivery quality.

Most content providers are interested in providing good video delivery QoE for all users, not just on average. State-of-the-art ABR algorithms like BOLA and MPC rely on parameters that are sensitive to network conditions, so may perform poorly for some users and/or videos. In this paper, we propose a technique called Oboe to auto-tune these parameters to different network conditions. Oboe pre-computes, for a given ABR algorithm, the best possible parameters for different network conditions, then dynamically adapts the parameters at run-time for the current network conditions. Using testbed experiments, we show that Oboe significantly improves BOLA, MPC, and a commercially deployed ABR. Oboe also betters a recently proposed reinforcement learning based ABR, Pensieve, by 24% on average on a composite QoE metric, in part because it is able to better specialize ABR behavior across different network states.

Computer-Aided Biomimetics (CAB) tools aim to support the integration of relevant biological knowledge into biomimetic problem-solving processes. Specific steps of biomimetic processes that require support include the identification, selection and abstraction of relevant biological analogies. Existing CAB tools usually aim to support these steps by describing biological systems in terms of functions, although engineering functions do not map naturally to biological functions. Consequentially, the resulting static, functional view provides an incomplete understanding of biological processes, which are dynamic, cyclic and self-organizing. This paper proposes an alternative approach that revolves around the concept of trade-offs. The aim is to include the biological context, such as environmental characteristics, that may provide information crucial to the transfer of biological information to an engineering application. The proposed design process is exemplified by an illustrative case study.

The interdisciplinary character of Bio-Inspired Design (BID) has resulted in a plethora of approaches and methods that propose different types of design processes. Although sustainable, creative and complex system design processes are not mutually incompatible they do focus on different aspects of design. This research defines areas of focus for the development of computational tools to support biomimetics, technical problem solving through abstraction, transfer and application of knowledge from biological models. An overview of analysed literature is provided as well as a qualitative analysis of the main themes found in BID literature. The result is a set of recommendations for further research on Computer-Aided Biomimetics (CAB).

The introduction of multiple remote testers to apply a test or checking sequence in a test architecture brings out the possibility of controllability and observability problems. These problems often require the use of external coordination message exchanges among testers. In this paper, we consider constructing a test or checking sequence from the specification of the system under test such that it will be free from these problems and will not require the use of external coordination messages. We give an algorithm that can check whether it is possible to construct subsequences from a given specification that eliminate the need for using external coordination message exchanges, and when it is possible actually produces such subsequences.

Modern biological and chemical studies rely on life science databases as well as sophisticated software tools (e.g., homology search tools, modeling and visualization tools). These tools often have to be combined and integrated in order to support a given study. SIBIOS (System for the Integration of Bioinformatics Services) serves this purpose. The services are both life science database search services and software tools. The task engine is the core component of SIBIOS. It supports the execution of dynamic workflows that incorporate multiple bioinformatics services. The architecture of SIBIOS, the approaches to addressing the heterogeneity as well as interoperability of bioinformatics services, including data integration are presented in this paper.

The development of GUI-based applications has raised a lot of new issues, one of them being how to automate effective testing for applications with complicated graphical user interactions. In this paper, we discuss the architectural issues and the implementation concerns of our approach to an automated specification-based testing technique for GUI-based applications. This approach is carried out by enriching existing architecture for automated specification-based testing. An essential part of our work is a visual environment to obtain test specifications. This environment pre-runs the Application Under Test (AUT) under its own control, with two prominent characteristics: First, testers can edit test specifications within the true GUI environment of the AUT. Second, the recorded input and output contain the same references as those in the AUT, so that the test cases generated from the edited specification can be used directly by test oracles during the automated testing procedure. We present our running prototype of a visual specification editor that allows users to graphically manipulate test specifications when these specifications are given in term of Finite State Machines (FSM) and the implementations of the AUT are GUI-based Java applications.

The deep web crawling is the process of collecting data items inside a data source hidden behind searchable interfaces. Since the only method to access the data is by sending queries, one of the research challenges is the selection of a set of queries such that they can retrieve most of the data with minimal network traffic. This is a set covering problem that is NP-hard. The large size of the problem, in terms of both large number of documents and terms involved, calls for new approximation algorithms for efficient deep web data crawling. Inspired by the TF-IDF weighting measure in information retrieval, this paper proposes the TS-IDS algorithm that assigns an importance value to each document proportional to term size (TS), and inversely proportional to document size (IDS). The algorithm is extensively tested on a variety of datasets, and compared with the traditional greedy algorithm and the more recent IDS algorithm. We demonstrate that TS-IDS outperforms the greedy algorithm and IDS algorithm up to 33% and 24%, respectively. Our work also makes a contribution to the classic set covering problem by leveraging the long-tail distributions of the terms and documents in natural languages. Since long-tail distribution is ubiquitous in real world, our approach can be applied in areas other than the deep web crawling.

Distributed multithreaded software systems are becoming more and more important in modern networked environment. For these systems, concurrency control and thread synchronization make it much harder to do traditional extensive testing to guarantee the quality of the systems. In contrast to testing, software verification under certain formalisms and methodologies usually gives us higher confidence about the system. In this paper, we consider translating some parts of program code that are sensitive to concurrency control into certain formal description so that we can reuse existing verification tools to enhance our confidence in the final code. Java language is gaining increasing popularity in distributed multithreaded system development, and CCS is one of the convenient tools for describing concurrent and multi-process systems. Under a set of reasonable restrictions, we present a general framework on how to translate the thread control and synchronization portion of distributed, multithreaded Java programs into formal specification in CCS. With the translated process terms, we are able to use some model checkers to verify properties expressed in modal μ-calculus, such as invariance, eventualities, fairness etc, which are by nature hard to test.

Correct navigational behavior of a web application is essential to its reliability. An effective means to improve our confidence in the correct behavior of a web application is to test it by exploring the possible navigation among the webpages at client side: The tester carries out the testing by consecutively clicking the hyperlinks along with some possible search parameters and checking whether the returned webpages are as expected. This type of client-side testing can be viewed as a traverse in a graph representing the considered webpages together with the hyperlinks among them. To reach an efficient test that traverses all hyperlinks considered, we make use of the interface provided by web browsers, typically, the goto menu. In doing so, the issues raised by cookies and URL rewriting are taken into account. Compared to the case without using the interface of web browsers, our experiments show a 17%-24% saving on the test sequence lengths in most cases.

Crawling the deep web often requires the selection of an appropriate set of queries so that they can cover most of the documents in the data source with low cost. This can be modeled as a set covering problem which has been extensively studied. The conventional set covering algorithms, however, do not work well when applied to deep web crawling due to various special features of this application domain. Typically, most set covering algorithms assume the uniform distribution of the elements being covered, while for deep web crawling, neither the sizes of documents nor the document frequencies of the queries is distributed uniformly. Instead, they follow the power law distribution. Hence, we have developed a new set covering algorithm that targets at web crawling. Compared to our previous deep web crawling method that uses a straightforward greedy set covering algorithm, it introduces weights into the greedy strategy. Our experiment carried out on a variety of corpora shows that this new method consistently outperforms its un-weighted version.

Crawling deep web is the process of collecting data from search interfaces by issuing queries. With wide availability of programmable interface encoded in web services, deep web crawling has received a large variety of applications. One of the major challenges crawling deep web is the selection of the queries so that most of the data can be retrieved at a low cost. We propose a general method in this regard. In order to minimize the duplicates retrieved, we reduced the problem of selecting an optimal set of queries from a sample of the data source into the well-known set-covering problem and adopt a classical algorithm to resolve it. To verify that the queries selected from a sample also produce a good result for the entire data source, we carried out a set of experiments on large corpora including Wikipedia and Reuters. We show that our sampling-based method is effective by empirically proving that 1) The queries selected from samples can harvest most of the data in the original database; 2) The queries with low overlapping rate in samples will also result in a low overlapping rate in the original database; and 3) The size of the sample and the size of the terms from where to select the queries do not need to be very large.

The introduction of multiple remote testers to apply a test or checking sequence introduces the possibility of controllability and observability problems. These problems can require the use of external coordination message exchanges among testers. It is desirable to construct a test or checking sequence from the specification of the system under test such that it is free from these problems without requiring the use of external coordination messages. Here we define criteria on the specification of the system under test for this to be possible. For specifications satisfying the criteria, algorithms for constructing subsequences that eliminate the need for external coordination messages are given.

Testing each component in isolation is not always feasible. We consider FSM-based deterministic testing on an Implementation Under Test (IUT) together with some other correctly implemented components as its context. The behavior of the context needs to be taken into account for generating test sequences. We employ model checking tools to retrieve necessary information from the context specification so that a test suite for the IUT integrated with its context can be generated. The use of model checking tools frees us from the necessity of constructing the global model of the IUT and its context, and thus helps avoid the state explosion problem. In the current work, we consider the situations when the context is an embedded system, i.e. it communicates and only communicates with the IUT. In this setting, we present a method to derive a completetest suite that can be used to check for trace pre-order between the FSM representing the integrated implementation of the IUT and its context and the synchronous product of the specification FSM of the IUT and that of its context.

Explosion of information and increasing demands on semantic processing Web applications have pushed software systems to their limits. To address this problem, we propose a semantic-based formal framework (ADP) that makes use of promising technologies to enable knowledge generation and retrieval. We argue that this approach is costeffective, as it reuses and builds on existing knowledge and structure. It is also a good starting point for creating an Organizational Memory and providing Knowledge Management functions.

The quality of our daily life is getting more and more dependent on the quality of many important Web applications running on the Internet. With the rapid evolutions of the Web applications, effective maintenance techniques to guarantee the correctness of the evolutions are highly demanded. We present our initial work on exploring automated verification techniques for this purpose, via algebraic reasoning and model checking on the abstract navigational behavior of the evolving Web applications expressed in labelled transition systems, against the desired properties expressed in temporal logic formulas combined with tree automata.

When an implementation under test (IUT) is state-based, and its expected abstract behavior is given in terms of a finite state machine (FSM), a checking sequence generated from the specification FSM and applied on the lUTfor testing can provide us with high-level confidence in the correct functional behavior of our implementation. One of the issues here is to generate efficient checking sequences in terms of their lengths. In this paper, we discuss the possibility of reducing the lengths of checking sequences by making use of the invertible transitions in the specification FSM to increase the choice of betasequences to be included into a checking sequence. We present a sufficient condition for adopting alternative beta-sequences and illustrate a possible way of incorporating these alternative beta-sequences into existing methods for checking sequence generation to further reduce their lengths.

Conformance testing has been extensively studied in the context where the desired behavior of the implementation under test is modeled in terms of finite state machines. An essential issue in FSM-based conformance testing is to generate from a given finite state machine a test sequence that is both effective in detecting the faults in the implementation under test and efficient in terms of its length. In this paper, we consider test sequences satisfying the test criterion of the U-method as they have been proved to have high fault detectability. We present our solution to reduce the length of such a test sequence by maximizing the overlap among the test segments through the use of invertible sequences.

Distributed applications are usually concurrent and nondeterministic. For this reason, formal verification on their design specifications is an essential technique for us to gain more confidence in the correctness of the behavioral aspects of our design before putting them into coding stage. Message-Oriented Middleware (MOM) is widely used to simplify the task of interprocess communications in distributed applications. To model the MOM-based applications for verification purpose, the services provided by MOM must also be integrated into the models. However, MOM modeling is non-trivial. While providing highlevel program interfaces which shield programmers from the complexity of the underlying operating systems and networks, MOM may also conceals under such interfaces the concurrency and nondeterminism present in the underlying networks. This increases the possibility of misinterpretting the behavior of the applications, which in turn causes design errors. An over-abstracted MOM model based on Application Programming Interface may bury such design errors while an over-detailed model may consume too much resource and render the verification infeasible. As a guideline for MOM modeling, we present several formal models of various behavioral aspects of MOM in terms of Promela, the specification language used in SPIN model checker. Based on our empirical study, we also discuss the impact of incorporating these formal models in different settings into the MOM-based application models, in terms of increased state space for model checking.

Finite-state-machine-based conformance testing has been extensively studied in the literature in the context of centralized test architecture. With a distributed test architecture which involves multiple remote testers, the application of a test sequence may encounter controllability problems. One of the possible solutions to overcome this problem is to carefully select a suitable test sequence so that its application to the implementation under test will not involve controllability problems. A common problem in doing so is to generate a test sequence, avoiding controllability problems during its application in the test procedure, so that all given test segments have been contained in the test sequence. In this paper, we present an optimal solution to this problem, taking into account possible overlaps among the test segments.

Input-Predicate/Output (IP/O)_{n}-chains coverage criterion, originally proposed for black-box testing of telecommunications software, is adapted to white-box testing of programs written in block-structured languages. This criterion is based on the analysis of the effects of inputs on predicates and outputs in a program. It requires that each such effect in a program is examined at least once during testing and thus provides a means of capturing the implemented functionality and checking the consistency of the program with respect to its functional requirements. It is shown that its fault-detecting ability is higher than the all-uses criterion, and compares favorably with the required k-tuples^+ criterion.

Application of a test or checking sequence in a distributed test architecture often requires the use of external coordination message exchanges among multiple remote testers for eluding potential controllability and observability problems. Recent literature reports on conditions on a given finite state machine (FSM) under which controllability and observability problems can be overcome without using external coordination messages. However, these conditions do not guarantee that any test/checking sequence constructed from such FSMs are free from controllability and observability problems. For a given test or checking sequence, this paper investigates whether it is possible to eliminate the need for external coordination messages and proposes algorithms to identify or construct subsequences either within the given sequence or as an extension to the given sequence, respectively.

Finite-state-machine-based conformance testing has been extensively studied in the literature in the context of centralized test architecture. With a distributed test architecture which involves multiple remote testers, the application of a test sequence may encounter controllability problems. This problem can be overcome by introducing additional external coordination messages exchanged among remote testers. Such an approach requires for extra resources for the communication among remote testers and sometimes suffers from unexpected delay. It is thus desirable to avoid the controllability problem by selecting suitable test sequences. However, this is not always possible. For some finite state machines, we cannot generate a test sequence without using external coordination messages and apply it without encountering controllability problems during testing. In this paper, we present sufficient and necessary conditions on a given finite state machine for constructing test sequences so that it does not involve external coordination messages and its application to the implementation under test is free from controllability problems.

Distributed multithreaded software systems are becoming more and more important in modern networked environment. For these systems, concurrency control and thread synchronization make it much harder to do traditional extensive testing to guarantee the quality of the systems. In contrast to testing, software verification under certain formalisms and methodologies usually gives us higher confidence about the system. In this paper we consider translating some parts of program code that are sensitive to concurrency control into certain formal description so that we can reuse existing verification tools to enhance our confidence in the final code. Java language is gaining increasing popularity in distributed multithreaded system development, and CCS is one of the convenient tools for describing concurrent and multi-process systems. Under a set of reasonable restrictions, we present a general framework on how to translate the threaded control and synchronization portion of distributed multithreaded Java programs into formal specification in CCS. With the translated process terms, we are able to use some model checkers to verify properties expressed in modal /spl mu/-calculus, such as invariance eventualities, fairness etc., which are by nature hard to test.

Under certain well–defined conditions, determining the correctness of a system under test (SUT) is based on a checking sequence generated from a finite state machine (FSM) specification of the SUT. When there is a distinguishing sequence for the FSM, an efficient checking sequence may be produced from the elements of a set Eα′ of α′-sequences that verify subsets of states and the elements of a set EC of subsequences that test the individual transitions. An optimization algorithm may be used in order to produce a shortest checking sequence by connecting the elements of Eα′ and EC using transitions drawn from an acyclic set. Previous work did not consider whether some transition tests may be omitted from EC. This paper investigates the problem of eliminating subsequences from EC for those transitions that correspond to the last transitions traversed when a distinguishing sequence is applied in an α′–sequence to obtain a further reduction in the length of a checking sequence.

The introduction of multiple remote testers to apply a test or checking sequence in a test architecture brings out the possibility of controllability and observability problems. These problems often require the use of external coordination message exchanges among testers. In this paper, we consider constructing a test or checking sequence from the specification of the system under test such that it will be free from these problems and will not require the use of external coordination messages. We give an algorithm that can check whether it is possible to construct subsequences from a given specification that eliminate the need for using external coordination message exchanges, and when it is possible actually produces such subsequences.

While providing better performance, transparency and expressiveness, the main features of the web technologies such as web caching, session and cookies, dynamically generated web pages etc. may also affect the correct understanding of the web applications running on top of them. From the viewpoint of formal verification and specification-based testing, this suggests that the formal models of the web applications we use for static analysis or test case generation should subsume the abstract behavior of their supporting environment. Here we provide the definition of such a model in terms of labelled transition systems from a given abstract description of the navigations of a web application by incorporating the abstract behavioral model of the web browsers in the presence of session control and browser cache. The significance of the work is twofold: on one hand, it provides a formal basis for better understanding of the web systems; on the other hand, it lays the ground work for both model checking and specification-based testing on the web applications where we take into account the affect of the internal mechanism to the correct web navigations, which can be quite sensitive to the security of the information they carry.

Middleware interceptors are a well-recognized powerful technique that enables the extensions of the middleware functionality in a way transparent to both the existing middleware implementations and the distributed applications built on top of them. In recent CORBA specifications, OMG has provided the standard specification of portable interceptors. This specification determined the interception service that any CORBA implementation should provide. As a well-known middleware however, Java RMI did not offer the interception mechanism. Based on our experiment, we address in this paper, the architectural and design issues on embedding interception service into the existing implementation of Java RMI from SUN Microsystems. Our interception service follows the style and the functionality of CORBA interception service to support request portable interceptors.

Controllability and observability problems may manifest themselves during the application of a test or checking sequence in a test architecture where there are multiple remote testers. These problems often require the use of external coordination message exchanges among testers during testing. It is desired to construct a test or checking sequence from the specification of the system under test such that it will be free from these problems without requiring the use of external coordination messages. This paper investigates conditions that allow us to construct such a test or checking sequence. For specifications satisfying these conditions, procedures for constructing subsequences that eliminate the need for using external coordination messages are given.

Nowadays, many distributed applications take advantage of the transparent distributed object systems provided by CORBA middlewares. While greatly reduce the design and coding effort, the distributed object systems may also introduce subtle faults into the applications, which on the other hand, complicate the validation of the applications. In this paper, we present our work on applying SPIN to check the correctness of the designs of CORBA-based applications, taking into account those characteristics of CORBA that are essential to the correctness of the applications. In doing so, we provide adaptations to UML, so that the CORBA-based applications can be modeled with succinct yet sufficient details of the underlying middlewares. An automated translation tool is developed to generate Promela models from such UML design models. The translation tool embeds the behavioral details of the middleware automatically. In this way, the software developers can stay in their comfort zone while design faults, including those caused by the underlying distributed object systems can be pinpointed through the verification or the simulation with SPIN.

Executions with internal nondeterministic choices make the testing procedure non-repeatable. A natural solution is to artificially enforce and direct the execution to take the desired path so that a test can be reproduced. With geographically distributed processes and heterogeneous platform architectures, distributed systems have raised new dimensions of challenges to develop effective techniques for the reproducible testing. In this paper, we discuss the architectural and design issues on constructing an environment to automate such a testing for distributed Java applications. Our focus is on controlling the order of input and remote call events in the application under test during the test procedure. The testing environment is by itself distributed and does not require code intrusion.

One of the difficulties in testing concurrent systems comes from the fact that executions with internal nondeterministic choices make the testing procedure non-repeatable. A natural solution is to artificially enforce and direct the execution to take the desired path so that a test can be reproduced. With a reproducible testing technique, we use a set of test scenarios which consist of pairs of test cases and path constraints, the latter expressing the ordering among certain interesting events during the execution. We consider the automated generation of significant sets of path constraints with a given test case, and we are interested in those sets of path constraints that reflect the possible serializations upon synchronization events during the executions of different processes in the program. Here we present our study on exploring formal engineering methods to generate path constraints when the synchronization events are governed by monitors.

Reproducible testing is one of the effective ways to perform or repeat a desired test scenario in concurrent systems. When we apply it to distributed systems where remote calls are used as communication facilities, new deadlocks may be introduced when we incorporate the test control mechanism to the execution of the program under test. A static analysis technique has been thus explored to solve this problem. Using the static analysis, we can derive a test model from a given test constraint. This test model is then used in the test control procedure to help the test controller to avoid deadlocks. The test constraint carries information of not only the constraint from the test users, but also the program structure related to the remote calls. In this paper, we present our work on the automated construction of such test constraints from user's input and the program source code.

As more and more applications now involve graphical user's interactions, an essential issue we are facing is how to automate effective testing on GUI-based applications. Many factors have contributed to the new dimensions of the complexity in the automated testing in this regard, one of them being how to properly characterize the graphical user's input from the prospective of test users. Here we propose a possible way of characterizing graphical user's input. This treatment is used in our prototype implementation of an automated tool to support the testing of the presentation logic in GUI-based applications. It plays an important role in enhancing the scalability of this testing environment with respect to the various types of graphical user's input. We introduce the respect enhancement and discuss the important design issues in it.

Programming in Java Swing and AWT can be quite error-prone due to the implicit nondeterminism caused by the complex event handling realized via multithreading. In this work, we provide a framework on formal modelling of Java GUI event handling in terms of labelled transition systems. The significance of the work is twofold: on one hand, it provides a formal basis for a better understanding and correct use of Java GUI event handling mechanism; on the other hand, it lays the ground work for formally reasoning about the correctness of a GUI-based Java application against certain properties that, due to the nondeterminism involved, may be hard to detect.

As testing has always been our primary device to gain the confidence in the correctness, robustness, and reliability of a system, a typical issue in web engineering is how to automate effective testing on web applications. Many factors have contributed to the new dimensions of the complexity in the automated testing in this regard. Here we present our work in progress towards the specification-based testing of the presentation logic in web applications. This work is realized by extending an existing testing technique for window-based applications.

Reproducible testing is one of the effective ways to perform or repeat a desired test scenario in concurrent systems. This technique can be naturally applied to distributed environments as well. However, when it is applied to distributed systems where remote calls are used as communication facilities, new deadlocks may be introduced when we incorporate the test control mechanism to the execution of the program under test. In this paper, we present our work on using static analysis technique to solve this problem.

Humpback whale song research has focused on analyzing the full song structure rarely describing individual song units. Even less progress has been made in automatically distinguishing and classifying these individual units. Two different techniques were employed to study their call units, visual/aural and automated/statistical. Humpback whale songs were recorded in the Hawaiian Islands both remotely with an autonomous acoustic recorder and by a snorkeler with a portable digital tape recorder. Humpback whale song units collected by the autonomous acoustic recorders were aurally separated into 23 distinct units in a companion study. Song units collected by a snorkeler using the portable recorder off Maui were analyzed using a specialized Matlab script that defined 48 frequency and temporal parameters for each unit. From the 48 parameters, the units were separated into distinct categories using a multivariate categorical analysis. The distinct units were compared between the different techniques to gage if a...