How statically-typed functional programmers write code

Lubin, Justin; Chasins, Sarah

doi:10.1145/3485532

Cited by 8 publications

(3 citation statements)

References 74 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…That said, GT is an established and popular method in Software Engineering research [Stol et al 2016], and recently [Lubin and Chasins 2021] employed Constructivist GT [Charmaz 2006] to develop a deeper understanding of how statically-typed functional programmers write code. Which is why I recommend building a grounded theory of "How Rust Programmers Write Code".…”

Section: Grounded Theorymentioning

confidence: 99%

The Usability of Advanced Type Systems: Rust as a Case Study

Ferdowsi¹

2023

Preprint

View full text Add to dashboard Cite

Advanced type systems that enforce various correctness and safety guarantees-such as linear and ownership types-have a long history in the Programming Languages research community. Despite this history, a humancentered evaluation of these type systems and their usability was all but absent, with empirical evaluations limited to testing their expressiveness in programs written by experts, i.e. the creators of the type system.In the past few years, this has begun to change with the adoption of a version of affine types and ownership in the popular Rust programming language. With the increase in Rust's popularity, various studies have begun empirically evaluating the usability of Rust's Ownership and Lifetime rules, providing a breadth of qualitative and quantitative information on the usability of such type systems. They found that despite Rust's general success in achieving its promise of safety and performance, these rules come with a steep learning curve and have been repeatedly cited as a barrier to adopting Rust.In this report, I provide a brief history of linear types and region-based memory management, which directly inspired Rust's type system. I then introduce Rust's Ownership and Lifetime rules, and present the state-of-the-art in academic research into their usability. I discuss both theoretical arguments and empirical evidence for why these rules are difficult to learn and apply, and survey existing work on addressing some of these difficulties. I also draw from broader works in the HCI and CS Education communities to recommend future work in this area.

show abstract

Section: Grounded Theorymentioning

confidence: 99%

The Usability of Advanced Type Systems: Rust as a Case Study

Ferdowsi¹

2023

Preprint

View full text Add to dashboard Cite

show abstract

“…Recent work has broadened scope to develop theories about how programmers read functional programs [Marceau et al 2011a], leverage the type system during development [Lubin and Chasins 2021], and solve problems with higher-order functions [Rivera and Krishnamurthi 2022].…”

Section: Related Workmentioning

confidence: 99%

A Grounded Conceptual Model for Ownership Types in Rust

Crichton,

Gray,

Krishnamurthi

2023

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

Programmers learning Rust struggle to understand ownership types, Rust’s core mechanism for ensuring memory safety without garbage collection. This paper describes our attempt to systematically design a pedagogy for ownership types. First, we studied Rust developers’ misconceptions of ownership to create the Ownership Inventory, a new instrument for measuring a person’s knowledge of ownership. We found that Rust learners could not connect Rust’s static and dynamic semantics, such as determining why an ill-typed program would (or would not) exhibit undefined behavior. Second, we created a conceptual model of Rust’s semantics that explains borrow checking in terms of flow-sensitive permissions on paths into memory. Third, we implemented a Rust compiler plugin that visualizes programs under the model. Fourth, we integrated the permissions model and visualizations into a broader pedagogy of ownership by writing a new ownership chapter for The Rust Programming Language , a popular Rust textbook. Fifth, we evaluated an initial deployment of our pedagogy against the original version, using reader responses to the Ownership Inventory as a point of comparison. Thus far, the new pedagogy has improved learner scores on the Ownership Inventory by an average of 9

show abstract

“…Apart from being a tool for correcting syntax errors, it has been suggested that compilers can also serve as psychological reassurance [21,23], and also as a means to correct mental models of the problem domain and as a dynamic task-direction mechanism [27].…”

Section: Prior Workmentioning

confidence: 99%

Sympathy for the (Novice) Developer

Karvelas

Becker

2022

Proceedings of the 53rd ACM Technical Symposium on Computer Science Education

View full text Add to dashboard Cite

In this work we investigate compilation behavior and error resolution time of thousands of novice programmers using two different versions of the BlueJ pedagogical Java programming environment. The two versions feature different compilation and error message presentation mechanisms. BlueJ 3 is a click-to-compile environment with enforced first error message presentation whereas BlueJ 4 features automatic compilation and on-demand error message presentation. We provide an overview of compilation activity based on novices' programming time spent in different compilation states and also present differences in the time it takes students to reach successful compilation states in each version. We find that compilation activity differs for each version and that students reach successful compilations faster in BlueJ 4. Based on our findings, we discuss the effectiveness of each version and argue against the constant red underlining of code -an error indicator mechanism present in BlueJ 4 -as this can lead to false positive errors that may mislead novices during their programming tasks. CCS CONCEPTS• Social and professional topics → Computing education; CS1.

show abstract

How statically-typed functional programmers write code

Cited by 8 publications

References 74 publications

The Usability of Advanced Type Systems: Rust as a Case Study

The Usability of Advanced Type Systems: Rust as a Case Study

A Grounded Conceptual Model for Ownership Types in Rust

Sympathy for the (Novice) Developer

Contact Info

Product

Resources

About