<Programming> Companion '21: "Oron: Towards a Dynamic Analysis ..."
Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript
Aäron Munsters, Angel Luis Scull Pupo, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
The dynamic nature of JavaScript may lead to challenges and issues regarding efficiency and security. Analysis tools can help developers tackle some of these issues. In the context of web applications, dynamic analyses are best suited for handling those dynamic features but may affect the programs execution performance. In a first experiment, we attempted to improve the performance of the Aran dynamic analysis platform for JavaScript by utilizing WebAssembly. The extension caused extra performance hits due to context switches between JavaScript and WebAssembly. Because these context switches are inevitable, we decided to refit our work for the analysis of AssemblyScript, a variant of TypeScript which compiles to WebAssembly (and therefore excluding context switches). In this work, we explore this approach in the form of a new source code instrumentation platform named Oron, which allows for the instrumentation of AssemblyScript code. The presented platform is evaluated and shows promising improvements which provide a solid basis for efficient dynamic analysis of AssemblyScript applications.
@InProceedings{<Programming>21p6,
author = {Aäron Munsters and Angel Luis Scull Pupo and Jim Bauwens and Elisa Gonzalez Boix},
title = {Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {6--13},
doi = {10.1145/3464432.3464780},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Rec.HTML: Declarative HTML ..."
Rec.HTML: Declarative HTML
Bob Reynders and Kwanghoon Choi
(Chonnam National University, South Korea)
Interactive user experiences on the web are becoming the norm. Client-side programs are becoming more complicated and have to deal with event handling, reading HTML document state and updating the interface. In this paper we propose a declarative language that supports these three facets of client-side browser development declaratively and provides a programming model where complex interfaces can be written using simple programming techniques such as records, functions and recursion.
@InProceedings{<Programming>21p1,
author = {Bob Reynders and Kwanghoon Choi},
title = {Rec.HTML: Declarative HTML},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {1--5},
doi = {10.1145/3464432.3464779},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Oron: Towards a Dynamic Analysis ..."
Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript
Aäron Munsters, Angel Luis Scull Pupo, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
The dynamic nature of JavaScript may lead to challenges and issues regarding efficiency and security. Analysis tools can help developers tackle some of these issues. In the context of web applications, dynamic analyses are best suited for handling those dynamic features but may affect the programs execution performance. In a first experiment, we attempted to improve the performance of the Aran dynamic analysis platform for JavaScript by utilizing WebAssembly. The extension caused extra performance hits due to context switches between JavaScript and WebAssembly. Because these context switches are inevitable, we decided to refit our work for the analysis of AssemblyScript, a variant of TypeScript which compiles to WebAssembly (and therefore excluding context switches). In this work, we explore this approach in the form of a new source code instrumentation platform named Oron, which allows for the instrumentation of AssemblyScript code. The presented platform is evaluated and shows promising improvements which provide a solid basis for efficient dynamic analysis of AssemblyScript applications.
@InProceedings{<Programming>21p6,
author = {Aäron Munsters and Angel Luis Scull Pupo and Jim Bauwens and Elisa Gonzalez Boix},
title = {Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {6--13},
doi = {10.1145/3464432.3464780},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Exploring Modal Locking in ..."
Exploring Modal Locking in Window Manipulation: Why Programmers Should Stash, Duplicate, Split, and Link Composite Views
Marcel Taeumel and Robert Hirschfeld
(HPI, Germany; University of Potsdam, Germany)
Window manipulation plays a vital role in multi-tool user interaction, especially for programmers exploring software artifacts, gathering information for better understanding. However, today's window managers offer only limited means to organize screen contents, which increases cognitive efforts for both tool builders and users. Builders must account for live integration of composite views; users might have to work around disruptive mode errors when actual tasks conflict with a tool's design. We follow a pattern-finding approach and present four new verbs for direct window manipulation, which we consolidated from existing tools and systems. If window managers would offer to stash, duplicate, split, and link views, we believe that programmers could better maintain flow during exploration activities.
@InProceedings{<Programming>21p14,
author = {Marcel Taeumel and Robert Hirschfeld},
title = {Exploring Modal Locking in Window Manipulation: Why Programmers Should Stash, Duplicate, Split, and Link Composite Views},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {14--20},
doi = {10.1145/3464432.3464433},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Toward Exploratory Understanding ..."
Toward Exploratory Understanding of Software using Test Suites
Dominik Meier, Toni Mattis, and Robert Hirschfeld
(HPI, Germany; University of Potsdam, Germany)
Changing software without correctly understanding it often leads to confusion, as developers do not understand how the change corresponds to the new observed behaviour of the system. Today, many software systems are equipped with a test suite. Test suites document code and give feedback on changed program behaviour. We explored ways to use test suites for software comprehension and implemented a tool that provides additional visualisation and gives immediate feedback on software changes. Information about changes in the software and their implications to the test suite are collected using mutation testing. The tool uses this information to present relevant test cases for developers, and additionally prioritise test executions for immediate feedback. Our research indicates that entropy metrics can find test cases that are relevant for a specific context in the source code. Additionally, simple test case prioritisation strategies can already lead to a significant decrease in feedback time. Based on our case study we argue that test suites are not only useful for regression testing but can be used to generate meaningful information for software comprehension activities.
@InProceedings{<Programming>21p59,
author = {Dominik Meier and Toni Mattis and Robert Hirschfeld},
title = {Toward Exploratory Understanding of Software using Test Suites},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {59--66},
doi = {10.1145/3464432.3464438},
year = {2021},
}
Publisher's Version
Video
<Programming> Companion '21: "Towards End-User Web Scraping ..."
Towards End-User Web Scraping for Customization
Kapaya Katongo, Geoffrey Litt, and Daniel Jackson
(Massachusetts Institute of Technology, USA)
Websites are malleable: users can run code in the browser to customize them. However, this malleability is typically only accessible to programmers with knowledge of HTML and Javascript. Previously, we developed a tool called Wildcard which empowers end-users to customize websites through a spreadsheet-like table interface without doing traditional programming. However, there is a limit to end-user agency with Wildcard, because programmers need to first create site-specific adapters mapping website data to the table interface. This means that end-users can only customize a website if a programmer has written an adapter for it, and cannot extend or repair existing adapters. In this paper, we extend Wildcard with a new system for end-user web scraping for customization. It enables end-users to create, extend and repair adapters, by performing concrete demonstrations of how the website user interface maps to a data table. We describe three design principles that guided our system's development and are applicable to other end-user web scraping and customization systems: (a) users should be able to scrape data and use it in a single, unified environment, (b) users should be able to extend and repair the programs that scrape data via demonstration and (c) users should receive live feedback during their demonstrations. We have successfully used our system to create, extend and repair adapters by demonstration on a variety of websites and we provide example usage scenarios that showcase each of our design principles. Our ultimate goal is to empower end-users to customize websites in the course of their daily use in an intuitive and flexible way, and thus making the web more malleable for all of its users.
@InProceedings{<Programming>21p48,
author = {Kapaya Katongo and Geoffrey Litt and Daniel Jackson},
title = {Towards End-User Web Scraping for Customization},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {48--58},
doi = {10.1145/3464432.3464437},
year = {2021},
}
Publisher's Version
Info
<Programming> Companion '21: "Studying Programmer Behaviour ..."
Studying Programmer Behaviour at Scale: A Case Study using Amazon Mechanical Turk
Jason T. Jacques and Per Ola Kristensson
(University of Cambridge, UK)
Developing and maintaining a correct and consistent model of how code will be executed is an ongoing challenge for software developers. However, validating the tools and techniques we develop to aid programmers can be a challenge plagued by small sample sizes, high costs, or poor generalisability. This paper serves as a case study using a web-based crowdsourcing approach to study programmer behaviour at scale. We demonstrate this method to create controlled coding experiments at modest cost, highlight the efficacy of this approach with objective validation, and comment on notable findings from our prototype experiment into one of the most ubiquitous, yet understudied, features of modern software development environments: syntax highlighting.
@InProceedings{<Programming>21p35,
author = {Jason T. Jacques and Per Ola Kristensson},
title = {Studying Programmer Behaviour at Scale: A Case Study using Amazon Mechanical Turk},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {35--47},
doi = {10.1145/3464432.3464436},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Towards End-User Web Scraping ..."
Towards End-User Web Scraping for Customization
Kapaya Katongo, Geoffrey Litt, and Daniel Jackson
(Massachusetts Institute of Technology, USA)
Websites are malleable: users can run code in the browser to customize them. However, this malleability is typically only accessible to programmers with knowledge of HTML and Javascript. Previously, we developed a tool called Wildcard which empowers end-users to customize websites through a spreadsheet-like table interface without doing traditional programming. However, there is a limit to end-user agency with Wildcard, because programmers need to first create site-specific adapters mapping website data to the table interface. This means that end-users can only customize a website if a programmer has written an adapter for it, and cannot extend or repair existing adapters. In this paper, we extend Wildcard with a new system for end-user web scraping for customization. It enables end-users to create, extend and repair adapters, by performing concrete demonstrations of how the website user interface maps to a data table. We describe three design principles that guided our system's development and are applicable to other end-user web scraping and customization systems: (a) users should be able to scrape data and use it in a single, unified environment, (b) users should be able to extend and repair the programs that scrape data via demonstration and (c) users should receive live feedback during their demonstrations. We have successfully used our system to create, extend and repair adapters by demonstration on a variety of websites and we provide example usage scenarios that showcase each of our design principles. Our ultimate goal is to empower end-users to customize websites in the course of their daily use in an intuitive and flexible way, and thus making the web more malleable for all of its users.
@InProceedings{<Programming>21p48,
author = {Kapaya Katongo and Geoffrey Litt and Daniel Jackson},
title = {Towards End-User Web Scraping for Customization},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {48--58},
doi = {10.1145/3464432.3464437},
year = {2021},
}
Publisher's Version
Info
<Programming> Companion '21: "Studying Programmer Behaviour ..."
Studying Programmer Behaviour at Scale: A Case Study using Amazon Mechanical Turk
Jason T. Jacques and Per Ola Kristensson
(University of Cambridge, UK)
Developing and maintaining a correct and consistent model of how code will be executed is an ongoing challenge for software developers. However, validating the tools and techniques we develop to aid programmers can be a challenge plagued by small sample sizes, high costs, or poor generalisability. This paper serves as a case study using a web-based crowdsourcing approach to study programmer behaviour at scale. We demonstrate this method to create controlled coding experiments at modest cost, highlight the efficacy of this approach with objective validation, and comment on notable findings from our prototype experiment into one of the most ubiquitous, yet understudied, features of modern software development environments: syntax highlighting.
@InProceedings{<Programming>21p35,
author = {Jason T. Jacques and Per Ola Kristensson},
title = {Studying Programmer Behaviour at Scale: A Case Study using Amazon Mechanical Turk},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {35--47},
doi = {10.1145/3464432.3464436},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Towards End-User Web Scraping ..."
Towards End-User Web Scraping for Customization
Kapaya Katongo, Geoffrey Litt, and Daniel Jackson
(Massachusetts Institute of Technology, USA)
Websites are malleable: users can run code in the browser to customize them. However, this malleability is typically only accessible to programmers with knowledge of HTML and Javascript. Previously, we developed a tool called Wildcard which empowers end-users to customize websites through a spreadsheet-like table interface without doing traditional programming. However, there is a limit to end-user agency with Wildcard, because programmers need to first create site-specific adapters mapping website data to the table interface. This means that end-users can only customize a website if a programmer has written an adapter for it, and cannot extend or repair existing adapters. In this paper, we extend Wildcard with a new system for end-user web scraping for customization. It enables end-users to create, extend and repair adapters, by performing concrete demonstrations of how the website user interface maps to a data table. We describe three design principles that guided our system's development and are applicable to other end-user web scraping and customization systems: (a) users should be able to scrape data and use it in a single, unified environment, (b) users should be able to extend and repair the programs that scrape data via demonstration and (c) users should receive live feedback during their demonstrations. We have successfully used our system to create, extend and repair adapters by demonstration on a variety of websites and we provide example usage scenarios that showcase each of our design principles. Our ultimate goal is to empower end-users to customize websites in the course of their daily use in an intuitive and flexible way, and thus making the web more malleable for all of its users.
@InProceedings{<Programming>21p48,
author = {Kapaya Katongo and Geoffrey Litt and Daniel Jackson},
title = {Towards End-User Web Scraping for Customization},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {48--58},
doi = {10.1145/3464432.3464437},
year = {2021},
}
Publisher's Version
Info
<Programming> Companion '21: "Toward Exploratory Understanding ..."
Toward Exploratory Understanding of Software using Test Suites
Dominik Meier, Toni Mattis, and Robert Hirschfeld
(HPI, Germany; University of Potsdam, Germany)
Changing software without correctly understanding it often leads to confusion, as developers do not understand how the change corresponds to the new observed behaviour of the system. Today, many software systems are equipped with a test suite. Test suites document code and give feedback on changed program behaviour. We explored ways to use test suites for software comprehension and implemented a tool that provides additional visualisation and gives immediate feedback on software changes. Information about changes in the software and their implications to the test suite are collected using mutation testing. The tool uses this information to present relevant test cases for developers, and additionally prioritise test executions for immediate feedback. Our research indicates that entropy metrics can find test cases that are relevant for a specific context in the source code. Additionally, simple test case prioritisation strategies can already lead to a significant decrease in feedback time. Based on our case study we argue that test suites are not only useful for regression testing but can be used to generate meaningful information for software comprehension activities.
@InProceedings{<Programming>21p59,
author = {Dominik Meier and Toni Mattis and Robert Hirschfeld},
title = {Toward Exploratory Understanding of Software using Test Suites},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {59--66},
doi = {10.1145/3464432.3464438},
year = {2021},
}
Publisher's Version
Video
<Programming> Companion '21: "Toward Exploratory Understanding ..."
Toward Exploratory Understanding of Software using Test Suites
Dominik Meier, Toni Mattis, and Robert Hirschfeld
(HPI, Germany; University of Potsdam, Germany)
Changing software without correctly understanding it often leads to confusion, as developers do not understand how the change corresponds to the new observed behaviour of the system. Today, many software systems are equipped with a test suite. Test suites document code and give feedback on changed program behaviour. We explored ways to use test suites for software comprehension and implemented a tool that provides additional visualisation and gives immediate feedback on software changes. Information about changes in the software and their implications to the test suite are collected using mutation testing. The tool uses this information to present relevant test cases for developers, and additionally prioritise test executions for immediate feedback. Our research indicates that entropy metrics can find test cases that are relevant for a specific context in the source code. Additionally, simple test case prioritisation strategies can already lead to a significant decrease in feedback time. Based on our case study we argue that test suites are not only useful for regression testing but can be used to generate meaningful information for software comprehension activities.
@InProceedings{<Programming>21p59,
author = {Dominik Meier and Toni Mattis and Robert Hirschfeld},
title = {Toward Exploratory Understanding of Software using Test Suites},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {59--66},
doi = {10.1145/3464432.3464438},
year = {2021},
}
Publisher's Version
Video
<Programming> Companion '21: "Oron: Towards a Dynamic Analysis ..."
Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript
Aäron Munsters, Angel Luis Scull Pupo, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
The dynamic nature of JavaScript may lead to challenges and issues regarding efficiency and security. Analysis tools can help developers tackle some of these issues. In the context of web applications, dynamic analyses are best suited for handling those dynamic features but may affect the programs execution performance. In a first experiment, we attempted to improve the performance of the Aran dynamic analysis platform for JavaScript by utilizing WebAssembly. The extension caused extra performance hits due to context switches between JavaScript and WebAssembly. Because these context switches are inevitable, we decided to refit our work for the analysis of AssemblyScript, a variant of TypeScript which compiles to WebAssembly (and therefore excluding context switches). In this work, we explore this approach in the form of a new source code instrumentation platform named Oron, which allows for the instrumentation of AssemblyScript code. The presented platform is evaluated and shows promising improvements which provide a solid basis for efficient dynamic analysis of AssemblyScript applications.
@InProceedings{<Programming>21p6,
author = {Aäron Munsters and Angel Luis Scull Pupo and Jim Bauwens and Elisa Gonzalez Boix},
title = {Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {6--13},
doi = {10.1145/3464432.3464780},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Improving on the Experience ..."
Improving on the Experience of Hand-Assembling Programs for Application-Specific Architectures
Ian Piumarta
(Kyoto University of Advanced Science, Japan)
Creating an application-specific processor is an effective and popular way to solve many problems in embedded hardware design using FPGAs, ASICs, or custom silicon. Programming these processors is complicated by the lack of toolchain support for creating the necessary binary code as part of hardware design, implementation, and evaluation. Hardware developers who cannot create their own ad-hoc assembler are left to hand-assemble their code into binary instructions which is both painful and error prone. We present a tool that supports the rapid creation of assemblers for application-specific processors. A single language is used to specify both instruction formats as collections of bit fields and the instantiation of those formats into sequences of binary instructions as a single, homogeneous activity that is designed to be as familiar and accessible to hardware designers as possible. The output from the tool can be used directly by hardware synthesis tools to initialise the program memory of an application-specific processor.
@InProceedings{<Programming>21p21,
author = {Ian Piumarta},
title = {Improving on the Experience of Hand-Assembling Programs for Application-Specific Architectures},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {21--29},
doi = {10.1145/3464432.3464434},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Oron: Towards a Dynamic Analysis ..."
Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript
Aäron Munsters, Angel Luis Scull Pupo, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
The dynamic nature of JavaScript may lead to challenges and issues regarding efficiency and security. Analysis tools can help developers tackle some of these issues. In the context of web applications, dynamic analyses are best suited for handling those dynamic features but may affect the programs execution performance. In a first experiment, we attempted to improve the performance of the Aran dynamic analysis platform for JavaScript by utilizing WebAssembly. The extension caused extra performance hits due to context switches between JavaScript and WebAssembly. Because these context switches are inevitable, we decided to refit our work for the analysis of AssemblyScript, a variant of TypeScript which compiles to WebAssembly (and therefore excluding context switches). In this work, we explore this approach in the form of a new source code instrumentation platform named Oron, which allows for the instrumentation of AssemblyScript code. The presented platform is evaluated and shows promising improvements which provide a solid basis for efficient dynamic analysis of AssemblyScript applications.
@InProceedings{<Programming>21p6,
author = {Aäron Munsters and Angel Luis Scull Pupo and Jim Bauwens and Elisa Gonzalez Boix},
title = {Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {6--13},
doi = {10.1145/3464432.3464780},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "From ASTs to Machine Code ..."
From ASTs to Machine Code with LLVM
Dimitri Racordon
(University of Geneva, Switzerland)
A compiler is a program that translates source code written in a particular language into another language. Internally, the whole process is typically split into multiple stages that handle one particular aspect of this translation. One of these consists of translating the high-level representation of the program, typically an abstract syntax tree, into a simpler form that is suitable for analysis, optimizations, and code generation. This tutorial paper focuses on this process, and uses LLVM to compile programs into optimized machine code. LLVM is a language-agnostic compiler toolchain that handles program optimization and code generation. It is based on its own internal representation, called LLVM IR, which is then transformed into machine code.
We give a brief introduction to LLVM IR, and describe a few patterns to translate high-level language constructs expressed as abstract syntax trees. We implement these patterns in a compiler for a toy programming language, named Cocodol, which supports dynamic typing, unbounded loops, and higher-order functions.
@InProceedings{<Programming>21p67,
author = {Dimitri Racordon},
title = {From ASTs to Machine Code with LLVM},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {67--76},
doi = {10.1145/3464432.3464777},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Rec.HTML: Declarative HTML ..."
Rec.HTML: Declarative HTML
Bob Reynders and Kwanghoon Choi
(Chonnam National University, South Korea)
Interactive user experiences on the web are becoming the norm. Client-side programs are becoming more complicated and have to deal with event handling, reading HTML document state and updating the interface. In this paper we propose a declarative language that supports these three facets of client-side browser development declaratively and provides a programming model where complex interfaces can be written using simple programming techniques such as records, functions and recursion.
@InProceedings{<Programming>21p1,
author = {Bob Reynders and Kwanghoon Choi},
title = {Rec.HTML: Declarative HTML},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {1--5},
doi = {10.1145/3464432.3464779},
year = {2021},
}
Publisher's Version
<Programming> Companion '21: "Javardeye: Gaze Input for ..."
Javardeye: Gaze Input for Cursor Control in a Structured Editor
André L. Santos
(ISCTE-IUL, Portugal)
Programmers spend a considerable time jumping through editing positions in the source code, often requiring the use of the mouse and/or arrow keys to position the cursor at the desired editing position. We developed Javardeye, a prototype code editor for Java integrated with eye tracking technology for controlling the editing cursor. Our implementation is based on a structured editor, leveraging on its particular characteristics, and augmenting it with a secondary--latent cursor--controlled by eye gaze. This paper describes the main design decisions and tradeoffs of our approach.
@InProceedings{<Programming>21p30,
author = {André L. Santos},
title = {Javardeye: Gaze Input for Cursor Control in a Structured Editor},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {30--34},
doi = {10.1145/3464432.3464435},
year = {2021},
}
Publisher's Version
Video
<Programming> Companion '21: "Exploring Modal Locking in ..."
Exploring Modal Locking in Window Manipulation: Why Programmers Should Stash, Duplicate, Split, and Link Composite Views
Marcel Taeumel and Robert Hirschfeld
(HPI, Germany; University of Potsdam, Germany)
Window manipulation plays a vital role in multi-tool user interaction, especially for programmers exploring software artifacts, gathering information for better understanding. However, today's window managers offer only limited means to organize screen contents, which increases cognitive efforts for both tool builders and users. Builders must account for live integration of composite views; users might have to work around disruptive mode errors when actual tasks conflict with a tool's design. We follow a pattern-finding approach and present four new verbs for direct window manipulation, which we consolidated from existing tools and systems. If window managers would offer to stash, duplicate, split, and link views, we believe that programmers could better maintain flow during exploration activities.
@InProceedings{<Programming>21p14,
author = {Marcel Taeumel and Robert Hirschfeld},
title = {Exploring Modal Locking in Window Manipulation: Why Programmers Should Stash, Duplicate, Split, and Link Composite Views},
booktitle = {Proc.\ <Programming>},
publisher = {ACM},
pages = {14--20},
doi = {10.1145/3464432.3464433},
year = {2021},
}
Publisher's Version