In programming courses, test-based automated feedback systems often face a limitation: instructors cannot effectively enhance feedback during ongoing assignments. While a passing test case may adequately indicate that certain rubric criteria have been met by a student's program, failure can arise from many reasons. When a test case fails due to reasons not previously coded for, it can create confusion. This tends to divert a student's focus from genuine learning towards guessing the test. A more effective approach would be for the system to notify instructors when a test fails, rather than automatically returning a "test case failed'' message. Instructors could then diagnose the cause to provide an initial ''human-in-the-loop'' feedback. Subsequently, this feedback can be coded into the test suite. This method enables the improvement of feedback during an on-going assignment. In this poster, we propose an approach to achieve this objective and introduce a supporting tool.

Instructors often grant students extensions or grace days to relax deadline constraints. However, researchers have yet to investigate the value of time extensions in identifying students' abilities and why students use them in computing education. Our study shows that scheduling conflicts and underestimation of the coursework were the top two reasons why students were late, providing the very first qualitative analysis results. By categorizing students who used and did not use cost-free time extensions, we found that students who used time extensions had a significantly lower assignment and exam grades than those who chose not to use them. We first observed this phenomenon when looking at grace day usages in a final-year programming course and validated the result by looking at the usage of extended lab time in a first-year programming course. This result suggests that offering a cost-free mechanism such as grace days or a time extension can provide a very early indicator of student abilities and those likely to need assistance.

Logs are an essential part of the development and maintenance of large and complex software systems as they contain rich information pertaining to the dynamic content and state of the system. As such, developers and practitioners rely heavily on the logs to monitor their systems. In parallel, the increasing volume and scale of the logs, due to the growing complexity of modern software systems, renders the traditional way of manual log inspection insurmountable. Consequently, to handle large volumes of logs efficiently and effectively, various prior research aims to automate the analysis of log files. Thus, in this paper, we begin with the hypothesis that log files are natural and local and these attributes can be applied for automating log analysis tasks. We guide our research with six research questions with regards to the naturalness and localness of the log files, and present a case study on anomaly detection and introduce a tool for anomaly detection, called ANALOG, to demonstrate how our new findings facilitate the automated analysis of logs.

Execution logs are a crucial medium as they record runtime information of software systems. Although extensive logs are helpful to provide valuable details to identify the root cause in postmortem analysis in case of a failure, this may also incur performance overhead and storage cost. Therefore, in this research, we present the result of our experimental study on seven Spark benchmarks to illustrate the impact of different logging verbosity levels on the execution time and storage cost of distributed software systems. We also evaluate the log effectiveness and the information gain values, and study the changes in performance and the generated logs for each benchmark with various types of distributed system failures. Our research draws insightful findings for developers and practitioners on how to set up and utilize their distributed systems to benefit from the execution logs.

As smart electricity meters are becoming more popular and starting to replace conventional meters worldwide, new area of research for meter data analytics has emerged. Wide spectrum of computations in this context has been applied, ranging from computationally inexpensive tasks such as calculating monthly bills and peak usage, to elaborate computations to provide energy saving feedback to consumers in order to reduce peak energy demand. Examples include model building approaches for usage predictions and recommendations. Although research efforts in this field are progressing, majority of research in this domain still has overlooked the incremental aspects of energy data analytics, or in best cases, researches have not been able to properly utilize the incremental nature of the energy data. We have noticed that incremental approaches can significantly improve performance of smart meter analytics. For example, per-hour readings of a smart meter can efficiently become integrated with the previous readings and result in an incremental re-computation of a particular smart meter task. In this paper, we introduce UW Incremental Spark Analytics (UWISA), our incremental smart meter data platform, which applies efficient incremental techniques for calculating “energy-temperature” model (also called three-line model) [9]. Our platform can achieve better multi-core scalability and speedup of 4.5× (on average) compared to non-incremental implementation and speedup of higher than 2× when compared to previous incremental research for smart meter datasets up to tens of GBs. We also investigate the reasons behind better performance of incremental method when compared to the non-incremental and Spark Streaming approaches.

