360 research outputs found
A Calculus for Variational Programming
Variation is ubiquitous in software. Many applications can benefit from making this variation explicit, then manipulating and computing with it directly---a technique we call "variational programming". This idea has been independently discovered in several application domains, such as efficiently analyzing and verifying software product lines, combining bounded and symbolic model-checking, and computing with alternative privacy profiles. Although these
domains share similar core problems, and there are also many similarities in the solutions, there is no dedicated programming language support for variational programming. This makes the various implementations tedious, prone to errors, hard to maintain and reuse, and difficult to compare.
In this paper we present a calculus that forms the basis of a programming language with explicit support for representing, manipulating, and computing with variation in programs and data. We illustrate how such a language can simplify the implementation of variational programming tasks. We present the syntax and semantics of the core calculus, a sound type system, and a type inference algorithm that produces principal types
Symbolic quantum programming for supporting applications of quantum computing technologies
The goal of this paper is to deliver the overview of the current state of the
art, to provide experience report on developing quantum software tools, and to
outline the perspective for developing quantum programming tools supporting
symbolic programming for the needs of quantum computing technologies. The main
focus of this paper is on quantum computing technologies, as they can in the
most direct way benefit from developing tools enabling the symbolic
manipulation of quantum circuits and providing software tools for creating,
optimizing, and testing quantum programs. We deliver a short survey of the most
popular approaches in the field of quantum software development and we aim at
pointing their strengths and weaknesses. This helps to formulate a list of
desirable characteristics which should be included in quantum computing
frameworks. Next, we describe a software architecture and its preliminary
implementation supporting the development of quantum programs using symbolic
approach, encouraging the functional programming paradigm, and, at the same,
time enabling the integration with high-performance and cloud computing. The
described software consists of several packages developed to address different
needs, but nevertheless sharing common design concepts. We also outline how the
presented approach could be used in tasks in quantum software engineering,
namely quantum software testing and quantum circuit construction.Comment: 14 pages, contribution to QP2023 Workshop, Programming'23, Tokyo, JP,
March 13-17, 202
Quantitative Robustness Analysis of Quantum Programs (Extended Version)
Quantum computation is a topic of significant recent interest, with practical
advances coming from both research and industry. A major challenge in quantum
programming is dealing with errors (quantum noise) during execution. Because
quantum resources (e.g., qubits) are scarce, classical error correction
techniques applied at the level of the architecture are currently
cost-prohibitive. But while this reality means that quantum programs are almost
certain to have errors, there as yet exists no principled means to reason about
erroneous behavior. This paper attempts to fill this gap by developing a
semantics for erroneous quantum while-programs, as well as a logic for
reasoning about them. This logic permits proving a property we have identified,
called -robustness, which characterizes possible "distance" between
an ideal program and an erroneous one. We have proved the logic sound, and
showed its utility on several case studies, notably: (1) analyzing the
robustness of noisy versions of the quantum Bernoulli factory (QBF) and quantum
walk (QW); (2) demonstrating the (in)effectiveness of different error
correction schemes on single-qubit errors; and (3) analyzing the robustness of
a fault-tolerant version of QBF.Comment: 34 pages, LaTeX; v2: fixed typo
Recommended from our members
Variational Typing and Its Applications
The study of variational typing originated from the problem of type inference for variational programs, which encode numerous different but related plain programs. In this dissertation, I present a sound and complete type inference algorithm for inferring types of all plain programs encoded in variational programs. The proposed algorithm runs exponentially faster than the strategy of generating all plain programs and applying type inference to them separately. I also present an error-tolerant version of variational type inference to deliver better feedback in the presence of ill-typed plain programs. All presented algorithms require various kinds of variational unification. I prove that all these problems are decidable and unitary, and I develop sound and complete unification algorithms. The idea of variational typing has many applications. As one example, I present how variational typing can be employed to improve the diagnosis of type errors in functional programs, a problem that has been extensively studied
A Versioned Approach to Web Service Evolution
Applications based on micro-services or web services have had a significant growth
due to the exponential increase in the use of mobile devices whose applications rely
almost entirely on this type of interfaces. However, using an external interface comes
with no guarantees to the developers using it. Changes may be introduced at any moment, which can break the software that is using those APIs. It is necessary to give the consumers guarantees that their software will not break, but not at the expense of stagnating thedevelopment of said web service.
In this document we present a programming model to evolve web services in a sustainable way and to automate most of the maintainability that might be required by the consumer. This model works by allowing multiple versions to be deployed, and then using a relation containing metadata to type check versions. By doing this, it is possible toguarantee type safety between all the versions to provide a sustainable way to evolve the service. A prototype framework was implemented in JavaScript, where it is possible to visualize the model working in an environment similar to what it is used in the industry
nowadays.
Finally we present a comparison of our prototype with the state of the art, thus demonstrating that our solution presents a viable method of evolution of web services
Recommended from our members
Extending Type Inference to Variational Programs
Through the use of conditional compilation and related tools, many software projects can be used to generate a huge
number of related programs. The problem of typing such variational software is difficult. The brute-force strategy
of generating all variants and typing each one individually is (1) usually infeasible for efficiency reasons and (2)
produces results that do not map well to the underlying variational program. Recent research has focused mainly
on efficiency and addressed only the problem of type checking. In this work we tackle the more general problem of
variational type inference and introduce variational types to represent the result of typing a variational program. We
introduce the variational lambda calculus (VLC) as a formal foundation for research on typing variational programs.
We define a type system for VLC in which VLC expressions are mapped to correspondingly variational types. We
show that the type system is correct by proving that the typing of expressions is preserved over the process of
variation elimination, which eventually results in a plain lambda calculus expression and its corresponding type.
We identify a set of equivalence rules for variational types and prove that the type unification problem modulo these
equivalence rules is unitary and decidable; we also present a sound and complete unification algorithm. Based on
the unification algorithm, the variational type inference algorithm is an extension of algorithm W. We show that
it is sound and complete and computes principal types. We also consider the extension of VLC with sum types, a
necessary feature for supporting variational data types, and demonstrate that the previous theoretical results also
hold under this extension. Finally, we characterize the complexity of variational type inference and demonstrate the
efficiency gains over the brute-force strategy.This is an author's peer-reviewed final manuscript, as accepted by the publisher. The published article is copyrighted by the Association for Computing Machinery and can be found at: http://toplas.acm.org/.Keywords: variational type inference, variational types, variational lambda calculu
PlinyCompute: A Platform for High-Performance, Distributed, Data-Intensive Tool Development
This paper describes PlinyCompute, a system for development of
high-performance, data-intensive, distributed computing tools and libraries. In
the large, PlinyCompute presents the programmer with a very high-level,
declarative interface, relying on automatic, relational-database style
optimization to figure out how to stage distributed computations. However, in
the small, PlinyCompute presents the capable systems programmer with a
persistent object data model and API (the "PC object model") and associated
memory management system that has been designed from the ground-up for high
performance, distributed, data-intensive computing. This contrasts with most
other Big Data systems, which are constructed on top of the Java Virtual
Machine (JVM), and hence must at least partially cede performance-critical
concerns such as memory management (including layout and de/allocation) and
virtual method/function dispatch to the JVM. This hybrid approach---declarative
in the large, trusting the programmer's ability to utilize PC object model
efficiently in the small---results in a system that is ideal for the
development of reusable, data-intensive tools and libraries. Through extensive
benchmarking, we show that implementing complex objects manipulation and
non-trivial, library-style computations on top of PlinyCompute can result in a
speedup of 2x to more than 50x or more compared to equivalent implementations
on Spark.Comment: 48 pages, including references and Appendi
Aircraft Vertical Profile Implementation using Directed-Graph Methods
Aircraft Vertical Profile Simulation is Realized using a Demand-Driven Minimal-Calculation Directed Graph Structure to Reduce Calculation Time and to Force Synchronization of the Performance Measurement Functions with the System State Variables. Performance-Directed Model Adaptation Makes Dynamic Vertical Profile Path Corrections, in the Presence of Fixed Drag Variations, Possible. Drag Variations Ranging from + 10 Percent to - 10 Percent Yielded Fuel Consumption Improvements of Less Than 1 Percent in the Majority of the Cases. Calculation Time Improvement for Path Simulation Ranges from a Factor of 1.19 in the Worst Case to 1.5 in the Best Case. © 1988 IEE
- …