An empirical study on program comprehension with reactive programming

Salvaneschi, Guido; Amann, Sven; Proksch, Sebastian; Mezini, Mira

doi:10.1145/2635868.2635895

Cited by 34 publications

(16 citation statements)

References 50 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Intertwining in the same code the assembly of UI events to build user interactions and the transformation of UI events into commands makes the code more complex: it can lead to "spaghetti" code [6], [7] and can be affected by design smells [12]. Moreover, the UI process model strongly relies on the Observer pattern that suffers from several major flaws [8], [9], [10], [11]. This also makes the code more difficult to test.…”

Section: Limitations Of the Ui Event Processing Modelmentioning

confidence: 99%

Interacto: A Modern User Interaction Processing Model

Blouin

Jézéquel

2022

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

Since most software systems provide their users with interactive features, building user interfaces (UI) is one of the core software engineering tasks. It consists in designing, implementing and testing ever more sophisticated and versatile ways for users to interact with software systems, and safely connecting these interactions with commands querying or modifying their state. However, most UI frameworks still rely on a low level model, the bare bone UI event processing model. This model was suitable for the rather simple UIs of the early 80's (menus, buttons, keyboards, mouse clicks), but now exhibits major software engineering flaws for modern, highly interactive UIs. These flaws include lack of separation of concerns, weak modularity and thus low reusability of code for advanced interactions, as well as low testability. To mitigate these flaws, we propose Interacto as a high level user interaction processing model. By reifying the concept of user interaction, Interacto makes it easy to design, implement and test modular and reusable advanced user interactions, and to connect them to commands with built-in undo/redo support. To demonstrate its applicability and generality, we briefly present two open source implementations of Interacto for Java/JavaFX and TypeScript/Angular. We evaluate Interacto interest (1) on a real world case study, where it has been used since 2013, and with (2) a controlled experiment with 44 master students, comparing it with traditionnal UI frameworks.Index Terms-user interface, user interaction, UI event processing, separation of concerns, undo/redo ! INTRODUCTION"Anytime you turn on a computer, you're dealing with a user interface" [1]. User Interfaces (UIs), and the user interactions they supply, pervade our daily lives by enabling users to interact with software systems. The user interactions provided by a UI form a dialect between a system and its users [2]: a given user interaction can be viewed as a sentence composed of predefined words, i.e. low-level UI events, such as mouse pressure or mouse move. For example, we can view the execution of a drag-and-drop interaction as a sentence emitted by a user to the system. This sentence is usually composed of the words pressure, move, and release, that are UI events assembled in this specific order. The humancomputer interaction community designs novel and complex user interactions. As explained by [3], "Human-Computer Interaction (HCI) researchers have created a variety of novel [user] interaction techniques and shown their effectiveness in the lab [...]. Software developers need models, methods, and tools that allow them to transfer these techniques to commercial applications." Currently, to use such novel user interactions in software systems developers must complete two software engineering tasks: (i) They must assemble low-level UI events to build the expected user interaction. For example, a developer must manually assemble the events pressure, move, and release to build a drag-and-drop. (ii) They have to code how to process suc...

show abstract

Section: Limitations Of the Ui Event Processing Modelmentioning

confidence: 99%

Interacto: A Modern User Interaction Processing Model

Blouin

Jézéquel

2022

IIEEE Trans. Software Eng.

View full text Add to dashboard Cite

show abstract

“…First, several different tasks can be performed to find out whether a participant has understood a program. Such tasks include answering comprehension-related questions [12,29], filling out blank program parts [8], or more advanced tasks, such as extending or modifying existing code or finding bugs [18].…”

Section: Source Code Understandabilitymentioning

confidence: 99%

An Empirical Validation of Cognitive Complexity as a Measure of Source Code Understandability

Barón

Wyrich

Wagner

2020

Proceedings of the 14th ACM / IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM)

View full text Add to dashboard Cite

Background: Developers spend a lot of their time on understanding source code. Static code analysis tools can draw attention to code that is difficult for developers to understand. However, most of the findings are based on non-validated metrics, which can lead to confusion and code that is hard to understand not being identified. Aims: In this work, we validate a metric called Cognitive Complexity which was explicitly designed to measure code understandability and which is already widely used due to its integration in wellknown static code analysis tools. Method: We conducted a systematic literature search to obtain data sets from studies which measured code understandability. This way we obtained about 24,000 understandability evaluations of 427 code snippets. We calculated the correlations of these measurements with the corresponding metric values and statistically summarized the correlation coefficients through a meta-analysis. Results: Cognitive Complexity positively correlates with comprehension time and subjective ratings of understandability. The metric showed mixed results for the correlation with the correctness of comprehension tasks and with physiological measures. Conclusions: It is the first validated and solely code-based metric which is able to reflect at least some aspects of code understandability. Moreover, due to its methodology, this work shows that code understanding is currently measured in many different ways, which we also do not know how they are related. This makes it difficult to compare the results of individual studies as well as to develop a metric that measures code understanding in all its facets. CCS CONCEPTS • Software and its engineering → Empirical software validation.

show abstract

“…Link latency is uniformly distributed between 1 ms and 5 ms. Clients can reach the lock manager within two network hops, on average. We assume that packet's processing time is negligible with respect to link latency 4 . We consider changes from ten vars propagating across a dependency graph of depth five, with an average of two nodes per level.…”

Section: Experiments Setupmentioning

confidence: 99%

“…Instead, they declare the dependencies between variables and entirely delegate the update process to the runtime. This results in more compact and readable code, and reduces the possibility of subtle errors [4], [5]. Most significantly, the runtime takes care of ensuring the correctness of the propagation.…”

Section: Introductionmentioning

confidence: 99%

On the Semantics of Distributed Reactive Programming: The Cost of Consistency

Margara

Salvaneschi

2018

IIEEE Trans. Software Eng.

Self Cite

View full text Add to dashboard Cite

The reactive programming paradigm aims to simplify the development of reactive systems. It provides abstractions to define time-changing values that are automatically updated by the runtime according to their dependencies. The benefits of reactive programming in distributed settings have been recognized for long. Yet, existing solutions for distributed reactive programming enforce the same semantics as in single processes, introducing communication and synchronization costs that hamper scalability. Establishing suitable abstractions for distributed reactive programming demands for a deeper investigation of the semantics of change propagation. This paper takes a foundational approach and defines precise propagation semantics in terms of consistency guarantees that constrain the order and isolation of value updates. We study the benefits and costs of these consistency guarantees both theoretically and empirically, using case studies and synthetic benchmarks. We show that different applications require different levels of consistency and that manually implementing the required level on a middleware that provides a lower one annuls the abstraction improvements of reactive programming. This motivates a framework that enables the developers to select the best trade-off between consistency and overhead for the problem at hand. To this end, we present DREAM, a distributed reactive programming middleware with flexible consistency guarantees.

show abstract

An empirical study on program comprehension with reactive programming

Cited by 34 publications

References 50 publications

Interacto: A Modern User Interaction Processing Model

Interacto: A Modern User Interaction Processing Model

An Empirical Validation of Cognitive Complexity as a Measure of Source Code Understandability

On the Semantics of Distributed Reactive Programming: The Cost of Consistency

Contact Info

Product

Resources

About