The migration of application logic to the client side of modern web applications and the use of JavaScript as the main language for client-side development have made memory leaks in JavaScript an issue for web applications. Client-side web applications communicate with the server asynchronously, remaining on the same web page during their lifetime. Thus, even minor memory leaks can eventually lead to excessive memory usage, negatively affecting user-perceived response time and possibly causing page crashes. To detect memory leaks and guide developers in fixing the leaks quickly and easily, this paper introduces LeakSpot, a tool that creates a run-time heap model by modifying the application code in a browser-agnostic way to record object allocations, accesses, and references created to objects. LeakSpot reports those allocation sites causing the leaks instead of all the leaky allocation sites. It also identifies the locations in the code where leaked objects are accumulated, for example, the locations where a reference from a data structure is created but forgotten to be removed by the developer. To facilitate debugging and fixing the leaks, for every leaked object, LeakSpot reports all the locations in the code that create a reference to the object. To confirm usefulness and efficacy of LeakSpot experimentally, we have used LeakSpot to find and fix four memory leaks in a JavaScript benchmark suite and in open-source web applications. LeakSpot is also shown to be effective in pointing out the potential causes of three leaks in large and popular web applications. Copyright © 2016 John Wiley & Sons, Ltd.

Although most smartphones today have both cellular data and WiFi capacity, network-selection techniques typically only allow for a single data interface to be used at a time. This leads to several problems including the interruption of existing connections when switching interfaces, complete loss of connectivity when the selected network is not functioning correctly, and significantly less bandwidth to the device than is possible if the available wireless capacity is aggregated. While interface bonding is not new, aggregating two such diverse networks is particularly challenging given that different wireless technologies, and even different networks of the same type, offer inconsistent link parameters, presenting dynamically fluctuating bandwidth, latency, and packet loss. In this paper we present a simple, but extremely efficient, hashing technique for multi-interface packet scheduling. We have implemented our system with aggregation proxies running in well-connected data centers and client code running on a Galaxy Nexus running Android 4.1. Our experimental results show that our prototype never loses connectivity even when networks fail as long as at least one network is functioning, does not break connections as interface selection is adjusted, and can increase bandwidth to the smartphone to the available aggregated network capacities. Transmission time is reduced by up to 60% vs. using a single network interface.

Tiled displays provide an effective means of displaying very large images but these displays suffer from unique grid-type distortions. These are caused by the gaps between each sub-display's active area and have been largely ignored in the image quality assessment (IQA) literature. Recent work has suggested that current IQA metrics perform poorly when evaluating the effects of grid distortions and demonstrated the need for a new metric. This paper introduces this new IQA metric and tests it against a significantly expanded IQA database for grid-distorted images. We describe this new metric in detail and show how it provides a clear improvement over existing IQA quality metrics in evaluation of tiled image quality.

Web pages take noticeably longer to load when accessing the Internet using high latency wide-area wireless networks like 3G. This delay can result in lower user satisfaction and lost revenue for web site operators. By locating a just-in-time prefetching push proxy in the cloud and routing mobile client web requests through it, web page load times can be perceivably reduced. Our analysis and experimental results demonstrate that the use of a push proxy results in a much smaller dependency on the mobile client to network latency than seen in environments where no proxy is used, in particular, only one full round trip from client to server is necessary regardless of the number of resources referenced by a web page. In addition, we find that the ideal location for a push proxy minimizes the latency between the proxy and the servers that the mobile client accesses through it, in contrast to traditional proxies which are best deployed in a manner that minimizes the latency between client and proxy.

IEEE 802.11 PHY supports multiple transmission rates, varying from as low as 1 Mbps in 802.11b, up to 54 Mbps in 802.11g, and higher in 802.11n, with each Wi-Fi station selecting its transmission rate according to its own algorithm. The per-packet fairness scheme adopted by the 802.11 MAC reduces the effective throughput to that of the lowest sending rate. In multi-vehicle opportunistic downloading scenarios the communicating nodes will achieve the maximum transmission rate at some point, therefore in such scenarios the preferred bit-rate selection algorithm is: transmit at the highest bit rate or remain silent. We have implemented this policy and our experimental evaluation demonstrates that there is only a small loss in throughput in single-vehicle scenarios, while throughput is approximately 15% higher than the best alternative in multi-vehicle scenarios, with significantly less contention, and thus loss, on the medium.

