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...
Gespeichert in:
Veröffentlicht in: | Proceedings of ACM on programming languages 2023-10, Vol.7 (OOPSLA2), p.544-573, Article 241 |
---|---|
Hauptverfasser: | , , |
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 |