8 research outputs found
Algorithm Diversity for Resilient Systems
Diversity can significantly increase the resilience of systems, by reducing
the prevalence of shared vulnerabilities and making vulnerabilities harder to
exploit. Work on software diversity for security typically creates variants of
a program using low-level code transformations. This paper is the first to
study algorithm diversity for resilience. We first describe how a method based
on high-level invariants and systematic incrementalization can be used to
create algorithm variants. Executing multiple variants in parallel and
comparing their outputs provides greater resilience than executing one variant.
To prevent different parallel schedules from causing variants' behaviors to
diverge, we present a synchronized execution algorithm for DistAlgo, an
extension of Python for high-level, precise, executable specifications of
distributed algorithms. We propose static and dynamic metrics for measuring
diversity. An experimental evaluation of algorithm diversity combined with
implementation-level diversity for several sequential algorithms and
distributed algorithms shows the benefits of algorithm diversity
Logic Programming Applications: What Are the Abstractions and Implementations?
This article presents an overview of applications of logic programming,
classifying them based on the abstractions and implementations of logic
languages that support the applications. The three key abstractions are join,
recursion, and constraint. Their essential implementations are for-loops, fixed
points, and backtracking, respectively. The corresponding kinds of applications
are database queries, inductive analysis, and combinatorial search,
respectively. We also discuss language extensions and programming paradigms,
summarize example application problems by application areas, and touch on
example systems that support variants of the abstractions with different
implementations
Assurance of Distributed Algorithms and Systems: Runtime Checking of Safety and Liveness
This paper presents a general framework and methods for complete programming
and checking of distributed algorithms at a high-level, as in pseudocode
languages, but precisely specified and directly executable, as in formal
specification languages and practical programming languages, respectively. The
checking framework, as well as the writing of distributed algorithms and
specification of their safety and liveness properties, use DistAlgo, a
high-level language for distributed algorithms. We give a complete executable
specification of the checking framework, with a complete example algorithm and
example safety and liveness properties.Comment: Small fixes to improve property specifications, including
improvements not in the RV 2020 final versio
IceDust: Incremental and Eventual Computation of Derived Values in Persistent Object Graphs
Derived values are values calculated from base values. They can be
expressed in object-oriented languages by means of getters calculating the derived value, and in relational or logic databases by means of (materialized) views. However, switching to a different calculation strategy (for example caching) in object-oriented programming requires invasive code changes, and the databases limit expressiveness by disallowing recursive aggregation.
In this paper, we present IceDust, a data modeling language for
expressing derived attribute values without committing to a calculation strategy. IceDust provides three strategies for calculating derived values in persistent object graphs: Calculate-on-Read, Calculate-on-Write, and Calculate-Eventually. We have developed a path-based abstract interpretation that provides static dependency analysis to generate code for these strategies. Benchmarks show that different strategies perform better in different scenarios. In addition we have conducted a case study that suggests that derived value calculations of systems used in practice can be expressed in IceDust
Integrating Logic Rules with Everything Else, Seamlessly
This paper presents a language, Alda, that supports all of logic rules, sets,
functions, updates, and objects as seamlessly integrated built-ins. The key
idea is to support predicates in rules as set-valued variables that can be used
and updated in any scope, and support queries using rules as either explicit or
implicit automatic calls to an inference function.
We have defined a formal semantics of the language, implemented a prototype
compiler that builds on an object-oriented language that supports concurrent
and distributed programming and on an efficient logic rule system, and
successfully used the language and implementation on benchmarks and problems
from a wide variety of application domains. We describe the compilation method
and results of experimental evaluation.Comment: To be published in Theory and Practice of Logic Programming, Special
issue for selected papers from 39nd International Conference on Logic
Programming. arXiv admin note: substantial text overlap with arXiv:2205.1520