Enterprise software systems are large and complex with limited support for automated root-cause analysis. Avoiding system downtime and loss of revenue dictates a fast and efficient root-cause analysis process. Operator practice and academic research have shown that about 80% of failures in such systems have recurrent causes; therefore, significant efficiency gains can be achieved by automating their identification. In this paper, we present a novel approach to modelling features of log files. This model offers a compact representation of log data that can be efficiently extracted from large amounts of monitoring data. We also use decision-tree classifiers to learn and classify symptoms of recurrent faults. This representation enables automated fault matching and, in addition, enables human investigators to understand manifestations of failure easily. Our model does not require any access to application source code, a specification of log messages, or deep application knowledge. We evaluate our proposal using fault-injection experiments against other proposals in the field. First, we show that the features needed for symptom definition can be extracted more efficiently than does related work. Second, we show that these features enable an accurate classification of recurrent faults using only standard machine learning techniques. This enables us to identify accurately up to 78% of the faults in our evaluation data set.

Business success is contingent on dependable, yet affordable, software systems; this implies a need for self-recovering cloud-based component software systems. In prior work we demonstrated a discrete controller that allows scheduling of recovery actions based on uncertain fault knowledge. That approach required detailed analysis of historic failure data. In this paper we examine adaptive learning through active exploration and demonstrate the impact of drifting or invalid knowledge about recovery actions.

Custom hardware is expensive and making software reliable is difficult to achieve as complexity increases. Recent trends towards cloud computing highlight the importance of operating continuously using both unreliable commodity hardware and, as services grow in complexity, failure-vulnerable software. We have developed an approach for building dependable networking software that exposes a reliable encapsulation service to clients although it executes on commodity hardware, we do so without substantially increasing the implementation complexity of the encapsulation software. Our approach demonstrates the viability of building reliable systems using unreliable components, including unreliable server software.

The use of multi-hop wireless networks is extensive and growing. Such networks often have no single administrative authority. As such, they are best modeled by game theory. Existing approaches to this problem have focused on competitive game-theory analysis. In this paper we study the problem from the perspective of cooperative game theory. We assume that nodes wish to maximize their individual utility and cooperate solely for the purpose of increasing that utility. By assuming that the utility of a node is equal to its bandwidth, and by adopting the KS-Raiffa solution to cooperation, we are able to compute the fair bandwidth allocation in two-hop wireless networks. We then generalize these results to arbitrary multi-hop wireless networks. By assuming that any node can perform denial-of-service attack on the network, we are able to prove that Raiffa cooperation will result in temporal fairness in the network. Our results suggest that the ideal MAC for a wireless network will be one based on KS-Raiffa solution.

Management metrics of complex software systems exhibit stable correlations which can enable fault detection and diagnosis. Current approaches use specific analytic forms, typically linear, for modeling correlations. In practice, more complex nonlinear relationships exist between metrics. Moreover, most intermetric correlations form clusters rather than simple pairwise correlations. These clusters provide additional information and offer the possibility for optimization. In this paper, we address these issues by using Normalized Mutual Information (NMI) as a similarity measure to identify clusters of correlated metrics, without assuming any specific form for the metric relationships. We show how to apply the Wilcoxon Rank-Sum test on the entropy measures to detect errors in the system. We also present three diagnosis algorithms to locate faulty components: RatioScore, based on the Jaccard coefficient, SigScore, which incorporates knowledge of component dependencies, and BayesianScore, which uses Bayesian inference to assign a fault probability to each component. We evaluate our approach in the context of a complex enterprise application, and show that 1) stable, nonlinear correlations exist and can be captured with our approach; 2) we can detect a large fraction of faults with a low false positive rate (we detect up to 18 of the 22 faults we injected); and 3) we improve the diagnosis with our new diagnosis algorithms.

Modern software systems expose management metrics to help track their health. Recently, it was demonstrated that correlations among these metrics allow errors to be detected and their causes localized. Prior research shows that linear models can capture many of these correlations. However, our research shows that several factors may prevent linear models from accurately describing correlations, even if the underlying relationship is linear. Common phenomena we have observed include relationships that evolve, relationships with missing variables, and heterogeneous residual variance of the correlated metrics. Usually these phenomena can be discovered by testing for heteroscedasticity of the underlying linear models. Such behaviour violates the assumptions of simple linear regression, which thus fail to describe system dynamics correctly. In this paper we address the above challenges by employing efficient variants of Ordinary Least Squares regression models. In addition, we automate the process of error detection by introducing the Wilcoxon Rank-Sum test after proper correlations modeling. We validate our models using a realistic Java-Enterprise-Edition application. Using fault-injection experiments we show that our improved models capture system behavior accurately.

