How Profilers Can Help Navigate Type Migration

Sound migratory typing envisions a safe and smooth refactoring of untyped code bases to typed ones. However, the cost of enforcing safety with run-time checks is often prohibitively high, thus performance regressions are a likely occurrence. Additional types can often recover performance, but choosi...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
Veröffentlicht in:Proceedings of ACM on programming languages 2023-10, Vol.7 (OOPSLA2), p.544-573, Article 241
Hauptverfasser: Greenman, Ben, Felleisen, Matthias, Dimoulas, Christos
Format: Artikel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 573
container_issue OOPSLA2
container_start_page 544
container_title Proceedings of ACM on programming languages
container_volume 7
creator Greenman, Ben
Felleisen, Matthias
Dimoulas, Christos
description Sound migratory typing envisions a safe and smooth refactoring of untyped code bases to typed ones. However, the cost of enforcing safety with run-time checks is often prohibitively high, thus performance regressions are a likely occurrence. Additional types can often recover performance, but choosing the right components to type is difficult because of the exponential size of the migratory typing lattice. In principal though, migration could be guided by off-the-shelf profiling tools. To examine this hypothesis, this paper follows the rational programmer method and reports on the results of an experiment on tens of thousands of performance-debugging scenarios via seventeen strategies for turning profiler output into an actionable next step. The most effective strategy is the use of deep types to eliminate the most costly boundaries between typed and untyped components; this strategy succeeds in more than 50% of scenarios if two performance degradations are tolerable along the way.
doi_str_mv 10.1145/3622817
format Article
fullrecord <record><control><sourceid>acm_cross</sourceid><recordid>TN_cdi_crossref_primary_10_1145_3622817</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>3622817</sourcerecordid><originalsourceid>FETCH-LOGICAL-a239t-9eb45f3afaf5407017fa3078463d25c19bb6722f96cb292861e2ef7acf8848713</originalsourceid><addsrcrecordid>eNpNj8FLwzAYxYMoOLbh3VNunjrzfUmb5ChFrTCnh3kuX2MyKt1akqLsv9exKZ7eg_fjwY-xKxALAJXfygLRgD5jE1Q6z0AhnP_rl2ye0ocQAqxURtoJW1T9F3-NfWg7HxMvaccr3w18RZ_thkbP1_vB8-d2E2ls-92MXQTqkp-fcsreHu7XZZUtXx6fyrtlRijtmFnfqDxIChRyJbQAHUgKbVQh3zF3YJum0IjBFq5Bi6YAjz5ocsEYZTTIKbs5_rrYpxR9qIfYbinuaxD1wbQ-mf6Q10eS3PYP-h2_ASULSzU</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype></control><display><type>article</type><title>How Profilers Can Help Navigate Type Migration</title><source>ACM Digital Library Complete</source><source>EZB-FREE-00999 freely available EZB journals</source><creator>Greenman, Ben ; Felleisen, Matthias ; Dimoulas, Christos</creator><creatorcontrib>Greenman, Ben ; Felleisen, Matthias ; Dimoulas, Christos</creatorcontrib><description>Sound migratory typing envisions a safe and smooth refactoring of untyped code bases to typed ones. However, the cost of enforcing safety with run-time checks is often prohibitively high, thus performance regressions are a likely occurrence. Additional types can often recover performance, but choosing the right components to type is difficult because of the exponential size of the migratory typing lattice. In principal though, migration could be guided by off-the-shelf profiling tools. To examine this hypothesis, this paper follows the rational programmer method and reports on the results of an experiment on tens of thousands of performance-debugging scenarios via seventeen strategies for turning profiler output into an actionable next step. The most effective strategy is the use of deep types to eliminate the most costly boundaries between typed and untyped components; this strategy succeeds in more than 50% of scenarios if two performance degradations are tolerable along the way.</description><identifier>ISSN: 2475-1421</identifier><identifier>EISSN: 2475-1421</identifier><identifier>DOI: 10.1145/3622817</identifier><language>eng</language><publisher>New York, NY, USA: ACM</publisher><subject>Constraints ; Functional languages ; Semantics ; Software and its engineering</subject><ispartof>Proceedings of ACM on programming languages, 2023-10, Vol.7 (OOPSLA2), p.544-573, Article 241</ispartof><rights>Owner/Author</rights><lds50>peer_reviewed</lds50><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed><cites>FETCH-LOGICAL-a239t-9eb45f3afaf5407017fa3078463d25c19bb6722f96cb292861e2ef7acf8848713</cites><orcidid>0000-0001-6678-1004 ; 0000-0002-9338-7034 ; 0000-0001-7078-9287</orcidid></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktopdf>$$Uhttps://dl.acm.org/doi/pdf/10.1145/3622817$$EPDF$$P50$$Gacm$$Hfree_for_read</linktopdf><link.rule.ids>314,776,780,2276,27901,27902,40172,75970</link.rule.ids></links><search><creatorcontrib>Greenman, Ben</creatorcontrib><creatorcontrib>Felleisen, Matthias</creatorcontrib><creatorcontrib>Dimoulas, Christos</creatorcontrib><title>How Profilers Can Help Navigate Type Migration</title><title>Proceedings of ACM on programming languages</title><addtitle>ACM PACMPL</addtitle><description>Sound migratory typing envisions a safe and smooth refactoring of untyped code bases to typed ones. However, the cost of enforcing safety with run-time checks is often prohibitively high, thus performance regressions are a likely occurrence. Additional types can often recover performance, but choosing the right components to type is difficult because of the exponential size of the migratory typing lattice. In principal though, migration could be guided by off-the-shelf profiling tools. To examine this hypothesis, this paper follows the rational programmer method and reports on the results of an experiment on tens of thousands of performance-debugging scenarios via seventeen strategies for turning profiler output into an actionable next step. The most effective strategy is the use of deep types to eliminate the most costly boundaries between typed and untyped components; this strategy succeeds in more than 50% of scenarios if two performance degradations are tolerable along the way.</description><subject>Constraints</subject><subject>Functional languages</subject><subject>Semantics</subject><subject>Software and its engineering</subject><issn>2475-1421</issn><issn>2475-1421</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2023</creationdate><recordtype>article</recordtype><recordid>eNpNj8FLwzAYxYMoOLbh3VNunjrzfUmb5ChFrTCnh3kuX2MyKt1akqLsv9exKZ7eg_fjwY-xKxALAJXfygLRgD5jE1Q6z0AhnP_rl2ye0ocQAqxURtoJW1T9F3-NfWg7HxMvaccr3w18RZ_thkbP1_vB8-d2E2ls-92MXQTqkp-fcsreHu7XZZUtXx6fyrtlRijtmFnfqDxIChRyJbQAHUgKbVQh3zF3YJum0IjBFq5Bi6YAjz5ocsEYZTTIKbs5_rrYpxR9qIfYbinuaxD1wbQ-mf6Q10eS3PYP-h2_ASULSzU</recordid><startdate>20231016</startdate><enddate>20231016</enddate><creator>Greenman, Ben</creator><creator>Felleisen, Matthias</creator><creator>Dimoulas, Christos</creator><general>ACM</general><scope>AAYXX</scope><scope>CITATION</scope><orcidid>https://orcid.org/0000-0001-6678-1004</orcidid><orcidid>https://orcid.org/0000-0002-9338-7034</orcidid><orcidid>https://orcid.org/0000-0001-7078-9287</orcidid></search><sort><creationdate>20231016</creationdate><title>How Profilers Can Help Navigate Type Migration</title><author>Greenman, Ben ; Felleisen, Matthias ; Dimoulas, Christos</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-a239t-9eb45f3afaf5407017fa3078463d25c19bb6722f96cb292861e2ef7acf8848713</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2023</creationdate><topic>Constraints</topic><topic>Functional languages</topic><topic>Semantics</topic><topic>Software and its engineering</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><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>Greenman, Ben</au><au>Felleisen, Matthias</au><au>Dimoulas, Christos</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>How Profilers Can Help Navigate Type Migration</atitle><jtitle>Proceedings of ACM on programming languages</jtitle><stitle>ACM PACMPL</stitle><date>2023-10-16</date><risdate>2023</risdate><volume>7</volume><issue>OOPSLA2</issue><spage>544</spage><epage>573</epage><pages>544-573</pages><artnum>241</artnum><issn>2475-1421</issn><eissn>2475-1421</eissn><abstract>Sound migratory typing envisions a safe and smooth refactoring of untyped code bases to typed ones. However, the cost of enforcing safety with run-time checks is often prohibitively high, thus performance regressions are a likely occurrence. Additional types can often recover performance, but choosing the right components to type is difficult because of the exponential size of the migratory typing lattice. In principal though, migration could be guided by off-the-shelf profiling tools. To examine this hypothesis, this paper follows the rational programmer method and reports on the results of an experiment on tens of thousands of performance-debugging scenarios via seventeen strategies for turning profiler output into an actionable next step. The most effective strategy is the use of deep types to eliminate the most costly boundaries between typed and untyped components; this strategy succeeds in more than 50% of scenarios if two performance degradations are tolerable along the way.</abstract><cop>New York, NY, USA</cop><pub>ACM</pub><doi>10.1145/3622817</doi><tpages>30</tpages><orcidid>https://orcid.org/0000-0001-6678-1004</orcidid><orcidid>https://orcid.org/0000-0002-9338-7034</orcidid><orcidid>https://orcid.org/0000-0001-7078-9287</orcidid><oa>free_for_read</oa></addata></record>
fulltext fulltext
identifier ISSN: 2475-1421
ispartof Proceedings of ACM on programming languages, 2023-10, Vol.7 (OOPSLA2), p.544-573, Article 241
issn 2475-1421
2475-1421
language eng
recordid cdi_crossref_primary_10_1145_3622817
source ACM Digital Library Complete; EZB-FREE-00999 freely available EZB journals
subjects Constraints
Functional languages
Semantics
Software and its engineering
title How Profilers Can Help Navigate Type Migration
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-02-10T11%3A49%3A07IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-acm_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=How%20Profilers%20Can%20Help%20Navigate%20Type%20Migration&rft.jtitle=Proceedings%20of%20ACM%20on%20programming%20languages&rft.au=Greenman,%20Ben&rft.date=2023-10-16&rft.volume=7&rft.issue=OOPSLA2&rft.spage=544&rft.epage=573&rft.pages=544-573&rft.artnum=241&rft.issn=2475-1421&rft.eissn=2475-1421&rft_id=info:doi/10.1145/3622817&rft_dat=%3Cacm_cross%3E3622817%3C/acm_cross%3E%3Curl%3E%3C/url%3E&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true