Jules White

WreckWatch: Automatic Traffic Accident Detection and Notification with Smartphones

Traffic accidents are one of the leading causes of fatalities in the US. An important indicator of survival rates after an accident is the time between the accident and when emergency medical personnel are dispatched to the scene. Eliminating the time between when an accident occurs and when first responders are dispatched to the scene decreases mortality rates by 6%. One approach to eliminating the delay between accident occurrence and first responder dispatch is to use in-vehicle automatic accident detection and notification systems, which sense when traffic accidents occur and immediately notify emergency personnel. These in-vehicle systems, however, are not available in all cars and are expensive to retrofit for older vehicles. This paper describes how smartphones, such as the iPhone and Google Android platforms, can automatically detect traffic accidents using accelerometers and acoustic data, immediately notify a central emergency dispatch server after an accident, and provide situational awareness through photographs, GPS coordinates, VOIP communication channels, and accident data recording. This paper provides the following contributions to the study of detecting traffic accidents via smartphones: (1) we present a formal model for accident detection that combines sensors and context data, (2) we show how smartphone sensors, network connections, and web services can be used to provide situational awareness to first responders, and (3) we provide empirical results demonstrating the efficacy of different approaches employed by smartphone accident detection systems to prevent false positives.

Automated Diagnosis of Product-Line Configuration Errors in Feature Models

Feature models are widely used to model software product-line (SPL) variability. SPL variants are configured by selecting feature sets that satisfy feature model constraints. Configuration of large feature models can involve multiple stages and participants, which makes it hard to avoid conflicts and errors. New techniques are therefore needed to debug invalid configurations and derive the minimal set of changes to fix flawed configurations. This paper provides three contributions to debugging feature model configurations: (1) we present a technique for transforming a flawed feature model configuration into a constraint satisfaction problem (CSP) and show how a constraint solver can derive the minimal set of feature selection changes to fix an invalid configuration, (2) we show how this diagnosis CSP can automatically resolve conflicts between configuration participant decisions, and (3) we present experiment results that evaluate our technique. These results show that our technique scales to models with over 5,000 features, which is well beyond the size used to validate other automated techniques.

Selecting highly optimal architectural feature sets with Filtered Cartesian Flattening

Feature modeling is a common method used to capture the variability in a configurable application. A key challenge developers face when using a feature model is determining how to select a set of features for a variant that simultaneously satisfy a series of resource constraints. This paper presents an approximation technique for selecting highly optimal feature sets while adhering to resource limits. The paper provides the following contributions to configuring application variants from feature models: (1) we provide a polynomial time approximation algorithm for selecting a highly optimal set of features that adheres to a set of resource constraints, (2) we show how this algorithm can incorporate complex configuration constraints; and (3) we present empirical results showing that the approximation algorithm can be used to derive feature sets that are more than 90%+ optimal.

A genetic algorithm for optimized feature selection with resource constraints in software product lines

Abstract: Software product line (SPL) engineering is a software engineering approach to building configurable software systems. SPLs commonly use a feature model to capture and document the commonalities and variabilities of the underlying software system. A key challenge when using a feature model to derive a new SPL configuration is determining how to find an optimized feature selection that minimizes or maximizes an objective function, such as total cost, subject to resource constraints. To help address the challenges of optimizing feature selection in the face of resource constraints, this paper presents an approach that uses G enetic A lgorithms for optimized FE ature S election (GAFES) in SPLs. Our empirical results show that GAFES can produce solutions with 86-97% of the optimality of other automated feature selection algorithms and in 45-99% less time than existing exact and heuristic feature selection techniques.

Model-driven auto-scaling of green cloud computing infrastructure

Cloud computing can reduce power consumption by using virtualized computational resources to provision an applications computational resources on demand. Auto-scaling is an important cloud computing technique that dynamically allocates computational resources to applications to match their current loads precisely, thereby removing resources that would otherwise remain idle and waste power. This paper presents a model-driven engineering approach to optimizing the configuration, energy consumption, and operating cost of cloud auto-scaling infrastructure to create greener computing environments that reduce emissions resulting from superfluous idle resources. The paper provides four contributions to the study of model-driven configuration of cloud auto-scaling infrastructure by (1) explaining how virtual machine configurations can be captured in feature models, (2) describing how these models can be transformed into constraint satisfaction problems (CSPs) for configuration and energy consumption optimization, (3) showing how optimal auto-scaling configurations can be derived from these CSPs with a constraint solver, and (4) presenting a case study showing the energy consumption/cost reduction produced by this model-driven approach.

Using Smartphones to Detect Car Accidents and Provide Situational Awareness to Emergency Responders

Accident detection systems help reduce fatalities stemming from car accidents by decreasing the response time of emergency responders. Smartphones and their onboard sensors (such as GPS receivers and accelerometers) are promising platforms for constructing such systems. This paper provides three contributions to the study of using smartphone-based accident detection systems. First, we describe solutions to key issues associated with detecting traffic accidents, such as preventing false positives by utilizing mobile context information and polling onboard sensors to detect large accelerations. Second, we present the architecture of our prototype smartphone-based accident detection system and empirically analyze its ability to resist false positives as well as its capabilities for accident reconstruction. Third, we discuss how smartphone-based accident detection can reduce overall traffic congestion and increase the preparedness of emergency responders.

Model Transformation by Demonstration

Model transformations provide a powerful capability to automate model refinements. However, the use of model transformation languages may present challenges to those who are unfamiliar with a specific transformation language. This paper presents an approach called model transformation by demonstration (MTBD), which allows an end-user to demonstrate the exact transformation desired by actually editing a source model and demonstrating the changes that evolve to a target model. An inference engine built into the underlying modeling tool records all editing operations and infers a transformation pattern, which can be reused in other models. The paper motivates the need for the approach and discusses the technical contributions of MTBD. A case study with several sample inferred transformations serves as a concrete example of the benefits of MTBD.

Applying machine learning classifiers to dynamic Android malware detection at scale

The widespread adoption and contextually sensitive nature of smartphone devices has increased concerns over smartphone malware. Machine learning classifiers are a current method for detecting malicious applications on smartphone systems. This paper presents the evaluation of a number of existing classifiers, using a dataset containing thousands of real (i.e. not synthetic) applications. We also present our STREAM framework, which was developed to enable rapid large-scale validation of mobile malware machine learning classifiers.

Automating Product-Line Variant Selection for Mobile Devices

Product-line architectures (PLAs) designed for mobile devices create a unique challenge for automated product variant selection engines since variants must be derived on-the-fly as devices are discovered. Current automation techniques do not incorporate device resource consumption constraints into variant selection and do not address how a PLA can be designed to improve automated variant selection speed. This paper presents a tool called Scatter whose input is (1) the requirements of PLA construction and (2) the resources available on a discovered mobile device and whose output is the optimal variant that can be deployed to the device. Scatter provides automatic variant selection based on configuration and resource constraints and also ensures that variant selection is optimal with regard to a configurable cost function. The paper presents our results from experiments with Scatter and how PLA design decisions affect a constraint-based variant selection engines solving speed.

Improving Domain-Specific Language Reuse with Software Product Line Techniques

Complex software systems, such as traffic management systems and shipboard computing environments, raise several concerns (such as performance, reliability, and fault tolerance) that developers must manage throughout the software life cycle. Domain-specific languages (DSLs) have emerged as a powerful mechanism for capturing and reasoning about these diverse concerns. For each system concern, you can design a DSL to precisely capture key domain-level information while shielding developers and users from the technical solutions implementation-level details.