The normal operation of enterprise software systems can be modeled by stable correlations between various system metrics; errors are detected when some of these correlations fail to hold. The typical approach to diagnosis (i.e., pinpoint the faulty component) based on the correlation models is to use the Jaccard coefficient or some variant thereof, without reference to system structure, dependency data, or prior fault data. In this paper we demonstrate the intrinsic limitations of this approach, and propose a solution that mitigates these limitations. We assume knowledge of dependencies between components in the system, and take this information into account when analyzing the correlation models. We also propose the use of the Tanimoto coefficient instead of the Jaccard coefficient to assign anomaly scores to components. We evaluate our new algorithm with a Trade6-based test-bed. We show that we can find the faulty components within top-3 components with the highest anomaly score in four out of nine cases, while the prior method can only find one.

In recent years autonomic computing, specifically autonomic data centre management has gained significant attention. Human intervention be minimized to reduce the operating costs of business applications. In this paper we focus our attention to the self-repair dimension and present a flexible probabilistic framework to develop agents for self-repair in the context of business-information-system components. Our framework seeks to pick the optimal sequence of repair actions given only imperfect information about the experienced fault. In contrast to existing recovery-oriented approaches, our model explicitly considers fault prevalence, symptoms of recurrent failures, and inclusive repair actions. We evaluate our proposal using discrete event simulation. Our evaluation shows that an optimal repair policy can be computed from a brief specification of repair actions. Even in the context of very unreliable error detection our controller is able to estimate the current state of the monitored system and recover from failure.

The manual process to identifying causes of failure in distributed information systems is difficult and time-consuming. The underlying reason is the large size and complexity of these systems, and the vast amount of monitoring data they generate. Despite its high cost, this manual process is necessary in order to avoid the detrimental consequences of system downtime. Several studies and operator practice suggest that a large fraction of the failures in these systems are caused by recurrent faults. Therefore, significant efficiency gains can be achieved by automating the identification of these faults. In this work we present methods, which draw from the areas of information retrieval as well as machine learning, to automate the task of infering symptoms pertinent to failures caused by specific faults. In particular, we present a method to infer message types from plain-text log messages, and we leverage these types to train classifiers and extract rules to identify symptoms of recurrent faults automatically.

Management metrics of complex software systems exhibit stable correlations which can enable fault detection and diagnosis. Current approaches use specific analytic forms, typically linear, for modeling correlations. In this paper we use normalized mutual information as a similarity measure to identify clusters of correlated metrics, without knowing the specific form. We show how we can apply the Wilcoxon rank-sum test to identify anomalous behaviour. We present two diagnosis algorithms to locate faulty components: RatioScore, based on the Jaccard coefficient, and SigScore, which incorporates knowledge of component dependencies. We evaluate our mechanisms in the context of a complex enterprise application. Through fault injection experiments, we show that we can detect 17 out of 22 faults without any false positives. We diagnose the faulty component in the top five anomaly scores 7 times out of 17 using SigScore, which is 40% better than when system structure is ignored.

Modern software systems expose management metrics to help track their health. Recently, it was demonstrated that correlations among these metrics allow faults to be detected and their causes localized. In particular, linear regression models have been used to capture metric correlations. We show that for many pairs of correlated metrics in software systems, such as those based on Java Enterprise Edition (JavaEE), the variance of the predicted variable is not constant. This behaviour violates the assumptions of linear regression, and we show that these models may produce inaccurate results. In this paper, leveraging insight from the system behaviour, we employ an efficient variant of linear regression to capture the non-constant variance. We show that this variant captures metric correlations, while taking the changing residual variance into consideration. We explore potential causes underlying this behaviour, and we construct and validate our models using a realistic multi-tier enterprise application. Using a set of 50 fault-injection experiments, we show that we can detect all faults without any false alarm.

