Search Results

Documents authored by Tip, Frank

Document
Artifact
DOI: 10.4230/DARTS.7.2.5
Enabling Additional Parallelism in Asynchronous JavaScript Applications (Artifact)

Authors: Ellen Arteca, Frank Tip, and Max Schäfer

Published in: DARTS, Volume 7, Issue 2, Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021)

Abstract
JavaScript is a single-threaded programming language, so asynchronous programming is practiced out of necessity to ensure that applications remain responsive in the presence of user input or interactions with file systems and networks. However, many JavaScript applications execute in environments that do exhibit concurrency by, e.g., interacting with multiple or concurrent servers, or by using file systems managed by operating systems that support concurrent I/O. In this paper, we demonstrate that JavaScript programmers often schedule asynchronous I/O operations suboptimally, and that reordering such operations may yield significant performance benefits. Concretely, we define a static side-effect analysis that can be used to determine how asynchronous I/O operations can be refactored so that asynchronous I/O-related requests are made as early as possible, and so that the results of these requests are awaited as late as possible. While our static analysis is potentially unsound, we have not encountered any situations where it suggested reorderings that change program behavior. We evaluate the refactoring on 20 applications that perform file- or network-related I/O. For these applications, we observe average speedups ranging between 0.99% and 53.6% for the tests that execute refactored code (8.1% on average).
Cite as

Ellen Arteca, Frank Tip, and Max Schäfer. Enabling Additional Parallelism in Asynchronous JavaScript Applications (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 5:1-5:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)

Copy BibTex To Clipboard

