Loading…

Edit - Run Behavior in Programming and Debugging

As developers program and debug, they continuously edit and run their code, a behavior known as edit-run cycles. While techniques such as live programming are intended to support this behavior, little is known about the characteristics of edit-run cycles themselves. To bridge this gap, we analyzed 2...

Full description

Saved in:
Bibliographic Details
Main Authors: Alaboudi, Abdulaziz, LaToza, Thomas D.
Format: Conference Proceeding
Language:English
Subjects:
Online Access:Request full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites
container_end_page 10
container_issue
container_start_page 1
container_title
container_volume
creator Alaboudi, Abdulaziz
LaToza, Thomas D.
description As developers program and debug, they continuously edit and run their code, a behavior known as edit-run cycles. While techniques such as live programming are intended to support this behavior, little is known about the characteristics of edit-run cycles themselves. To bridge this gap, we analyzed 28 hours of programming and debugging work from 11 professional developers which encompassed over three thousand development activities. We mapped activities to edit or run steps, constructing 581 debugging and 207 programming edit-run cycles. We found that edit-run cycles are frequent. Developers edit and run the program, on average, 7 times before fixing a defect and twice before introducing a defect. Developers waited longer before again running the program when programming than debugging, with a mean cycle length of 3 minutes for programming and 1 minute for debugging. Most cycles involved an edit to a single file after which a developer ran the program to observe the impact on the final output. Edit-run cycles which included activities beyond edit and run, such as navigating between files, consulting resources, or interacting with other IDE features, were much longer, with a mean length of 5 minutes, rather than 1.5 minutes. We conclude with a discussion of design recommendations for tools to enable more fluidity in edit-run cycles.
doi_str_mv 10.1109/VL/HCC51201.2021.9576170
format conference_proceeding
fullrecord <record><control><sourceid>ieee_CHZPO</sourceid><recordid>TN_cdi_ieee_primary_9576170</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><ieee_id>9576170</ieee_id><sourcerecordid>9576170</sourcerecordid><originalsourceid>FETCH-LOGICAL-i203t-f2f20b41427f441c3a41b2481528dcac42977cded609bb848bc8407a1089a85e3</originalsourceid><addsrcrecordid>eNotj8tKw0AUQEdBsNZ-gZv5gaT33tx5LTW2Vggoom7LTDKJIyaVpBX69wp2dTibA0cIiZAjglu-V8tNWSokwJyAMHfKaDRwJhbOWNRaMStHfC5m6LjINIK-FFfT9AmgUKOaCVg1aS8z-XIY5F388D9pN8o0yOdx142-79PQST808j6GQ9f92bW4aP3XFBcnzsXbevVabrLq6eGxvK2yRFDss5ZagsDIZFpmrAvPGIgtKrJN7WsmZ0zdxEaDC8GyDbVlMB7BOm9VLObi5r-bYozb7zH1fjxuT4PFLz2XQ4E</addsrcrecordid><sourcetype>Publisher</sourcetype><iscdi>true</iscdi><recordtype>conference_proceeding</recordtype></control><display><type>conference_proceeding</type><title>Edit - Run Behavior in Programming and Debugging</title><source>IEEE Xplore All Conference Series</source><creator>Alaboudi, Abdulaziz ; LaToza, Thomas D.</creator><creatorcontrib>Alaboudi, Abdulaziz ; LaToza, Thomas D.</creatorcontrib><description>As developers program and debug, they continuously edit and run their code, a behavior known as edit-run cycles. While techniques such as live programming are intended to support this behavior, little is known about the characteristics of edit-run cycles themselves. To bridge this gap, we analyzed 28 hours of programming and debugging work from 11 professional developers which encompassed over three thousand development activities. We mapped activities to edit or run steps, constructing 581 debugging and 207 programming edit-run cycles. We found that edit-run cycles are frequent. Developers edit and run the program, on average, 7 times before fixing a defect and twice before introducing a defect. Developers waited longer before again running the program when programming than debugging, with a mean cycle length of 3 minutes for programming and 1 minute for debugging. Most cycles involved an edit to a single file after which a developer ran the program to observe the impact on the final output. Edit-run cycles which included activities beyond edit and run, such as navigating between files, consulting resources, or interacting with other IDE features, were much longer, with a mean length of 5 minutes, rather than 1.5 minutes. We conclude with a discussion of design recommendations for tools to enable more fluidity in edit-run cycles.</description><identifier>EISSN: 1943-6106</identifier><identifier>EISBN: 9781665445924</identifier><identifier>EISBN: 1665445920</identifier><identifier>DOI: 10.1109/VL/HCC51201.2021.9576170</identifier><language>eng</language><publisher>IEEE</publisher><subject>Bridges ; Codes ; Debugging ; Development environments ; Live programming ; Navigation ; Programming ; Programming profession ; Visualization</subject><ispartof>2021 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC), 2021, p.1-10</ispartof><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><linktohtml>$$Uhttps://ieeexplore.ieee.org/document/9576170$$EHTML$$P50$$Gieee$$H</linktohtml><link.rule.ids>309,310,780,784,789,790,27923,54553,54930</link.rule.ids><linktorsrc>$$Uhttps://ieeexplore.ieee.org/document/9576170$$EView_record_in_IEEE$$FView_record_in_$$GIEEE</linktorsrc></links><search><creatorcontrib>Alaboudi, Abdulaziz</creatorcontrib><creatorcontrib>LaToza, Thomas D.</creatorcontrib><title>Edit - Run Behavior in Programming and Debugging</title><title>2021 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)</title><addtitle>VL/HCC</addtitle><description>As developers program and debug, they continuously edit and run their code, a behavior known as edit-run cycles. While techniques such as live programming are intended to support this behavior, little is known about the characteristics of edit-run cycles themselves. To bridge this gap, we analyzed 28 hours of programming and debugging work from 11 professional developers which encompassed over three thousand development activities. We mapped activities to edit or run steps, constructing 581 debugging and 207 programming edit-run cycles. We found that edit-run cycles are frequent. Developers edit and run the program, on average, 7 times before fixing a defect and twice before introducing a defect. Developers waited longer before again running the program when programming than debugging, with a mean cycle length of 3 minutes for programming and 1 minute for debugging. Most cycles involved an edit to a single file after which a developer ran the program to observe the impact on the final output. Edit-run cycles which included activities beyond edit and run, such as navigating between files, consulting resources, or interacting with other IDE features, were much longer, with a mean length of 5 minutes, rather than 1.5 minutes. We conclude with a discussion of design recommendations for tools to enable more fluidity in edit-run cycles.</description><subject>Bridges</subject><subject>Codes</subject><subject>Debugging</subject><subject>Development environments</subject><subject>Live programming</subject><subject>Navigation</subject><subject>Programming</subject><subject>Programming profession</subject><subject>Visualization</subject><issn>1943-6106</issn><isbn>9781665445924</isbn><isbn>1665445920</isbn><fulltext>true</fulltext><rsrctype>conference_proceeding</rsrctype><creationdate>2021</creationdate><recordtype>conference_proceeding</recordtype><sourceid>6IE</sourceid><recordid>eNotj8tKw0AUQEdBsNZ-gZv5gaT33tx5LTW2Vggoom7LTDKJIyaVpBX69wp2dTibA0cIiZAjglu-V8tNWSokwJyAMHfKaDRwJhbOWNRaMStHfC5m6LjINIK-FFfT9AmgUKOaCVg1aS8z-XIY5F388D9pN8o0yOdx142-79PQST808j6GQ9f92bW4aP3XFBcnzsXbevVabrLq6eGxvK2yRFDss5ZagsDIZFpmrAvPGIgtKrJN7WsmZ0zdxEaDC8GyDbVlMB7BOm9VLObi5r-bYozb7zH1fjxuT4PFLz2XQ4E</recordid><startdate>20211010</startdate><enddate>20211010</enddate><creator>Alaboudi, Abdulaziz</creator><creator>LaToza, Thomas D.</creator><general>IEEE</general><scope>6IE</scope><scope>6IL</scope><scope>CBEJK</scope><scope>RIE</scope><scope>RIL</scope></search><sort><creationdate>20211010</creationdate><title>Edit - Run Behavior in Programming and Debugging</title><author>Alaboudi, Abdulaziz ; LaToza, Thomas D.</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i203t-f2f20b41427f441c3a41b2481528dcac42977cded609bb848bc8407a1089a85e3</frbrgroupid><rsrctype>conference_proceedings</rsrctype><prefilter>conference_proceedings</prefilter><language>eng</language><creationdate>2021</creationdate><topic>Bridges</topic><topic>Codes</topic><topic>Debugging</topic><topic>Development environments</topic><topic>Live programming</topic><topic>Navigation</topic><topic>Programming</topic><topic>Programming profession</topic><topic>Visualization</topic><toplevel>online_resources</toplevel><creatorcontrib>Alaboudi, Abdulaziz</creatorcontrib><creatorcontrib>LaToza, Thomas D.</creatorcontrib><collection>IEEE Electronic Library (IEL) Conference Proceedings</collection><collection>IEEE Proceedings Order Plan All Online (POP All Online) 1998-present by volume</collection><collection>IEEE Xplore All Conference Proceedings</collection><collection>IEEE/IET Electronic Library (IEL)</collection><collection>IEEE Proceedings Order Plans (POP All) 1998-Present</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Alaboudi, Abdulaziz</au><au>LaToza, Thomas D.</au><format>book</format><genre>proceeding</genre><ristype>CONF</ristype><atitle>Edit - Run Behavior in Programming and Debugging</atitle><btitle>2021 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)</btitle><stitle>VL/HCC</stitle><date>2021-10-10</date><risdate>2021</risdate><spage>1</spage><epage>10</epage><pages>1-10</pages><eissn>1943-6106</eissn><eisbn>9781665445924</eisbn><eisbn>1665445920</eisbn><abstract>As developers program and debug, they continuously edit and run their code, a behavior known as edit-run cycles. While techniques such as live programming are intended to support this behavior, little is known about the characteristics of edit-run cycles themselves. To bridge this gap, we analyzed 28 hours of programming and debugging work from 11 professional developers which encompassed over three thousand development activities. We mapped activities to edit or run steps, constructing 581 debugging and 207 programming edit-run cycles. We found that edit-run cycles are frequent. Developers edit and run the program, on average, 7 times before fixing a defect and twice before introducing a defect. Developers waited longer before again running the program when programming than debugging, with a mean cycle length of 3 minutes for programming and 1 minute for debugging. Most cycles involved an edit to a single file after which a developer ran the program to observe the impact on the final output. Edit-run cycles which included activities beyond edit and run, such as navigating between files, consulting resources, or interacting with other IDE features, were much longer, with a mean length of 5 minutes, rather than 1.5 minutes. We conclude with a discussion of design recommendations for tools to enable more fluidity in edit-run cycles.</abstract><pub>IEEE</pub><doi>10.1109/VL/HCC51201.2021.9576170</doi><tpages>10</tpages></addata></record>
fulltext fulltext_linktorsrc
identifier EISSN: 1943-6106
ispartof 2021 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC), 2021, p.1-10
issn 1943-6106
language eng
recordid cdi_ieee_primary_9576170
source IEEE Xplore All Conference Series
subjects Bridges
Codes
Debugging
Development environments
Live programming
Navigation
Programming
Programming profession
Visualization
title Edit - Run Behavior in Programming and Debugging
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-14T10%3A28%3A45IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-ieee_CHZPO&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=proceeding&rft.atitle=Edit%20-%20Run%20Behavior%20in%20Programming%20and%20Debugging&rft.btitle=2021%20IEEE%20Symposium%20on%20Visual%20Languages%20and%20Human-Centric%20Computing%20(VL/HCC)&rft.au=Alaboudi,%20Abdulaziz&rft.date=2021-10-10&rft.spage=1&rft.epage=10&rft.pages=1-10&rft.eissn=1943-6106&rft_id=info:doi/10.1109/VL/HCC51201.2021.9576170&rft.eisbn=9781665445924&rft.eisbn_list=1665445920&rft_dat=%3Cieee_CHZPO%3E9576170%3C/ieee_CHZPO%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-i203t-f2f20b41427f441c3a41b2481528dcac42977cded609bb848bc8407a1089a85e3%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rft_ieee_id=9576170&rfr_iscdi=true