The classical max-min rate allocation is a commonly used fairness criterion in wired networks. Its implications, however, are not well understood in the context of wireless networks. In this paper we outline various considerations that govern max-min rate allocation in 802.11-based Wireless Mesh Networks (WMNs). Such considerations assume importance because WMNs exhibit extreme unfairness, including starvation, with backlogged TCP flows. We show that it is possible to achieve approximate max-min rate allocation simply by rate limiting the aggregate capacity of the network. Such rate limiting can be performed centrally at traffic aggregation points. In this context we propose a rate-based scheduler that can be implemented at gateway routers. Simulations show that our proposed controller can improve the fairness index by over two-fold compared with networks without any rate limiting, while maintaining upwards of 80% network throughput achievable with a perfect scheduler.

Wireless Mesh Networks (WMNs) based on commodity 802.11 radios exhibit extreme unfairness, including starvation, in the presence of backlogged traffic sources. While the underlying reasons for this performance degradation are well understood, yet only a few of the proposed solutions are compatible with the current generation of closed 802.11 firmware/hardware. Most existing proposals limit sources to their fair share through a distributed rate control mechanism, in the process incurring a significant overhead to enable such local computation of fair rates.

In infrastructure wireless networks, nodes at the edge of the coverage area need to spend more energy to transmit their packets than those close to the Access Point (AP). Less energy is required if intermediate nodes can be used to forward data. To enable this, intermediate nodes need an incentive and there must be a mechanism for selecting these nodes. In this paper we propose Energy-aware Co-Operative (ECO) relaying for selecting relays to forward packets. The technique is based on the idea of Relative Energy Usage (REU), which reflects the proportion of energy that a node saves by forwarding its packets through relays. A node which saves more energy by using relays is more likely to be chosen as a relay. Conversely, nodes are only permitted to use relays proportionate to the amount of energy they themselves have spent as relays. We compare our scheme with direct transmission, minimum energy path (MnEP), and maximum residual energy path (MxRE). We show that ECO can transmit 50% more data than direct transmission, while using less energy on average. Although MnEP and MxRE can also transmit more data than direct transmission, they do so at severe energy cost to a small number of nodes, doubling the average energy usage, making them ill-suited to commercial networks.

The use of 802.11-based multi-hop wireless mesh networks for Internet access is extensive and growing. The primary advantages of this approach are ease of deployment and lower cost. However, these networks are designed for web and e-mail applications. Highly interactive applications, such as multiplayer online games and VoIP, with their requirements for low delay, present significant challenges to these networks. In particular, the interaction between real-time traffic and TCP traffic tends to result in either a failure of the real-time traffic getting its needed QoS or the TCP traffic unnecessarily experiencing very poor throughput. To solve this problem we place real-time and TCP traffic into separate queues. We then rate-limit TCP traffic based on the average queue size of the real-time queue. Thus, TCP traffic is permitted to use excess bandwidth as long as it does not interfere with real-time traffic guarantees. Extensive simulations using the network simulator, ns-2, demonstrate that our approach is effective in providing soft real-time support, while allowing efficient use of the remaining bandwidth for TCP traffic.

Gateway nodes in a wireless mesh network (WMN) bridge traffic between the mesh nodes and the public Internet. This makes them a suitable aggregation point for policy enforcement or other traffic-shaping responsibilities that may be required to support a scalable, functional mesh network. In this paper we evaluate two gateway-enforced rate-limiting mechanisms so as to avoid congestion and support network-level fairness: automated queue management (AQM) techniques that have previously been widely studied in the context of wired networks, and our gateway rate control (GRC) mechanism. We evaluate the performance of these two techniques through simulations of an 802.11-based multihop mesh network. Our experiments show that the conventional use of AQM techniques fails to provide effective congestion control as these mesh networks exhibit different congestion characteristics than wired networks. Specifically, in a wired network, packet losses under congestion occur at the router queue feeding the bottleneck link. By contrast, in a WMN, many such geographically dispersed points of contention may exist due to asymmetric views of the channel state between different mesh routers. As such, gateway rate-limiting techniques like AQM are ineffective as the gateway queue is not the only bottleneck. Our GRC protocol takes a different approach by rate limiting each active flow to its fair share, thus preserving enough capacity to allow the disadvantaged flows to obtain their fair share of the network throughput. The GRC technique can be further extended to provide quality of service (QoS) guarantees or enforce different notions of fairness.

