Large-Scale Analysis of Framework-Specific Exceptions in Android Apps

Mobile apps have become ubiquitous. For app developers, it is a key priority to ensure their apps' correctness and reliability. However, many apps still suffer from occasional to frequent crashes, weakening their competitive edge. Large-scale, deep analyses of the characteristics of real-world app crashes can provide useful insights to guide developers, or help improve testing and analysis tools. However, such studies do not exist -- this paper fills this gap. Over a four-month long effort, we have collected 16,245 unique exception traces from 2,486 open-source Android apps, and observed that framework-specific exceptions account for the majority of these crashes. We then extensively investigated the 8,243 framework-specific exceptions (which took six person-months): (1) identifying their characteristics (e.g., manifestation locations, common fault categories), (2) evaluating their manifestation via state-of-the-art bug detection techniques, and (3) reviewing their fixes. Besides the insights they provide, these findings motivate and enable follow-up research on mobile apps, such as bug detection, fault localization and patch generation. In addition, to demonstrate the utility of our findings, we have optimized Stoat, a dynamic testing tool, and implemented ExLocator, an exception localization tool, for Android apps. Stoat is able to quickly uncover three previously-unknown, confirmed/fixed crashes in Gmail and Google+; ExLocator is capable of precisely locating the root causes of identified exceptions in real-world apps. Our substantial dataset is made publicly available to share with and benefit the community.Comment: ICSE'18: the 40th International Conference on Software Engineerin

Deterministic FOIES are Strictly Weaker

After a bounded update to a database, a first-order incremental evaluation system (abbreviated foies) derives the new answer to an expensive database query by applying a first-order query on the old answer and perhaps some stored auxiliary relations. The auxiliary relations are also maintained in first order. A foies can be deterministic or nondeterministic, depending on whether its (stored) auxiliary relations are defined by deterministic or nondeterministic mappings (from databases). In this paper we study the impact of the determinism restriction on foies and we compare nondeterminism with determinism in foies. It turns out that nondeterministic foies are more powerful than the deterministic ones: deterministic foies using auxiliary relations with arity \u3c= k are shown to be strictly weaker than their nondeterministic counterparts for each k \u3e 1, and it is shown that there is a simple query which has a nondeterministic foies with binary auxiliary relations but does not have any deterministic foies with auxiliary relations of any arity. A strict arity hierarchy of deterministic foies is established for the small arities (\u3c= 2). Interestingly, the deterministic foies arity hierarchy collapses to 0-ary when limited to queries over unary relatio

Increment boundedness and nonrecursive incremental evaluation of datalog queries

Abstract. Given a recursive (datalog) query, the nonrecursive incremental evaluation approach uses nonrecursive (datalog) programs to compute the difference of the answers to the query against successive databases between updates. The mechanism used in this approach is called a “First-Order Incremental Evaluation System ” (FOIES). We show that for two large classes of datalog queries, called “generalized (weakly) regular queries”, FOIES always exist. We also define “increment boundedness ” and its variations, which generalize boundedness. Increment bounded queries are shown to have FOIES of certain forms. We also relate increment boundedness to structural recursion, which was proposed for bulk data types. We characterize increment boundednessusing the “insertion idempotency”, “insertion commutativity”, and “determinism ” properties of structural recursion. Finally, we show that the increment boundedness notions are undecidable and a decidable sufficient condition is given.

Arity Bounds in First-Order Incremental Evaluation and Definition of Polynomial Time Database Queries

After inserting a tuple into or deleting a tuple from a database, a first-order incremental evaluation system (or a “foies”) for a database query derives the new query answer by using a first-order query on the new database, the old answer, and perhaps some stored auxiliary relations. Moreover, the auxiliary relations must also be maintained similarly using first-order queries. In this paper we measure the space needed by foies in terms of the maximal arity of the auxiliary relations and present results on the existence and nonexistence of such space-restricted foies for a variety of graph queries, including counting and transitive closure. We construct space efficient foies for these queries and show that the arity bounds are tight using Ehrenfeucht–Fraı̈ssé games. In particular, for transitive closure over undirected graphs, the minimum arity bound of its foies is shown to be exactly two; this resolves an open problem raised by Patnaik and Immerman in 1994. For the general case, we show that the arity-based hierarchy is strict for all arities. The strictness proof uses queries with input relations having arities much larger than the auxiliary relations. It is still open whether the hierarchy remains strict for arities two or greater when the input relations of queries have arities bounded by a fixed number, such as two, or by the arities of the auxiliary relations. Finally, we consider a variation of foies where the cost of storing the answer to the query is also “charged.” We show that the arity hierarchy in this case is also strict. The positions of queries in the two arity-based hierarchies can differ; we give the positions in this hierarchy of the queries considered for the other arity hierarchy

Incremental and Decremental Evaluation of Transitive Closure by First-Order Queries

We study the following problem. Suppose G is a graph and TCG its transitive closure. If G′ is a new graph obtained from G by inserting or deleting an edge e, can the new transitive closure TCG′, be defined in first-order logic using G, TCG and e? In this paper, we show that the answer is positive for (1) acyclic graphs (main result), (2) graphs where the vertices of the deleted edge are not in the same strongly connected component, and (3) graphs where there exists at most one path between each pair of vertices (0-1-path graphs). It is left open whether the new transitive closure is definable in first-order logic for all graphs. We also consider the first-order on-line computation of the dominator relation. Copyright © 1995 Academic Press. All rights reserved

Object Behaviors and Scripts (Extended Abstract)

An object-oriented database (OODB) schema consists of class hierarchies, attributes, and methods. Two method languages are considered: one has operators to create, delete, modify, and migrate objects; the other is extended with temporal conditions. A script is a graph with edges labelled by methods. An object state includes the set of classes it belongs to and values of attributes. The object behavior is a sequence of object states the object goes through during its lifetime. Object behaviors under OODB schemas with sripts are studied. A tool, domain automaton, is introduced, extending a finite state automaton to an infinite alphabet. The equivalence of two domain automata is shown to be decidable. For the simple (extended) language, behaviors under each OODB schema with scripts correspond to the language of a (two-way) domain automaton. Testing whether two OODB schemas with scripts generate the same behaviors is decidable for the simple language; still open for the extended language