@book{SchreiberKrahnIngallsetal.2016,
author = {Schreiber, Robin and Krahn, Robert and Ingalls, Daniel H. H. and Hirschfeld, Robert},
title = {Transmorphic},
number = {110},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-387-9},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-98300},
publisher = {Universit{\"a}t Potsdam},
pages = {100},
year = {2016},
abstract = {Defining Graphical User Interfaces (GUIs) through functional abstractions can reduce the complexity that arises from mutable abstractions. Recent examples, such as Facebook's React GUI framework have shown, how modelling the view as a functional projection from the application state to a visual representation can reduce the number of interacting objects and thus help to improve the reliabiliy of the system. This however comes at the price of a more rigid, functional framework where programmers are forced to express visual entities with functional abstractions, detached from the way one intuitively thinks about the physical world. In contrast to that, the GUI Framework Morphic allows interactions in the graphical domain, such as grabbing, dragging or resizing of elements to evolve an application at runtime, providing liveness and directness in the development workflow. Modelling each visual entity through mutable abstractions however makes it difficult to ensure correctness when GUIs start to grow more complex. Furthermore, by evolving morphs at runtime through direct manipulation we diverge more and more from the symbolic description that corresponds to the morph. Given that both of these approaches have their merits and problems, is there a way to combine them in a meaningful way that preserves their respective benefits? As a solution for this problem, we propose to lift Morphic's concept of direct manipulation from the mutation of state to the transformation of source code. In particular, we will explore the design, implementation and integration of a bidirectional mapping between the graphical representation and a functional and declarative symbolic description of a graphical user interface within a self hosted development environment. We will present Transmorphic, a functional take on the Morphic GUI Framework, where the visual and structural properties of morphs are defined in a purely functional, declarative fashion. In Transmorphic, the developer is able to assemble different morphs at runtime through direct manipulation which is automatically translated into changes in the code of the application. In this way, the comprehensiveness and predictability of direct manipulation can be used in the context of a purely functional GUI, while the effects of the manipulation are reflected in a medium that is always in reach for the programmer and can even be used to incorporate the source transformations into the source files of the application.},
language = {en}
}
@book{OttoPollakWerneretal.2015,
author = {Otto, Philipp and Pollak, Jaqueline and Werner, Daniel and Wolff, Felix and Steinert, Bastian and Thamsen, Lauritz and Taeumel, Marcel and Lincke, Jens and Krahn, Robert and Ingalls, Daniel H. H. and Hirschfeld, Robert},
title = {Exploratives Erstellen von interaktiven Inhalten in einer dynamischen Umgebung​},
number = {101},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-346-6},
issn = {1613-5652},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus4-83806},
publisher = {Universit{\"a}t Potsdam},
pages = {vii, 115},
year = {2015},
abstract = {Bei der Erstellung von Visualisierungen gibt es im Wesentlichen zwei Ans{\"a}tze. Zum einen k{\"o}nnen mit geringem Aufwand schnell Standarddiagramme erstellt werden. Zum anderen gibt es die M{\"o}glichkeit, individuelle und interaktive Visualisierungen zu programmieren. Dies ist jedoch mit einem deutlich h{\"o}heren Aufwand verbunden. Flower erm{\"o}glicht eine schnelle Erstellung individueller und interaktiver Visualisierungen, indem es den Entwicklungssprozess stark vereinfacht und die Nutzer bei den einzelnen Aktivit{\"a}ten wie dem Import und der Aufbereitung von Daten, deren Abbildung auf visuelle Elemente sowie der Integration von Interaktivit{\"a}t direkt unterst{\"u}tzt.},
language = {de}
}
@article{ReinRamsonLinckeetal.2017,
author = {Rein, Patrick and Ramson, Stefan and Lincke, Jens and Felgentreff, Tim and Hirschfeld, Robert},
title = {Group-Based Behavior Adaptation Mechanisms in Object-Oriented Systems},
series = {IEEE software},
volume = {34},
journal = {IEEE software},
number = {6},
publisher = {Inst. of Electr. and Electronics Engineers},
address = {Los Alamitos},
issn = {0740-7459},
doi = {10.1109/MS.2017.4121224},
pages = {78 -- 82},
year = {2017},
abstract = {Dynamic and distributed systems require behavior adaptations for groups of objects. Group-based behavior adaptation mechanisms scope adaptations to objects matching conditions beyond class membership. The specification of groups can be explicit or implicit.},
language = {en}
}
@article{HirschfeldKawarnura2006,
author = {Hirschfeld, Robert and Kawarnura, Katsuya},
title = {Dynamic service adaptation},
series = {Software : practice \& experience},
volume = {36},
journal = {Software : practice \& experience},
number = {11-12},
publisher = {Wiley},
address = {Chichester},
issn = {0038-0644},
doi = {10.1002/spe.766},
pages = {1115 -- 1131},
year = {2006},
abstract = {Change can be observed in our environment and in the technology we build. While changes in the environment happen continuously and implicitly, our technology has to be kept in sync with the changing world around it. Although we can prepare for some of the changes for most of them we cannot. This is especially true for next-generation mobile communication systems that are expected to support the creation of a ubiquitous society where virtually everything is connected and made available within an organic information network. Resources will frequently join or leave the network, new types of media or new combinations of existing types will be used to interact and cooperate, and services will be tailored to preferences and needs of individual customers to better meet their needs. This paper outlines our research in the area of dynamic service adaptation to provide concepts and technologies allowing for such environments. Copyright (C) 2006 John Wiley \& Sons, Ltd.},
language = {en}
}
@article{MattisBeckmannReinetal.2022,
author = {Mattis, Toni and Beckmann, Tom and Rein, Patrick and Hirschfeld, Robert},
title = {First-class concepts},
series = {Journal of object technology : JOT / ETH Z{\"u}rich, Department of Computer Science},
volume = {21},
journal = {Journal of object technology : JOT / ETH Z{\"u}rich, Department of Computer Science},
number = {2},
publisher = {ETH Z{\"u}rich, Department of Computer Science},
address = {Z{\"u}rich},
issn = {1660-1769},
doi = {10.5381/jot.2022.21.2.a6},
pages = {1 -- 15},
year = {2022},
abstract = {Ideally, programs are partitioned into independently maintainable and understandable modules. As a system grows, its architecture gradually loses the capability to accommodate new concepts in a modular way. While refactoring is expensive and not always possible, and the programming language might lack dedicated primary language constructs to express certain cross-cutting concerns, programmers are still able to explain and delineate convoluted concepts through secondary means: code comments, use of whitespace and arrangement of code, documentation, or communicating tacit knowledge.
Secondary constructs are easy to change and provide high flexibility in communicating cross-cutting concerns and other concepts among programmers. However, such secondary constructs usually have no reified representation that can be explored and manipulated as first-class entities through the programming environment.
In this exploratory work, we discuss novel ways to express a wide range of concepts, including cross-cutting concerns, patterns, and lifecycle artifacts independently of the dominant decomposition imposed by an existing architecture. We propose the representation of concepts as first-class objects inside the programming environment that retain the capability to change as easily as code comments. We explore new tools that allow programmers to view, navigate, and change programs based on conceptual perspectives. In a small case study, we demonstrate how such views can be created and how the programming experience changes from draining programmers' attention by stretching it across multiple modules toward focusing it on cohesively presented concepts. Our designs are geared toward facilitating multiple secondary perspectives on a system to co-exist in symbiosis with the original architecture, hence making it easier to explore, understand, and explain complex contexts and narratives that are hard or impossible to express using primary modularity constructs.},
language = {en}
}
@book{HauptMarrHirschfeld2011,
author = {Haupt, Michael and Marr, Stefan and Hirschfeld, Robert},
title = {CSOM/PL : a virtual machine product line},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-134-9},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-52332},
publisher = {Universit{\"a}t Potsdam},
pages = {26},
year = {2011},
abstract = {CSOM/PL is a software product line (SPL) derived from applying multi-dimensional separation of concerns (MDSOC) techniques to the domain of high-level language virtual machine (VM) implementations. For CSOM/PL, we modularised CSOM, a Smalltalk VM implemented in C, using VMADL (virtual machine architecture description language). Several features of the original CSOM were encapsulated in VMADL modules and composed in various combinations. In an evaluation of our approach, we show that applying MDSOC and SPL principles to a domain as complex as that of VMs is not only feasible but beneficial, as it improves understandability, maintainability, and configurability of VM implementations without harming performance.},
language = {en}
}
@book{CalmezHesseSiegmundetal.2013,
author = {Calmez, Conrad and Hesse, Hubert and Siegmund, Benjamin and Stamm, Sebastian and Thomschke, Astrid and Hirschfeld, Robert and Ingalls, Dan and Lincke, Jens},
title = {Explorative authoring of Active Web content in a mobile environment},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-232-2},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-64054},
publisher = {Universit{\"a}t Potsdam},
pages = {132},
year = {2013},
abstract = {Developing rich Web applications can be a complex job - especially when it comes to mobile device support. Web-based environments such as Lively Webwerkstatt can help developers implement such applications by making the development process more direct and interactive. Further the process of developing software is collaborative which creates the need that the development environment offers collaboration facilities. This report describes extensions of the webbased development environment Lively Webwerkstatt such that it can be used in a mobile environment. The extensions are collaboration mechanisms, user interface adaptations but as well event processing and performance measuring on mobile devices.},
language = {en}
}
@book{GellerHirschfeldBracha2010,
author = {Geller, Felix and Hirschfeld, Robert and Bracha, Gilad},
title = {Pattern Matching for an object-oriented and dynamically typed programming language},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-065-6},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-43035},
publisher = {Universit{\"a}t Potsdam},
pages = {81},
year = {2010},
abstract = {Pattern matching is a well-established concept in the functional programming community. It provides the means for concisely identifying and destructuring values of interest. This enables a clean separation of data structures and respective functionality, as well as dispatching functionality based on more than a single value. Unfortunately, expressive pattern matching facilities are seldomly incorporated in present object-oriented programming languages. We present a seamless integration of pattern matching facilities in an object-oriented and dynamically typed programming language: Newspeak. We describe language extensions to improve the practicability and integrate our additions with the existing programming environment for Newspeak. This report is based on the first author's master's thesis.},
language = {en}
}
@article{PerscheidSiegmundTaeumeletal.2017,
author = {Perscheid, Michael and Siegmund, Benjamin and Taeumel, Marcel and Hirschfeld, Robert},
title = {Studying the advancement in debugging practice of professional software developers},
series = {Software Quality Journal},
volume = {25},
journal = {Software Quality Journal},
publisher = {Springer},
address = {Dordrecht},
issn = {0963-9314},
doi = {10.1007/s11219-015-9294-2},
pages = {83 -- 110},
year = {2017},
abstract = {In 1997, Henry Lieberman stated that debugging is the dirty little secret of computer science. Since then, several promising debugging technologies have been developed such as back-in-time debuggers and automatic fault localization methods. However, the last study about the state-of-the-art in debugging is still more than 15 years old and so it is not clear whether these new approaches have been applied in practice or not. For that reason, we investigate the current state of debugging in a comprehensive study. First, we review the available literature and learn about current approaches and study results. Second, we observe several professional developers while debugging and interview them about their experiences. Third, we create a questionnaire that serves as the basis for a larger online debugging survey. Based on these results, we present new insights into debugging practice that help to suggest new directions for future research.},
language = {en}
}
@article{FelgentreffPerscheidHirschfeld2017,
author = {Felgentreff, Tim and Perscheid, Michael and Hirschfeld, Robert},
title = {Implementing record and refinement for debugging timing-dependent communication},
series = {Science of computer programming},
volume = {134},
journal = {Science of computer programming},
publisher = {Elsevier},
address = {Amsterdam},
issn = {0167-6423},
doi = {10.1016/j.scico.2015.11.006},
pages = {4 -- 18},
year = {2017},
abstract = {Distributed applications are hard to debug because timing-dependent network communication is a source of non-deterministic behavior. Current approaches to debug non deterministic failures include post-mortem debugging as well as record and replay. However, the first impairs system performance to gather data, whereas the latter requires developers to understand the timing-dependent communication at a lower level of abstraction than they develop at. Furthermore, both approaches require intrusive core library modifications to gather data from live systems. In this paper, we present the Peek-At-Talk debugger for investigating non-deterministic failures with low overhead in a systematic, top-down method, with a particular focus on tool-building issues in the following areas: First, we show how our debugging framework Path Tools guides developers from failures to their root causes and gathers run-time data with low overhead. Second, we present Peek-At-Talk, an extension to our Path Tools framework to record non-deterministic communication and refine behavioral data that connects source code with network events. Finally, we scope changes to the core library to record network communication without impacting other network applications.},
language = {en}
}
@article{ReinTaeumelHirschfeld2017,
author = {Rein, Patrick and Taeumel, Marcel and Hirschfeld, Robert},
title = {Making the domain tangible},
series = {Design Thinking Research},
journal = {Design Thinking Research},
publisher = {Springer},
address = {New York},
isbn = {978-3-319-60967-6},
doi = {10.1007/978-3-319-60967-6_9},
pages = {171 -- 194},
year = {2017},
abstract = {Programmers collaborate continuously with domain experts to explore the problem space and to shape a solution that fits the users' needs. In doing so, all parties develop a shared vocabulary, which is above all a list of named concepts and their relationships to each other. Nowadays, many programmers favor object-oriented programming because it allows them to directly represent real-world concepts and interactions from the vocabulary as code. However, when existing domain data is not yet represented as objects, it becomes a challenge to initially bring existing domain data into object-oriented systems and to keep the source code readable. While source code might be comprehensible to programmers, domain experts can struggle, given their non-programming background. We present a new approach to provide a mapping of existing data sources into the object-oriented programming environment. We support keeping the code of the domain model compact and readable while adding implicit means to access external information as internal domain objects. This should encourage programmers to explore different ways to build the software system quickly. Eventually, our approach fosters communication with the domain experts, especially at the beginning of a project. When the details in the problem space are not yet clear, the source code provides a valuable, tangible communication artifact.},
language = {en}
}
@book{BerovHenningMattisetal.2013,
author = {Berov, Leonid and Henning, Johannes and Mattis, Toni and Rein, Patrick and Schreiber, Robin and Seckler, Eric and Steinert, Bastian and Hirschfeld, Robert},
title = {Vereinfachung der Entwicklung von Gesch{\"a}ftsanwendungen durch Konsolidierung von Programmierkonzepten und -technologien},
publisher = {Universit{\"a}tsverlag Potsdam},
address = {Potsdam},
isbn = {978-3-86956-231-5},
url = {http://nbn-resolving.de/urn:nbn:de:kobv:517-opus-64045},
publisher = {Universit{\"a}t Potsdam},
pages = {186},
year = {2013},
abstract = {Die Komplexit{\"a}t heutiger Gesch{\"a}ftsabl{\"a}ufe und die Menge der zu verwaltenden Daten stellen hohe Anforderungen an die Entwicklung und Wartung von Gesch{\"a}ftsanwendungen. Ihr Umfang entsteht unter anderem aus der Vielzahl von Modellentit{\"a}ten und zugeh{\"o}rigen Nutzeroberfl{\"a}chen zur Bearbeitung und Analyse der Daten. Dieser Bericht pr{\"a}sentiert neuartige Konzepte und deren Umsetzung zur Vereinfachung der Entwicklung solcher umfangreichen Gesch{\"a}ftsanwendungen. Erstens: Wir schlagen vor, die Datenbank und die Laufzeitumgebung einer dynamischen objektorientierten Programmiersprache zu vereinen. Hierzu organisieren wir die Speicherstruktur von Objekten auf die Weise einer spaltenorientierten Hauptspeicherdatenbank und integrieren darauf aufbauend Transaktionen sowie eine deklarative Anfragesprache nahtlos in dieselbe Laufzeitumgebung. Somit k{\"o}nnen transaktionale und analytische Anfragen in derselben objektorientierten Hochsprache implementiert werden, und dennoch nah an den Daten ausgef{\"u}hrt werden. Zweitens: Wir beschreiben Programmiersprachkonstrukte, welche es erlauben, Nutzeroberfl{\"a}chen sowie Nutzerinteraktionen generisch und unabh{\"a}ngig von konkreten Modellentit{\"a}ten zu beschreiben. Um diese abstrakte Beschreibung nutzen zu k{\"o}nnen, reichert man die Dom{\"a}nenmodelle um vormals implizite Informationen an. Neue Modelle m{\"u}ssen nur um einige Informationen erweitert werden um bereits vorhandene Nutzeroberfl{\"a}chen und -interaktionen auch f{\"u}r sie verwenden zu k{\"o}nnen. Anpassungen, die nur f{\"u}r ein Modell gelten sollen, k{\"o}nnen unabh{\"a}ngig vom Standardverhalten, inkrementell, definiert werden. Drittens: Wir erm{\"o}glichen mit einem weiteren Programmiersprachkonstrukt die zusammenh{\"a}ngende Beschreibung von Abl{\"a}ufen der Anwendung, wie z.B. Bestellprozesse. Unser Programmierkonzept kapselt Nutzerinteraktionen in synchrone Funktionsaufrufe und macht somit Prozesse als zusammenh{\"a}ngende Folge von Berechnungen und Interaktionen darstellbar. Viertens: Wir demonstrieren ein Konzept, wie Endnutzer komplexe analytische Anfragen intuitiver formulieren k{\"o}nnen. Es basiert auf der Idee, dass Endnutzer Anfragen als Konfiguration eines Diagramms sehen. Entsprechend beschreibt ein Nutzer eine Anfrage, indem er beschreibt, was sein Diagramm darstellen soll. Nach diesem Konzept beschriebene Diagramme enthalten ausreichend Informationen, um daraus eine Anfrage generieren zu k{\"o}nnen. Hinsichtlich der Ausf{\"u}hrungsdauer sind die generierten Anfragen {\"a}quivalent zu Anfragen, die mit konventionellen Anfragesprachen formuliert sind. Das Anfragemodell setzen wir in einem Prototypen um, der auf den zuvor eingef{\"u}hrten Konzepten aufsetzt.},
language = {de}
}
@article{SteinertCassouHirschfeld2013,
author = {Steinert, Bastian and Cassou, Damien and Hirschfeld, Robert},
title = {CoExist overcoming aversion to change preserving immediate access to source code and run-time information of previous development states},
series = {ACM SIGPLAN notices},
volume = {48},
journal = {ACM SIGPLAN notices},
number = {2},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2480360.2384591},
pages = {107 -- 117},
year = {2013},
abstract = {Programmers make many changes to the program to eventually find a good solution for a given task. In this course of change, every intermediate development state can of value, when, for example, a promising ideas suddenly turn out inappropriate or the interplay of objects turns out more complex than initially expected before making changes. Programmers would benefit from tool support that provides immediate access to source code and run-time of previous development states of interest. We present IDE extensions, implemented for Squeak/Smalltalk, to preserve, retrieve, and work with this information. With such tool support, programmers can work without worries because they can rely on tools that help them with whatever their explorations will reveal. They no longer have to follow certain best practices only to avoid undesired consequences of changing code.},
language = {en}
}
@article{HauptAdamsTimbermontetal.2009,
author = {Haupt, Michael and Adams, Bram and Timbermont, Stijn and Gibbs, Celina and Coady, Yvonne and Hirschfeld, Robert},
title = {Disentangling virtual machine architecture},
issn = {1751-8806},
doi = {10.1049/iet-sen.2007.0121},
year = {2009},
abstract = {Virtual machine (VM) implementations are made of intricately intertwined subsystems, interacting largely through implicit dependencies. As the degree of crosscutting present in VMs is very high, VM implementations exhibit significant internal complexity. This study proposes an architecture approach for VMs that regards a VM as a composite of service modules coordinated through explicit bidirectional interfaces. Aspect-oriented programming techniques are used to establish these interfaces, to coordinate module interaction, and to declaratively express concrete VM architectures. A VM architecture description language is presented in a case study, illustrating the application of the proposed architectural principles.},
language = {en}
}
@article{SteinertHirschfeld2012,
author = {Steinert, Bastian and Hirschfeld, Robert},
title = {Applying design knowledge to programming},
year = {2012},
language = {en}
}
@article{HirschfeldSteinertLincke2011,
author = {Hirschfeld, Robert and Steinert, Bastian and Lincke, Jens},
title = {Agile software development in virtual collaboration environments},
isbn = {978-3-642-13756-3},
year = {2011},
language = {en}
}
@article{HirschfeldPerscheidHaupt2012,
author = {Hirschfeld, Robert and Perscheid, Michael and Haupt, Michael},
title = {Explicit use-case representation in object-oriented programming languages},
series = {ACM SIGPLAN notices},
volume = {47},
journal = {ACM SIGPLAN notices},
number = {2},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2168696.2047856},
pages = {51 -- 60},
year = {2012},
abstract = {Use-cases are considered an integral part of most contemporary development processes since they describe a software system's expected behavior from the perspective of its prospective users. However, the presence of and traceability to use-cases is increasingly lost in later more code-centric development activities. Use-cases, being well-encapsulated at the level of requirements descriptions, eventually lead to crosscutting concerns in system design and source code. Tracing which parts of the system contribute to which use-cases is therefore hard and so limits understandability. In this paper, we propose an approach to making use-cases first-class entities in both the programming language and the runtime environment. Having use-cases present in the code and the running system will allow developers, maintainers, and operators to easily associate their units of work with what matters to the users. We suggest the combination of use-cases, acceptance tests, and dynamic analysis to automatically associate source code with use-cases. We present UseCasePy, an implementation of our approach to use-case-centered development in Python, and its application to the Django Web framework.},
language = {en}
}
@article{LinckeAppeltauerSteinertetal.2011,
author = {Lincke, Jens and Appeltauer, Malte and Steinert, Bastian and Hirschfeld, Robert},
title = {An open implementation for context-oriented layer composition in ContextJS},
series = {Science of computer programming},
volume = {76},
journal = {Science of computer programming},
number = {12},
publisher = {Elsevier},
address = {Amsterdam},
issn = {0167-6423},
doi = {10.1016/j.scico.2010.11.013},
pages = {1194 -- 1209},
year = {2011},
abstract = {Context-oriented programming (COP) provides dedicated support for defining and composing variations to a basic program behavior. A variation, which is defined within a layer, can be de-/activated for the dynamic extent of a code block. While this mechanism allows for control flow-specific scoping, expressing behavior adaptations can demand alternative scopes. For instance, adaptations can depend on dynamic object structure rather than control flow. We present scenarios for behavior adaptation and identify the need for new scoping mechanisms. The increasing number of scoping mechanisms calls for new language abstractions representing them. We suggest to open the implementation of scoping mechanisms so that developers can extend the COP language core according to their specific needs. Our open implementation moves layer composition into objects to be affected and with that closer to the method dispatch to be changed. We discuss the implementation of established COP scoping mechanisms using our approach and present new scoping mechanisms developed for our enhancements to Lively Kernel.},
language = {en}
}
@article{WeiherHirschfeld2014,
author = {Weiher, Marcel and Hirschfeld, Robert},
title = {Polymorphic identifiers: uniform resource access in objective-smalltalk},
series = {ACM SIGPLAN notices},
volume = {49},
journal = {ACM SIGPLAN notices},
number = {2},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2508168.2508169},
pages = {61 -- 71},
year = {2014},
abstract = {In object-oriented programming, polymorphic dispatch of operations decouples clients from specific providers of services and allows implementations to be modified or substituted without affecting clients. The Uniform Access Principle (UAP) tries to extend these qualities to resource access by demanding that access to state be indistinguishable from access to operations. Despite language features supporting the UAP, the overall goal of substitutability has not been achieved for either alternative resources such as keyed storage, files or web pages, or for alternate access mechanisms: specific kinds of resources are bound to specific access mechanisms and vice versa. Changing storage or access patterns either requires changes to both clients and service providers and trying to maintain the UAP imposes significant penalties in terms of code-duplication and/or performance overhead. We propose introducing first class identifiers as polymorphic names for storage locations to solve these problems. With these Polymorphic Identifiers, we show that we can provide uniform access to a wide variety of resource types as well as storage and access mechanisms, whether parametrized or direct, without affecting client code, without causing code duplication or significant performance penalties.},
language = {en}
}
@article{BaumanBolzHirschfeldetal.2015,
author = {Bauman, Spenser and Bolz, Carl Friedrich and Hirschfeld, Robert and Kirilichev, Vasily and Pape, Tobias and Siek, Jeremy G. and Tobin-Hochstadt, Sam},
title = {Pycket: A Tracing JIT for a Functional Language},
series = {ACM SIGPLAN notices},
volume = {50},
journal = {ACM SIGPLAN notices},
number = {9},
publisher = {Association for Computing Machinery},
address = {New York},
issn = {0362-1340},
doi = {10.1145/2784731.2784740},
pages = {22 -- 34},
year = {2015},
abstract = {We present Pycket, a high-performance tracing JIT compiler for Racket. Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more. On average, over a standard suite of benchmarks, Pycket outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers. Further, Pycket provides much better performance for Racket proxies than existing systems, dramatically reducing the overhead of contracts and gradual typing. We validate this claim with performance evaluation on multiple existing benchmark suites. The Pycket implementation is of independent interest as an application of the RPython meta-tracing framework (originally created for PyPy), which automatically generates tracing JIT compilers from interpreters. Prior work on meta-tracing focuses on bytecode interpreters, whereas Pycket is a high-level interpreter based on the CEK abstract machine and operates directly on abstract syntax trees. Pycket supports proper tail calls and first-class continuations. In the setting of a functional language, where recursion and higher-order functions are more prevalent than explicit loops, the most significant performance challenge for a tracing JIT is identifying which control flows constitute a loop-we discuss two strategies for identifying loops and measure their impact.},
language = {en}
}