@Article{arteca_et_al:DARTS.7.2.5,
  author =	{Arteca, Ellen and Tip, Frank and Sch\"{a}fer, Max},
  title =	{{Enabling Additional Parallelism in Asynchronous JavaScript Applications (Artifact)}},
  pages =	{5:1--5:6},
  journal =	{Dagstuhl Artifacts Series},
  ISSN =	{2509-8195},
  year =	{2021},
  volume =	{7},
  number =	{2},
  editor =	{Arteca, Ellen and Tip, Frank and Sch\"{a}fer, Max},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DARTS.7.2.5},
  URN =		{urn:nbn:de:0030-drops-140290},
  doi =		{10.4230/DARTS.7.2.5},
  annote =	{Keywords: asynchronous programming, refactoring, side-effect analysis, performance optimization, static analysis, JavaScript}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2021.7
Enabling Additional Parallelism in Asynchronous JavaScript Applications

Authors: Ellen Arteca, Frank Tip, and Max Schäfer

Published in: LIPIcs, Volume 194, 35th European Conference on Object-Oriented Programming (ECOOP 2021)

Abstract
JavaScript is a single-threaded programming language, so asynchronous programming is practiced out of necessity to ensure that applications remain responsive in the presence of user input or interactions with file systems and networks. However, many JavaScript applications execute in environments that do exhibit concurrency by, e.g., interacting with multiple or concurrent servers, or by using file systems managed by operating systems that support concurrent I/O. In this paper, we demonstrate that JavaScript programmers often schedule asynchronous I/O operations suboptimally, and that reordering such operations may yield significant performance benefits. Concretely, we define a static side-effect analysis that can be used to determine how asynchronous I/O operations can be refactored so that asynchronous I/O-related requests are made as early as possible, and so that the results of these requests are awaited as late as possible. While our static analysis is potentially unsound, we have not encountered any situations where it suggested reorderings that change program behavior. We evaluate the refactoring on 20 applications that perform file- or network-related I/O. For these applications, we observe average speedups ranging between 0.99% and 53.6% for the tests that execute refactored code (8.1% on average).
Cite as

Ellen Arteca, Frank Tip, and Max Schäfer. Enabling Additional Parallelism in Asynchronous JavaScript Applications. In 35th European Conference on Object-Oriented Programming (ECOOP 2021). Leibniz International Proceedings in Informatics (LIPIcs), Volume 194, pp. 7:1-7:28, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)

Copy BibTex To Clipboard

@InProceedings{arteca_et_al:LIPIcs.ECOOP.2021.7,
  author =	{Arteca, Ellen and Tip, Frank and Sch\"{a}fer, Max},
  title =	{{Enabling Additional Parallelism in Asynchronous JavaScript Applications}},
  booktitle =	{35th European Conference on Object-Oriented Programming (ECOOP 2021)},
  pages =	{7:1--7:28},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-190-0},
  ISSN =	{1868-8969},
  year =	{2021},
  volume =	{194},
  editor =	{M{\o}ller, Anders and Sridharan, Manu},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2021.7},
  URN =		{urn:nbn:de:0030-drops-140501},
  doi =		{10.4230/LIPIcs.ECOOP.2021.7},
  annote =	{Keywords: asynchronous programming, refactoring, side-effect analysis, performance optimization, static analysis, JavaScript}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2020.12
A Semantics for the Essence of React

Authors: Magnus Madsen, Ondřej Lhoták, and Frank Tip

Published in: LIPIcs, Volume 166, 34th European Conference on Object-Oriented Programming (ECOOP 2020)

Abstract
Traditionally, web applications have been written as HTML pages with embedded JavaScript code that implements dynamic and interactive features by manipulating the Document Object Model (DOM) through a low-level browser API. However, this unprincipled approach leads to code that is brittle, difficult to understand, non-modular, and does not facilitate incremental update of user-interfaces in response to state changes. React is a popular framework for constructing web applications that aims to overcome these problems. React applications are written in a declarative and object-oriented style, and consist of components that are organized in a tree structure. Each component has a set of properties representing input parameters, a state consisting of values that may vary over time, and a render method that declaratively specifies the subcomponents of the component. React’s concept of reconciliation determines the impact of state changes and updates the user-interface incrementally by selective mounting and unmounting of subcomponents. At designated points, the React framework invokes lifecycle hooks that enable programmers to perform actions outside the framework such as acquiring and releasing resources needed by a component. These mechanisms exhibit considerable complexity, but, to our knowledge, no formal specification of React’s semantics exists. This paper presents a small-step operational semantics that captures the essence of React, as a first step towards a long-term goal of developing automatic tools for program understanding, automatic testing, and bug finding for React web applications. To demonstrate that key operations such as mounting, unmounting, and reconciliation terminate, we define the notion of a well-behaved component and prove that well-behavedness is preserved by these operations.
Cite as

Magnus Madsen, Ondřej Lhoták, and Frank Tip. A Semantics for the Essence of React. In 34th European Conference on Object-Oriented Programming (ECOOP 2020). Leibniz International Proceedings in Informatics (LIPIcs), Volume 166, pp. 12:1-12:26, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2020)

Copy BibTex To Clipboard

@InProceedings{madsen_et_al:LIPIcs.ECOOP.2020.12,
  author =	{Madsen, Magnus and Lhot\'{a}k, Ond\v{r}ej and Tip, Frank},
  title =	{{A Semantics for the Essence of React}},
  booktitle =	{34th European Conference on Object-Oriented Programming (ECOOP 2020)},
  pages =	{12:1--12:26},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-154-2},
  ISSN =	{1868-8969},
  year =	{2020},
  volume =	{166},
  editor =	{Hirschfeld, Robert and Pape, Tobias},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2020.12},
  URN =		{urn:nbn:de:0030-drops-131697},
  doi =		{10.4230/LIPIcs.ECOOP.2020.12},
  annote =	{Keywords: JavaScript, React, operational semantics, lifecycle, reconciliation}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2016.1
Trace Typing: An Approach for Evaluating Retrofitted Type Systems

Authors: Esben Andreasen, Colin S. Gordon, Satish Chandra, Manu Sridharan, Frank Tip, and Koushik Sen

Published in: LIPIcs, Volume 56, 30th European Conference on Object-Oriented Programming (ECOOP 2016)

Abstract
Recent years have seen growing interest in the retrofitting of type systems onto dynamically-typed programming languages, in order to improve type safety, programmer productivity, or performance. In such cases, type system developers must strike a delicate balance between disallowing certain coding patterns to keep the type system simple, or including them at the expense of additional complexity and effort. Thus far, the process for designing retrofitted type systems has been largely ad hoc, because evaluating multiple variations of a type system on large bodies of existing code is a significant undertaking. We present trace typing: a framework for automatically and quantitatively evaluating variations of a retrofitted type system on large code bases. The trace typing approach involves gathering traces of program executions, inferring types for instances of variables and expressions occurring in a trace, and merging types according to merge strategies that reflect specific (combinations of) choices in the source-level type system design space. We evaluated trace typing through several experiments. We compared several variations of type systems retrofitted onto JavaScript, measuring the number of program locations with type errors in each case on a suite of over fifty thousand lines of JavaScript code. We also used trace typing to validate and guide the design of a new retrofitted type system that enforces fixed object layout for JavaScript objects. Finally, we leveraged the types computed by trace typing to automatically identify tag tests --- dynamic checks that refine a type --- and examined the variety of tests identified.
Cite as

Esben Andreasen, Colin S. Gordon, Satish Chandra, Manu Sridharan, Frank Tip, and Koushik Sen. Trace Typing: An Approach for Evaluating Retrofitted Type Systems. In 30th European Conference on Object-Oriented Programming (ECOOP 2016). Leibniz International Proceedings in Informatics (LIPIcs), Volume 56, pp. 1:1-1:26, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)

