@article {15475,
	title = {Skoll: A Process and Infrastructure for Distributed Continuous Quality Assurance},
	journal = {Software Engineering, IEEE Transactions on},
	volume = {33},
	year = {2007},
	month = {2007/08//},
	pages = {510 - 525},
	abstract = {Software engineers increasingly emphasize agility and flexibility in their designs and development approaches. They increasingly use distributed development teams, rely on component assembly and deployment rather than green field code writing, rapidly evolve the system through incremental development and frequent updating, and use flexible product designs supporting extensive end-user customization. While agility and flexibility have many benefits, they also create an enormous number of potential system configurations built from rapidly changing component implementations. Since today{\textquoteright}s quality assurance (QA) techniques do not scale to handle highly configurable systems, we are developing and validating novel software QA processes and tools that leverage the extensive computing resources of user and developer communities in a distributed, continuous manner to improve software quality significantly. This paper provides several contributions to the study of distributed, continuous QA (DCQA). First, it shows the structure and functionality of Skoll, which is an environment that defines a generic around-the-world, around-the-clock QA process and several sophisticated tools that support this process. Second, it describes several novel QA processes built using the Skoll environment. Third, it presents two studies using Skoll: one involving user testing of the Mozilla browser and another involving continuous build, integration, and testing of the ACE+TAO communication software package. The results of our studies suggest that the Skoll environment can manage and control distributed continuous QA processes more effectively than conventional QA processes. For example, our DCQA processes rapidly identified problems that had taken the ACE+TAO developers much longer to find and several of which they had not found. Moreover, the automatic analysis of QA results provided developers information that enabled them to quickly find the root causes of problems},
	keywords = {ACE+TAO communication software package, component assembly, component deployment, distributed continuous quality assurance, distributed development teams, distributed processing, end-user customization, flexible product design, incremental development, object-oriented programming, Skoll, software engineering, Software quality, systems analysis},
	isbn = {0098-5589},
	doi = {10.1109/TSE.2007.70719},
	author = {Porter, Adam and Yilmaz,C. and Memon, Atif M. and Schmidt,D. C and Natarajan,B.}
}
@conference {19027,
	title = {BIND: a fine-grained attestation service for secure distributed systems},
	year = {2005},
	month = {2005},
	pages = {154 - 168},
	abstract = {In this paper we propose BIND (binding instructions and data), a fine-grained attestation service for securing distributed systems. Code attestation has recently received considerable attention in trusted computing. However, current code attestation technology is relatively immature. First, due to the great variability in software versions and configurations, verification of the hash is difficult. Second, the time-of-use and time-of-attestation discrepancy remains to be addressed, since the code may be correct at the time of the attestation, but it may be compromised by the time of use. The goal of BIND is to address these issues and make code attestation more usable in securing distributed systems. BIND offers the following properties: (1) BIND performs fine-grained attestation. Instead of attesting to the entire memory content, BIND attests only to the piece of code we are concerned about. This greatly simplifies verification. (2) BIND narrows the gap between time-of-attestation and time-of-use. BIND measures a piece of code immediately before it is executed and uses a sandboxing mechanism to protect the execution of the attested code. (3) BIND ties the code attestation with the data that the code produces, such that we can pinpoint what code has been run to generate that data. In addition, by incorporating the verification of input data integrity into the attestation, BIND offers transitive integrity verification, i.e., through one signature, we can vouch for the entire chain of processes that have performed transformations over a piece of data. BIND offers a general solution toward establishing a trusted environment for distributed system designers.},
	keywords = {BIND, binding instructions and data, code attestation, data integrity, digital signatures, distributed processing, fine-grained attestation service, input data integrity, program verification, sandboxing mechanism, secure distributed systems, signature, time-of-attestation, time-of-use, transitive integrity verification, trusted computing},
	author = {Elaine Shi and Perrig, A. and Van Doorn, L.}
}
@conference {13367,
	title = {Exploiting Correlated Attributes in Acquisitional Query Processing},
	booktitle = {21st International Conference on Data Engineering, 2005. ICDE 2005. Proceedings},
	year = {2005},
	month = {2005/04/05/08},
	pages = {143 - 154},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Sensor networks and other distributed information systems (such as the Web) must frequently access data that has a high per-attribute acquisition cost, in terms of energy, latency, or computational resources. When executing queries that contain several predicates over such expensive attributes, we observe that it can be beneficial to use correlations to automatically introduce low-cost attributes whose observation will allow the query processor to better estimate the selectivity of these expensive predicates. In particular, we show how to build conditional plans that branch into one or more sub-plans, each with a different ordering for the expensive query predicates, based on the runtime observation of low-cost attributes. We frame the problem of constructing the optimal conditional plan for a given user query and set of candidate low-cost attributes as an optimization problem. We describe an exponential time algorithm for finding such optimal plans, and describe a polynomial-time heuristic for identifying conditional plans that perform well in practice. We also show how to compactly model conditional probability distributions needed to identify correlations and build these plans. We evaluate our algorithms against several real-world sensor-network data sets, showing several-times performance increases for a variety of queries versus traditional optimization techniques.},
	keywords = {acquisitional query processing, Computer networks, Costs, data acquisition, Delay, Distributed computing, distributed information system, Distributed information systems, distributed processing, exponential time algorithm, optimization techniques, polynomial-time heuristic, Polynomials, probability, Query processing, real-time systems, real-world sensor-network, Runtime, Sensor phenomena and characterization, Sensor systems},
	isbn = {0-7695-2285-8},
	doi = {10.1109/ICDE.2005.63},
	author = {Deshpande, Amol and Guestrin,C. and Wei Hong and Madden,S.}
}
@article {18648,
	title = {A global-state-triggered fault injector for distributed system evaluation},
	journal = {Parallel and Distributed Systems, IEEE Transactions on},
	volume = {15},
	year = {2004},
	month = {2004/07//},
	pages = {593 - 605},
	abstract = {Validation of the dependability of distributed systems via fault injection is gaining importance because distributed systems are being increasingly used in environments with high dependability requirements. The fact that distributed systems can fail in subtle ways that depend on the state of multiple parts of the system suggests that a global-state-based fault injection mechanism should be used to validate them. However, global-state-based fault injection is challenging since it is very difficult in practice to maintain the global state of a distributed system at runtime with minimal intrusion into the system execution. We present Loki, a global-state-based fault injector, which has been designed with the goals of low intrusion, high precision, and high flexibility. Loki achieves these goals by utilizing the ideas of partial view of global state, optimistic synchronization, and offline analysis. In Loki, faults are injected based on a partial, view of the global state of the system, and a post-runtime analysis is performed to place events and injections into a single global timeline and to discard experiments with incorrect fault injections. Finally, the experiments with correct fault injections are used to estimate user-specified performance and dependability measures. A flexible measure language has been designed that facilitates the specification of a wide range of measures.},
	keywords = {distributed processing, distributed system evaluation, fault tolerant computing, global-state-based fault injection mechanism, Loki, offline clock synchronization, performance evaluation, post-runtime analysis, Synchronisation, system recovery, user-specified performance},
	isbn = {1045-9219},
	doi = {10.1109/TPDS.2004.14},
	author = {Chandra,Ramesh and Lefever,R.M. and Joshi,K.R. and Michel Cukier and Sanders,W. H.}
}
@conference {18676,
	title = {Formal specification and verification of a group membership protocol for an intrusion-tolerant group communication system},
	year = {2002},
	month = {2002/12//},
	pages = {9 - 18},
	abstract = {We describe a group membership protocol that is part of an intrusion-tolerant group communication system, and present an effort to use formal tools to model and validate our protocol. We describe in detail the most difficult part of the validation exercise, which was the determination of the right level of abstraction of the protocol for formally specifying the protocol. The validation exercise not only formally showed that the protocol satisfies its correctness claims, but also provided information that will help us make the protocol more efficient without violating correctness.},
	keywords = {computer network reliability, distributed processing, distributed systems, fault tolerant computing, formal specification, formal verification, group membership protocol, intrusion-tolerant group communication system, PROMELA, Protocols},
	doi = {10.1109/PRDC.2002.1185613},
	author = {Ramasamy,H. V. and Michel Cukier and Sanders,W. H.}
}
@conference {18678,
	title = {Loki: a state-driven fault injector for distributed systems},
	year = {2000},
	month = {2000///},
	pages = {237 - 242},
	abstract = {Distributed applications can fail in subtle ways that depend on the state of multiple parts of a system. This complicates the validation of such systems via fault injection, since it suggests that faults should be injected based on the global state of the system. In Loki, fault injection is performed based on a partial view of the global state of a distributed system, i.e. faults injected in one node of the system can depend on the state of other nodes. Once faults are injected, a post-runtime analysis, using off-line clock synchronization, is used to place events and injections on a single global timeline and to determine whether the intended faults were properly injected. Finally, experiments containing successful fault injections are used to estimate the specified measures. In addition to briefly reviewing the concepts behind Loki and its organization, we detail Loki{\textquoteright}s user interface. In particular, we describe the graphical user interfaces for specifying state machines and faults, for executing a campaign and for verifying whether the faults were properly injected},
	keywords = {campaign execution, computer testing, distributed applications failure, distributed processing, distributed system validation, Fault diagnosis, fault event placement, fault specification, global system state, global timeline, Graphical user interfaces, Loki, off-line clock synchronization, post-runtime analysis, specified measures estimation, state machine specification, state-driven fault injection, Synchronisation},
	doi = {10.1109/ICDSN.2000.857544},
	author = {Chandra,R. and Lefever,R.M. and Michel Cukier and Sanders,W. H.}
}
@conference {15687,
	title = {Network service selection for distributed multimedia applications},
	booktitle = {Third International Conference on Computational Intelligence and Multimedia Applications, 1999. ICCIMA {\textquoteright}99. Proceedings},
	year = {1999},
	month = {1999///},
	pages = {388 - 392},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {An important question in the development of system support for distributed multimedia is the type of network service offered to applications. This paper compares two network service disciplines: weighted fair queueing (WFQ) and non-preemptive earliest deadline first (NEDF). We show that, for a broad class of high-bandwidth distributed multimedia applications, WFQ outperforms NEDF in terms of network throughput while still providing an application-adequate end-to-end service. This result holds despite the fact that NEDF offers applications far greater flexibility in terms of control over end-to-end delivery delay},
	keywords = {Admission control, Application software, application-adequate end-to-end service, Bandwidth, Communication system traffic control, Computer science, Delay, distributed processing, end-to-end delivery delay control, flexibility, high-bandwidth distributed multimedia applications, interactive multimedia, multimedia systems, network service selection, network throughput, nonpreemptive earliest deadline first, queueing theory, Regulators, system support, telecommunication services, Throughput, Traffic control, weighted fair queueing},
	isbn = {0-7695-0300-4},
	doi = {10.1109/ICCIMA.1999.798561},
	author = {Simon,R. and Sood,A. and Mundur, Padma}
}
@article {14770,
	title = {Critical path profiling of message passing and shared-memory programs},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	volume = {9},
	year = {1998},
	month = {1998/10//},
	pages = {1029 - 1040},
	abstract = {We introduce a runtime, nontrace-based algorithm to compute the critical path profile of the execution of message passing and shared-memory parallel programs. Our algorithm permits starting or stopping the critical path computation during program execution and reporting intermediate values. We also present an online algorithm to compute a variant of critical path, called critical path zeroing, that measures the reduction in application execution time that improving a selected procedure will have. Finally, we present a brief case study to quantify the runtime overhead of our algorithm and to show that online critical path profiling can be used to find program bottlenecks},
	keywords = {Computer Society, Concurrent computing, critical path computation, critical path profile, critical path zeroing, distributed processing, distributed shared memory systems, Instruments, Message passing, Monitoring, online algorithm, online critical path profiling, Parallel algorithms, program bottlenecks, Runtime, runtime nontrace-based algorithm, runtime overhead, shared-memory programs, system monitoring, Time measurement, Yarn},
	isbn = {1045-9219},
	doi = {10.1109/71.730530},
	author = {Hollingsworth, Jeffrey K}
}
@conference {14784,
	title = {LBF: a performance metric for program reorganization},
	booktitle = {18th International Conference on Distributed Computing Systems, 1998. Proceedings},
	year = {1998},
	month = {1998/05/26/29},
	pages = {222 - 229},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We introduce a new performance metric, called Load Balancing Factor (LBF), to assist programmers with evaluating different tuning alternatives. The LBF metric differs from traditional performance metrics since it is intended to measure the performance implications of a specific tuning alternative rather than quantifying where time is spent in the current version of the program. A second unique aspect of the metric is that it provides guidance about moving work within a distributed or parallel program rather than reducing it. A variation of the LBF metric can also be used to predict the performance impact of changing the underlying network. The LBF metric can be computed incrementally and online during the execution of the program to be tuned. We also present a case study that shows that our metric can predict the actual performance gains accurately for a test suite of six programs},
	keywords = {case study, Computational modeling, computer network, Computer science, Debugging, distributed processing, distributed program, Educational institutions, Integrated circuit testing, LBF metric, load balancing factor, Load management, measurement, NIST, parallel program, parallel programming, performance metric, program reorganization, program tuning, Programming profession, resource allocation, software metrics, software performance evaluation, US Department of Energy},
	isbn = {0-8186-8292-2},
	doi = {10.1109/ICDCS.1998.679505},
	author = {Eom, H. and Hollingsworth, Jeffrey K}
}
@conference {12783,
	title = {Verifying an intelligent structural control system: a case study},
	booktitle = {Real-Time Systems Symposium, 1994., Proceedings.},
	year = {1994},
	month = {1994/12/07/9},
	pages = {271 - 275},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Describes the formal verification of the timing properties of the design of an intelligent structural control system using the Concurrency Workbench, an automatic verification tool for finite-state processes. The high-level design of the system is first given in Modechart, a graphical specification language for real-time systems, and then translated into a temporal process algebra supported by the Workbench. The facilities provided by this tool are then used to analyze the system and ultimately show it to be correct},
	keywords = {automatic verification tool, case study, Concurrency Workbench, Distributed computing, Distributed control, distributed processing, finite automata, finite-state processes, formal verification, graphical specification language, high-level design, intelligent control, intelligent structural control system verification, Logic, Modechart, Process algebra, Real time systems, real-time systems, Specification languages, structural engineering computing, temporal logic, temporal process algebra, time-varying systems, Timing, timing properties, visual languages},
	isbn = {0-8186-6600-5},
	doi = {10.1109/REAL.1994.342708},
	author = {Elseaidy,W. M and Cleaveland, Rance and Baugh,J. W.}
}
