Art, Science, and Engineering of Programming

Context: In the context of exploring the art, science and engineering of programming, the question of which programming languages should be taught first has been fiercely debated since computer science teaching started in universities. Failure to grasp programming readily almost certainly implies failure to progress in computer science. Inquiry: What first programming languages are being taught? There have been regular national-scale surveys in Australia and New Zealand, with the only US survey reporting on a small subset of universities. This the first such national survey of universities in the UK. Approach: We report the results of the first survey of introductory programming courses (N=80) taught at UK universities as part of their first year computer science (or related) degree programmes, conducted in the first half of 2016. We report on student numbers, programming paradigm, programming languages and environment/tools used, as well as the underpinning rationale for these choices. Knowledge: The results in this first UK survey indicate a dominance of Java at a time when universities are still generally teaching students who are new to programming (and computer science), despite the fact that Python is perceived, by the same respondents, to be both easier to teach as well as to learn. Grounding: We compare the results of this survey with a related survey conducted since 2010 (as well as earlier surveys from 2001 and 2003) in Australia and New Zealand. Importance: This survey provides a starting point for valuable pedagogic baseline data for the analysis of the art, science and engineering of programming, in the context of substantial computer science curriculum reform in UK schools, as well as increasing scrutiny of teaching excellence and graduate employability for UK universities.

Ellen Murphy

Tom Crick

James H. Davenport

The Art Science and Engineering of Programming

An Analysis of Introductory Programming Courses at UK Universities

英国大学编程入门课程分析

To Err or Not to Err? : Subtle Interactions Between Parameters for Common Python Library Functions

Malin Källén

Tobias Wrigstad

是否出错？：常见Python库函数参数间的微妙交互

Many improvements to programming have come from shortening feedback loops, for example with Integrated Development Environments, Unit Testing, Live Programming, and Distributed Version Control. A barrier to feedback that deserves greater attention is Schema Evolution. When requirements on the shape of data change then existing data must be migrated into the new shape, and existing code must be modified to suit. Currently these adaptations are often performed manually, or with ad hoc scripts. Manual schema evolution not only delays feedback but since it occurs outside the purview of version control tools it also interrupts collaboration. Schema evolution has long been studied in databases. We observe that the problem also occurs in non-database contexts that have been less studied. We present a suite of challenge problems exemplifying this range of contexts, including traditional database programming as well as live front-end programming, model-driven development, and collaboration in computational documents. We systematize these various contexts by defining a set of layers and dimensions of schema evolution. We offer these challenge problems to ground future research on the general problem of schema evolution in interactive programming systems and to serve as a basis for evaluating the results of that research. We hope that better support for schema evolution will make programming more live and collaboration more fluid.

Jonathan Edwards

Tomas Petricek

Tijs van der Storm

Geoffrey Litt

Schema Evolution in Interactive Programming Systems

交互式编程系统中的模式演化

Live programming features can be found in a range of programming environments, from individual prototypes to widely used environments. While liveness is generally considered a useful property, there is little empirical evidence on when and how liveness can be beneficial. Even though there are few experimental studies, their results are largely inconclusive. We reviewed existing experiments and related studies to gather a collection of potential effects of liveness and moderating factors. Based on this collection, we concluded that **task complexity** and **prior experience addressing liveness** are potentially essential factors neglected in previous experiments. To fill this gap, we devised and conducted a controlled experiment (N = 37) testing the hypothesis that task complexity moderates the effects of live introspection tools on participants? debugging efficiency, given participants with prior experience with liveness. Our results do not support the hypothesis that task complexity moderates the effect of live introspection tools. This non-significant moderation effect might result from the low number of participants, as the data suggests a moderation effect. The results also show that in our experiment setting, live introspection tools significantly reduced the time participants took to debug the tasks. For researchers interested in the effects of liveness, our findings suggest that studies on liveness should make conscious choices about task complexity and participants' prior experience with liveness. For designers of programming environments, the results of our experiment are a step toward understanding when and how programming tools should be live to become more helpful to programmers.

Patrick Rein

Stefan Ramson

Tom Beckmann

Robert Hirschfeld

Does Task Complexity Moderate the Benefits of Liveness? A Controlled Experiment

任务复杂性是否会调节直播的效益？一项控制实验

In this paper, we present the design of Owi, a symbolic interpreter for WebAssembly written in OCaml, and how we used it to create a state-of-the-art tool to find bugs in programs combining C and Rust code. WebAssembly (Wasm) is a binary format for executable programs. Originally intended for web applications, Wasm is also considered a serious alternative for server-side runtimes and embedded systems due to its performance and security benefits. Despite its security guarantees and sandboxing capabilities, Wasm code is still vulnerable to buffer overflows and memory leaks, which can lead to exploits on production software. To help prevent those, different techniques can be used, including symbolic execution. Owi is built around a modular, monadic interpreter capable of both normal and symbolic execution of Wasm programs. Monads have been identified as a way to write modular interpreters since 1995 and this strategy has allowed us to build a robust and performant symbolic execution tool which our evaluation shows to be the best currently available for Wasm. Moreover, because WebAssembly is a compilation target for multiple languages (such as Rust and C), Owi can be used to find bugs in C and Rust code, as well as in codebases mixing the two. We demonstrate this flexibility through illustrative examples and evaluate its scalability via comprehensive experiments using the 2024 Test-Comp benchmarks. Results show that Owi achieves comparable performance to state-of-the-art tools like KLEE and Symbiotic, and exhibits advantages in specific scenarios where KLEE's approximations could lead to false negatives.

