This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

\includepdfset

pagecommand=

Programming with High-Level Abstractions


Proceedings of the 3rd Workshop on

Logic and Practice of Programming (LPOP)

December 13, 2022
Editors: David S. Warren and Yanhong A. Liu

Preface

High-level abstractions are essential for improving program correctness and programming productivity. The focus of the 2022 Logic and Practice of Programming workshop is programming with high-level abstractions, especially including sets and logic rules.

Programming with sets, started with SETL in 1969 [1], is central to relational database programming using SQL as well as NoSQL database programming using high-level languages such as Python. Programming with logic and rules, started with QA3 in 1969 [2] and Prolog in 1972 [3], is central to deductive database and knowledge base programming. For building large applications with modular components, programming with objects, such as supported in Python, is also essential.

The goal of this workshop is to bring together the best people and best languages, tools, and ideas to help improve programming with high-level abstractions for the practice of programming. Of particular interest are programming with sets (including relations and dictionaries), with general objects (including high-level types), and with logic rules (including constraints), with an eye to where programming is, and should be, going.

The workshop program consists of invited talks, presentations of position papers, an invited special session on SETL, and an invited panel on future directions.

Potential workshop participants were invited to submit a position paper (1 or 2 pages in PDF format). Because we intend to bring together people from a diverse range of language and programming communities, it is essential that all talks be accessible to non-specialists.

The program committee invited attendees based on their position paper submissions and attempted to accommodate presentation requests in ways that fit with the broader organizational goal. Each submitted paper, except for invited talks, was reviewed by at least three program committee members, and almost all accepted papers received an average score of ‘accept’, or three ‘accept’s or even higher.

LPOP 2022 is a followup to two previous successful LPOP workshops held as part of the Federated Logic Conference (FLoC) in Oxford, UK in 2018 and the ACM SIGPLAN conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH) in Chicago, USA, Virtual, in 2020. LPOP 2018 focused on the integration of logic programming with imperative programming. LPOP 2020 broadened to the practical use of logic as a crosscutting discipline through many areas of computer science. LPOP 2022 focuses on core high-level abstractions around sets and logic rules, to help bring them to the general practice of programming.

LPOP 2022 includes invited talks by four distinguished researchers and practitioners:

  • Robert Kowalski (Imperial College London) describes a way to combine logic programs, reactive systems, and imperative programs in a single system, LPS (Logic Production System).

  • Peter Norvig (Google) considers the use of machine learning with Large Language Models for programming, to examine its promise and pitfalls for programming in the future.

  • Ed Schonberg (NYU and Adacore) traverses the wide span from SETL prototyping to Ada2022, tackling expressiveness and complexity in language design and evolution.

  • Guido van Rossum (Microsoft) leads a discussion on language design with many different goals, driven by the goal of the ability to evolve amid formidable practical challenges.

The program includes eleven presentations by authors of contributed position papers, whose authors and titles are:

  • Fritz Henglein and Mikkel Kragh Mathiesen – Synthetic Algebraic Programming

  • Marc Denecker – Knowledge Representation and Reasoning in the FO(.) Knowledge Base paradigm with IDP-Z3

  • Bharat Jayaraman – Subset-logic Programming: a Declarative Approach to Sets

  • Maximiliano Cristia and Gianfranco Rossi – {log}: Programming and Automated Proof in Set Theory

  • Michael Gelfond – Sets in Logic Programming and Principles of Language Design

  • Michael Leuschel – Programming in B: Sets and Logic all the Way Down

  • Pavle Subotic and Bernhard Scholz – Designing a Datalog Engine for Industrial-Grade Static Analysis

  • Paul Tarau – An Organic Diet for Python: devouring a Logic-based Language

  • Yanhong A. Liu – Alda: Integrating Logic Rules with Everything Else, Seamlessly

  • Benjamin Grosof – Logic Programming in AI: Some Directions

  • Michael Hanus – A Set-Oriented View of Logic Programming

An invited special session on SETL is organized. It has two invited speakers, Micha Sharir (Tel Aviv University) and Eugenio Omodeo (University of Trieste), looking back at the critical optimization work as well as ambitous mathematical proofs project carried out with the vision of SETL creator Jack Schwartz, among a large collection of SETL publiations and software; and it brings up a panel discussion about essential language features for supporting programming with sets in large applications.

An invited panel is organized at the end, with a discussion focused on logic, knowledge, and where programming should be going. The idea is to bring together experts from different programming traditions to discuss views on how practical programming might evolve in the coming years to take better advantage of abstract constructs such as sets and rules.

The overall organization, combining invited talks, paper presentations, and panels, is structured to encourage a deeper understanding of the various approaches and how they might mutually interact. We hope you enjoy the variety of talks and discussions!