Copy BibTex To Clipboard

@InProceedings{andreasen_et_al:LIPIcs.ECOOP.2016.1,
  author =	{Andreasen, Esben and Gordon, Colin S. and Chandra, Satish and Sridharan, Manu and Tip, Frank and Sen, Koushik},
  title =	{{Trace Typing: An Approach for Evaluating Retrofitted Type Systems}},
  booktitle =	{30th European Conference on Object-Oriented Programming (ECOOP 2016)},
  pages =	{1:1--1:26},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-014-9},
  ISSN =	{1868-8969},
  year =	{2016},
  volume =	{56},
  editor =	{Krishnamurthi, Shriram and Lerner, Benjamin S.},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2016.1},
  URN =		{urn:nbn:de:0030-drops-60952},
  doi =		{10.4230/LIPIcs.ECOOP.2016.1},
  annote =	{Keywords: Retrofitted type systems, Type system design, trace typing}
}
Document
DOI: 10.4230/DagRep.3.2.1
Fault Prediction, Localization, and Repair (Dagstuhl Seminar 13061)

Authors: Mary Jean Harrold, Friedrich Steinmann, Frank Tip, and Andreas Zeller

Published in: Dagstuhl Reports, Volume 3, Issue 2 (2013)

Abstract
Software debugging, which involves localizing, understanding, and removing the cause of a failure, is a notoriously difficult, extremely time consuming, and human-intensive activity. For this reason, researchers have invested a great deal of effort in developing automated techniques and tools for supporting various debugging tasks. In this seminar, we discussed several different tools and techniques that aid in the task of Fault Prediction, Localization and Repair. The talks encompassed a wide variety of methodologies for fault prediction and localizing, such as - statistical fault localization, - core dump analysis, - taint analysis, - program slicing techniques, - dynamic fault-comprehension techniques, - visualization techniques, - combining hardware and software instrumentation for fault detection and failure prediction, - and verification techniques for checking safety properties of programs. For automatically (or semi-automatically) repairing faulty programs, the talks covered approaches such as - automated repair based on symbolic execution, constraint solving and program synthesis, - combining past fix patterns, machine learning and semantic patch generation - a technique that exploits the intrinsic redundancy of reusable components, - a technique based on memory-access patterns and a coverage matrix, - a technique that determines a combination of mutual-exclusion and order relationships that, once enforced, can prevent buggy interleaving. in addition, this seminar also explored some unusual topics such as Teaching Debugging, using Online Courses. Another interesting topic covered was the low representation of females in computing, and how programming and debugging tools interact with gender differences.
Cite as

