Earth: Atmospheric Evolution of a Habitable Planet

Our present-day atmosphere is often used as an analog for potentially habitable exoplanets, but Earth's atmosphere has changed dramatically throughout its 4.5 billion year history. For example, molecular oxygen is abundant in the atmosphere today but was absent on the early Earth. Meanwhile, the physical and chemical evolution of Earth's atmosphere has also resulted in major swings in surface temperature, at times resulting in extreme glaciation or warm greenhouse climates. Despite this dynamic and occasionally dramatic history, the Earth has been persistently habitable--and, in fact, inhabited--for roughly 4 billion years. Understanding Earth's momentous changes and its enduring habitability is essential as a guide to the diversity of habitable planetary environments that may exist beyond our solar system and for ultimately recognizing spectroscopic fingerprints of life elsewhere in the Universe. Here, we review long-term trends in the composition of Earth's atmosphere as it relates to both planetary habitability and inhabitation. We focus on gases that may serve as habitability markers (CO2, N2) or biosignatures (CH4, O2), especially as related to the redox evolution of the atmosphere and the coupled evolution of Earth's climate system. We emphasize that in the search for Earth-like planets we must be mindful that the example provided by the modern atmosphere merely represents a single snapshot of Earth's long-term evolution. In exploring the many former states of our own planet, we emphasize Earth's atmospheric evolution during the Archean, Proterozoic, and Phanerozoic eons, but we conclude with a brief discussion of potential atmospheric trajectories into the distant future, many millions to billions of years from now. All of these 'Alternative Earth' scenarios provide insight to the potential diversity of Earth-like, habitable, and inhabited worlds.Comment: 34 pages, 4 figures, 4 tables. Review chapter to appear in Handbook of Exoplanet

Potential Contribution of Existing Computer-Based Models to Comparative Assessment of Development Options

Abstract—While a large body of research is dedicated to testing for feature interactions in configurable software, there has been little work that examines what constitutes such a fault at the code level. In consequence, we do not know how prevalent real interaction faults are in practice, what a typical interaction fault looks like in code, how to seed interaction faults, or whether current interaction testing techniques are effective at finding the faults they aim to detect. We make a first step in this direction, by deriving a whitebox criterion for an interaction fault. Armed with this criterion, we perform an exploratory study on hundreds of faults from the field in two open source systems. We find that only three of the 28 which appear to be interaction faults are in fact due to features ’ interactions. We investigate the remaining 25 and find that, although they could have been detected without interaction testing, varying the system configuration amplifies the fault-finding power of a test suite, making these faults easier to expose. Thus, we characterize the benefits of interaction testing in regards to both interaction and non-interaction faults. We end with a discussion of several mutations that can be used to mimic interaction faults based on the faults we see in practice

The Variability-Space Topography of Interaction Faults

As software grows more prevalent and more integral to human activities, the potential impact of faulty software also grows, making cost-effective anticipation, prevention, and mitigation of software failures all the more important. But the rising number of purposes to which software is put also drives systems to become increasingly versatile and thus larger and more configurable. Once a system becomes highly configurable, the challenges of verification become subject to a combinatorial explosion: software engineers must consider not only whether each individual feature satisfies its requirements, but also whether requirements are satisfied under every feasible combination of those features, as the features might interact. While large combinatorial spaces can be dealt with, any such treatment depends critically on an accurate model of how faults are tied to the system configuration. Unfortunately, existing techniques for characterizing behaviorial properties like faultiness in highly configurable software use models that do little to account for the differences between a system\u27s features or the ways in which those features are related to each other. For instance, the most popular approach, fixed-strength combinatorial interaction testing, relies on estimates of the number of features that a fault might involve while ignoring questions about which features might be counted in those estimates. This imprecision limits practitioners\u27 ability to focus on fault-prone interactions, making it more difficult to prevent, diagnose, or mitigate interaction faults, and it also limits researchers\u27 ability to discern patterns in faults that might inform improved practices. In this work I develop a formalism, variability-space topography, with which one can express more nuanced relationships between features and configuration-dependent properties like the presence of a fault. I then apply variability-space topography to real systems in three studies using a dynamic analysis, a static analysis, and a combined dynamic/static analysis, and find that the additional precision reveals a structure underlying the distribution of interaction faults. I also demonstrate the practical value of these findings in applications such as mapping configuration-dependent code, avoiding failures by reconfiguration, distinguishing interaction and non-interaction faults, and seeding realistic configuration-dependent and interaction faults

A Slice-based Decision Procedure for Type-based Partial Orders TR-UNL-CSE-2010-0004

Automated software verification and path-sensitive program analysis require the ability to distinguish executable program paths from those that are infeasible. To achieve this, program paths are encoded symbolically as a conjunction of constraints and submitted to an SMT solver; satisfiable path constraints are then analyzed further. In this paper, we study type-related constraints that arise in pathsensitive analysis of object-oriented programs with forms of multiple inheritance. The dynamic type of a value is critical in determining program branching related to dynamic dispatch, type casting, and explicit type tests. We develop a custom decision procedure for queries in a theory of type-based partial orders and show that the procedure is sound and complete, has low complexity, and is amenable to integration into an SMT framework. We present an empirical evaluation that demonstrates the speed and robustness of our procedure relative to Z3.

Deciding Type-Based Partial-Order Constraints for Path-Sensitive Analysis

The precision and scalability of path-sensitive program analyses depend on their ability to distinguish feasible and infeasible program paths. Analyses express path feasibility as the satisfiability of conjoined branch conditions, which is then decided by cooperating decision procedures such as those in satisfiability modulo theory (SMT) solvers. Consequently, efficient underlying decision procedures are key to precise, scalable program analyses. When we investigate the branch conditions accumulated by inter-procedural path-sensitive analyses of object-oriented programs, we find that many relate to an object\u27s dynamic type. These conditions arise from explicit type tests and the branching implicit in dynamic dispatch and type casting. These conditions share a common form that comprises a fragment of the theory of partial orders, which we refer to as type-based partial orders (TPO). State-of-the-art SMT solvers can heuristically instantiate the quantified formulae that axiomatize partial orders, and thereby support TPO constraints. We present two custom decision procedures with significantly better performance. On benchmarks that reflect inter-procedural path-sensitive analyses applied to significant Java systems, the custom procedures run three orders of magnitude faster. The performance of the two decision procedures varies across benchmarks, which suggests that a portfolio approach may be beneficial for solving constraints generated by program analyses

An improved meta-heuristic search for constrained interaction testing

Combinatorial interaction testing (CIT) is a costeffective sampling technique for discovering interaction faults in highly configurable systems. Recent work with greedy CIT algorithms efficiently supports constraints on the features that can coexist in a configuration. But when testing a single system configuration is expensive, greedy techniques perform worse than meta-heuristic algorithms because they produce larger samples. Unfortunately, current meta-heuristic algorithms are inefficient when constraints are present. We investigate the sources of inefficiency, focusing on simulated annealing, a well-studied meta-heuristic algorithm. From our findings we propose changes to improve performance, including a reorganized search space based on the CIT problem structure. Our empirical evaluation demonstrates that the optimizations reduce run-time by three orders of magnitude and yield smaller samples. Moreover, on real problems the new version compares favorably with greedy algorithms. 1