We thank all LPOP program committee members for providing timely helpful and insightful reviews. Special thanks to Paul McJones for excellent help that made the SETL session possible, especially through his marvelous work at the Computer History Museum for creating the SETL Historical Sources Archive [1], as well as ALGOL, LISP, Prolog, and other historical software archives.

December 2022 David S. Warren

Y. Annie Liu

Program

Tuesday December 13, 2022
Displayed time zone: Eastern Time (US & Canada)

10:00 Opening and Introduction (David Warren and Annie Liu)
10:10-11:45 From Programming with Sets
(Chair: Ana Milanova, Invited Talk Chair: Fritz Henglein)
10:10 Invited Talk: From SETL Prototyping to Ada2022: A Lesser-Known Passage up the Tower of Babel
Ed Schonberg
10:50 Synthetic Algebraic Programming
Fritz Henglein and Mikkel Kragh Mathiesen
11:00 Invited Session on SETL: Sets, Abstractions, and Programming Language Perspectives
Ed Schonberg, Fritz Henglein, Micha Sharir, Eugenio Omodeo, Guido van Rossum (Chair: David Bacon)
      11:00    On SETL Optimization Work and Memories of Jack
Micha Sharir
      11:15    AEtnaNova, An Alter Ego of SETL
Domenico Cantone, Eugenio Omodeo, and Alberto Policriti
      11:25    Panel: Sets, Abstractions, and Programming Language Perspectives
11:45-12:00 Break: Discussion on Programming with Sets (Host: David Bacon)
12:00-13:20 From Programming with Logic Rules and Sets
(Chair: Peter Van Roy, Invited Talk Chair: Michael Kifer)
12:00 Invited Talk: Combining Logic Programs and Imperative Programs in LPS
Robert Kowalski
12:40 Knowledge Representation and Reasoning in the FO(.) Knowledge Base paradigm with IDP-Z3
Marc Denecker
12:50 Subset-logic Programming: a Declarative Approach to Sets
Bharat Jayaraman
13:00 {log}: Programming and Automated Proof in Set Theory
Maximiliano Cristia and Gianfranco Rossi
13:10 Sets in Logic Programming and Principles of Language Design
Michael Gelfond
13:20-13:40 Break: Discussion on Programming with Logic Rules and Sets (Host: Martin Gebser)
13:40-15:00 Programming with Sets, Logic Rules, and More
(Chair: Tuncay Tekle, Invited Talk Chair: Annie Liu)
13:40 Invited Talk: Q&A: Language Design for Usability and Evolution
Guido van Rossum
14:20 Programming in B: Sets and Logic all the Way Down
Michael Leuschel
14:20 Designing a Datalog Engine for Industrial-Grade Static Analysis
Pavle Subotic and Bernhard Scholz
14:40 An Organic Diet for Python: devouring a Logic-based Language
Paul Tarau
14:50 Alda: Integrating Logic Rules with Everything Else, Seamlessly
Yanhong A. Liu
15:00-15:20 Break: Discussion on Programming with Sets, Logic Rules, and More (Host: Joost Vennekens)
15:20-17:00 Programming, AI, Promise, and Pitfalls
(Chair: David Warren, Invied Talk Chair: Paul Tarau)
15:20 Invited Talk: Programming with Machine Learning: Promise and Pitfalls
Peter Norvig
16:00 Logic Programming in AI: Some Directions
Benjamin Grosof
16:10 A Set-Oriented View of Logic Programming
Michael Hanus
16:20 Invited Panel: Logic, Knowledge, and Where Programming Should Be Going
Ed Schonberg, Robert Kowalski, Guido van Rossum, Peter Norvig, Gopal Gupta, Neng-Fa Zhou (Chair: David Warren)
17:00 Closing (David Warren and Annie Liu)

Organization

General Chairs

David Warren, Stony Brook University and XSB Inc.
Y. Annie Liu, Stony Brook University

Program Chair

Y. Annie Liu, Stony Brook University

Program Committee

Martin Gebser, University of Klagenfurt
Fritz Henglein, University of Copenhagen
Michael Kifer, Stony Brook University
Ana Milanova, Rensselaer Polytechnic Institute
Paul Tarau, University of North Texas
Tuncay Tekle, Stony Brook University and Columbus Consulting
Peter Van Roy, Catholic University of Louvain
Joost Vennekens, KU Leuven
Neng-Fa Zhou, City University of New York

LPOP Website

Abstracts for Invited Talks

From SETL Prototyping to Ada2022: A Lesser-Known Passage up the Tower of Babel

Ed Schonberg

Abstract