Mary Jean Harrold, Friedrich Steinmann, Frank Tip, and Andreas Zeller. Fault Prediction, Localization, and Repair (Dagstuhl Seminar 13061). In Dagstuhl Reports, Volume 3, Issue 2, pp. 1-21, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2013)

Copy BibTex To Clipboard

@Article{harrold_et_al:DagRep.3.2.1,
  author =	{Harrold, Mary Jean and Steinmann, Friedrich and Tip, Frank and Zeller, Andreas},
  title =	{{Fault Prediction, Localization, and Repair (Dagstuhl Seminar 13061)}},
  pages =	{1--21},
  journal =	{Dagstuhl Reports},
  ISSN =	{2192-5283},
  year =	{2013},
  volume =	{3},
  number =	{2},
  editor =	{Harrold, Mary Jean and Steinmann, Friedrich and Tip, Frank and Zeller, Andreas},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagRep.3.2.1},
  URN =		{urn:nbn:de:0030-drops-40166},
  doi =		{10.4230/DagRep.3.2.1},
  annote =	{Keywords: Program analysis, Automated debugging, Fault prediction, Fault repair, Fault localization, Statistical debugging, Change impact analysis}
}
Document
DOI: 10.4230/DagSemProc.10152.1
10152 Abstracts Collection – Relationships, Objects, Roles, and Queries in Modern Languages

Authors: Guido Boella, Erik Meijer, David J. Pearce, Friedrich Steimann, and Frank Tip

Published in: Dagstuhl Seminar Proceedings, Volume 10152, Relationships, Objects, Roles, and Queries in Modern Programming Languages (2010)

Abstract
From 11/04/10 to 16/04/10, the Dagstuhl Seminar 10152 ``Relationships, Objects, Roles, and Queries in Modern Programming Languages'' was held in Schloss Dagstuhl~--~Leibniz Center for Informatics. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar as well as abstracts of seminar results and ideas are put together in this paper. The first section describes the seminar topics and goals in general. Links to extended abstracts or full papers are provided, if available.
Cite as

Guido Boella, Erik Meijer, David J. Pearce, Friedrich Steimann, and Frank Tip. 10152 Abstracts Collection – Relationships, Objects, Roles, and Queries in Modern Languages. In Relationships, Objects, Roles, and Queries in Modern Programming Languages. Dagstuhl Seminar Proceedings, Volume 10152, pp. 1-11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2010)

Copy BibTex To Clipboard

@InProceedings{boella_et_al:DagSemProc.10152.1,
  author =	{Boella, Guido and Meijer, Erik and Pearce, David J. and Steimann, Friedrich and Tip, Frank},
  title =	{{10152 Abstracts Collection – Relationships, Objects, Roles, and Queries in Modern Languages}},
  booktitle =	{Relationships, Objects, Roles, and Queries in Modern Programming Languages},
  pages =	{1--11},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2010},
  volume =	{10152},
  editor =	{Guido Boella and Erik Meijer and David J. Pearce and Friedrich Steimann and Frank Tip},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.10152.1},
  URN =		{urn:nbn:de:0030-drops-25750},
  doi =		{10.4230/DagSemProc.10152.1},
  annote =	{Keywords: Relationships, Roles, Software Modelling, Programming Languages}
}
Document
DOI: 10.4230/DagSemProc.10152.2
10152 Executive Summary – Relationships, Objects, Roles, and Queries in Modern Languages

Authors: Guido Boella, Erik Meijer, David J. Pearce, Friedrich Steimann, and Frank Tip

Published in: Dagstuhl Seminar Proceedings, Volume 10152, Relationships, Objects, Roles, and Queries in Modern Programming Languages (2010)

Abstract
During the 4 days of the seminar, 21 talks, 4 tutorials and 6 demos were given by the participants. In addition, a beauty contest was run on the last day, where participants were invited to solve a benchmark problem using their system.
Cite as