Léo Andrès

Filipe Marques

Arthur Carcano

Pierre Chambart

José Fragoso Santos

Jean-Christophe Filliâtre

Owi: Performant Parallel Symbolic Execution Made Easy, an Application to WebAssembly

Owi：轻松实现高性能并行符号执行，应用于WebAssembly

Context Roblox Studio lets millions of creators build interactive experiences by programming in a variant of Lua called Luau.The creators form a broad group, ranging from novices writing their first script to professional developers; thus, Luau must support a wide audience.As part of its efforts to support all kinds of programmers, Luau includes an optional, gradual type system and goes to great lengths to minimize false positive errors.Inquiry Since Luau is currently being used by many creators, we want to collect data to improve the language and, in particular, the type system.The standard way to collect data is to deploy client-side telemetry; however, we cannot scrape personal data or proprietary information, which means we cannot collect source code fragments, error messages, or even filepaths.The research questions are thus about how to conduct telemetry that is not invasive and obtain insights from it about type errors.Approach We designed and implemented a pseudonymized, randomly-sampling telemetry system for Luau.Telemetry records include a timestamp, a session id, a reason for sending, and a numeric summary of the most recent type analyses.This information lets us study type errors over time without revealing private data.We deployed the system in Roblox Studio during Spring and collected over . million telemetry records from over , sessions.Knowledge We present several findings about Luau, all of which suggest that telemetry is an effective way to study type error pragmatics.One of the less-surprising findings is that opt-in gradual types are unpopular: there is anx gap between the number of untyped Luau sessions and the number of typed ones.One surprise is that the strict mode for type analysis is overly conservative about interactions with data assets.A reassuring finding is that type analysis rarely hits its internal limits on problem size.Grounding Our findings are supported by a dataset of over . million telemetry records.The data and scripts for analyzing it are available in an artifact.Importance Beyond the immediate benefits to Luau, our findings about types and type errors have implications for adoption and ergonomics in other gradual languages such as TypeScript, Elixir, and Typed Racket.Our telemetry design is of broad interest, as it reports on type errors without revealing sensitive information.

Ben Greenman

Alan Jeffrey

Shriram Krishnamurthi

Mitesh Shah

Privacy-Respecting Type Error Telemetry at Scale

大规模隐私保护类型错误遥测

Context Edge graphs are graphs whose edges are labelled with identifiers, and nodes can have multiple edges between them.They are used to model a wide range of systems, including networks with distances or degrees of connection and complex relational data.Inquiry Unfortunately, the homogeneity of this graph structure prevents an effective representation in (functional) programs.Either their interface is riddled with partial functions, or the representations are computationally inefficient to process.Approach We present a novel data type for edge graphs, based on total and recursive definitions, that prevents usage errors from partial APIs and promotes structurally recursive computations.We follow an algebraic approach and provide a set of primitive constructors and combinators, along with equational laws that identify semantically equivalent constructions.Knowledge This algebra translates directly into an implementation using algebraic data types, and its homomorphisms give rise to functions for manipulating and transforming these edge graphs.Grounding We exploit the fact that many common graph algorithms are such homomorphisms to implement them in our framework.Importance In giving a theoretical grounding for the edge graph data type, we can formalise properties such as soundness and completeness of the representation while also minimising usage errors and maximising re-usability.

Jack Liell-Cock

Tom Schrijvers

Let a Thousand Flowers Bloom

让百花齐放

ISSN	2473-7321
h-index	10

Publication Information	Publisher: AOSA Inc.，Publishing cycle: ，Journal Type: journal，Open Access Journals: No
Basic data	Year of publication: 2017，Proportion of original research papers: ，Self Citation Rate:， Gold OA Rate:

Art, Science, and Engineering of Programming

Journal Citation Format

A journal article with 1 author

A journal article with 2 authors

A journal article with 3 authors

A journal article with 5 or more authors

Books Citation Format

Thesis Citation Format

Web sites Citation Format

Patent Citation Format

Staying up late manually editing references? ivySCI automatically matches journals and helps you generate references with a single click.

Share Submission Experience

An Analysis of Introductory Programming Courses at UK Universities

To Err or Not to Err? : Subtle Interactions Between Parameters for Common Python Library Functions

To Err or Not to Err? : Subtle Interactions Between Parameters for Common Python Library Functions

Schema Evolution in Interactive Programming Systems

Does Task Complexity Moderate the Benefits of Liveness? A Controlled Experiment

Schema Evolution in Interactive Programming Systems

Does Task Complexity Moderate the Benefits of Liveness? A Controlled Experiment

Owi: Performant Parallel Symbolic Execution Made Easy, an Application to WebAssembly

Privacy-Respecting Type Error Telemetry at Scale

Let a Thousand Flowers Bloom