Delay-tolerant networks (DTNs) have the potential to interconnect devices in regions that current networking technology cannot reach. To realize the DTN vision, routes must be found over multiple unreliable, intermittently-connected hops. In this paper we present a practical routing protocol that uses only observed information about the network. We designed a metric that estimates the average waiting time for each potential next hop. This learned topology information is distributed using a link-state routing protocol, where the link-state packets are "flooded" using epidemic routing. The routing is recomputed each time connections are established, allowing messages to take advantage of unpredictable contacts. A message is forwarded if the topology suggests that the connected node is "closer" to the destination than the current node. We demonstrate through simulation that our protocol provides performance similar to that of schemes that have global knowledge of the network topology, yet without requiring that knowledge. Further, it requires significantly less resources than the alternative, epidemic routing, suggesting that our approach scales better with the number of messages in the network. This performance is achieved with minimal protocol overhead for networks of approximately 100 nodes.

Multi-hop wireless networks have the potential to dramatically reduce the cost of deploying communication infrastructure. However, the nature of this technology limits the capacity of radio links. Thus, it is important to utilize them as efficiently as possible. In this paper, we investigate load balancing across multiple paths as a possible mechanism to improve performance in multi-hop wireless networks. Given the inherent interference of multi-hop transmissions in a single radio channel, it is generally assumed that single-channel multipath routing cannot provide any benefits, but in fact would have detrimental effects on resource efficiency. However, a careful investigation of the issue reveals that under certain theoretic conditions, significant gains are possible. In fact, we show throughput improvements of 80-100% in some scenarios. We present a novel interference metric to assess the quality of a set of disjoint paths. We further present a heuristic path selection algorithm to find appropriate routing paths in structured networks, which is a first step towards the application of our basic results in realistic scenarios.

Many of the community-area networks use commodity 802.11 hardware to form small wireless networks. Generally organized as a mesh, employing a single channel, and having a few gateways for wider-area access, they tend to offer poor bandwidth to end users. To increase bandwidth, the idea of leveraging multiple interfaces operating on different, non-overlapping, channels has been put forward recently. In this paper, we examine the performance of community wireless networks based on such multi-interface nodes. Our experiments demonstrate that the mere use of more dual-interface nodes does not necessarily create higher capacity. Indeed, in a number of cases we show that the throughput is lower than cases where fewer interfaces are used. We identify three causes for this throughput limitation: channel load, RTS/CTS and exposed nodes, and unfairness due to local traffic. Furthermore, we show that in random topologies, it is very often hard to achieve adequate throughput gain.

Visualization tools that illustrate communication in parallel programs use Fidge/Mattern timestamps to efficiently answer precedence queries. These timestamps have poor execution efficiency when the number of processes is large, limiting the scalability of the tool. Self-organizing hierarchical cluster timestamps can scale if the clusters they use capture communication locality. However, no clustering algorithm has been presented that enables these timestamps to work. We evaluate two clustering strategies for such timestamps, one static and one dynamic. The static algorithm was chosen to demonstrate an unproven assumption of cluster timestamps, namely that good clustering will always yield significant space saving, and to demonstrate that it is possible to select a range of cluster sizes that provide such a savings. We then assessed the merge-on-N/sup th/-communication approach. In all but two cases it provides a timestamp size that is with 20% of the best achievable. We present detailed results for the strategies evaluated.

Partial-order data structures used in distributed-system observation tools typically use vector timestamps to efficiently determine event precedence. Unfortunately all current dynamic vector-timestamp algorithms either require a vector of size equal to the number of processes in the computation or require a graph search operation to determine event precedence. This fundamentally limits the scalability of such observation systems. In this paper we present an algorithm for hierarchical, clustered vector time-stamps. We present results for a variety of computation environments that demonstrate such timestamps can reduce space consumption by more than an order-of-magnitude over Fidge/Mattern timestamps while still providing acceptable time bounds for computing timestamps and determining event precedence.

The vector-clock size necessary to characterize causality in a distributed computation is bounded by the dimension of the partial order induced by that computation. In an arbitrary distributed computation, the dimension can be as large as the width, which in turn can be as large as the number of processes in the computation. Most vector clock algorithms, and all online ones, simply use a vector of size equal to the number of processes. In practice the dimension may be much smaller. It is the purpose of the paper to provide empirical evidence that the dimension of various distributed computations is often substantially smaller than the number of processes. We have found that typical distributed computations, with as many as 300 processes, have dimension less than 10. To achieve this quantification, we developed various theorems and algorithms which we also describe.