Andrew D. Gordon

Andrew D. Gordon

Auto-generated profile, based on publicly available information

Andrew D. Gordon

Microsoft Research

Research Focus & Metrics

Academic Career Length

25Years (2002-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
4 September 2016 in ACM SIGPLAN Notices
Verified
Journal Article
Open access
JBJohannes Borgström
Johannes Borgström
ULUgo Dal Lago
Ugo Dal Lago
AGAndrew D. Gordon
Andrew D. Gordon
MSMarcin Szymczak
Marcin Szymczak
We develop the operational semantics of an untyped probabilistic λ-calculus with continuous distributions, and both hard and soft constraints,as a foundation for universal probabilistic programming languages such as Church, Anglican, and Venture. Our first contribution is to adapt the classic operational semantics of λ-calculus to a continuous setting via creating a measure space on terms and defining step-indexed approximations. We prove equivalence of big-step and small-step formulations of this distribution-based semantics . To move closer to inference techniques, we also define the sampling-based semantics of a term as a function from a trace of random samples to a value. We show that the distribution induced by integration over the space of traces equals the distribution-based semantics. Our second contribution is to formalize the implementation technique of trace Markov chain Monte Carlo (MCMC) for our calculus and to show its correctness. A key step is defining sufficient conditions for the distribution induced by trace MCMC to converge to the distribution-based semantics. To the best of our knowledge, this is the first rigorous correctness proof for trace MCMC for a higher-order functional language, or for a language with soft constraints.

11 July 2014 in Journal of Computer Security
Verified
Journal Article
Open access
PDF file
FDFrançois Dupressoir
François Dupressoir
AGAndrew D. Gordon
Andrew D. Gordon
JJJan Jürjens
Jan Jürjens
DNDavid A. Naumann
David A. Naumann
We describe how to verify security properties of C code for cryptographic protocols by using a general-purpose verifier. We prove security theorems in the symbolic model of cryptography. Our techniques include: use of ghost state to attach formal alg

13 June 2005 in Theoretical Computer Science
Verified
Journal Article
Closed access
KBKarthikeyan Bhargavan
Karthikeyan Bhargavan
CFCédric Fournet
Cédric Fournet
AGAndrew D. Gordon
Andrew D. Gordon

26 May 2025 in ACM Transactions on Software Engineering and Methodology
Verified
Journal Article
Open access
DRDiana Robinson
Diana Robinson
CCChristian Cabrera
Christian Cabrera
AGAndrew D. Gordon
Andrew D. Gordon
NLNeil Lawrence
Neil Lawrence
LMLars Mennen
Lars Mennen
What if end-users could own the software development lifecycle from conception to deployment using only requirements expressed in language, images, video or audio? We explore this idea, building on the capabilities that Generative AI brings to software generation and maintenance techniques. How could designing software in this way better serve end-users? What are the implications of this process for the future of end-user software engineering and the software development lifecycle? We discuss the research needed to bridge the gap between where we are today and these imagined systems of the future.

1 January 2012 in Journal of Functional Programming
Verified
Journal Article
Open access
PDF file
GBGavin M. Bierman
Gavin M. Bierman
AGAndrew D. Gordon
Andrew D. Gordon
CHCătălin Hriţcu
Cătălin Hriţcu
DLDavid Langworthy
David Langworthy
We study a first-order functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and type-test (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; for example, intersection, union, negation, singleton, nullable, variant, and algebraic types are all derivable. We formulate a semantics in which expressions denote terms, and types are interpreted as first-order logic formulas. Subtyping is defined as valid implication between the semantics of types. The formulas are interpreted in a specific model that we axiomatize using standard first-order theories. On this basis, we present a novel type-checking algorithm able to eliminate many dynamic tests and to detect many errors statically. The key idea is to rely on a Satisfiability Modulo Theories solver to compute subtyping efficiently. Moreover, using a satisfiability modulo theories solver allows us to show the uniqueness of normal forms for non-deterministic expressions, provide precise counterexamples when type-checking fails, detect empty types, and compute instances of types statically and at run-time.

17 October 2022 in arXiv
Verified
Preprint
Open access
PDF file
ASAdvait Sarkar
Advait Sarkar
AGAndrew D. Gordon
Andrew D. Gordon
CNCarina Negreanu
Carina Negreanu
CPChristian Poelitz
Christian Poelitz
SRSruti Srinivasa Ragavan
Sruti Srinivasa Ragavan
BZBen Zorn
Ben Zorn
Large language models, such as OpenAI's codex and Deepmind's AlphaCode, can generate code to solve a variety of problems expressed in natural language. This technology has already been commercialised in at least one widely-used programming editor extension: GitHub Copilot. In this paper, we explore how programming with large language models (LLM-assisted programming) is similar to, and differs from, prior conceptualisations of programmer assistance. We draw upon publicly available experience reports of LLM-assisted programming, as well as prior usability and design studies. We find that while LLM-assisted programming shares some properties of compilation, pair programming, and programming via search and reuse, there are fundamental differences both in the technical possibilities as well as the practical experience. Thus, LLM-assisted programming ought to be viewed as a new way of programming with its own distinct properties and challenges. Finally, we draw upon observations from a user study in which non-expert end user programmers use LLM-assisted tools for solving data tasks in spreadsheets. We discuss the issues that might arise, and open research challenges, in applying large language models to end-user programming, particularly with users who have little or no programming expertise.