In the 1980’s SETL was used in a large-scale project in Software Prototyping to create an executable definition of the new language Ada. That executable definition made more precise the static semantics of the language (such as type resolution) as well as the run-time semantics, in particular the Ada model of concurrency. Subsequent versions of Ada continue to address the original design objectives of the language: modularity, data abstraction, a strong static type model, and facilities for correctness analysis. At the same time, the language reflects the development of programming methodologies over the last 30 years, and has grown accordingly in expressiveness and complexity. This evolution puts into question the notion of ”high-level” and suggests that in the multi-language environment in which modern software lives, ”wide-spectrum” is a better goal for language design.

Bio

Ed Schonberg is professor of Computer Science (Emeritus) at the COurant Institute of Mathematical Sciences, NYU, and retired vice-president of Adacore Inc. He was part of the group at NYU under the leadership of Jack Schwartz that designed and implemented the programming language SETL. With a team led by Robert Dewar he participated in the construction of the first executable definition of Ada (1983). With Robert Dewar and Richard Kenner he co-founded AdaCore. He has been a member of the Ada Rapporteur Group since 1996, and has participated in the design and implementation of successive versions of Ada, up to the current Ada2022.

Combining Logic Programs and Imperative Programs in LPS

Robert Kowalski

Abstract

Logic programs and imperative programs employ different notions of computation. Logic programs compute by proving that a goal is a logical consequence of the program, or alternatively by showing that the goal is true in a model defined by the logic program. Imperative programs compute by starting from an initial state, executing actions to transition from one current state to the next, and terminating when the goal is solved.

I will argue that the two notions of computation can be combined, and that the resulting combination is more powerful than the sum of the two. In the proposed combination, exemplified by the computer language LPS (Logic Production System), logic programs represent the beliefs of an agent, and reactive rules of the logical form if antecedent then consequent represent the agent’s goals. Computation in LPS generates a model, defined by a logic program, to make the reactive rules true, by making consequents of rules true whenever antecedents become true. The model is a classical model with explicit time, but is constructed by starting from an initial state and destructively updating the current state. The model may be infinite if there is no end of time.

Bio

Robert Kowalski is Emeritus Professor at Imperial College London. His research is concerned both with developing human-oriented models of computing and computational models of human thinking. His early work in the field of automated theorem-proving contributed to the development of logic programming in the early 1970s. His later research has focused on the use of logic programming for knowledge representation and problem solving. It includes work on the event calculus, legal reasoning, abductive reasoning and argumentation. He received the IJCAI award for Research Excellence in 2011, and the JSPS Award for Eminent Scientists in 2012.

Q&A: Language Design for Usability and Evolution

Guido van Rossum

Abstract

Programming languages are designed with many different goals in mind. As language designers we imagine a typical user of our language and a typical task to perform. Then we apply other design criteria, for example, the program must run fast or conserve memory, or it must not experience certain types of errors. Finally there are constraints on the implementation, for example, the program must run on a certain class of hardware or in a given environment, or it must support some form of compatibility with another language. Or maybe we want to optimize the developer experience, for example, we want a fast compiler and linker, or we want the user to get to running code quickly.

Often our ambitions and practicalities don’t match. Users (ab)use the language for purposes we had never anticipated. A target platform becomes obsolete – or wildly successful. Users keep making the same mistakes over and over. Another language popularizes features that we wish our language had. Security vulnerabilities could be unpluggable. Lawyers could even get involved. What’s a language designer to do? You can retreat in maintenance (Tcl/Tk), design an ambitious new language (Perl 6), or build a translator (TypeScript). Most languages evolve, more or less successfully.

I invite you to pepper me with questions covering these topics, especially (but not exclusively) when it comes to Python.

Bio

Guido van Rossum is the creator of the Python programming language. He grew up in the Netherlands and studied at the University of Amsterdam, where he graduated with a Master’s Degree in Mathematics and Computer Science. His first job after college was as a programmer at CWI, where he worked on the ABC language, the Amoeba distributed operating system, and a variety of multimedia projects. During this time he created Python as side project. He then moved to the United States to take a job at a non-profit research lab in Virginia, married a Texan, worked for several other startups, and moved to California. In 2005 he joined Google, where he obtained the rank of Senior Staff Engineer, and in 2013 he started working for Dropbox as a Principal Engineer. In October 2019 he retired. After a short retirement he joined Microsoft as Distinguished Engineer in 2020. Until 2018 he was Python’s BDFL (Benevolent Dictator For Life), and he is still deeply involved in the Python community. Guido, his wife and their teenager live in Silicon Valley, where they love hiking, biking and birding.

Programming with Machine Learning: Promise and Pitfalls

Peter Norvig

Abstract