Guido Boella, Erik Meijer, David J. Pearce, Friedrich Steimann, and Frank Tip. 10152 Executive Summary – Relationships, Objects, Roles, and Queries in Modern Languages. In Relationships, Objects, Roles, and Queries in Modern Programming Languages. Dagstuhl Seminar Proceedings, Volume 10152, pp. 1-3, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2010)

Copy BibTex To Clipboard

@InProceedings{boella_et_al:DagSemProc.10152.2,
  author =	{Boella, Guido and Meijer, Erik and Pearce, David J. and Steimann, Friedrich and Tip, Frank},
  title =	{{10152 Executive Summary – Relationships, Objects, Roles, and Queries in Modern Languages}},
  booktitle =	{Relationships, Objects, Roles, and Queries in Modern Programming Languages},
  pages =	{1--3},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2010},
  volume =	{10152},
  editor =	{Guido Boella and Erik Meijer and David J. Pearce and Friedrich Steimann and Frank Tip},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.10152.2},
  URN =		{urn:nbn:de:0030-drops-25743},
  doi =		{10.4230/DagSemProc.10152.2},
  annote =	{Keywords: Relationships, Roles, Software Modelling, Programming Languages}
}
Document
DOI: 10.4230/DagSemRep.368
Program Analysis for Object-Oriented Evolution (Dagstuhl Seminar 03091)

Authors: Ralph Johnson, Gregor Snelting, and Frank Tip

Published in: Dagstuhl Seminar Reports. Dagstuhl Seminar Reports, Volume 1 (2021)

Abstract
Cite as

Ralph Johnson, Gregor Snelting, and Frank Tip. Program Analysis for Object-Oriented Evolution (Dagstuhl Seminar 03091). Dagstuhl Seminar Report 368, pp. 1-5, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2003)

Copy BibTex To Clipboard

@TechReport{johnson_et_al:DagSemRep.368,
  author =	{Johnson, Ralph and Snelting, Gregor and Tip, Frank},
  title =	{{Program Analysis for Object-Oriented Evolution (Dagstuhl Seminar 03091)}},
  pages =	{1--5},
  ISSN =	{1619-0203},
  year =	{2003},
  type = 	{Dagstuhl Seminar Report},
  number =	{368},
  institution =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemRep.368},
  URN =		{urn:nbn:de:0030-drops-152481},
  doi =		{10.4230/DagSemRep.368},
}
Document
DOI: 10.4230/DagSemRep.291
Effective Implementation of Object-Oriented Programming Languages (Dagstuhl Seminar 00451)

Authors: Uwe Aßmann, Laurie Hendren, Barbara Ryder, and Frank Tip

Published in: Dagstuhl Seminar Reports. Dagstuhl Seminar Reports, Volume 1 (2021)

Abstract
Cite as

Uwe Aßmann, Laurie Hendren, Barbara Ryder, and Frank Tip. Effective Implementation of Object-Oriented Programming Languages (Dagstuhl Seminar 00451). Dagstuhl Seminar Report 291, pp. 1-19, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2001)

Copy BibTex To Clipboard

@TechReport{amann_et_al:DagSemRep.291,
  author =	{A{\ss}mann, Uwe and Hendren, Laurie and Ryder, Barbara and Tip, Frank},
  title =	{{Effective Implementation of Object-Oriented Programming Languages (Dagstuhl Seminar 00451)}},
  pages =	{1--19},
  ISSN =	{1619-0203},
  year =	{2001},
  type = 	{Dagstuhl Seminar Report},
  number =	{291},
  institution =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemRep.291},
  URN =		{urn:nbn:de:0030-drops-151759},
  doi =		{10.4230/DagSemRep.291},
}
Any Issues?
X

Feedback on the Current Page

CAPTCHA

Thanks for your feedback!

Feedback submitted to Dagstuhl Publishing

Could not send message

Please try again later or send an E-mail
© 2023-2025 Schloss Dagstuhl – LZI GmbH About DROPS Imprint Privacy Contact