How to evaluate blame for gradual types

Programming language theoreticians develop blame assignment systems and prove blame theorems for gradually typed programming languages. Practical implementations of gradual typing almost completely ignore the idea of blame assignment. This contrast raises the question whether blame provides any valu...

Full description

Saved in:
Bibliographic Details
Published in:Proceedings of ACM on programming languages 2021-08, Vol.5 (ICFP), p.1-29
Main Authors: Lazarek, Lukas, Greenman, Ben, Felleisen, Matthias, Dimoulas, Christos
Format: Article
Language:English
Citations: Items that this one cites
Items that cite this one
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by cdi_FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73
cites cdi_FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73
container_end_page 29
container_issue ICFP
container_start_page 1
container_title Proceedings of ACM on programming languages
container_volume 5
creator Lazarek, Lukas
Greenman, Ben
Felleisen, Matthias
Dimoulas, Christos
description Programming language theoreticians develop blame assignment systems and prove blame theorems for gradually typed programming languages. Practical implementations of gradual typing almost completely ignore the idea of blame assignment. This contrast raises the question whether blame provides any value to the working programmer and poses the challenge of how to evaluate the effectiveness of blame assignment strategies. This paper contributes (1) the first evaluation method for blame assignment strategies and (2) the results from applying it to three different semantics for gradual typing. These results cast doubt on the theoretical effectiveness of blame in gradual typing. In most scenarios, strategies with imprecise blame assignment are as helpful to a rationally acting programmer as strategies with provably correct blame.
doi_str_mv 10.1145/3473573
format article
fullrecord <record><control><sourceid>crossref</sourceid><recordid>TN_cdi_crossref_primary_10_1145_3473573</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>10_1145_3473573</sourcerecordid><originalsourceid>FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73</originalsourceid><addsrcrecordid>eNpNj8FqAjEUAIO0UFHpL-TmaW1e3ssmOYq0VRB6qecl-zYpLSsrydri35eih55mTgMjxCOoFQCZJySLxuJETDVZUwFpuPvnD2JRypdSCjySQz8Vy-3wI8dBxu_Qn8MYZduHY5RpyPIjh-4cejleTrHMxX0KfYmLG2fi8PL8vtlW-7fX3Wa9r1gbN1ZglA62TVDX0RnHUXuXCAAMMCB0hkxNyL5TgM5qagNbqFvNOnrHbHEmltcu56GUHFNzyp_HkC8NqOZvsbkt4i_kDEAI</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>How to evaluate blame for gradual types</title><source>ACM Digital Library</source><creator>Lazarek, Lukas ; Greenman, Ben ; Felleisen, Matthias ; Dimoulas, Christos</creator><creatorcontrib>Lazarek, Lukas ; Greenman, Ben ; Felleisen, Matthias ; Dimoulas, Christos</creatorcontrib><description>Programming language theoreticians develop blame assignment systems and prove blame theorems for gradually typed programming languages. Practical implementations of gradual typing almost completely ignore the idea of blame assignment. This contrast raises the question whether blame provides any value to the working programmer and poses the challenge of how to evaluate the effectiveness of blame assignment strategies. This paper contributes (1) the first evaluation method for blame assignment strategies and (2) the results from applying it to three different semantics for gradual typing. These results cast doubt on the theoretical effectiveness of blame in gradual typing. In most scenarios, strategies with imprecise blame assignment are as helpful to a rationally acting programmer as strategies with provably correct blame.</description><identifier>ISSN: 2475-1421</identifier><identifier>EISSN: 2475-1421</identifier><identifier>DOI: 10.1145/3473573</identifier><language>eng</language><ispartof>Proceedings of ACM on programming languages, 2021-08, Vol.5 (ICFP), p.1-29</ispartof><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73</citedby><cites>FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73</cites></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,777,781,27905,27906</link.rule.ids></links><search><creatorcontrib>Lazarek, Lukas</creatorcontrib><creatorcontrib>Greenman, Ben</creatorcontrib><creatorcontrib>Felleisen, Matthias</creatorcontrib><creatorcontrib>Dimoulas, Christos</creatorcontrib><title>How to evaluate blame for gradual types</title><title>Proceedings of ACM on programming languages</title><description>Programming language theoreticians develop blame assignment systems and prove blame theorems for gradually typed programming languages. Practical implementations of gradual typing almost completely ignore the idea of blame assignment. This contrast raises the question whether blame provides any value to the working programmer and poses the challenge of how to evaluate the effectiveness of blame assignment strategies. This paper contributes (1) the first evaluation method for blame assignment strategies and (2) the results from applying it to three different semantics for gradual typing. These results cast doubt on the theoretical effectiveness of blame in gradual typing. In most scenarios, strategies with imprecise blame assignment are as helpful to a rationally acting programmer as strategies with provably correct blame.</description><issn>2475-1421</issn><issn>2475-1421</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2021</creationdate><recordtype>article</recordtype><recordid>eNpNj8FqAjEUAIO0UFHpL-TmaW1e3ssmOYq0VRB6qecl-zYpLSsrydri35eih55mTgMjxCOoFQCZJySLxuJETDVZUwFpuPvnD2JRypdSCjySQz8Vy-3wI8dBxu_Qn8MYZduHY5RpyPIjh-4cejleTrHMxX0KfYmLG2fi8PL8vtlW-7fX3Wa9r1gbN1ZglA62TVDX0RnHUXuXCAAMMCB0hkxNyL5TgM5qagNbqFvNOnrHbHEmltcu56GUHFNzyp_HkC8NqOZvsbkt4i_kDEAI</recordid><startdate>20210801</startdate><enddate>20210801</enddate><creator>Lazarek, Lukas</creator><creator>Greenman, Ben</creator><creator>Felleisen, Matthias</creator><creator>Dimoulas, Christos</creator><scope>AAYXX</scope><scope>CITATION</scope></search><sort><creationdate>20210801</creationdate><title>How to evaluate blame for gradual types</title><author>Lazarek, Lukas ; Greenman, Ben ; Felleisen, Matthias ; Dimoulas, Christos</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2021</creationdate><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Lazarek, Lukas</creatorcontrib><creatorcontrib>Greenman, Ben</creatorcontrib><creatorcontrib>Felleisen, Matthias</creatorcontrib><creatorcontrib>Dimoulas, Christos</creatorcontrib><collection>CrossRef</collection><jtitle>Proceedings of ACM on programming languages</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Lazarek, Lukas</au><au>Greenman, Ben</au><au>Felleisen, Matthias</au><au>Dimoulas, Christos</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>How to evaluate blame for gradual types</atitle><jtitle>Proceedings of ACM on programming languages</jtitle><date>2021-08-01</date><risdate>2021</risdate><volume>5</volume><issue>ICFP</issue><spage>1</spage><epage>29</epage><pages>1-29</pages><issn>2475-1421</issn><eissn>2475-1421</eissn><abstract>Programming language theoreticians develop blame assignment systems and prove blame theorems for gradually typed programming languages. Practical implementations of gradual typing almost completely ignore the idea of blame assignment. This contrast raises the question whether blame provides any value to the working programmer and poses the challenge of how to evaluate the effectiveness of blame assignment strategies. This paper contributes (1) the first evaluation method for blame assignment strategies and (2) the results from applying it to three different semantics for gradual typing. These results cast doubt on the theoretical effectiveness of blame in gradual typing. In most scenarios, strategies with imprecise blame assignment are as helpful to a rationally acting programmer as strategies with provably correct blame.</abstract><doi>10.1145/3473573</doi><tpages>29</tpages><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 2475-1421
ispartof Proceedings of ACM on programming languages, 2021-08, Vol.5 (ICFP), p.1-29
issn 2475-1421
2475-1421
language eng
recordid cdi_crossref_primary_10_1145_3473573
source ACM Digital Library
title How to evaluate blame for gradual types
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-21T07%3A58%3A27IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-crossref&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=How%20to%20evaluate%20blame%20for%20gradual%20types&rft.jtitle=Proceedings%20of%20ACM%20on%20programming%20languages&rft.au=Lazarek,%20Lukas&rft.date=2021-08-01&rft.volume=5&rft.issue=ICFP&rft.spage=1&rft.epage=29&rft.pages=1-29&rft.issn=2475-1421&rft.eissn=2475-1421&rft_id=info:doi/10.1145/3473573&rft_dat=%3Ccrossref%3E10_1145_3473573%3C/crossref%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-c258t-1502a7bf166e858ce298f411151c131d545643c9d0138724bac716b2c2e98cc73%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true