Machine Learning has shown that Large Language Models can solve many problems, including writing code, and explaining solutions to math problems. How reliable are these systems? What would it take to make them better? How will they change what it means to program in the future? This talk attempts some preliminary answers.

Bio

Peter Norvig is a Distinguished Education Fellow at Stanford’s Human-Centered Artificial Intelligence Institute and a researcher at Google Inc; previously he directed Google’s core search algorithms group and Google’s Research group. He was head of NASA Ames’s Computational Sciences Division, where he was NASA’s senior computer scientist and a recipient of NASA’s Exceptional Achievement Award in 2001. He has taught at the University of Southern California, Stanford University, and the University of California at Berkeley, from which he received a Ph.D. in 1986 and the distinguished alumni award in 2006. He was co-teacher of an Artifical Intelligence class that signed up 160,000 students, helping to kick off the current round of massive open online classes. His publications include the books Data Science in Context (to appear in 2022), Artificial Intelligence: A Modern Approach (the leading textbook in the field), Paradigms of AI Programming: Case Studies in Common Lisp, Verbmobil: A Translation System for Face-to-Face Dialog, and Intelligent Help Systems for UNIX. He is also the author of the Gettysburg Powerpoint Presentation and the world’s longest palindromic sentence. He is a fellow of the AAAI, ACM, California Academy of Science and American Academy of Arts & Sciences.

Papers for Invited Talks

See pages 1-last of LPOP22_paper_3599_kowalski.pdf

Contributed Position Papers

See pages 1-last of LPOP22_paper_5208_henglein.pdf

See pages 1-last of LPOP22_paper_7858_denecker.pdf

See pages 1-last of LPOP22_paper_3844_jayaraman.pdf

See pages 1-last of LPOP22_paper_6877_cristia.pdf

See pages 1-last of LPOP22_paper_3647_gelfond.pdf

See pages 1-last of LPOP22_paper_4375_leuschel.pdf

See pages 1-last of LPOP22_paper_1826_subotic.pdf

See pages 1-last of LPOP22_paper_2157_tarau.pdf

See pages 1-last of LPOP22_paper_577_liu.pdf

See pages 1-last of LPOP22_paper_1041_grosof.pdf

See pages 1-last of LPOP22_paper_7620_hanus.pdf

Abstracts for Invited Session on SETL

On SETL Optimization Work and Memories of Jack

Micha Sharir

Abstract

I will briefly mention some concepts and techniques related to the SETL optimizer, and some more advanced program optimization techniques developed in the SETL project, and will devote some time to memories of my scientific and personal interaction with Jack Schwartz, both during and after the SETL years.

Bio

Micha Sharir received his B.Sc., M.Sc., and Ph.D. degrees in Mathematics from Tel Aviv University in 1970, 1972, and 1976, respectively.

He then switched to Computer Science, doing his postdoctoral studies at the Courant Institute of New York University. He returned to Tel Aviv University in 1980, and has been there, at the School of Computer Science, ever since. He has also been a visiting research professor at the Courant Institute, where he has been the deputy head of the Robotics Lab (1985-89). He has served as the head of the Computer Science Department at Tel Aviv University (twice) and as the head of the School of Mathematics (1997-99). He has been one of the co-founders of the Minerva Center for Geometry at Tel Aviv University.

His research interests are in computational and combinatorial geometry and their applications. He has pioneered (with Jack Schwartz) the study of algorithmic motion planning in robotics during the early 1980s, and has been involved in many fundamental research studies that have helped to shape the fields of computational and combinatorial geometry. Among his main achievements, in addition to his earlier work on robotics, are the study of Davenport-Schinzel sequences and their numerous geometric applications, the study of geometric arrangements and their applications, efficient algorithms in geometric optimization (including the introduction and analysis of generalized linear programming), and the study of combinatorial problems involving point configurations. In the past decade, a significant part of his work was devoted to the study of algebraic techniques for combinatorial geometry.

He has written four books, about 350 papers in journals and books, four written and edited books, and about 250 papers in selective conferences.

His work won him several prizes, including a Max-Planck research prize (1992, jointly with Emo Welzl), the Feher Prize (1999), the Mif’al Hapais’ Landau Prize (2002), and the EMET Prize (2007). He was the incumbent of the Nizri Chair in Computational Geometry and Robotics, a Fellow of the Association for Computing Machinery (since 1997), and has an honorary doctorate degree from the University of Utrecht (1996). He is a member of the Israeli Academy of Sciences and Humanities (since 2018). He has supervised 27 Ph.D. students, many of which are now at various stages of an academic career (ranging from postdocs to chaired full professors), in Israel and abroad.

Papers for Invited Session on SETL

See pages 1-last of LPOP22_paper_6854_omodeo.pdf