CGChristian Uldal Graulund
Christian Uldal Graulund
*This is an algorithmically generated author record based on publicly available information.
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Research Subjects
Christian Uldal Graulund has a total of 5 co-authors. Here are the top co-authors by number of shared publications:
- Dmitrij Szamozvancev
University of Cambridge CB3 0FD Cambridge UK
2 shared publications - Neel Krishnaswami
University of Cambridge, Cambridge, United Kingdom
2 shared publications - Martin Törngren
KTH Royal Institute of Technology, Stockholm, Sweden
1 shared publication - Paul Pop
Technical University of Denmark, Kongens Lyngby, Denmark
1 shared publication - Sonia Yeh
Chalmers University of Technology
1 shared publication
Latest Publications
- Open Access
- 17 September 2023
- Published by Association for Computing Machinery (ACM)
- p. 18-23
Special Session: Digital Technologies for Sustainability: Research Challenges and Opportunities
- 17 September 2023
- Published by Association for Computing Machinery (ACM)
- p. 18-23
Open AccessSpecial Session: Digital Technologies for Sustainability: Research Challenges and Opportunities
- Open Access
- 23 March 2021
- Published by Springer Nature
- Vol. 12650, 289-309
Adjoint Reactive GUI Programming
Most interaction with a computer is via graphical user interfaces. These are traditionally implemented imperatively, using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages are synchronous and continually check for new data. This means that an FRP-style GUI will “wake up” on each program cycle. This is problematic for applications like text editors and browsers, where often nothing happens for extended periods of time, and we want the implementation to sleep until new data arrives. In this paper, we present an asynchronous FRP language for designing GUIs called $$\lambda _{\mathsf {Widget}}$$ . Our language provides a novel semantics for widgets, the building block of GUIs, which offers both a natural Curry–Howard logical interpretation and an efficient implementation strategy.- 23 March 2021
- Published by Springer Nature
- Vol. 12650, 289-309
Open AccessAdjoint Reactive GUI Programming
Most interaction with a computer is via graphical user interfaces. These are traditionally implemented imperatively, using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages are synchronous and continually check for new data. This means that an FRP-style GUI will “wake up” on each program cycle. This is problematic for applications like text editors and browsers, where often nothing happens for extended periods of time, and we want the implementation to sleep until new data arrives. In this paper, we present an asynchronous FRP language for designing GUIs called $$\lambda _{\mathsf {Widget}}$$ . Our language provides a novel semantics for widgets, the building block of GUIs, which offers both a natural Curry–Howard logical interpretation and an efficient implementation strategy. - Open Access
Adjoint Reactive GUI
Most interaction with a computer is done via a graphical user interface. Traditionally, these are implemented in an imperative fashion using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages are synchronous and continually check for new data. This means that an FRP-style GUI will "wake up" on each program cycle. This is problematic for applications like text editors and browsers, where often nothing happens for extended periods of time, and we want the implementation to sleep until new data arrives. In this paper, we present an asynchronous FRP language for designing GUIs called $\lambda_{\mathsf{Widget}}$. Our language provides a novel semantics for widgets, the building block of GUIs, which offers both a natural Curry--Howard logical interpretation and an efficient implementation strategy.Open AccessAdjoint Reactive GUI
Most interaction with a computer is done via a graphical user interface. Traditionally, these are implemented in an imperative fashion using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages are synchronous and continually check for new data. This means that an FRP-style GUI will "wake up" on each program cycle. This is problematic for applications like text editors and browsers, where often nothing happens for extended periods of time, and we want the implementation to sleep until new data arrives. In this paper, we present an asynchronous FRP language for designing GUIs called $\lambda_{\mathsf{Widget}}$. Our language provides a novel semantics for widgets, the building block of GUIs, which offers both a natural Curry--Howard logical interpretation and an efficient implementation strategy.