• Deutsch

University Logo

  • Home
  • Search
  • Browse
  • Submit
  • Sitemap
Schließen

Refine

Has Fulltext

  • yes (20)
  • no (13)

Author

  • Hirschfeld, Robert (33)
  • Felgentreff, Tim (10)
  • Pape, Tobias (8)
  • Steinert, Bastian (7)
  • Lincke, Jens (6)
  • Taeumel, Marcel (5)
  • Bolz, Carl Friedrich (4)
  • Haupt, Michael (4)
  • Bracha, Gilad (3)
  • Niephaus, Fabio (3)
+ more

Year of publication

  • 2020 (1)
  • 2019 (1)
  • 2018 (1)
  • 2017 (3)
  • 2016 (4)
  • 2015 (6)
  • 2014 (2)
  • 2013 (5)
  • 2012 (3)
  • 2011 (4)
+ more

Document Type

  • Monograph/edited volume (20)
  • Article (13)

Language

  • English (29)
  • German (4)

Is part of the Bibliography

  • yes (33)

Keywords

  • Smalltalk (4)
  • Lively Kernel (3)
  • Debugging (2)
  • Experimentation (2)
  • JavaScript (2)
  • Prototyping (2)
  • Python (2)
  • Squeak (2)
  • Visualisierung (2)
  • collection types (2)
+ more

Institute

  • Hasso-Plattner-Institut für Digital Engineering gGmbH (22)
  • Hasso-Plattner-Institut für Digital Engineering GmbH (5)
  • Institut für Informatik und Computational Science (4)
  • Extern (1)

33 search hits

  • 1 to 10
  • BibTeX
  • CSV
  • RIS
  • XML
  • 10
  • 20
  • 50
  • 100

Sort by

  • Year
  • Year
  • Title
  • Title
  • Author
  • Author
Transmorphic (2016)
Schreiber, Robin ; Krahn, Robert ; Ingalls, Daniel H. H. ; Hirschfeld, Robert
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.
Exploratives Erstellen von interaktiven Inhalten in einer dynamischen Umgebung​ (2015)
Otto, Philipp ; Pollak, Jaqueline ; Werner, Daniel ; Wolff, Felix ; Steinert, Bastian ; Thamsen, Lauritz ; Taeumel, Marcel ; Lincke, Jens ; Krahn, Robert ; Ingalls, Daniel H. H. ; Hirschfeld, Robert
Bei der Erstellung von Visualisierungen gibt es im Wesentlichen zwei Ansätze. Zum einen können mit geringem Aufwand schnell Standarddiagramme erstellt werden. Zum anderen gibt es die Möglichkeit, individuelle und interaktive Visualisierungen zu programmieren. Dies ist jedoch mit einem deutlich höheren Aufwand verbunden. Flower ermöglicht eine schnelle Erstellung individueller und interaktiver Visualisierungen, indem es den Entwicklungssprozess stark vereinfacht und die Nutzer bei den einzelnen Aktivitäten wie dem Import und der Aufbereitung von Daten, deren Abbildung auf visuelle Elemente sowie der Integration von Interaktivität direkt unterstützt.
Pattern Matching for an object-oriented and dynamically typed programming language (2010)
Geller, Felix ; Hirschfeld, Robert ; Bracha, Gilad
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.
An abstraction for version control systems (2011)
Kleine, Matthias ; Hirschfeld, Robert ; Bracha, Gilad
Version Control Systems (VCS) allow developers to manage changes to software artifacts. Developers interact with VCSs through a variety of client programs, such as graphical front-ends or command line tools. It is desirable to use the same version control client program against different VCSs. Unfortunately, no established abstraction over VCS concepts exists. Instead, VCS client programs implement ad-hoc solutions to support interaction with multiple VCSs. This thesis presents Pur, an abstraction over version control concepts that allows building rich client programs that can interact with multiple VCSs. We provide an implementation of this abstraction and validate it by implementing a client application.
Disentangling virtual machine architecture (2009)
Haupt, Michael ; Adams, Bram ; Timbermont, Stijn ; Gibbs, Celina ; Coady, Yvonne ; Hirschfeld, Robert
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.
An open implementation for context-oriented layer composition in ContextJS (2011)
Lincke, Jens ; Appeltauer, Malte ; Steinert, Bastian ; Hirschfeld, Robert
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.
Agile software development in virtual collaboration environments (2011)
Hirschfeld, Robert ; Steinert, Bastian ; Lincke, Jens
Applying design knowledge to programming (2012)
Steinert, Bastian ; Hirschfeld, Robert
SqueakJS A Modern and Practical Smalltalk that Runs in Any Browser (2015)
Freudenberg, Bert ; Ingalls, Dan ; Felgentreff, Tim ; Pape, Tobias ; Hirschfeld, Robert
We report our experience in implementing SqueakJS, a bitcompatible implementation of Squeak/Smalltalk written in pure JavaScript. SqueakJS runs entirely in theWeb browser with a virtual file system that can be directed to a server or client-side storage. Our implementation is notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment. We present several novel techniques as well as performance measurements for the resulting virtual machine. Much of this experience is potentially relevant to preserving other dynamic language systems and making them available in a browser-based environment.
Object Versioning to Support Recovery Needs Using Proxies to Preserve Previous Development States in Lively (2015)
Steinert, Bastian ; Thamsen, Lauritz ; Felgentreff, Tim ; Hirschfeld, Robert
We present object versioning as a generic approach to preserve access to previous development and application states. Version-aware references can manage the modifications made to the target object and record versions as desired. Such references can be provided without modifications to the virtual machine. We used proxies to implement the proposed concepts and demonstrate the Lively Kernel running on top of this object versioning layer. This enables Lively users to undo the effects of direct manipulation and other programming actions.
  • 1 to 10

OPUS4 Logo  KOBV Logo  OAI Logo  DINI Zertifikat 2007  OA Netzwerk Logo

    • Publication server
    • University Bibliography
    • University Library
    • Policy
    • Contact
    • Imprint
    • Privacy Policy
    • Accessibility

    Login